From 47bc72e5ec27bec349dcfc9468af6325f0a51019 Mon Sep 17 00:00:00 2001
From: Josh Kearney <josh.kearney@rackspace.com>
Date: Wed, 12 Jan 2011 12:10:26 -0600
Subject: Start to add rescue/unrescue support

---
 nova/api/openstack/__init__.py | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'nova')

diff --git a/nova/api/openstack/__init__.py b/nova/api/openstack/__init__.py
index f96e2af91..a9b01548a 100644
--- a/nova/api/openstack/__init__.py
+++ b/nova/api/openstack/__init__.py
@@ -95,6 +95,8 @@ class APIRouter(wsgi.Router):
             server_members["actions"] = "GET"
             server_members['suspend'] = 'POST'
             server_members['resume'] = 'POST'
+            server_members['rescue'] = 'POST'
+            server_members['unrescue'] = 'POST'
 
         mapper.resource("server", "servers", controller=servers.Controller(),
                         collection={'detail': 'GET'},
-- 
cgit 


From 7f2a4fdf5e43620081e163fc46f2ca4fdefd18f3 Mon Sep 17 00:00:00 2001
From: Josh Kearney <josh.kearney@rackspace.com>
Date: Wed, 12 Jan 2011 15:07:51 -0600
Subject: Make rescue/unrescue available to API

---
 nova/api/openstack/servers.py | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 29af82533..3a6c61a3a 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -283,6 +283,28 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPUnprocessableEntity())
         return exc.HTTPAccepted()
 
+    def rescue(self, req, id):
+        """Permit users to rescue the server."""
+        context = req.environ["nova.context"]
+        try:
+            self.compute_api.rescue(context, id)
+        except:
+            readable = traceback.format_exc()
+            LOG.exception(_("compute.api::rescue %s"), readable)
+            return faults.Fault(exc.HTTPUnprocessableEntity())
+        return exc.HTTPAccepted()
+
+    def unrescue(self, req, id):
+        """Permit users to unrescue the server."""
+        context = req.environ["nova.context"]
+        try:
+            self.compute_api.unrescue(context, id)
+        except:
+            readable = traceback.format_exc()
+            LOG.exception(_("compute.api::unrescue %s"), readable)
+            return faults.Fault(exc.HTTPUnprocessableEntity())
+        return exc.HTTPAccepted()
+
     def get_ajax_console(self, req, id):
         """ Returns a url to an instance's ajaxterm console. """
         try:
-- 
cgit 


From 752bed3311f09e7a43e642231e1638b4252f74a6 Mon Sep 17 00:00:00 2001
From: Josh Kearney <josh.kearney@rackspace.com>
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')

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 <josh.kearney@rackspace.com>
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')

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 ff6606938749ce5f1a8e430b24d279cde7556c1b Mon Sep 17 00:00:00 2001
From: Josh Kearney <josh.kearney@rackspace.com>
Date: Thu, 13 Jan 2011 11:24:11 -0600
Subject: Make libvirt and XenAPI play nice together

---
 nova/compute/manager.py | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 6b2fc4adb..f1fdd64e6 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -321,7 +321,11 @@ class ComputeManager(manager.Manager):
                                    power_state.NOSTATE,
                                    'rescuing')
         self.network_manager.setup_compute_network(context, instance_id)
-        self.driver.rescue(instance_ref)
+        self.driver.rescue(instance_ref,
+            lambda result: self._update_state_callback(self,
+                                                       context,
+                                                       instance_id,
+                                                       result))
         self._update_state(context, instance_id)
 
     @exception.wrap_exception
@@ -335,7 +339,11 @@ class ComputeManager(manager.Manager):
                                    instance_id,
                                    power_state.NOSTATE,
                                    'unrescuing')
-        self.driver.unrescue(instance_ref)
+        self.driver.unrescue(instance_ref,
+            lambda result: self._update_state_callback(self,
+                                                       context,
+                                                       instance_id,
+                                                       result))
         self._update_state(context, instance_id)
 
     @staticmethod
-- 
cgit 


From fe22186eb989b0302e1cb26a5b92cd77ce47bb9b Mon Sep 17 00:00:00 2001
From: Andy Southgate <andy.southgate@citrix.com>
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')

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 912e4343cf2622fa42aa4e1c5eac392ce1be96e0 Mon Sep 17 00:00:00 2001
From: Josh Kearney <josh.kearney@rackspace.com>
Date: Fri, 14 Jan 2011 11:49:59 -0600
Subject: Create and use a generic handler for RPC calls to compute.

---
 nova/compute/api.py | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/api.py b/nova/compute/api.py
index 90273da36..40b9e33e8 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -331,7 +331,7 @@ class API(base.Base):
         return self.db.instance_get_all(context)
 
     def _cast_compute_message(self, method, context, instance_id, host=None):
-        """Generic handler for RPC calls to compute."""
+        """Generic handler for RPC casts to compute."""
         if not host:
             instance = self.get(context, instance_id)
             host = instance['host']
@@ -339,6 +339,15 @@ class API(base.Base):
         kwargs = {'method': method, 'args': {'instance_id': instance_id}}
         rpc.cast(context, queue, kwargs)
 
+    def _call_compute_message(self, method, context, instance_id, host=None):
+        """Generic handler for RPC calls to compute."""
+        if not host:
+            instance = self.get(context, instance_id)
+            host = instance["host"]
+        queue = self.db.queue_get_for(context, FLAGS.compute_topic, host)
+        kwargs = {"method": method, "args": {"instance_id": instance_id}}
+        return rpc.call(context, queue, kwargs)
+
     def snapshot(self, context, instance_id, name):
         """Snapshot the given instance."""
         self._cast_compute_message('snapshot_instance', context, instance_id)
@@ -357,7 +366,10 @@ class API(base.Base):
 
     def get_diagnostics(self, context, instance_id):
         """Retrieve diagnostics for the given instance."""
-        self._cast_compute_message('get_diagnostics', context, instance_id)
+        return self._call_compute_message(
+            "get_diagnostics",
+            context,
+            instance_id)
 
     def get_actions(self, context, instance_id):
         """Retrieve actions for the given instance."""
-- 
cgit 


From 3300e692b61dc53ac8ae3bfdbac5bb1019983feb Mon Sep 17 00:00:00 2001
From: Josh Kearney <josh.kearney@rackspace.com>
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')

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 <josh.kearney@rackspace.com>
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')

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 <josh.kearney@rackspace.com>
Date: Tue, 18 Jan 2011 15:49:42 -0600
Subject: Plug VBD to existing instance and minor cleanup

---
 nova/tests/xenapi/stubs.py    |  2 +-
 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 +++++++++------
 6 files changed, 52 insertions(+), 26 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/xenapi/stubs.py b/nova/tests/xenapi/stubs.py
index 292bd9ba9..313668826 100644
--- a/nova/tests/xenapi/stubs.py
+++ b/nova/tests/xenapi/stubs.py
@@ -37,7 +37,7 @@ def stubout_instance_snapshot(stubs):
                     return self.rv
 
             done = FakeEvent()
-            self._poll_task(id, task, done)
+            self._poll_task(task, id, done)
             rv = done.wait()
             return rv
 
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 <matt.dietz@rackspace.com>
Date: Tue, 18 Jan 2011 17:40:36 -0600
Subject: Basic stubbing throughout the stack

---
 nova/api/openstack/servers.py | 37 ++++++++++++++++++++++++++++++++++++-
 nova/compute/api.py           | 14 ++++++++++++++
 nova/compute/manager.py       | 13 +++++++++++++
 nova/virt/fake.py             | 12 ++++++++++++
 nova/virt/xenapi/vmops.py     |  4 ++++
 nova/virt/xenapi_conn.py      |  4 ++++
 6 files changed, 83 insertions(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 8cbcebed2..06104b37e 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -182,9 +182,44 @@ class Controller(wsgi.Controller):
         return exc.HTTPNoContent()
 
     def action(self, req, id):
-        """ Multi-purpose method used to reboot, rebuild, and
+        """ Multi-purpose method used to reboot, rebuild, or
         resize a server """
+
+        actions = {
+            'reboot':self._action_reboot,
+            'resize':self._action_resize,
+            'confirmResize':self._action_confirm_resize,
+            'revertResize':self._action_revert_resize,
+            'rebuild':self._action_rebuild
+        }
+
         input_dict = self._deserialize(req.body, req)
+        for key in actions.keys():
+            if key in input_dict:
+                return actions[key](input_dict, req, id)
+        return faults.Fault(exc.HTTPNotImplemented())
+
+    def _action_confirm_resize(self, input_dict, req, id):
+        return fault.Fault(exc.HTTPNotImplemented())
+
+    def _action_revert_resize(self, input_dict, req, id):
+        return fault.Fault(exc.HTTPNotImplemented())
+
+    def _action_rebuild(self, input_dict, req, id):
+        return fault.Fault(exc.HTTPNotImplemented())
+
+    def _action_resize(self, input_dict, req, id):
+        """ Resizes a given instance to the flavor size requested """
+        try:
+            resize_flavor = input_dict['resize']['flavorId']
+            self.compute_api.resize(req.environ['nova.context'], id,
+                    flavor_id)
+        except:
+            return faults.Fault(exc.HTTPUnprocessableEntity())
+        return fault.Fault(exc.HTTPAccepted())
+
+
+    def _action_reboot(self, input_dict, req, id):
         #TODO(sandy): rebuild/resize not supported.
         try:
             reboot_type = input_dict['reboot']['type']
diff --git a/nova/compute/api.py b/nova/compute/api.py
index cc85ec691..22d5964c6 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -361,6 +361,20 @@ class API(base.Base):
         """Reboot the given instance."""
         self._cast_compute_message('reboot_instance', context, instance_id)
 
+    def revert_resize(self, context, instance_id):
+        """Reverts a resize, deleting the 'new' instance in the process"""
+        raise NotImplemented()
+
+    def confirm_resize(self, context, instance_id):
+        """Confirms a migration/resize, deleting the 'old' instance in the
+        process."""
+        raise NotImplemented()
+
+    def resize(self, context, instance_id, flavor_id):
+        """Resize a running instance."""
+        self._cast_compute_message('resize_instance', context, instance_id,
+                flavor_id)
+        
     def pause(self, context, instance_id):
         """Pause the given instance."""
         self._cast_compute_message('pause_instance', context, instance_id)
diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 613ee45f6..714cec209 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -376,6 +376,19 @@ class ComputeManager(manager.Manager):
         """Update instance state when async task completes."""
         self._update_state(context, instance_id)
 
+    @exception.wrap_exception
+    @checks_instance_lock
+    def resize_instance(self, context, instance_id, flavor_id):
+        """Moves a running instance to another host, possibly changing the RAM
+        and disk size in the process"""
+        context = context.elevated()
+        instance_ref = self.db.instance_get(context. instance_id)
+        LOG.audit(_('instance %s: migrating'), instance_id, context=context)
+        self.db.instance_set_state(context, instance_id, power_state.RUNNING,
+                'migrating')
+        self.driver.resize(instance_ref, flavor_id)
+        self._update_state(context, instance_id)
+
     @exception.wrap_exception
     @checks_instance_lock
     def pause_instance(self, context, instance_id):
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 2b2f08dc1dfe1b55433c9122d7d42a480cdb5e67 Mon Sep 17 00:00:00 2001
From: Josh Kearney <josh.kearney@rackspace.com>
Date: Tue, 18 Jan 2011 17:57:11 -0600
Subject: Fixed unit tests

---
 nova/tests/xenapi/stubs.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/xenapi/stubs.py b/nova/tests/xenapi/stubs.py
index c1ba25e10..13603717c 100644
--- a/nova/tests/xenapi/stubs.py
+++ b/nova/tests/xenapi/stubs.py
@@ -27,7 +27,7 @@ def stubout_instance_snapshot(stubs):
     def fake_fetch_image(cls, session, instance_id, image, user, project,
                          type):
         # Stubout wait_for_task
-        def fake_wait_for_task(self, id, task):
+        def fake_wait_for_task(self, task, id=None):
             class FakeEvent:
 
                 def send(self, value):
@@ -37,7 +37,7 @@ def stubout_instance_snapshot(stubs):
                     return self.rv
 
             done = FakeEvent()
-            self._poll_task(task, id, done)
+            self._poll_task(id, task, done)
             rv = done.wait()
             return rv
 
-- 
cgit 


From bb727b7032104d3d3966108d846dd3e5b8a1a37d Mon Sep 17 00:00:00 2001
From: Josh Kearney <josh.kearney@rackspace.com>
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')

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 4b77a532fd641947c9259327cef9104f689f1127 Mon Sep 17 00:00:00 2001
From: Josh Kearney <josh.kearney@rackspace.com>
Date: Tue, 18 Jan 2011 18:09:58 -0600
Subject: Fixed unit tests

---
 nova/tests/xenapi/stubs.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/tests/xenapi/stubs.py b/nova/tests/xenapi/stubs.py
index 13603717c..66d232a7f 100644
--- a/nova/tests/xenapi/stubs.py
+++ b/nova/tests/xenapi/stubs.py
@@ -27,7 +27,7 @@ def stubout_instance_snapshot(stubs):
     def fake_fetch_image(cls, session, instance_id, image, user, project,
                          type):
         # Stubout wait_for_task
-        def fake_wait_for_task(self, task, id=None):
+        def fake_wait_for_task(self, task, id):
             class FakeEvent:
 
                 def send(self, value):
-- 
cgit 


From dd70c9f3909c800d72d73d507e9da05a6ed932de Mon Sep 17 00:00:00 2001
From: Josh Kearney <josh.kearney@rackspace.com>
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')

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 <andy.southgate@citrix.com>
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')

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 <andy.southgate@citrix.com>
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')

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 1dbdb180cb93a812f8336bbfc49bf67a5203d1eb Mon Sep 17 00:00:00 2001
From: Andy Southgate <andy.southgate@citrix.com>
Date: Fri, 21 Jan 2011 12:00:45 +0000
Subject: OS-55: Fix current unit tests

---
 nova/tests/db/fakes.py       | 2 ++
 nova/virt/xenapi/fake.py     | 4 ++++
 nova/virt/xenapi/vm_utils.py | 4 ++--
 3 files changed, 8 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/db/fakes.py b/nova/tests/db/fakes.py
index 05bdd172e..72e093f99 100644
--- a/nova/tests/db/fakes.py
+++ b/nova/tests/db/fakes.py
@@ -58,6 +58,7 @@ def stub_out_db_instance_api(stubs):
             'project_id': values['project_id'],
             'launch_time': time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime()),
             'instance_type': values['instance_type'],
+            'key_data': None,
             'memory_mb': type_data['memory_mb'],
             'mac_address': values['mac_address'],
             'vcpus': type_data['vcpus'],
@@ -68,6 +69,7 @@ def stub_out_db_instance_api(stubs):
     def fake_network_get_by_instance(context, instance_id):
         fields = {
             'bridge': 'xenbr0',
+            'injected': False
             }
         return FakeModel(fields)
 
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 <andy.southgate@citrix.com>
Date: Fri, 21 Jan 2011 16:06:32 +0000
Subject: OS-55: Added unit test for network injection via xenstore

---
 nova/tests/db/fakes.py     | 54 ++++++++++++++++++++++++++++++----------------
 nova/tests/test_xenapi.py  | 46 +++++++++++++++++++++++++++++++++------
 nova/tests/xenapi/stubs.py | 15 +++++++++++++
 nova/virt/xenapi/fake.py   | 12 +++++++++--
 4 files changed, 100 insertions(+), 27 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/db/fakes.py b/nova/tests/db/fakes.py
index 72e093f99..e92efbedd 100644
--- a/nova/tests/db/fakes.py
+++ b/nova/tests/db/fakes.py
@@ -23,23 +23,22 @@ from nova import db
 from nova import utils
 from nova.compute import instance_types
 
+class FakeModel(object):
+    """ Stubs out for model """
+    def __init__(self, values):
+        self.values = values
 
-def stub_out_db_instance_api(stubs):
-    """ Stubs out the db API for creating Instances """
+    def __getattr__(self, name):
+        return self.values[name]
 
-    class FakeModel(object):
-        """ Stubs out for model """
-        def __init__(self, values):
-            self.values = values
+    def __getitem__(self, key):
+        if key in self.values:
+            return self.values[key]
+        else:
+            raise NotImplementedError()
 
-        def __getattr__(self, name):
-            return self.values[name]
-
-        def __getitem__(self, key):
-            if key in self.values:
-                return self.values[key]
-            else:
-                raise NotImplementedError()
+def stub_out_db_instance_api(stubs):
+    """ Stubs out the db API for creating Instances """
 
     def fake_instance_create(values):
         """ Stubs out the db.instance_create method """
@@ -66,12 +65,29 @@ def stub_out_db_instance_api(stubs):
             }
         return FakeModel(base_options)
 
-    def fake_network_get_by_instance(context, instance_id):
-        fields = {
+    stubs.Set(db, 'instance_create', fake_instance_create)
+
+def stub_out_db_network_api(stubs, injected = False):
+    """Stubs out the db API for retrieving networks"""
+    network_fields = {
             'bridge': 'xenbr0',
-            'injected': False
+            'injected': injected
             }
-        return FakeModel(fields)
 
-    stubs.Set(db, 'instance_create', fake_instance_create)
+    if injected:
+        network_fields.update({
+            'netmask': '255.255.255.0',
+            'gateway': '10.0.0.1',
+            'broadcast': '10.0.0.255',
+            'dns': '10.0.0.2'
+            })
+
+    def fake_network_get_by_instance(context, instance_id):
+        return FakeModel(network_fields)
+
+    def fake_instance_get_fixed_address(context, instance_id):
+        return '10.0.0.3'
+
     stubs.Set(db, 'network_get_by_instance', fake_network_get_by_instance)
+    stubs.Set(db, 'instance_get_fixed_address', fake_instance_get_fixed_address)
+
diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index 9f5b266f3..2a32845d3 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -50,6 +50,7 @@ class XenAPIVolumeTestCase(test.TestCase):
         FLAGS.xenapi_connection_url = 'test_url'
         FLAGS.xenapi_connection_password = 'test_pass'
         db_fakes.stub_out_db_instance_api(self.stubs)
+        db_fakes.stub_out_db_network_api(self.stubs)
         stubs.stub_out_get_target(self.stubs)
         xenapi_fake.reset()
         self.values = {'name': 1, 'id': 1,
@@ -158,6 +159,7 @@ class XenAPIVMTestCase(test.TestCase):
         xenapi_fake.reset()
         xenapi_fake.create_local_srs()
         db_fakes.stub_out_db_instance_api(self.stubs)
+        db_fakes.stub_out_db_network_api(self.stubs)
         xenapi_fake.create_network('fake', FLAGS.flat_network_bridge)
         stubs.stubout_session(self.stubs, stubs.FakeSessionForVMTests)
         stubs.stubout_get_this_vm_uuid(self.stubs)
@@ -211,7 +213,7 @@ class XenAPIVMTestCase(test.TestCase):
 
         check()
 
-    def check_vm_record(self, conn):
+    def check_vm_record(self, conn, check_injection = False):
         instances = conn.list_instances()
         self.assertEquals(instances, [1])
 
@@ -219,10 +221,10 @@ class XenAPIVMTestCase(test.TestCase):
         vm_info = conn.get_info(1)
 
         # Get XenAPI record for VM
-        vms = [rec for ref, rec
+        vms = [(ref, rec) for ref, rec
                in xenapi_fake.get_all_records('VM').iteritems()
                if not rec['is_control_domain']]
-        vm = vms[0]
+        vm_ref, vm = vms[0]
 
         # Check that m1.large above turned into the right thing.
         instance_type = instance_types.INSTANCE_TYPES['m1.large']
@@ -242,8 +244,35 @@ class XenAPIVMTestCase(test.TestCase):
 
         # Check that the VM is running according to XenAPI.
         self.assertEquals(vm['power_state'], 'Running')
-
-    def _test_spawn(self, image_id, kernel_id, ramdisk_id):
+        
+        if check_injection:
+            xenstore_data = xenapi_fake.VM_get_xenstore_data(vm_ref)
+            key_prefix = 'vm-data/vif/22_33_2A_B3_CC_DD/tcpip/'
+            tcpip_data = dict([(k.replace(key_prefix, ''), v)
+                for k, v in xenstore_data.iteritems() if k.startswith(key_prefix) ])
+
+            self.assertEquals(tcpip_data, {
+                'BroadcastAddress/data/0': '10.0.0.255',
+                'BroadcastAddress/name': 'BroadcastAddress',
+                'BroadcastAddress/type': 'multi_sz',
+                'DefaultGateway/data/0': '10.0.0.1',
+                'DefaultGateway/name': 'DefaultGateway',
+                'DefaultGateway/type': 'multi_sz',
+                'EnableDhcp/data': '0',
+                'EnableDhcp/name': 'EnableDhcp',
+                'EnableDhcp/type': 'dword',
+                'IPAddress/data/0': '10.0.0.3',
+                'IPAddress/name': 'IPAddress',
+                'IPAddress/type': 'multi_sz',
+                'NameServer/data': '10.0.0.2',
+                'NameServer/name': 'NameServer',
+                'NameServer/type': 'string',
+                'SubnetMask/data/0': '255.255.255.0',
+                'SubnetMask/name': 'SubnetMask',
+                'SubnetMask/type': 'multi_sz'
+             })
+
+    def _test_spawn(self, image_id, kernel_id, ramdisk_id, check_injection = False):
         stubs.stubout_session(self.stubs, stubs.FakeSessionForVMTests)
         values = {'name': 1,
                   'id': 1,
@@ -258,7 +287,7 @@ class XenAPIVMTestCase(test.TestCase):
         conn = xenapi_conn.get_connection(False)
         instance = db.instance_create(values)
         conn.spawn(instance)
-        self.check_vm_record(conn)
+        self.check_vm_record(conn, check_injection = check_injection)
 
     def test_spawn_raw_objectstore(self):
         FLAGS.xenapi_image_service = 'objectstore'
@@ -276,6 +305,11 @@ class XenAPIVMTestCase(test.TestCase):
         FLAGS.xenapi_image_service = 'glance'
         self._test_spawn(1, 2, 3)
 
+    def test_spawn_netinject(self):
+        FLAGS.xenapi_image_service = 'glance'
+        db_fakes.stub_out_db_network_api(self.stubs, injected = True)
+        self._test_spawn(1, 2, 3, check_injection = True)
+        
     def tearDown(self):
         super(XenAPIVMTestCase, self).tearDown()
         self.manager.delete_project(self.project)
diff --git a/nova/tests/xenapi/stubs.py b/nova/tests/xenapi/stubs.py
index 624995ada..3cfc8e5f9 100644
--- a/nova/tests/xenapi/stubs.py
+++ b/nova/tests/xenapi/stubs.py
@@ -171,6 +171,21 @@ class FakeSessionForVMTests(fake.SessionBase):
     def VM_destroy(self, session_ref, vm_ref):
         fake.destroy_vm(vm_ref)
 
+    def VM_get_VIFs(self, session_ref, vm_ref):
+        return (['0', '1', '2'])
+            
+    def VIF_get_device(self, session_ref, vif_ref):
+        return ('1', '0', '2')[int(vif_ref)]
+    
+    def VIF_get_MAC(self, session_ref, vif_ref):
+        return (
+            '11:22:2a:b3:CC:dd',
+            '22:33:2a:b3:CC:dd',
+            '44:44:2a:b3:CC:dd'
+            )[int(vif_ref)]
+            
+    def VM_add_to_xenstore_data(self, session_ref, vm_ref, key, value):
+        fake.VM_add_to_xenstore_data(vm_ref, key, value)
 
 class FakeSessionForVolumeTests(fake.SessionBase):
     """ Stubs out a XenAPISession for Volume tests """
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 48990b109eb39f0dd4ea7bf86be79f6e03c3ad74 Mon Sep 17 00:00:00 2001
From: Andy Southgate <andy.southgate@citrix.com>
Date: Fri, 21 Jan 2011 16:23:30 +0000
Subject: OS55: pylint fixes

---
 nova/tests/test_xenapi.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index 2a32845d3..c94aeefd1 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -249,7 +249,8 @@ class XenAPIVMTestCase(test.TestCase):
             xenstore_data = xenapi_fake.VM_get_xenstore_data(vm_ref)
             key_prefix = 'vm-data/vif/22_33_2A_B3_CC_DD/tcpip/'
             tcpip_data = dict([(k.replace(key_prefix, ''), v)
-                for k, v in xenstore_data.iteritems() if k.startswith(key_prefix) ])
+                for k, v in xenstore_data.iteritems()
+                if k.startswith(key_prefix) ])
 
             self.assertEquals(tcpip_data, {
                 'BroadcastAddress/data/0': '10.0.0.255',
@@ -272,7 +273,8 @@ class XenAPIVMTestCase(test.TestCase):
                 'SubnetMask/type': 'multi_sz'
              })
 
-    def _test_spawn(self, image_id, kernel_id, ramdisk_id, check_injection = False):
+    def _test_spawn(self, image_id, kernel_id, ramdisk_id,
+        check_injection = False):
         stubs.stubout_session(self.stubs, stubs.FakeSessionForVMTests)
         values = {'name': 1,
                   'id': 1,
-- 
cgit 


From c97618e1eaff4091f01381073a298d0f67050126 Mon Sep 17 00:00:00 2001
From: Andy Southgate <andy.southgate@citrix.com>
Date: Mon, 24 Jan 2011 18:28:50 +0000
Subject: OS-55: Post-merge fixes

---
 nova/tests/db/fakes.py       | 3 ++-
 nova/virt/xenapi/vm_utils.py | 2 +-
 2 files changed, 3 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/db/fakes.py b/nova/tests/db/fakes.py
index e92efbedd..4a0d1cc3c 100644
--- a/nova/tests/db/fakes.py
+++ b/nova/tests/db/fakes.py
@@ -79,7 +79,8 @@ def stub_out_db_network_api(stubs, injected = False):
             'netmask': '255.255.255.0',
             'gateway': '10.0.0.1',
             'broadcast': '10.0.0.255',
-            'dns': '10.0.0.2'
+            'dns': '10.0.0.2',
+            'ra_server': None
             })
 
     def fake_network_get_by_instance(context, instance_id):
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 <andy.southgate@citrix.com>
Date: Mon, 24 Jan 2011 19:04:25 +0000
Subject: OS-55: PEP8 fixes

---
 nova/tests/db/fakes.py       | 17 +++++-----
 nova/tests/test_xenapi.py    | 19 +++++------
 nova/tests/xenapi/stubs.py   | 10 +++---
 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 ++--
 8 files changed, 77 insertions(+), 69 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/db/fakes.py b/nova/tests/db/fakes.py
index 4a0d1cc3c..c47fba5f3 100644
--- a/nova/tests/db/fakes.py
+++ b/nova/tests/db/fakes.py
@@ -23,6 +23,7 @@ from nova import db
 from nova import utils
 from nova.compute import instance_types
 
+
 class FakeModel(object):
     """ Stubs out for model """
     def __init__(self, values):
@@ -37,6 +38,7 @@ class FakeModel(object):
         else:
             raise NotImplementedError()
 
+
 def stub_out_db_instance_api(stubs):
     """ Stubs out the db API for creating Instances """
 
@@ -67,12 +69,12 @@ def stub_out_db_instance_api(stubs):
 
     stubs.Set(db, 'instance_create', fake_instance_create)
 
-def stub_out_db_network_api(stubs, injected = False):
+
+def stub_out_db_network_api(stubs, injected=False):
     """Stubs out the db API for retrieving networks"""
     network_fields = {
-            'bridge': 'xenbr0',
-            'injected': injected
-            }
+        'bridge': 'xenbr0',
+        'injected': injected}
 
     if injected:
         network_fields.update({
@@ -80,8 +82,7 @@ def stub_out_db_network_api(stubs, injected = False):
             'gateway': '10.0.0.1',
             'broadcast': '10.0.0.255',
             'dns': '10.0.0.2',
-            'ra_server': None
-            })
+            'ra_server': None})
 
     def fake_network_get_by_instance(context, instance_id):
         return FakeModel(network_fields)
@@ -90,5 +91,5 @@ def stub_out_db_network_api(stubs, injected = False):
         return '10.0.0.3'
 
     stubs.Set(db, 'network_get_by_instance', fake_network_get_by_instance)
-    stubs.Set(db, 'instance_get_fixed_address', fake_instance_get_fixed_address)
-
+    stubs.Set(db, 'instance_get_fixed_address',
+        fake_instance_get_fixed_address)
diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index c94aeefd1..f7f7102a8 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -213,7 +213,7 @@ class XenAPIVMTestCase(test.TestCase):
 
         check()
 
-    def check_vm_record(self, conn, check_injection = False):
+    def check_vm_record(self, conn, check_injection=False):
         instances = conn.list_instances()
         self.assertEquals(instances, [1])
 
@@ -244,13 +244,13 @@ class XenAPIVMTestCase(test.TestCase):
 
         # Check that the VM is running according to XenAPI.
         self.assertEquals(vm['power_state'], 'Running')
-        
+
         if check_injection:
             xenstore_data = xenapi_fake.VM_get_xenstore_data(vm_ref)
             key_prefix = 'vm-data/vif/22_33_2A_B3_CC_DD/tcpip/'
             tcpip_data = dict([(k.replace(key_prefix, ''), v)
                 for k, v in xenstore_data.iteritems()
-                if k.startswith(key_prefix) ])
+                if k.startswith(key_prefix)])
 
             self.assertEquals(tcpip_data, {
                 'BroadcastAddress/data/0': '10.0.0.255',
@@ -270,11 +270,10 @@ class XenAPIVMTestCase(test.TestCase):
                 'NameServer/type': 'string',
                 'SubnetMask/data/0': '255.255.255.0',
                 'SubnetMask/name': 'SubnetMask',
-                'SubnetMask/type': 'multi_sz'
-             })
+                'SubnetMask/type': 'multi_sz'})
 
     def _test_spawn(self, image_id, kernel_id, ramdisk_id,
-        check_injection = False):
+        check_injection=False):
         stubs.stubout_session(self.stubs, stubs.FakeSessionForVMTests)
         values = {'name': 1,
                   'id': 1,
@@ -289,7 +288,7 @@ class XenAPIVMTestCase(test.TestCase):
         conn = xenapi_conn.get_connection(False)
         instance = db.instance_create(values)
         conn.spawn(instance)
-        self.check_vm_record(conn, check_injection = check_injection)
+        self.check_vm_record(conn, check_injection=check_injection)
 
     def test_spawn_raw_objectstore(self):
         FLAGS.xenapi_image_service = 'objectstore'
@@ -309,9 +308,9 @@ class XenAPIVMTestCase(test.TestCase):
 
     def test_spawn_netinject(self):
         FLAGS.xenapi_image_service = 'glance'
-        db_fakes.stub_out_db_network_api(self.stubs, injected = True)
-        self._test_spawn(1, 2, 3, check_injection = True)
-        
+        db_fakes.stub_out_db_network_api(self.stubs, injected=True)
+        self._test_spawn(1, 2, 3, check_injection=True)
+
     def tearDown(self):
         super(XenAPIVMTestCase, self).tearDown()
         self.manager.delete_project(self.project)
diff --git a/nova/tests/xenapi/stubs.py b/nova/tests/xenapi/stubs.py
index 3cfc8e5f9..027855592 100644
--- a/nova/tests/xenapi/stubs.py
+++ b/nova/tests/xenapi/stubs.py
@@ -173,20 +173,20 @@ class FakeSessionForVMTests(fake.SessionBase):
 
     def VM_get_VIFs(self, session_ref, vm_ref):
         return (['0', '1', '2'])
-            
+
     def VIF_get_device(self, session_ref, vif_ref):
         return ('1', '0', '2')[int(vif_ref)]
-    
+
     def VIF_get_MAC(self, session_ref, vif_ref):
         return (
             '11:22:2a:b3:CC:dd',
             '22:33:2a:b3:CC:dd',
-            '44:44:2a:b3:CC:dd'
-            )[int(vif_ref)]
-            
+            '44:44:2a:b3:CC:dd')[int(vif_ref)]
+
     def VM_add_to_xenstore_data(self, session_ref, vm_ref, key, value):
         fake.VM_add_to_xenstore_data(vm_ref, key, value)
 
+
 class FakeSessionForVolumeTests(fake.SessionBase):
     """ Stubs out a XenAPISession for Volume tests """
     def __init__(self, uri):
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 <josh.kearney@rackspace.com>
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')

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 0f868b00dbb2de469dde3519f2370e59937c4fc6 Mon Sep 17 00:00:00 2001
From: Andy Southgate <andy.southgate@citrix.com>
Date: Wed, 26 Jan 2011 19:58:45 +0000
Subject: OS-55: Added a test case for XenAPI file-based network injection
 OS-55: Stubbed out utils.execute for all XenAPI VM tests, including command
 simulation where necessary

---
 nova/tests/fake_utils.py  | 98 +++++++++++++++++++++++++++++++++++++++++++++++
 nova/tests/test_xenapi.py | 83 ++++++++++++++++++++++++++++++++++++++-
 2 files changed, 180 insertions(+), 1 deletion(-)
 create mode 100644 nova/tests/fake_utils.py

(limited to 'nova')

diff --git a/nova/tests/fake_utils.py b/nova/tests/fake_utils.py
new file mode 100644
index 000000000..f51d31e0c
--- /dev/null
+++ b/nova/tests/fake_utils.py
@@ -0,0 +1,98 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright (c) 2011 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.
+
+"""This modules stubs out functions in nova.utils
+"""
+
+import re
+import types
+
+from eventlet import greenthread
+
+from nova import exception
+from nova import log as logging
+from nova import utils
+
+LOG = logging.getLogger('nova.tests.fake_utils')
+
+_fake_execute_repliers = []
+_fake_execute_log = []
+
+
+def fake_execute_get_log():
+    global _fake_execute_log
+    return _fake_execute_log
+
+
+def fake_execute_clear_log():
+    global _fake_execute_log
+    _fake_execute_log = []
+
+
+def fake_execute_set_repliers(repliers):
+    """Allows the client to configure replies to commands"""
+    global _fake_execute_repliers
+    _fake_execute_repliers = repliers
+
+
+def fake_execute_default_reply_handler(*ignore_args):
+    """A reply handler for commands that haven't been added to the reply
+    list.  Returns empty strings for stdout and stderr
+    """
+    return '', ''
+
+
+def fake_execute(cmd, process_input=None, addl_env=None, check_exit_code=True):
+    """This function stubs out execute, optionally executing
+    a preconfigued function to return expected data
+    """
+    global _fake_execute_repliers
+
+    LOG.debug(_("Faking execution of cmd (subprocess): %s"), cmd)
+    _fake_execute_log.append(cmd)
+
+    reply_handler = fake_execute_default_reply_handler
+
+    for fake_replier in _fake_execute_repliers:
+        if re.match(fake_replier[0], cmd):
+            reply_handler = fake_replier[1]
+            LOG.debug(_('Faked command matched %s') % fake_replier[0])
+            break
+
+    if isinstance(reply_handler, types.StringTypes):
+        # If the reply handler is a string, return it as stdout
+        reply = reply_handler, ''
+    else:
+        try:
+            # Alternative is a function, so call it
+            reply = reply_handler(cmd, process_input, addl_env,
+                check_exit_code)
+        except exception.ProcessExecutionError as e:
+            LOG.debug(_('Faked command raised an exception %s' % str(e)))
+            raise
+
+    LOG.debug(_("Reply to faked command is stdout='%(0)s' stderr='%(1)s'") %
+        {'0': reply[0], '1': reply[1]})
+
+    # Replicate the sleep call in the real function
+    greenthread.sleep(0)
+    return reply
+
+
+def stub_out_utils_execute(stubs):
+    fake_execute_set_repliers([])
+    fake_execute_clear_log()
+    stubs.Set(utils, 'execute', fake_execute)
diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index f7f7102a8..8af47da63 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -18,11 +18,14 @@
 Test suite for XenAPI
 """
 
+import os
+import re
 import stubout
 
 from nova import db
 from nova import context
 from nova import flags
+from nova import log as logging
 from nova import test
 from nova import utils
 from nova.auth import manager
@@ -35,6 +38,9 @@ from nova.virt.xenapi.vmops import SimpleDH
 from nova.tests.db import fakes as db_fakes
 from nova.tests.xenapi import stubs
 from nova.tests.glance import stubs as glance_stubs
+from nova.tests import fake_utils
+
+LOG = logging.getLogger('nova.tests.test_xenapi')
 
 FLAGS = flags.FLAGS
 
@@ -166,6 +172,7 @@ class XenAPIVMTestCase(test.TestCase):
         stubs.stubout_stream_disk(self.stubs)
         glance_stubs.stubout_glance_client(self.stubs,
                                            glance_stubs.FakeGlance)
+        fake_utils.stub_out_utils_execute(self.stubs)
         self.conn = xenapi_conn.get_connection(False)
 
     def test_list_instances_0(self):
@@ -306,11 +313,85 @@ class XenAPIVMTestCase(test.TestCase):
         FLAGS.xenapi_image_service = 'glance'
         self._test_spawn(1, 2, 3)
 
-    def test_spawn_netinject(self):
+    def test_spawn_netinject_file(self):
+        FLAGS.xenapi_image_service = 'glance'
+        db_fakes.stub_out_db_network_api(self.stubs, injected=True)
+
+        self._tee_executed = False
+
+        def _tee_handler(cmd, input, *ignore_args):
+            self.assertNotEqual(input, None)
+
+            config = [line.strip() for line in input.split("\n")]
+
+            # Find the start of eth0 configuration and check it
+            index = config.index('auto eth0')
+            self.assertEquals(config[index + 1:index + 8], [
+                'iface eth0 inet static',
+                'address 10.0.0.3',
+                'netmask 255.255.255.0',
+                'broadcast 10.0.0.255',
+                'gateway 10.0.0.1',
+                'dns-nameservers 10.0.0.2',
+                ''])
+
+            self._tee_executed = True
+
+            return '', ''
+
+        fake_utils.fake_execute_set_repliers([
+            # Capture the sudo tee .../etc/network/interfaces command
+            (r'(sudo\s+)?tee.*interfaces', _tee_handler),
+        ])
+        self._test_spawn(1, 2, 3, check_injection=True)
+        self.assertTrue(self._tee_executed)
+
+    def test_spawn_netinject_xenstore(self):
         FLAGS.xenapi_image_service = 'glance'
         db_fakes.stub_out_db_network_api(self.stubs, injected=True)
+
+        self._tee_executed = False
+
+        def _mount_handler(cmd, *ignore_args):
+            # When mounting, create real files under the mountpoint to simulate
+            # files in the mounted filesystem
+
+            # RegExp extracts the path of the mountpoint
+            match = re.match(r'(sudo\s+)?mount[^"]*"[^"]*"\s+"([^"]*)"', cmd)
+            self._tmpdir = match.group(2)
+            LOG.debug(_('Creating files in %s to simulate guest agent' %
+                self._tmpdir))
+            os.makedirs(os.path.join(self._tmpdir, 'usr', 'sbin'))
+            # Touch the file using open
+            open(os.path.join(self._tmpdir, 'usr', 'sbin',
+                'xe-update-networking'), 'w').close()
+            return '', ''
+
+        def _umount_handler(cmd, *ignore_args):
+            # Umount would normall make files in the m,ounted filesystem
+            # disappear, so do that here
+            LOG.debug(_('Removing simulated guest agent files in %s' %
+                self._tmpdir))
+            os.remove(os.path.join(self._tmpdir, 'usr', 'sbin',
+                'xe-update-networking'))
+            os.rmdir(os.path.join(self._tmpdir, 'usr', 'sbin'))
+            os.rmdir(os.path.join(self._tmpdir, 'usr'))
+            return '', ''
+
+        def _tee_handler(cmd, input, *ignore_args):
+            self._tee_executed = True
+            return '', ''
+
+        fake_utils.fake_execute_set_repliers([
+            (r'(sudo\s+)?mount', _mount_handler),
+            (r'(sudo\s+)?umount', _umount_handler),
+            (r'(sudo\s+)?tee.*interfaces', _tee_handler)])
         self._test_spawn(1, 2, 3, check_injection=True)
 
+        # tee must not run in this case, where an injection-capable
+        # guest agent is detected
+        self.assertFalse(self._tee_executed)
+
     def tearDown(self):
         super(XenAPIVMTestCase, self).tearDown()
         self.manager.delete_project(self.project)
-- 
cgit 


From 7c8096384507908a5e583f4554d0fc765ae5f2eb Mon Sep 17 00:00:00 2001
From: Kei Masumoto <masumotok@nttdata.co.jp>
Date: Thu, 27 Jan 2011 20:39:33 +0900
Subject: adding testcode

---
 nova/compute/manager.py      |  66 ++--
 nova/db/sqlalchemy/api.py    |  49 +--
 nova/db/sqlalchemy/models.py |  12 +-
 nova/scheduler/driver.py     |  53 ++--
 nova/scheduler/manager.py    |  28 +-
 nova/tests/test_compute.py   | 305 ++++++++++++++++++
 nova/tests/test_scheduler.py | 722 +++++++++++++++++++++++++++++++++++++++++++
 nova/tests/test_service.py   |  61 +++-
 nova/tests/test_virt.py      | 520 ++++++++++++++++++++++++++++++-
 nova/virt/fake.py            |  12 +-
 nova/virt/libvirt_conn.py    | 159 +++++-----
 nova/virt/xenapi_conn.py     |  14 +-
 nova/volume/manager.py       |   2 +-
 13 files changed, 1807 insertions(+), 196 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index efb5753aa..4acba7153 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -125,12 +125,12 @@ class ComputeManager(manager.Manager):
         """Insert compute node specific information to DB."""
 
         try:
-            service_ref = db.service_get_by_args(ctxt,
-                                                 host,
-                                                 binary)
+            service_ref = self.db.service_get_by_args(ctxt,
+                                                      host,
+                                                      binary)
         except exception.NotFound:
-            msg = _(("""Cannot insert compute manager specific info"""
-                      """Because no service record found."""))
+            msg = _(("""Cannot insert compute manager specific info,"""
+                      """ Because no service record found."""))
             raise exception.Invalid(msg)
 
         # Updating host information
@@ -141,14 +141,14 @@ class ComputeManager(manager.Manager):
         version = self.driver.get_hypervisor_version()
         cpu_info = self.driver.get_cpu_info()
 
-        db.service_update(ctxt,
-                          service_ref['id'],
-                          {'vcpus': vcpu,
-                           'memory_mb': memory_mb,
-                           'local_gb': local_gb,
-                           'hypervisor_type': hypervisor,
-                           'hypervisor_version': version,
-                           'cpu_info': cpu_info})
+        self.db.service_update(ctxt,
+                               service_ref['id'],
+                               {'vcpus': vcpu,
+                                'memory_mb': memory_mb,
+                                'local_gb': local_gb,
+                                'hypervisor_type': hypervisor,
+                                'hypervisor_version': version,
+                                'cpu_info': cpu_info})
 
     def _update_state(self, context, instance_id):
         """Update the state of an instance from the driver info."""
@@ -596,22 +596,22 @@ class ComputeManager(manager.Manager):
         """ Check the host cpu is compatible to a cpu given by xml."""
         return self.driver.compare_cpu(cpu_info)
 
-    def pre_live_migration(self, context, instance_id, dest):
+    def pre_live_migration(self, context, instance_id):
         """Any preparation for live migration at dst host."""
 
         # Getting instance info
-        instance_ref = db.instance_get(context, instance_id)
+        instance_ref = self.db.instance_get(context, instance_id)
         ec2_id = instance_ref['hostname']
 
         # Getting fixed ips
-        fixed_ip = db.instance_get_fixed_address(context, instance_id)
+        fixed_ip = self.db.instance_get_fixed_address(context, instance_id)
         if not fixed_ip:
             msg = _('%s(%s) doesnt have fixed_ip') % (instance_id, ec2_id)
             raise exception.NotFound(msg)
 
         # If any volume is mounted, prepare here.
         if len(instance_ref['volumes']) == 0:
-            logging.info(_("%s has no volume.") % ec2_id)
+            LOG.info(_("%s has no volume."), ec2_id)
         else:
             for v in instance_ref['volumes']:
                 self.volume_manager.setup_compute_volume(context, v['id'])
@@ -634,7 +634,7 @@ class ComputeManager(manager.Manager):
         """executes live migration."""
 
         # Get instance for error handling.
-        instance_ref = db.instance_get(context, instance_id)
+        instance_ref = self.db.instance_get(context, instance_id)
         ec2_id = instance_ref['hostname']
 
         try:
@@ -647,27 +647,27 @@ class ComputeManager(manager.Manager):
                            "args": {'instance_id': instance_id}})
 
             # Asking dest host to preparing live migration.
-            compute_topic = db.queue_get_for(context,
-                                             FLAGS.compute_topic,
-                                             dest)
+            compute_topic = self.db.queue_get_for(context,
+                                                  FLAGS.compute_topic,
+                                                  dest)
             rpc.call(context,
-                        compute_topic,
-                        {"method": "pre_live_migration",
-                         "args": {'instance_id': instance_id,
-                                    'dest': dest}})
+                     compute_topic,
+                     {"method": "pre_live_migration",
+                      "args": {'instance_id': instance_id}})
 
         except Exception, e:
+            print e
             msg = _('Pre live migration for %s failed at %s')
-            logging.error(msg, ec2_id, dest)
-            db.instance_set_state(context,
-                                  instance_id,
-                                  power_state.RUNNING,
-                                  'running')
+            LOG.error(msg, ec2_id, dest)
+            self.db.instance_set_state(context,
+                                       instance_id,
+                                       power_state.RUNNING,
+                                       'running')
 
             for v in instance_ref['volumes']:
-                db.volume_update(context,
-                                 v['id'],
-                                 {'status': 'in-use'})
+                self.db.volume_update(context,
+                                      v['id'],
+                                      {'status': 'in-use'})
 
             # e should be raised. just calling "raise" may raise NotFound.
             raise e
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 248a46f65..1cdd5a286 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -897,41 +897,42 @@ def instance_get_all_by_host(context, hostname):
 
 
 @require_context
-def _instance_get_sum_by_host_and_project(context, column, hostname, proj_id):
+def instance_get_vcpu_sum_by_host_and_project(context, hostname, proj_id):
     session = get_session()
-
     result = session.query(models.Instance).\
-                     filter_by(host=hostname).\
-                     filter_by(project_id=proj_id).\
-                     filter_by(deleted=can_read_deleted(context)).\
-                     value(column)
-    if not result:
+                      filter_by(host=hostname).\
+                      filter_by(project_id=proj_id).\
+                      filter_by(deleted=False).\
+                      value(func.sum(models.Instance.vcpus))
+    if None == result:
         return 0
     return result
 
 
-@require_context
-def instance_get_vcpu_sum_by_host_and_project(context, hostname, proj_id):
-    return _instance_get_sum_by_host_and_project(context,
-                                                 'vcpus',
-                                                 hostname,
-                                                 proj_id)
-
-
 @require_context
 def instance_get_memory_sum_by_host_and_project(context, hostname, proj_id):
-    return _instance_get_sum_by_host_and_project(context,
-                                                 'memory_mb',
-                                                 hostname,
-                                                 proj_id)
-
+    session = get_session()
+    result = session.query(models.Instance).\
+                      filter_by(host=hostname).\
+                      filter_by(project_id=proj_id).\
+                      filter_by(deleted=False).\
+                      value(func.sum(models.Instance.memory_mb))
+    if None == result:
+        return 0
+    return result
 
 @require_context
 def instance_get_disk_sum_by_host_and_project(context, hostname, proj_id):
-    return _instance_get_sum_by_host_and_project(context,
-                                                 'local_gb',
-                                                 hostname,
-                                                 proj_id)
+    session = get_session()
+    result = session.query(models.Instance).\
+                      filter_by(host=hostname).\
+                      filter_by(project_id=proj_id).\
+                      filter_by(deleted=False).\
+                      value(func.sum(models.Instance.local_gb))
+    if None == result:
+        return 0
+    return result
+
 
 
 @require_context
diff --git a/nova/db/sqlalchemy/models.py b/nova/db/sqlalchemy/models.py
index b28c64b59..7c40d5596 100644
--- a/nova/db/sqlalchemy/models.py
+++ b/nova/db/sqlalchemy/models.py
@@ -161,11 +161,11 @@ class Service(BASE, NovaBase):
 
     # The below items are compute node only.
     # -1 or None is inserted for other service.
-    vcpus = Column(Integer, nullable=False, default=-1)
-    memory_mb = Column(Integer, nullable=False, default=-1)
-    local_gb = Column(Integer, nullable=False, default=-1)
-    hypervisor_type = Column(String(128))
-    hypervisor_version = Column(Integer, nullable=False, default=-1)
+    vcpus = Column(Integer, nullable=True)
+    memory_mb = Column(Integer, nullable=True)
+    local_gb = Column(Integer, nullable=True)
+    hypervisor_type = Column(String(128), nullable=True)
+    hypervisor_version = Column(Integer, nullable=True)
     # Note(masumotok): Expected Strings example:
     #
     # '{"arch":"x86_64", "model":"Nehalem",
@@ -174,7 +174,7 @@ class Service(BASE, NovaBase):
     #
     # Points are "json translatable" and it must have all
     # dictionary keys above.
-    cpu_info = Column(String(512))
+    cpu_info = Column(Text(), nullable=True)
 
 
 class Certificate(BASE, NovaBase):
diff --git a/nova/scheduler/driver.py b/nova/scheduler/driver.py
index 65745093b..d4ad42388 100644
--- a/nova/scheduler/driver.py
+++ b/nova/scheduler/driver.py
@@ -69,11 +69,10 @@ class Scheduler(object):
         raise NotImplementedError(_("Must implement a fallback schedule"))
 
     def schedule_live_migration(self, context, instance_id, dest):
-        """ live migration method """
+        """live migration method"""
 
         # Whether instance exists and running
         instance_ref = db.instance_get(context, instance_id)
-        ec2_id = instance_ref['hostname']
 
         # Checking instance.
         self._live_migration_src_check(context, instance_ref)
@@ -159,48 +158,45 @@ class Scheduler(object):
 
     def _live_migration_common_check(self, context, instance_ref, dest):
         """
-           Live migration check routine.
-           Below pre-checkings are followed by
-           http://wiki.libvirt.org/page/TodoPreMigrationChecks
+        Live migration check routine.
+        Below pre-checkings are followed by
+        http://wiki.libvirt.org/page/TodoPreMigrationChecks
 
         """
 
         # Checking dest exists.
         dservice_refs = db.service_get_all_by_host(context, dest)
         if len(dservice_refs) <= 0:
-            msg = _('%s does not exists.')
-            raise exception.Invalid(msg % dest)
+            raise exception.Invalid(_('%s does not exists.') % dest)
         dservice_ref = dservice_refs[0]
 
         # Checking original host( where instance was launched at) exists.
-        orighost = instance_ref['launched_on']
-        oservice_refs = db.service_get_all_by_host(context, orighost)
+        oservice_refs = db.service_get_all_by_host(context,
+                                                   instance_ref['launched_on'])
         if len(oservice_refs) <= 0:
             msg = _('%s(where instance was launched at) does not exists.')
-            raise exception.Invalid(msg % orighost)
+            raise exception.Invalid(msg % instance_ref['launched_on'])
         oservice_ref = oservice_refs[0]
 
         # Checking hypervisor is same.
-        otype = oservice_ref['hypervisor_type']
-        dtype = dservice_ref['hypervisor_type']
-        if otype != dtype:
+        if oservice_ref['hypervisor_type'] != dservice_ref['hypervisor_type']:
             msg = _('Different hypervisor type(%s->%s)')
-            raise exception.Invalid(msg % (otype, dtype))
+            raise exception.Invalid(msg % (oservice_ref['hypervisor_type'],
+                                           dservice_ref['hypervisor_type']))
 
         # Checkng hypervisor version.
-        oversion = oservice_ref['hypervisor_version']
-        dversion = dservice_ref['hypervisor_version']
-        if oversion > dversion:
+        if oservice_ref['hypervisor_version'] > \
+           dservice_ref['hypervisor_version']:
             msg = _('Older hypervisor version(%s->%s)')
-            raise exception.Invalid(msg % (oversion, dversion))
+            raise exception.Invalid(msg % (oservice_ref['hypervisor_version'],
+                                           dservice_ref['hypervisor_version']))
 
         # Checking cpuinfo.
-        cpu_info = oservice_ref['cpu_info']
         try:
             rpc.call(context,
                      db.queue_get_for(context, FLAGS.compute_topic, dest),
                      {"method": 'compare_cpu',
-                      "args": {'cpu_info': cpu_info}})
+                      "args": {'cpu_info': oservice_ref['cpu_info']}})
 
         except rpc.RemoteError, e:
             msg = _(("""%s doesnt have compatibility to %s"""
@@ -211,7 +207,7 @@ class Scheduler(object):
             raise e
 
     def has_enough_resource(self, context, instance_ref, dest):
-        """ Check if destination host has enough resource for live migration"""
+        """Check if destination host has enough resource for live migration"""
 
         # Getting instance information
         ec2_id = instance_ref['hostname']
@@ -222,28 +218,27 @@ class Scheduler(object):
         # Gettin host information
         service_refs = db.service_get_all_by_host(context, dest)
         if len(service_refs) <= 0:
-            msg = _('%s does not exists.')
-            raise exception.Invalid(msg % dest)
+            raise exception.Invalid(_('%s does not exists.') % dest)
         service_ref = service_refs[0]
 
         total_cpu = int(service_ref['vcpus'])
         total_mem = int(service_ref['memory_mb'])
         total_hdd = int(service_ref['local_gb'])
 
-        instances_ref = db.instance_get_all_by_host(context, dest)
-        for i_ref in instances_ref:
+        instances_refs = db.instance_get_all_by_host(context, dest)
+        for i_ref in instances_refs:
             total_cpu -= int(i_ref['vcpus'])
             total_mem -= int(i_ref['memory_mb'])
             total_hdd -= int(i_ref['local_gb'])
 
         # Checking host has enough information
-        logging.debug('host(%s) remains vcpu:%s mem:%s hdd:%s,' %
+        logging.debug(_('host(%s) remains vcpu:%s mem:%s hdd:%s,') %
                       (dest, total_cpu, total_mem, total_hdd))
-        logging.debug('instance(%s) has vcpu:%s mem:%s hdd:%s,' %
+        logging.debug(_('instance(%s) has vcpu:%s mem:%s hdd:%s,') %
                       (ec2_id, vcpus, mem, hdd))
 
         if total_cpu <= vcpus or total_mem <= mem or total_hdd <= hdd:
-            msg = '%s doesnt have enough resource for %s' % (dest, ec2_id)
-            raise exception.NotEmpty(msg)
+            raise exception.NotEmpty(_('%s is not capable to migrate %s') %
+                                     (dest, ec2_id))
 
         logging.debug(_('%s has_enough_resource() for %s') % (dest, ec2_id))
diff --git a/nova/scheduler/manager.py b/nova/scheduler/manager.py
index 1cc767a03..a181225a6 100644
--- a/nova/scheduler/manager.py
+++ b/nova/scheduler/manager.py
@@ -73,17 +73,13 @@ class SchedulerManager(manager.Manager):
     #                    Based on bear design summit discussion,
     #                    just put this here for bexar release.
     def show_host_resource(self, context, host, *args):
-        """ show the physical/usage resource given by hosts."""
+        """show the physical/usage resource given by hosts."""
 
-        services = db.service_get_all_by_host(context, host)
-        if len(services) == 0:
-            return {'ret': False, 'msg': 'No such Host'}
-
-        compute = [s for s in services if s['topic'] == 'compute']
-        if 0 == len(compute):
-            service_ref = services[0]
-        else:
-            service_ref = compute[0]
+        computes = db.service_get_all_compute_sorted(context)
+        computes = [s for s,v in computes if s['host'] == host]
+        if 0 == len(computes):
+            return {'ret': False, 'msg': 'No such Host or not compute node.'}
+        service_ref = computes[0]
 
         # Getting physical resource information
         h_resource = {'vcpus': service_ref['vcpus'],
@@ -92,13 +88,15 @@ class SchedulerManager(manager.Manager):
 
         # Getting usage resource information
         u_resource = {}
-        instances_ref = db.instance_get_all_by_host(context,
-                                                    service_ref['host'])
+        instances_refs = db.instance_get_all_by_host(context,
+                                                     service_ref['host'])
 
-        if 0 == len(instances_ref):
-            return {'ret': True, 'phy_resource': h_resource, 'usage': {}}
+        if 0 == len(instances_refs):
+            return {'ret': True,
+                    'phy_resource': h_resource,
+                    'usage': u_resource}
 
-        project_ids = [i['project_id'] for i in instances_ref]
+        project_ids = [i['project_id'] for i in instances_refs]
         project_ids = list(set(project_ids))
         for p_id in project_ids:
             vcpus = db.instance_get_vcpu_sum_by_host_and_project(context,
diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index 09f6ee94a..344c2d2b5 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -20,6 +20,7 @@ Tests For Compute
 """
 
 import datetime
+import mox
 
 from nova import compute
 from nova import context
@@ -27,9 +28,12 @@ from nova import db
 from nova import exception
 from nova import flags
 from nova import log as logging
+from nova import rpc
 from nova import test
 from nova import utils
 from nova.auth import manager
+from nova.compute import manager as compute_manager
+from nova.compute import power_state
 
 
 LOG = logging.getLogger('nova.tests.compute')
@@ -219,3 +223,304 @@ class ComputeTestCase(test.TestCase):
         self.assertEqual(ret_val, None)
 
         self.compute.terminate_instance(self.context, instance_id)
+
+    def test_update_service_exception(self): 
+        """nova-compute updates Serivce table on DB like below.
+           nova.service.Serivce.start -> 
+               nova.compute.ComputeManager.update_service.
+           This testcase confirms if no record found on Service
+           table, exception can be raised.
+        """
+        host = 'foo'
+        binary = 'nova-compute'
+        dbmock = self.mox.CreateMock(db)
+        dbmock.service_get_by_args(mox.IgnoreArg(), 
+                                   mox.StrContains(host), 
+                                   mox.StrContains(binary)).\
+                                   AndRaise(exception.NotFound())
+        self.compute.db = dbmock
+        self.mox.ReplayAll()
+        try: 
+            self.compute.update_service('dummy', host, binary)
+        except exception.Invalid, e:
+            msg = 'Cannot insert compute manager specific info'
+            c1 = ( 0 <= e.message.find(msg))
+            self.assertTrue(c1)
+        self.mox.ResetAll()
+
+    def test_update_service_success(self): 
+        """nova-compute updates Serivce table on DB like below.
+           nova.service.Serivce.start ->
+               nova.compute.ComputeManager.update_service.
+           In this method, vcpus/memory_mb/local_gb/hypervisor_type/
+           hypervisor_version/cpu_info should be changed.
+           Based on this specification, this testcase confirms 
+           if this method finishes successfully,
+           meaning self.db.service_update is called with dictinary
+
+           {'vcpu':aaa, 'memory_mb':bbb, 'local_gb':ccc, 
+            'hypervisor_type':ddd, 'hypervisor_version':eee, 
+            'cpu_info':fff}
+
+           Since each value of above dict can be obtained through
+           driver(different depends on environment), 
+           only dictionary keys are checked.
+        """
+
+        def dic_key_check(dic): 
+            validkey = ['vcpus', 'memory_mb', 'local_gb', 
+                        'hypervisor_type', 'hypervisor_version', 'cpu_info']
+            return (list(set(validkey)) == list(set(dic.keys())))
+
+        host = 'foo'
+        binary = 'nova-compute'
+        service_ref = {'id':1, 'binary':'nova-compute', 'topic':'compute'} 
+        dbmock = self.mox.CreateMock(db)
+        dbmock.service_get_by_args(mox.IgnoreArg(), 
+                                   mox.StrContains(host), 
+                                   mox.StrContains(binary)).\
+                                   AndReturn(service_ref)
+        dbmock.service_update(mox.IgnoreArg(), 
+                              service_ref['id'], 
+                              mox.Func(dic_key_check))
+
+        self.compute.db = dbmock
+        self.mox.ReplayAll()
+        try: 
+            self.compute.update_service('dummy', host, binary)
+        except exception.Invalid, e:
+            msg = 'Cannot insert compute manager specific info'
+            c1 = ( 0 <= e.message.find(msg))
+            self.assertTrue(c1)
+        self.mox.ResetAll()
+
+    def _setup_other_managers(self):
+        self.volume_manager = utils.import_object(FLAGS.volume_manager)
+        self.network_manager = utils.import_object(FLAGS.network_manager)
+        self.compute_driver = utils.import_object(FLAGS.compute_driver)
+
+    def test_pre_live_migration_instance_has_no_fixed_ip(self): 
+        """
+           if instances that are intended to be migrated doesnt have fixed_ip
+           (not happens usually), pre_live_migration has to raise Exception.
+        """
+        instance_ref={'id':1, 'volumes':[{'id':1}, {'id':2}], 
+                      'hostname':'i-000000001'}
+        c = context.get_admin_context()
+        i_id = instance_ref['id']
+
+        dbmock = self.mox.CreateMock(db)
+        dbmock.instance_get(c, i_id).AndReturn(instance_ref)
+        dbmock.instance_get_fixed_address(c, i_id).AndReturn(None)
+
+        self.compute.db = dbmock
+        self.mox.ReplayAll()
+        self.assertRaises(exception.NotFound,
+                          self.compute.pre_live_migration,
+                          c, instance_ref['id'])
+        self.mox.ResetAll()
+
+    def test_pre_live_migration_instance_has_volume(self): 
+        """if any volumes are attached to the instances that are 
+           intended to be migrated, setup_compute_volume must be
+           called because aoe module should be inserted at destination
+           host. This testcase checks on it.
+        """
+        instance_ref={'id':1, 'volumes':[{'id':1}, {'id':2}], 
+                      'hostname':'i-000000001'}
+        c = context.get_admin_context()
+        i_id=instance_ref['id']
+
+        self._setup_other_managers()
+        dbmock = self.mox.CreateMock(db)
+        volmock = self.mox.CreateMock(self.volume_manager)
+        netmock = self.mox.CreateMock(self.network_manager)
+        drivermock = self.mox.CreateMock(self.compute_driver)
+
+        dbmock.instance_get(c, i_id).AndReturn(instance_ref)
+        dbmock.instance_get_fixed_address(c, i_id).AndReturn('dummy')
+        for i in range(len(instance_ref['volumes'])):
+            vid = instance_ref['volumes'][i]['id']
+            volmock.setup_compute_volume(c, vid).InAnyOrder('g1')
+        netmock.setup_compute_network(c, instance_ref['id'])
+        drivermock.ensure_filtering_rules_for_instance(instance_ref)
+                                     
+        self.compute.db = dbmock
+        self.compute.volume_manager = volmock
+        self.compute.network_manager = netmock
+        self.compute.driver = drivermock
+
+        self.mox.ReplayAll()
+        ret = self.compute.pre_live_migration(c, i_id)
+        self.assertEqual(ret, None)
+        self.mox.ResetAll()
+        
+    def test_pre_live_migration_instance_has_no_volume(self): 
+        """if any volumes are not attached to the instances that are 
+           intended to be migrated, log message should be appears
+           because administrator can proove instance conditions before
+           live_migration if any trouble occurs.
+        """
+        instance_ref={'id':1, 'volumes':[], 'hostname':'i-20000001'}
+        c = context.get_admin_context()
+        i_id = instance_ref['id']
+
+        self._setup_other_managers()
+        dbmock = self.mox.CreateMock(db)
+        netmock = self.mox.CreateMock(self.network_manager)
+        drivermock = self.mox.CreateMock(self.compute_driver)
+        
+        dbmock.instance_get(c, i_id).AndReturn(instance_ref)
+        dbmock.instance_get_fixed_address(c, i_id).AndReturn('dummy')
+        self.mox.StubOutWithMock(compute_manager.LOG, 'info')
+        compute_manager.LOG.info(_("%s has no volume."), instance_ref['hostname'])
+        netmock.setup_compute_network(c, i_id)
+        drivermock.ensure_filtering_rules_for_instance(instance_ref)
+                                     
+        self.compute.db = dbmock
+        self.compute.network_manager = netmock
+        self.compute.driver = drivermock
+
+        self.mox.ReplayAll()
+        ret = self.compute.pre_live_migration(c, i_id)
+        self.assertEqual(ret, None)
+        self.mox.ResetAll()
+
+    def test_live_migration_instance_has_volume(self): 
+        """Any volumes are mounted by instances to be migrated are found,
+           vblade health must be checked before starting live-migration.
+           And that is checked by check_for_export().
+           This testcase confirms check_for_export() is called. 
+        """
+        instance_ref={'id':1, 'volumes':[{'id':1}, {'id':2}], 'hostname':'i-00000001'}
+        c = context.get_admin_context()
+        dest='dummydest'
+        i_id = instance_ref['id']
+
+        self._setup_other_managers()
+        dbmock = self.mox.CreateMock(db)
+        drivermock = self.mox.CreateMock(self.compute_driver)
+
+        dbmock.instance_get(c, instance_ref['id']).AndReturn(instance_ref)
+        self.mox.StubOutWithMock(rpc, 'call')
+        rpc.call(c, FLAGS.volume_topic,
+                 {"method": "check_for_export",
+                  "args": {'instance_id': i_id}}).InAnyOrder('g1')
+        rpc.call(c, db.queue_get_for(c, FLAGS.compute_topic, dest),
+                 {"method": "pre_live_migration",
+                  "args": {'instance_id': i_id}}).InAnyOrder('g1')
+
+        self.compute.db = dbmock
+        self.compute.driver = drivermock
+        self.mox.ReplayAll()
+        ret = self.compute.live_migration(c, i_id, dest)
+        self.assertEqual(ret, None)
+        self.mox.ResetAll()
+
+    def test_live_migration_instance_has_volume_and_exception(self): 
+        """In addition to test_live_migration_instance_has_volume testcase, 
+           this testcase confirms if any exception raises from check_for_export().
+           Then, valid seaquence of this method should recovering instance/volumes
+           status(ex. instance['state_description'] is changed from 'migrating'
+           -> 'running', was changed by scheduler)
+        """
+        instance_ref={'id':1, 'volumes':[{'id':1}, {'id':2}], 
+                      'hostname':'i-000000001'}
+        dest='dummydest'
+        c = context.get_admin_context()
+        i_id = instance_ref['id']
+
+        self._setup_other_managers()
+        dbmock = self.mox.CreateMock(db)
+        drivermock = self.mox.CreateMock(self.compute_driver)
+
+        dbmock.instance_get(c, instance_ref['id']).AndReturn(instance_ref)
+        self.mox.StubOutWithMock(rpc, 'call')
+        rpc.call(c, FLAGS.volume_topic,
+                 {"method": "check_for_export",
+                  "args": {'instance_id': i_id}}).InAnyOrder('g1')
+        compute_topic = db.queue_get_for(c, FLAGS.compute_topic, dest)
+        dbmock.queue_get_for(c, FLAGS.compute_topic, dest).AndReturn(compute_topic)
+        rpc.call(c, db.queue_get_for(c, FLAGS.compute_topic, dest),
+                 {"method": "pre_live_migration",
+                  "args": {'instance_id': i_id}}).\
+                 InAnyOrder('g1').AndRaise(rpc.RemoteError('du', 'mm', 'y'))
+        self.mox.StubOutWithMock(compute_manager.LOG, 'error')
+        compute_manager.LOG.error('Pre live migration for %s failed at %s', 
+                                   instance_ref['hostname'], dest)
+        dbmock.instance_set_state(c, i_id, power_state.RUNNING, 'running')
+        for i in range(len(instance_ref['volumes'])):
+            vid = instance_ref['volumes'][i]['id']
+            dbmock.volume_update(c, vid, {'status': 'in-use'})
+
+        self.compute.db = dbmock
+        self.compute.driver = drivermock
+        self.mox.ReplayAll()
+        self.assertRaises(rpc.RemoteError, 
+                          self.compute.live_migration,
+                          c, i_id, dest)
+        self.mox.ResetAll()
+
+    def test_live_migration_instance_has_no_volume_and_exception(self): 
+        """Simpler than test_live_migration_instance_has_volume_and_exception"""
+
+        instance_ref={'id':1, 'volumes':[], 'hostname':'i-000000001'}
+        dest='dummydest'
+        c = context.get_admin_context()
+        i_id = instance_ref['id']
+
+        self._setup_other_managers()
+        dbmock = self.mox.CreateMock(db)
+        drivermock = self.mox.CreateMock(self.compute_driver)
+
+        dbmock.instance_get(c, instance_ref['id']).AndReturn(instance_ref)
+        self.mox.StubOutWithMock(rpc, 'call')
+        compute_topic = db.queue_get_for(c, FLAGS.compute_topic, dest)
+        dbmock.queue_get_for(c, FLAGS.compute_topic, dest).AndReturn(compute_topic)
+        rpc.call(c, compute_topic,
+                 {"method": "pre_live_migration",
+                  "args": {'instance_id': i_id}}).\
+                 AndRaise(rpc.RemoteError('du', 'mm', 'y'))
+        self.mox.StubOutWithMock(compute_manager.LOG, 'error')
+        compute_manager.LOG.error('Pre live migration for %s failed at %s', 
+                                   instance_ref['hostname'], dest)
+        dbmock.instance_set_state(c, i_id, power_state.RUNNING, 'running')
+
+        self.compute.db = dbmock
+        self.compute.driver = drivermock
+        self.mox.ReplayAll()
+        self.assertRaises(rpc.RemoteError, 
+                          self.compute.live_migration,
+                          c, i_id, dest)
+        self.mox.ResetAll()
+
+    def test_live_migration_instance_has_volume(self): 
+        """Simpler version than test_live_migration_instance_has_volume."""
+        instance_ref={'id':1, 'volumes':[{'id':1}, {'id':2}], 
+                      'hostname':'i-000000001'}
+        c = context.get_admin_context()
+        dest='dummydest'
+        i_id = instance_ref['id']
+
+        self._setup_other_managers()
+        dbmock = self.mox.CreateMock(db)
+        drivermock = self.mox.CreateMock(self.compute_driver)
+
+        dbmock.instance_get(c, i_id).AndReturn(instance_ref)
+        self.mox.StubOutWithMock(rpc, 'call')
+        rpc.call(c, FLAGS.volume_topic,
+                 {"method": "check_for_export",
+                  "args": {'instance_id': i_id}}).InAnyOrder('g1')
+        compute_topic = db.queue_get_for(c, FLAGS.compute_topic, dest)
+        dbmock.queue_get_for(c, FLAGS.compute_topic, dest).AndReturn(compute_topic)
+        rpc.call(c, compute_topic,
+                 {"method": "pre_live_migration",
+                  "args": {'instance_id': i_id}}).InAnyOrder('g1')
+        drivermock.live_migration(c, instance_ref, dest)
+
+        self.compute.db = dbmock
+        self.compute.driver = drivermock
+        self.mox.ReplayAll()
+        ret = self.compute.live_migration(c, i_id, dest)
+        self.assertEqual(ret, None)
+        self.mox.ResetAll()
diff --git a/nova/tests/test_scheduler.py b/nova/tests/test_scheduler.py
index 9d458244b..c62bca9b1 100644
--- a/nova/tests/test_scheduler.py
+++ b/nova/tests/test_scheduler.py
@@ -20,10 +20,12 @@ Tests For Scheduler
 """
 
 import datetime
+import mox
 
 from mox import IgnoreArg
 from nova import context
 from nova import db
+from nova import exception
 from nova import flags
 from nova import service
 from nova import test
@@ -32,6 +34,8 @@ from nova import utils
 from nova.auth import manager as auth_manager
 from nova.scheduler import manager
 from nova.scheduler import driver
+from nova.compute import power_state
+from nova.db.sqlalchemy import models
 
 
 FLAGS = flags.FLAGS
@@ -75,7 +79,102 @@ class SchedulerTestCase(test.TestCase):
                   'args': {'num': 7}})
         self.mox.ReplayAll()
         scheduler.named_method(ctxt, 'topic', num=7)
+         
+    def test_show_host_resource_host_not_exit(self):
+        """
+        A testcase of driver.has_enough_resource 
+        given host does not exists.
+        """
+        scheduler = manager.SchedulerManager()
+        dest = 'dummydest'
+        ctxt = context.get_admin_context()
+
+        self.mox.StubOutWithMock(manager, 'db', use_mock_anything=True)
+        manager.db.service_get_all_compute_sorted(mox.IgnoreArg()).\
+                                      AndReturn([])
+
+        self.mox.ReplayAll()
+        result =  scheduler.show_host_resource(ctxt, dest)
+        # ret should be dict
+        keys = ['ret', 'msg']
+        c1 = list(set(result.keys())) == list(set(keys))
+        c2 = not result['ret']
+        c3 = result['msg'].find('No such Host or not compute node') <= 0
+        self.assertTrue( c1 and c2 and c3)
+        self.mox.UnsetStubs()
+
+    def test_show_host_resource_no_project(self):
+        """
+        A testcase of driver.show_host_resource 
+        no instance stays on the given host
+        """
+        scheduler = manager.SchedulerManager()
+        dest = 'dummydest'
+        ctxt = context.get_admin_context()
+        r0 = {'vcpus':16, 'memory_mb':32, 'local_gb':100}
+        service_ref = {'id':1, 'host':dest}
+        service_ref.update(r0)
+
+        self.mox.StubOutWithMock(manager, 'db', use_mock_anything=True)
+        manager.db.service_get_all_compute_sorted(mox.IgnoreArg()).\
+                                      AndReturn([(service_ref, 0)])
+        manager.db.instance_get_all_by_host(mox.IgnoreArg(), dest).\
+                                      AndReturn([])
+        
+        self.mox.ReplayAll()
+        result =  scheduler.show_host_resource(ctxt, dest)
+        # ret should be dict
+        keys = ['ret', 'phy_resource', 'usage']
+        c1 = list(set(result.keys())) == list(set(keys))
+        c2 = result['ret']
+        c3 = result['phy_resource'] == r0
+        c4 = result['usage'] == {}
+        self.assertTrue( c1 and c2 and c3 and c4)
+        self.mox.UnsetStubs()
+
+    def test_show_host_resource_works_correctly(self):
+        """
+        A testcase of driver.show_host_resource 
+        to make sure everything finished with no error.
+        """
+        scheduler = manager.SchedulerManager()
+        dest = 'dummydest'
+        ctxt = context.get_admin_context()
+        r0 = {'vcpus':16, 'memory_mb':32, 'local_gb':100}
+        r1 = {'vcpus':10, 'memory_mb':4, 'local_gb':20}
+        r2 = {'vcpus':10, 'memory_mb':20, 'local_gb':30}
+        service_ref = {'id':1, 'host':dest}
+        service_ref.update(r0)
+        instance_ref2 = {'id':2, 'project_id':'p-01', 'host':'dummy'}
+        instance_ref2.update(r1)
+        instance_ref3 = {'id':3, 'project_id':'p-02', 'host':'dummy'}
+        instance_ref3.update(r1)
 
+        self.mox.StubOutWithMock(manager, 'db', use_mock_anything=True)
+        manager.db.service_get_all_compute_sorted(mox.IgnoreArg()).\
+                                      AndReturn([(service_ref, 0)])
+        manager.db.instance_get_all_by_host(mox.IgnoreArg(), dest).\
+                          AndReturn([instance_ref2, instance_ref3])
+        for p in ['p-01', 'p-02']:
+            manager.db.instance_get_vcpu_sum_by_host_and_project(
+                                ctxt, dest, p).AndReturn(r2['vcpus'])
+            manager.db.instance_get_memory_sum_by_host_and_project(
+                            ctxt, dest, p).AndReturn(r2['memory_mb'])
+            manager.db.instance_get_disk_sum_by_host_and_project(
+                            ctxt, dest, p).AndReturn(r2['local_gb'])
+        
+        self.mox.ReplayAll()
+        result =  scheduler.show_host_resource(ctxt, dest)
+        # ret should be dict
+        keys = ['ret', 'phy_resource', 'usage']
+        c1 = list(set(result.keys())) == list(set(keys))
+        c2 = result['ret']
+        c3 = result['phy_resource'] == r0
+        c4 = result['usage'].keys() == ['p-01', 'p-02']
+        c5 = result['usage']['p-01'] == r2
+        c6 = result['usage']['p-02'] == r2
+        self.assertTrue( c1 and c2 and c3 and c4 and c5 and c6)
+        self.mox.UnsetStubs()
 
 class ZoneSchedulerTestCase(test.TestCase):
     """Test case for zone scheduler"""
@@ -384,3 +483,626 @@ class SimpleDriverTestCase(test.TestCase):
             volume2.delete_volume(self.context, volume_id)
         volume1.kill()
         volume2.kill()
+
+    def test_scheduler_live_migraiton_with_volume(self):
+        """
+        driver.scheduler_live_migration finishes successfully
+        (volumes are attached to instances)
+        This testcase make sure schedule_live_migration
+        changes instance state from 'running' -> 'migrating'
+        """
+        driver_i = self.scheduler.driver
+        ctxt = context.get_admin_context()
+        topic = FLAGS.compute_topic
+        i_ref = {'id':1, 'hostname':'i-00000001', 'host':'dummy',
+                       'volumes':[{'id':1}, {'id':2}]}
+        dest = 'dummydest'
+
+        self.mox.StubOutWithMock(driver, 'db', use_mock_anything=True)
+        # must be IgnoreArg() because scheduler changes ctxt's memory address
+        driver.db.instance_get(mox.IgnoreArg(), i_ref['id']).AndReturn(i_ref)
+
+        self.mox.StubOutWithMock(driver_i, '_live_migration_src_check')
+        driver_i._live_migration_src_check(mox.IgnoreArg(), i_ref)
+        self.mox.StubOutWithMock(driver_i, '_live_migration_dest_check')
+        driver_i._live_migration_dest_check(mox.IgnoreArg(), i_ref, dest)
+        self.mox.StubOutWithMock(driver_i, '_live_migration_common_check')
+        driver_i._live_migration_common_check(mox.IgnoreArg(), i_ref, dest)
+        driver.db.instance_set_state(mox.IgnoreArg(), i_ref['id'],
+                                     power_state.PAUSED, 'migrating')
+        for v in i_ref['volumes']:
+            driver.db.volume_update(mox.IgnoreArg(), v['id'],
+                                   {'status': 'migrating'})
+        self.mox.StubOutWithMock(rpc, 'cast', use_mock_anything=True)
+        kwargs={'instance_id':i_ref['id'], 'dest':dest}
+        rpc.cast(ctxt, db.queue_get_for(ctxt, topic, i_ref['host']),
+                 {"method": 'live_migration', 
+                 "args": kwargs})
+
+        self.mox.ReplayAll()
+        self.scheduler.live_migration(ctxt, topic,
+                                      instance_id=i_ref['id'], dest=dest)
+        self.mox.UnsetStubs()
+
+    def test_scheduler_live_migraiton_no_volume(self):
+        """
+        driver.scheduler_live_migration finishes successfully
+        (volumes are attached to instances)
+        This testcase make sure schedule_live_migration
+        changes instance state from 'running' -> 'migrating'
+        """
+        driver_i = self.scheduler.driver
+        ctxt = context.get_admin_context()
+        topic = FLAGS.compute_topic
+        i_ref = {'id':1, 'hostname':'i-01', 'host':'dummy', 'volumes':[]}
+        dest = 'dummydest'
+
+        self.mox.StubOutWithMock(driver, 'db', use_mock_anything=True)
+        # must be IgnoreArg() because scheduler changes ctxt's memory address
+        driver.db.instance_get(mox.IgnoreArg(), i_ref['id']).AndReturn(i_ref)
+        self.mox.StubOutWithMock(driver_i, '_live_migration_src_check')
+        driver_i._live_migration_src_check(mox.IgnoreArg(), i_ref)
+        self.mox.StubOutWithMock(driver_i, '_live_migration_dest_check')
+        driver_i._live_migration_dest_check(mox.IgnoreArg(), i_ref, dest)
+        self.mox.StubOutWithMock(driver_i, '_live_migration_common_check')
+        driver_i._live_migration_common_check(mox.IgnoreArg(), i_ref, dest)
+        driver.db.instance_set_state(mox.IgnoreArg(), i_ref['id'],
+                                     power_state.PAUSED, 'migrating')
+        self.mox.StubOutWithMock(rpc, 'cast', use_mock_anything=True)
+        kwargs={'instance_id':i_ref['id'], 'dest':dest}
+        rpc.cast(ctxt, db.queue_get_for(ctxt, topic, i_ref['host']),
+                 {"method": 'live_migration', 
+                 "args": kwargs})
+
+        self.mox.ReplayAll()
+        self.scheduler.live_migration(ctxt, topic,
+                                 instance_id=i_ref['id'], dest=dest)
+        self.mox.UnsetStubs()
+
+    def test_live_migraiton_src_check_instance_not_running(self):
+        """
+        A testcase of driver._live_migration_src_check. 
+        The instance given by instance_id is not running.
+        """
+        ctxt = context.get_admin_context()
+        topic = FLAGS.compute_topic
+        dest = 'dummydest'
+        i_ref = {'id':1, 'hostname':'i-01', 'host':'dummy',
+                        'volumes':[], 'state_description':'migrating',
+                        'state':power_state.RUNNING}
+
+        self.mox.ReplayAll()
+        try:
+            self.scheduler.driver._live_migration_src_check(ctxt, i_ref)
+        except exception.Invalid, e:
+            self.assertTrue(e.message.find('is not running') > 0)
+        self.mox.UnsetStubs()
+
+    def test_live_migraiton_src_check_volume_node_not_alive(self):
+        """
+        A testcase of driver._live_migration_src_check. 
+        Volume node is not alive if any volumes are attached to 
+        the given instance.
+        """
+        dest = 'dummydest'
+        ctxt = context.get_admin_context()
+        topic = FLAGS.compute_topic
+        i_ref = {'id':1, 'hostname':'i-01', 'host':'dummy',
+                 'volumes':[{'id':1}, {'id':2}], 
+                 'state_description':'running', 'state':power_state.RUNNING}
+
+        self.mox.StubOutWithMock(driver, 'db', use_mock_anything=True)
+        driver.db.service_get_all_by_topic(mox.IgnoreArg(), 'volume').\
+                                           AndReturn([])
+        
+        self.mox.ReplayAll()
+        try:
+            self.scheduler.driver._live_migration_src_check(ctxt, i_ref)
+        except exception.Invalid, e:
+            self.assertTrue(e.message.find('volume node is not alive') >= 0)
+        self.mox.UnsetStubs()
+
+    def test_live_migraiton_src_check_volume_node_not_alive(self):
+        """
+        A testcase of driver._live_migration_src_check. 
+        The testcase make sure src-compute node is alive.
+        """
+        dest = 'dummydest'
+        ctxt = context.get_admin_context()
+        topic = FLAGS.compute_topic
+        i_ref = {'id':1, 'hostname':'i-01', 'host':'dummy', 'volumes':[], 
+                 'state_description':'running', 'state':power_state.RUNNING}
+
+        self.mox.StubOutWithMock(driver, 'db', use_mock_anything=True)
+        driver.db.service_get_all_by_topic(mox.IgnoreArg(), 'compute').\
+                                           AndReturn([])
+        
+        self.mox.ReplayAll()
+        try:
+            self.scheduler.driver._live_migration_src_check(ctxt, i_ref)
+        except exception.Invalid, e:
+            self.assertTrue(e.message.find('is not alive') >= 0)
+        self.mox.UnsetStubs()
+
+    def test_live_migraiton_src_check_works_correctly(self):
+        """
+        A testcase of driver._live_migration_src_check. 
+        The testcase make sure everything finished with no error.
+        """
+        driver_i = self.scheduler.driver
+        dest = 'dummydest'
+        ctxt = context.get_admin_context()
+        topic = FLAGS.compute_topic
+        i_ref = {'id':1, 'hostname':'i-01', 'host':'dummy', 'volumes':[],
+                 'state_description':'running', 'state':power_state.RUNNING}
+        service_ref = models.Service()
+        service_ref.__setitem__('id', 1)
+        service_ref.__setitem__('host', i_ref['host'])
+
+        self.mox.StubOutWithMock(driver, 'db', use_mock_anything=True)
+        driver.db.service_get_all_by_topic(mox.IgnoreArg(), 'compute').\
+                                           AndReturn([service_ref])
+        self.mox.StubOutWithMock(driver_i, 'service_is_up')
+        driver_i.service_is_up(service_ref).AndReturn(True)
+        
+        self.mox.ReplayAll()
+        ret = driver_i._live_migration_src_check(ctxt, i_ref)
+        self.assertTrue(ret == None)
+        self.mox.UnsetStubs()
+
+    def test_live_migraiton_dest_check_service_not_exists(self):
+        """
+        A testcase of driver._live_migration_dst_check. 
+        Destination host does not exist.
+        """
+        driver_i = self.scheduler.driver
+        dest = 'dummydest'
+        ctxt = context.get_admin_context()
+        topic = FLAGS.compute_topic
+        i_ref = {'id':1, 'hostname':'i-01', 'host':'dummy'}
+        service_ref = models.Service()
+        service_ref.__setitem__('id', 1)
+        service_ref.__setitem__('host', i_ref['host'])
+
+        self.mox.StubOutWithMock(driver, 'db', use_mock_anything=True)
+        driver.db.service_get_all_by_host(mox.IgnoreArg(), dest).\
+                                           AndReturn([])
+        
+        self.mox.ReplayAll()
+        try:
+            driver_i._live_migration_dest_check(ctxt, i_ref, dest)
+        except exception.Invalid, e:
+            self.assertTrue(e.message.find('does not exists') >= 0)
+        self.mox.UnsetStubs()
+
+    def test_live_migraiton_dest_check_service_isnot_compute(self):
+        """
+        A testcase of driver._live_migration_dst_check. 
+        Destination host does not provide compute.
+        """
+        driver_i = self.scheduler.driver
+        dest = 'dummydest'
+        ctxt = context.get_admin_context()
+        topic = FLAGS.compute_topic
+        i_ref = {'id':1, 'hostname':'i-01', 'host':'dummy'}
+        service_ref = models.Service()
+        service_ref.__setitem__('id', 1)
+        service_ref.__setitem__('host', i_ref['host'])
+        service_ref.__setitem__('topic', 'api')
+
+        self.mox.StubOutWithMock(driver, 'db', use_mock_anything=True)
+        driver.db.service_get_all_by_host(mox.IgnoreArg(), dest).\
+                                           AndReturn([service_ref])
+        
+        self.mox.ReplayAll()
+        try:
+            driver_i._live_migration_dest_check(ctxt, i_ref, dest)
+        except exception.Invalid, e:
+            self.assertTrue(e.message.find('must be compute node') >= 0)
+        self.mox.UnsetStubs()
+
+    def test_live_migraiton_dest_check_service_not_alive(self):
+        """
+        A testcase of driver._live_migration_dst_check. 
+        Destination host compute service is not alive.
+        """
+        dest = 'dummydest'
+        ctxt = context.get_admin_context()
+        topic = FLAGS.compute_topic
+        i_ref = {'id':1, 'hostname':'i-01', 'host':'dummy'}
+        service_ref = models.Service()
+        service_ref.__setitem__('id', 1)
+        service_ref.__setitem__('host', i_ref['host'])
+        service_ref.__setitem__('topic', 'compute')
+
+        self.mox.StubOutWithMock(driver, 'db', use_mock_anything=True)
+        driver.db.service_get_all_by_host(mox.IgnoreArg(), dest).\
+                                           AndReturn([service_ref])
+        self.mox.StubOutWithMock(self.scheduler.driver, 'service_is_up')
+        self.scheduler.driver.service_is_up(service_ref).AndReturn(False)
+        
+        self.mox.ReplayAll()
+        try:
+            self.scheduler.driver._live_migration_dest_check(ctxt, i_ref, dest)
+        except exception.Invalid, e:
+            self.assertTrue(e.message.find('is not alive') >= 0)
+        self.mox.UnsetStubs()
+
+    def test_live_migraiton_dest_check_service_same_host(self):
+        """
+        A testcase of driver._live_migration_dst_check. 
+        Destination host is same as src host.
+        """
+        dest = 'dummydest'
+        ctxt = context.get_admin_context()
+        topic = FLAGS.compute_topic
+        i_ref = {'id':1, 'hostname':'i-01', 'host':'dummydest'}
+        service_ref = models.Service()
+        service_ref.__setitem__('id', 1)
+        service_ref.__setitem__('host', i_ref['host'])
+        service_ref.__setitem__('topic', 'compute')
+
+        self.mox.StubOutWithMock(driver, 'db', use_mock_anything=True)
+        driver.db.service_get_all_by_host(mox.IgnoreArg(), dest).\
+                                           AndReturn([service_ref])
+        self.mox.StubOutWithMock(self.scheduler.driver, 'service_is_up')
+        self.scheduler.driver.service_is_up(service_ref).AndReturn(True)
+        
+        self.mox.ReplayAll()
+        try:
+            self.scheduler.driver._live_migration_dest_check(ctxt, i_ref, dest)
+        except exception.Invalid, e:
+            self.assertTrue(e.message.find('is running now. choose other host') >= 0)
+        self.mox.UnsetStubs()
+
+    def test_live_migraiton_dest_check_service_works_correctly(self):
+        """
+        A testcase of driver._live_migration_dst_check. 
+        The testcase make sure everything finished with no error.
+        """
+        dest = 'dummydest'
+        ctxt = context.get_admin_context()
+        topic = FLAGS.compute_topic
+        i_ref = {'id':1, 'hostname':'i-01', 'host':'dummydest'}
+        service_ref = models.Service()
+        service_ref.__setitem__('id', 1)
+        service_ref.__setitem__('host', i_ref['host'])
+        service_ref.__setitem__('topic', 'compute')
+
+        self.mox.StubOutWithMock(driver, 'db', use_mock_anything=True)
+        driver.db.service_get_all_by_host(mox.IgnoreArg(), dest).\
+                                           AndReturn([service_ref])
+        self.mox.StubOutWithMock(self.scheduler.driver, 'service_is_up')
+        self.scheduler.driver.service_is_up(service_ref).AndReturn(True)
+        self.mox.StubOutWithMock(self.scheduler.driver, 'has_enough_resource')
+        self.scheduler.driver.has_enough_resource(mox.IgnoreArg(), i_ref, dest)
+        
+        self.mox.ReplayAll()
+        try:
+            self.scheduler.driver._live_migration_dest_check(ctxt, i_ref, dest)
+        except exception.Invalid, e:
+            self.assertTrue(e.message.find('is running now. choose other host') >= 0)
+        self.mox.UnsetStubs()
+
+    def test_live_migraiton_common_check_service_dest_not_exists(self):
+        """
+        A testcase of driver._live_migration_common_check. 
+        Destination host does not exist.
+        """
+        dest = 'dummydest'
+        ctxt = context.get_admin_context()
+        topic = FLAGS.compute_topic
+        i_ref = {'id':1, 'hostname':'i-01', 'host':'dummy'}
+
+        self.mox.StubOutWithMock(driver, 'db', use_mock_anything=True)
+        driver.db.service_get_all_by_host(mox.IgnoreArg(), dest).\
+                                           AndReturn([])
+        
+        self.mox.ReplayAll()
+        try:
+            self.scheduler.driver._live_migration_common_check(ctxt,
+                                                               i_ref,
+                                                               dest)
+        except exception.Invalid, e:
+            self.assertTrue(e.message.find('does not exists') >= 0)
+        self.mox.UnsetStubs()
+
+    def test_live_migraiton_common_check_service_orig_not_exists(self):
+        """
+        A testcase of driver._live_migration_common_check. 
+        Original host(an instance launched on) does not exist.
+        """
+        dest = 'dummydest'
+        ctxt = context.get_admin_context()
+        topic = FLAGS.compute_topic
+        i_ref = {'id':1, 'hostname':'i-01', 'host':'dummy', 'launched_on':'h1'}
+        service_ref = models.Service()
+        service_ref.__setitem__('id', 1)
+        service_ref.__setitem__('topic', 'compute')
+        service_ref.__setitem__('host', i_ref['host'])
+
+        self.mox.StubOutWithMock(driver, 'db', use_mock_anything=True)
+        driver.db.service_get_all_by_host(mox.IgnoreArg(), dest).\
+                                           AndReturn([service_ref])
+        driver.db.service_get_all_by_host(mox.IgnoreArg(),
+                                          i_ref['launched_on']).\
+                                          AndReturn([])
+        
+        self.mox.ReplayAll()
+        try:
+            self.scheduler.driver._live_migration_common_check(ctxt,
+                                                               i_ref,
+                                                               dest)
+        except exception.Invalid, e:
+            msg = 'where instance was launched at) does not exists'
+            self.assertTrue(e.message.find(msg) >= 0)
+        self.mox.UnsetStubs()
+
+    def test_live_migraiton_common_check_service_different_hypervisor(self):
+        """
+        A testcase of driver._live_migration_common_check. 
+        Original host and dest host has different hypervisor type.
+        """
+        dest = 'dummydest'
+        ctxt = context.get_admin_context()
+        topic = FLAGS.compute_topic
+        i_ref = {'id':1, 'hostname':'i-01',
+                        'host':'dummy', 'launched_on':'h1'}
+        service_ref = models.Service()
+        service_ref.__setitem__('id', 1)
+        service_ref.__setitem__('topic', 'compute')
+        service_ref.__setitem__('hypervisor_type', 'kvm')
+        service_ref2 = models.Service()
+        service_ref2.__setitem__('id', 2)
+        service_ref2.__setitem__('hypervisor_type', 'xen')
+
+        self.mox.StubOutWithMock(driver, 'db', use_mock_anything=True)
+        driver.db.service_get_all_by_host(mox.IgnoreArg(), dest).\
+                                           AndReturn([service_ref])
+        driver.db.service_get_all_by_host(mox.IgnoreArg(),
+                                          i_ref['launched_on']).\
+                                          AndReturn([service_ref2])
+        
+        self.mox.ReplayAll()
+        try:
+            self.scheduler.driver._live_migration_common_check(ctxt,
+                                                               i_ref,
+                                                               dest)
+        except exception.Invalid, e:
+            msg = 'Different hypervisor type'
+            self.assertTrue(e.message.find(msg) >= 0)
+        self.mox.UnsetStubs()
+
+    def test_live_migraiton_common_check_service_different_version(self):
+        """
+        A testcase of driver._live_migration_common_check. 
+        Original host and dest host has different hypervisor version.
+        """
+        dest = 'dummydest'
+        ctxt = context.get_admin_context()
+        topic = FLAGS.compute_topic
+        i_ref = {'id':1, 'hostname':'i-01',
+                        'host':'dummy', 'launched_on':'h1'}
+        service_ref = models.Service()
+        service_ref.__setitem__('id', 1)
+        service_ref.__setitem__('topic', 'compute')
+        service_ref.__setitem__('hypervisor_version', 12000)
+        service_ref2 = models.Service()
+        service_ref2.__setitem__('id', 2)
+        service_ref2.__setitem__('hypervisor_version', 12001)
+
+        self.mox.StubOutWithMock(driver, 'db', use_mock_anything=True)
+        driver.db.service_get_all_by_host(mox.IgnoreArg(), dest).\
+                                           AndReturn([service_ref])
+        driver.db.service_get_all_by_host(mox.IgnoreArg(),
+                                          i_ref['launched_on']).\
+                                          AndReturn([service_ref2])
+        
+        self.mox.ReplayAll()
+        try:
+            self.scheduler.driver._live_migration_common_check(ctxt,
+                                                               i_ref,
+                                                               dest)
+        except exception.Invalid, e:
+            msg = 'Older hypervisor version'
+            self.assertTrue(e.message.find(msg) >= 0)
+        self.mox.UnsetStubs()
+
+    def test_live_migraiton_common_check_service_checking_cpuinfo_fail(self):
+        """
+        A testcase of driver._live_migration_common_check. 
+        Original host and dest host has different hypervisor version.
+        """
+        dest = 'dummydest'
+        ctxt = context.get_admin_context()
+        topic = FLAGS.compute_topic
+        i_ref = {'id':1, 'hostname':'i-01',
+                 'host':'dummy', 'launched_on':'h1'}
+        service_ref = models.Service()
+        service_ref.__setitem__('id', 1)
+        service_ref.__setitem__('topic', 'compute')
+        service_ref.__setitem__('hypervisor_version', 12000)
+        service_ref2 = models.Service()
+        service_ref2.__setitem__('id', 2)
+        service_ref2.__setitem__('hypervisor_version', 12000)
+        service_ref2.__setitem__('cpuinfo', '<cpu>info</cpu>')
+
+        self.mox.StubOutWithMock(driver, 'db', use_mock_anything=True)
+        driver.db.service_get_all_by_host(mox.IgnoreArg(), dest).\
+                                           AndReturn([service_ref])
+        driver.db.service_get_all_by_host(mox.IgnoreArg(),
+                                          i_ref['launched_on']).\
+                                          AndReturn([service_ref2])
+        driver.db.queue_get_for(mox.IgnoreArg(), FLAGS.compute_topic, dest)
+        self.mox.StubOutWithMock(driver, 'rpc', use_mock_anything=True)
+        driver.rpc.call(mox.IgnoreArg(), mox.IgnoreArg(),
+            {"method": 'compare_cpu',
+            "args": {'cpu_info': service_ref2['cpu_info']}}).\
+             AndRaise(rpc.RemoteError('doesnt have compatibility to', '', ''))
+        
+        self.mox.ReplayAll()
+        try:
+            self.scheduler.driver._live_migration_common_check(ctxt,
+                                                               i_ref,
+                                                               dest)
+        except rpc.RemoteError, e:
+            msg = 'doesnt have compatibility to'
+            self.assertTrue(e.message.find(msg) >= 0)
+        self.mox.UnsetStubs()
+
+    def test_live_migraiton_common_check_service_works_correctly(self):
+        """
+        A testcase of driver._live_migration_common_check. 
+        The testcase make sure everything finished with no error.
+        """
+        dest = 'dummydest'
+        ctxt = context.get_admin_context()
+        topic = FLAGS.compute_topic
+        i_ref = {'id':1, 'hostname':'i-01',
+                 'host':'dummy', 'launched_on':'h1'}
+        service_ref = models.Service()
+        service_ref.__setitem__('id', 1)
+        service_ref.__setitem__('topic', 'compute')
+        service_ref.__setitem__('hypervisor_version', 12000)
+        service_ref2 = models.Service()
+        service_ref2.__setitem__('id', 2)
+        service_ref2.__setitem__('hypervisor_version', 12000)
+        service_ref2.__setitem__('cpuinfo', '<cpu>info</cpu>')
+
+        self.mox.StubOutWithMock(driver, 'db', use_mock_anything=True)
+        driver.db.service_get_all_by_host(mox.IgnoreArg(), dest).\
+                                           AndReturn([service_ref])
+        driver.db.service_get_all_by_host(mox.IgnoreArg(),
+                                          i_ref['launched_on']).\
+                                          AndReturn([service_ref2])
+        driver.db.queue_get_for(mox.IgnoreArg(), FLAGS.compute_topic, dest)
+        self.mox.StubOutWithMock(driver, 'rpc', use_mock_anything=True)
+        driver.rpc.call(mox.IgnoreArg(), mox.IgnoreArg(),
+            {"method": 'compare_cpu',
+            "args": {'cpu_info': service_ref2['cpu_info']}})
+        
+        self.mox.ReplayAll()
+        ret = self.scheduler.driver._live_migration_common_check(ctxt,
+                                                                 i_ref,
+                                                                 dest)
+        self.assertTrue(ret == None)
+        self.mox.UnsetStubs()
+
+    def test_has_enough_resource_lack_resource_vcpu(self):
+        """
+        A testcase of driver.has_enough_resource. 
+        Lack of vcpu.(boundary check)
+        """
+        dest = 'dummydest'
+        ctxt = context.get_admin_context()
+        topic = FLAGS.compute_topic
+        service_ref = {'id':1, 'vcpus':16, 'memory_mb':32, 'local_gb':100}
+        i_ref1    = {'id':1, 'hostname':'i-01', 'host':'dummy', 
+                    'vcpus':6, 'memory_mb':8, 'local_gb':10}
+        i_ref2 = {'id':2, 'hostname':'i-01', 'host':'dummy', 
+                    'vcpus':5, 'memory_mb':8, 'local_gb':10}
+        i_ref3 = {'id':3, 'hostname':'i-02', 'host':'dummy', 
+                    'vcpus':5, 'memory_mb':8, 'local_gb':10}
+
+        self.mox.StubOutWithMock(driver, 'db', use_mock_anything=True)
+        driver.db.service_get_all_by_host(mox.IgnoreArg(), dest).\
+                                           AndReturn([service_ref])
+        driver.db.instance_get_all_by_host(mox.IgnoreArg(), dest).\
+                      AndReturn([i_ref2, i_ref3])
+        
+        self.mox.ReplayAll()
+        try:
+            self.scheduler.driver.has_enough_resource(ctxt, i_ref1, dest)
+        except exception.NotEmpty, e:
+            msg = 'is not capable to migrate'
+            self.assertTrue(e.message.find(msg) >= 0)
+        self.mox.UnsetStubs()
+
+    def test_has_enough_resource_lack_resource_memory(self):
+        """
+        A testcase of driver.has_enough_resource. 
+        Lack of memory_mb.(boundary check)
+        """
+        dest = 'dummydest'
+        ctxt = context.get_admin_context()
+        topic = FLAGS.compute_topic
+        service_ref = {'id':1, 'vcpus':16, 'memory_mb':32, 'local_gb':100}
+        i_ref1 = {'id':1, 'hostname':'i-01', 'host':'dummy', 
+                     'vcpus':5, 'memory_mb':16, 'local_gb':10}
+        i_ref2 = {'id':2, 'hostname':'i-01', 'host':'dummy', 
+                  'vcpus':5, 'memory_mb':8, 'local_gb':10}
+        i_ref3 = {'id':3, 'hostname':'i-02', 'host':'dummy', 
+                  'vcpus':5, 'memory_mb':8, 'local_gb':10}
+
+        self.mox.StubOutWithMock(driver, 'db', use_mock_anything=True)
+        driver.db.service_get_all_by_host(mox.IgnoreArg(), dest).\
+                                           AndReturn([service_ref])
+        driver.db.instance_get_all_by_host(mox.IgnoreArg(), dest).\
+                      AndReturn([i_ref2, i_ref3])
+        
+        self.mox.ReplayAll()
+        try:
+            self.scheduler.driver.has_enough_resource(ctxt, i_ref1, dest)
+        except exception.NotEmpty, e:
+            msg = 'is not capable to migrate'
+            self.assertTrue(e.message.find(msg) >= 0)
+        self.mox.UnsetStubs()
+        self.mox.UnsetStubs()
+
+    def test_has_enough_resource_lack_resource_disk(self):
+        """
+        A testcase of driver.has_enough_resource. 
+        Lack of local_gb.(boundary check)
+        """
+        scheduler = manager.SchedulerManager()
+        dest = 'dummydest'
+        ctxt = context.get_admin_context()
+        topic = FLAGS.compute_topic
+        service_ref = {'id':1, 'vcpus':16, 'memory_mb':32, 'local_gb':100}
+        i_ref1 = {'id':1, 'hostname':'i-01', 'host':'dummy', 
+                  'vcpus':5, 'memory_mb':8, 'local_gb':80}
+        i_ref2 = {'id':2, 'hostname':'i-01', 'host':'dummy', 
+                  'vcpus':5, 'memory_mb':8, 'local_gb':10}
+        i_ref3 = {'id':3, 'hostname':'i-02', 'host':'dummy', 
+                  'vcpus':5, 'memory_mb':8, 'local_gb':10}
+
+        self.mox.StubOutWithMock(driver, 'db', use_mock_anything=True)
+        driver.db.service_get_all_by_host(mox.IgnoreArg(), dest).\
+                                           AndReturn([service_ref])
+        driver.db.instance_get_all_by_host(mox.IgnoreArg(), dest).\
+                      AndReturn([i_ref2, i_ref3])
+        
+        self.mox.ReplayAll()
+        try:
+            self.scheduler.driver.has_enough_resource(ctxt, i_ref1, dest)
+        except exception.NotEmpty, e:
+            msg = 'is not capable to migrate'
+            self.assertTrue(e.message.find(msg) >= 0)
+        self.mox.UnsetStubs()
+
+    def test_has_enough_resource_works_correctly(self):
+        """
+        A testcase of driver.has_enough_resource 
+        to make sure everything finished with no error.
+        """
+        dest = 'dummydest'
+        ctxt = context.get_admin_context()
+        topic = FLAGS.compute_topic
+        service_ref = {'id':1, 'vcpus':16, 'memory_mb':32, 'local_gb':100}
+        i_ref1 = {'id':1, 'hostname':'i-01', 'host':'dummy', 
+                  'vcpus':5, 'memory_mb':8, 'local_gb':10}
+        i_ref2 = {'id':2, 'hostname':'i-01', 'host':'dummy', 
+                  'vcpus':5, 'memory_mb':8, 'local_gb':10}
+        i_ref3 = {'id':3, 'hostname':'i-02', 'host':'dummy', 
+                  'vcpus':5, 'memory_mb':8, 'local_gb':10}
+
+        self.mox.StubOutWithMock(driver, 'db', use_mock_anything=True)
+        driver.db.service_get_all_by_host(mox.IgnoreArg(), dest).\
+                                           AndReturn([service_ref])
+        driver.db.instance_get_all_by_host(mox.IgnoreArg(), dest).\
+                      AndReturn([i_ref2, i_ref3])
+        
+        self.mox.ReplayAll()
+        ret = self.scheduler.driver.has_enough_resource(ctxt, i_ref1, dest)
+        self.assertTrue(ret == None)
+        self.mox.UnsetStubs()
diff --git a/nova/tests/test_service.py b/nova/tests/test_service.py
index a67c8d1e8..a147e69b4 100644
--- a/nova/tests/test_service.py
+++ b/nova/tests/test_service.py
@@ -30,6 +30,7 @@ from nova import rpc
 from nova import test
 from nova import service
 from nova import manager
+from nova.compute import manager as compute_manager
 
 FLAGS = flags.FLAGS
 flags.DEFINE_string("fake_manager", "nova.tests.test_service.FakeManager",
@@ -41,7 +42,20 @@ class FakeManager(manager.Manager):
     def test_method(self):
         return 'manager'
 
-
+# temporary variable to store host/binary/self.mox from each method to fake class.
+global_host = None
+global_binary = None
+global_mox = None
+class FakeComputeManager(compute_manager.ComputeManager):
+    """Fake computemanager manager for tests"""
+    
+    def __init__(self, compute_driver=None, *args, **kwargs):
+        global ghost, gbinary, gmox
+        self.update_service(mox.IgnoreArg(), mox.StrContains(ghost), mox.StrContains(gbinary))
+        gmox.ReplayAll()
+        super(FakeComputeManager, self).__init__(compute_driver, *args, **kwargs)
+
+   
 class ExtendedService(service.Service):
     def test_method(self):
         return 'service'
@@ -258,3 +272,48 @@ class ServiceTestCase(test.TestCase):
         serv.report_state()
 
         self.assert_(not serv.model_disconnected)
+
+    def test_compute_can_update_services(self): 
+        """
+        Test nova-compute successfully updated Service table on DB.
+        Doing so, self.manager.update_service must be called 
+        if 'self.binary == nova-compute', and this testcase checks on it.
+        """
+        host = 'foo'
+        binary = 'nova-compute'
+        topic = 'compute1'
+        service_create = {'host': host,
+                          'binary': binary,
+                          'topic': topic,
+                          'report_count': 0,
+                          'availability_zone': 'nova'}
+        service_ref = {'host': host,
+                          'binary': binary,
+                          'topic': topic,
+                          'report_count': 0,
+                          'availability_zone': 'nova',
+                          'id': 1}
+
+        service.db.service_get_by_args(mox.IgnoreArg(),
+                                      host,
+                                      binary).AndRaise(exception.NotFound())
+        service.db.service_create(mox.IgnoreArg(),
+                                  service_create).AndReturn(service_ref)
+        self.mox.StubOutWithMock(compute_manager.ComputeManager, 'update_service')
+
+
+        global ghost, gbinary, gmox
+        ghost = host
+        gbinary = binary
+        gmox = self.mox
+
+        serv = service.Service(host,
+                               binary,
+                               topic,
+                               'nova.tests.test_service.FakeComputeManager')
+        # ReplayAll has been executed FakeComputeManager.__init__()
+        #self.mox.ReplayAll()
+        serv.start()
+        serv.stop()
+
+
diff --git a/nova/tests/test_virt.py b/nova/tests/test_virt.py
index afdc89ba2..177e8f021 100644
--- a/nova/tests/test_virt.py
+++ b/nova/tests/test_virt.py
@@ -14,21 +14,29 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+import mox
+
 from xml.etree.ElementTree import fromstring as xml_to_tree
 from xml.dom.minidom import parseString as xml_to_dom
 
 from nova import context
 from nova import db
+from nova import exception
 from nova import flags
 from nova import test
+from nova import logging
 from nova import utils
 from nova.api.ec2 import cloud
 from nova.auth import manager
+from nova.db.sqlalchemy import models
+from nova.compute import power_state
 from nova.virt import libvirt_conn
 
 FLAGS = flags.FLAGS
 flags.DECLARE('instances_path', 'nova.compute.manager')
 
+libvirt = None
+libxml2 = None
 
 class LibvirtConnTestCase(test.TestCase):
     def setUp(self):
@@ -52,6 +60,38 @@ class LibvirtConnTestCase(test.TestCase):
                      'bridge':        'br101',
                      'instance_type': 'm1.small'}
 
+    def _driver_dependent_test_setup(self): 
+        """
+        Setup method.
+        Call this method at the top of each testcase method, 
+        if the testcase is necessary libvirt and cheetah.
+        """
+        try : 
+            global libvirt
+            global libxml2
+            libvirt_conn.libvirt = __import__('libvirt')
+            libvirt_conn.libxml2 = __import__('libxml2')
+            libvirt_conn._late_load_cheetah()
+            libvirt = __import__('libvirt')
+        except ImportError, e:
+            logging.warn("""This test has not been done since """
+                 """using driver-dependent library Cheetah/libvirt/libxml2.""")
+            raise e
+
+        # inebitable mocks for calling 
+        #nova.virt.libvirt_conn.LibvirtConnection.__init__
+        nwmock = self.mox.CreateMock(libvirt_conn.NWFilterFirewall)
+        self.mox.StubOutWithMock(libvirt_conn, 'NWFilterFirewall',
+                                 use_mock_anything=True)
+        libvirt_conn.NWFilterFirewall(mox.IgnoreArg()).AndReturn(nwmock)
+
+        obj = utils.import_object(FLAGS.firewall_driver)
+        fwmock = self.mox.CreateMock(obj)
+        self.mox.StubOutWithMock(libvirt_conn, 'utils',
+                                 use_mock_anything=True)
+        libvirt_conn.utils.import_object(FLAGS.firewall_driver).AndReturn(fwmock)
+        return nwmock, fwmock
+
     def test_xml_and_uri_no_ramdisk_no_kernel(self):
         instance_data = dict(self.test_instance)
         self._check_xml_and_uri(instance_data,
@@ -188,9 +228,8 @@ class LibvirtConnTestCase(test.TestCase):
                                  expected_result,
                                  '%s failed common check %d' % (xml, i))
 
-        # This test is supposed to make sure we don't override a specifically
-        # set uri
-        #
+        # This test is supposed to make sure we don't override a specifically set uri
+        # 
         # Deliberately not just assigning this string to FLAGS.libvirt_uri and
         # checking against that later on. This way we make sure the
         # implementation doesn't fiddle around with the FLAGS.
@@ -202,6 +241,480 @@ class LibvirtConnTestCase(test.TestCase):
             uri = conn.get_uri()
             self.assertEquals(uri, testuri)
 
+    def test_get_memory_mb(self):
+        """
+        Check if get_memory_mb returns memory value
+        Connection/OS/driver differenct does not matter for this method,
+        so everyone can execute for checking.
+        """
+        try: 
+            self._driver_dependent_test_setup()
+        except: 
+            return 
+
+        self.mox.ReplayAll()
+        conn = libvirt_conn.LibvirtConnection(False)
+        self.assertTrue(0 < conn.get_memory_mb())
+        self.mox.UnsetStubs()
+
+    def test_get_cpu_info_works_correctly(self):
+        """
+        Check if get_cpu_info works correctly.
+        (in case libvirt.getCapabilities() works correctly)
+        """
+        xml=("""<cpu><arch>x86_64</arch><model>Nehalem</model>"""
+             """<vendor>Intel</vendor><topology sockets='2' """
+             """cores='4' threads='2'/><feature name='rdtscp'/>"""
+             """<feature name='dca'/><feature name='xtpr'/>"""
+             """<feature name='tm2'/><feature name='est'/>"""
+             """<feature name='vmx'/><feature name='ds_cpl'/>"""
+             """<feature name='monitor'/><feature name='pbe'/>"""
+             """<feature name='tm'/><feature name='ht'/>"""
+             """<feature name='ss'/><feature name='acpi'/>"""
+             """<feature name='ds'/><feature name='vme'/></cpu>""")
+
+        try: 
+            self._driver_dependent_test_setup()
+        except: 
+            return 
+        self.mox.StubOutWithMock(libvirt_conn.LibvirtConnection, '_conn', use_mock_anything=True)
+        libvirt_conn.LibvirtConnection._conn.getCapabilities().AndReturn(xml)
+
+        self.mox.ReplayAll()
+        conn = libvirt_conn.LibvirtConnection(False)
+        self.assertTrue(0 < len(conn.get_cpu_info()))
+        self.mox.UnsetStubs()
+
+    def test_get_cpu_info_inappropreate_xml(self):
+        """
+        Check if get_cpu_info raises exception
+        in case libvirt.getCapabilities() returns wrong xml
+        (in case of xml doesnt have <cpu> tag)
+        """
+        xml=("""<cccccpu><arch>x86_64</arch><model>Nehalem</model>"""
+             """<vendor>Intel</vendor><topology sockets='2' """
+             """cores='4' threads='2'/><feature name='rdtscp'/>"""
+             """<feature name='dca'/><feature name='xtpr'/>"""
+             """<feature name='tm2'/><feature name='est'/>"""
+             """<feature name='vmx'/><feature name='ds_cpl'/>"""
+             """<feature name='monitor'/><feature name='pbe'/>"""
+             """<feature name='tm'/><feature name='ht'/>"""
+             """<feature name='ss'/><feature name='acpi'/>"""
+             """<feature name='ds'/><feature name='vme'/></cccccpu>""")
+
+        try: 
+            self._driver_dependent_test_setup()
+        except: 
+            return 
+        self.mox.StubOutWithMock(libvirt_conn.LibvirtConnection, '_conn', use_mock_anything=True)
+        libvirt_conn.LibvirtConnection._conn.getCapabilities().AndReturn(xml)
+
+        self.mox.ReplayAll()
+        conn = libvirt_conn.LibvirtConnection(False)
+        try: 
+            conn.get_cpu_info()
+        except exception.Invalid, e:
+            c1 = ( 0 <= e.message.find('Invalid xml') )
+            self.assertTrue(c1)
+        self.mox.UnsetStubs()
+            
+    def test_get_cpu_info_inappropreate_xml2(self):
+        """
+        Check if get_cpu_info raises exception
+        in case libvirt.getCapabilities() returns wrong xml
+        (in case of xml doesnt have inproper <topology> tag
+        meaning missing "socket" attribute)
+        """
+        xml=("""<cpu><arch>x86_64</arch><model>Nehalem</model>"""
+             """<vendor>Intel</vendor><topology """
+             """cores='4' threads='2'/><feature name='rdtscp'/>"""
+             """<feature name='dca'/><feature name='xtpr'/>"""
+             """<feature name='tm2'/><feature name='est'/>"""
+             """<feature name='vmx'/><feature name='ds_cpl'/>"""
+             """<feature name='monitor'/><feature name='pbe'/>"""
+             """<feature name='tm'/><feature name='ht'/>"""
+             """<feature name='ss'/><feature name='acpi'/>"""
+             """<feature name='ds'/><feature name='vme'/></cpu>""")
+
+        try: 
+            self._driver_dependent_test_setup()
+        except: 
+            return 
+        self.mox.StubOutWithMock(libvirt_conn.LibvirtConnection, '_conn', use_mock_anything=True)
+        libvirt_conn.LibvirtConnection._conn.getCapabilities().AndReturn(xml)
+
+        self.mox.ReplayAll()
+        conn = libvirt_conn.LibvirtConnection(False)
+        try: 
+            conn.get_cpu_info()
+        except exception.Invalid, e:
+            c1 = ( 0 <= e.message.find('Invalid xml: topology') )
+            self.assertTrue(c1)
+        self.mox.UnsetStubs()
+
+    def test_compare_cpu_works_correctly(self):
+        """Calling libvirt.compute_cpu() and works correctly """
+
+        t = ("""{"arch":"%s", "model":"%s", "vendor":"%s", """
+                    """"topology":{"cores":"%s", "threads":"%s", """
+                    """"sockets":"%s"}, "features":[%s]}""")
+        cpu_info = t % ('x86', 'model', 'vendor', '2', '1', '4', '"tm"')
+
+        try: 
+            self._driver_dependent_test_setup()
+        except: 
+            return 
+
+        self.mox.StubOutWithMock(libvirt_conn.LibvirtConnection, '_conn', use_mock_anything=True)
+        libvirt_conn.LibvirtConnection._conn.compareCPU(mox.IgnoreArg(),0).AndReturn(1)
+
+        self.mox.ReplayAll()
+        conn = libvirt_conn.LibvirtConnection(False)
+        self.assertTrue( None== conn.compare_cpu(cpu_info))
+        self.mox.UnsetStubs()
+
+    def test_compare_cpu_raises_exception(self):
+        """
+        Libvirt-related exception occurs when calling
+        libvirt.compare_cpu().
+        """
+        t = ("""{"arch":"%s", "model":"%s", "vendor":"%s", """
+                    """"topology":{"cores":"%s", "threads":"%s", """
+                    """"sockets":"%s"}, "features":[%s]}""")
+        cpu_info = t % ('x86', 'model', 'vendor', '2', '1', '4', '"tm"')
+
+        try: 
+            self._driver_dependent_test_setup()
+        except: 
+            return 
+
+        self.mox.StubOutWithMock(libvirt_conn.LibvirtConnection, '_conn',
+                                 use_mock_anything=True)
+        libvirt_conn.LibvirtConnection._conn.compareCPU(mox.IgnoreArg(),0).\
+            AndRaise(libvirt.libvirtError('ERR'))
+
+        self.mox.ReplayAll()
+        conn = libvirt_conn.LibvirtConnection(False)
+        self.assertRaises(libvirt.libvirtError, conn.compare_cpu, cpu_info)
+        self.mox.UnsetStubs()
+
+    def test_compare_cpu_no_compatibility(self):
+        """libvirt.compare_cpu() return less than 0.(no compatibility)"""
+
+        t = ("""{"arch":"%s", "model":"%s", "vendor":"%s", """
+                    """"topology":{"cores":"%s", "threads":"%s", """
+                    """"sockets":"%s"}, "features":[%s]}""")
+        cpu_info = t % ('x86', 'model', 'vendor', '2', '1', '4', '"tm"')
+
+        try: 
+            self._driver_dependent_test_setup()
+        except: 
+            return 
+
+        self.mox.StubOutWithMock(libvirt_conn.LibvirtConnection, '_conn',
+                                 use_mock_anything=True)
+        libvirt_conn.LibvirtConnection._conn.compareCPU(mox.IgnoreArg(),0).\
+            AndRaise(exception.Invalid('ERR'))
+
+        self.mox.ReplayAll()
+        conn = libvirt_conn.LibvirtConnection(False)
+        self.assertRaises(exception.Invalid, conn.compare_cpu, cpu_info)
+        self.mox.UnsetStubs()
+
+    def test_ensure_filtering_rules_for_instance_works_correctly(self):
+        """ensure_filtering_rules_for_instance works as expected correctly"""
+
+        instance_ref = models.Instance()
+        instance_ref.__setitem__('id', 1)
+
+        try: 
+            nwmock, fwmock = self._driver_dependent_test_setup()
+        except: 
+            return 
+
+        nwmock.setup_basic_filtering(mox.IgnoreArg())
+        fwmock.prepare_instance_filter(instance_ref)
+        self.mox.StubOutWithMock(libvirt_conn.LibvirtConnection, '_conn',
+                                 use_mock_anything=True)
+        n = 'nova-instance-%s' % instance_ref.name
+        libvirt_conn.LibvirtConnection._conn.nwfilterLookupByName(n)
+
+        self.mox.ReplayAll()
+        conn = libvirt_conn.LibvirtConnection(False)
+        conn.ensure_filtering_rules_for_instance(instance_ref)
+        self.mox.UnsetStubs()
+
+    def test_ensure_filtering_rules_for_instance_timeout(self):
+        """ensure_filtering_fules_for_instance finishes with timeout"""
+
+        instance_ref = models.Instance()
+        instance_ref.__setitem__('id', 1)
+
+        try: 
+            nwmock, fwmock = self._driver_dependent_test_setup()
+        except: 
+            return 
+
+        nwmock.setup_basic_filtering(mox.IgnoreArg())
+        fwmock.prepare_instance_filter(instance_ref)
+        self.mox.StubOutWithMock(libvirt_conn.LibvirtConnection, '_conn',
+                                 use_mock_anything=True)
+        n = 'nova-instance-%s' % instance_ref.name
+        for i in range(FLAGS.live_migration_timeout_sec * 2):
+            libvirt_conn.LibvirtConnection._conn.\
+                nwfilterLookupByName(n).AndRaise(libvirt.libvirtError('ERR'))
+
+        self.mox.ReplayAll()
+        conn = libvirt_conn.LibvirtConnection(False)
+        try: 
+            conn.ensure_filtering_rules_for_instance(instance_ref)
+        except exception.Error, e:
+            c1 = ( 0<=e.message.find('Timeout migrating for'))
+            self.assertTrue(c1)
+        self.mox.UnsetStubs()
+
+    def test_live_migration_works_correctly(self):
+        """_live_migration works as expected correctly """
+
+        class dummyCall(object):
+            f = None
+            def start(self, interval=0, now=False): 
+                pass
+
+        instance_ref = models.Instance()
+        instance_ref.__setitem__('id', 1)
+        dest = 'desthost'
+        ctxt = context.get_admin_context()
+
+        try: 
+            self._driver_dependent_test_setup()
+        except: 
+            return 
+
+        self.mox.StubOutWithMock(libvirt_conn.LibvirtConnection, '_conn',
+                                 use_mock_anything=True)
+        vdmock = self.mox.CreateMock(libvirt.virDomain)
+        self.mox.StubOutWithMock(vdmock, "migrateToURI",
+                                 use_mock_anything=True)
+        vdmock.migrateToURI(FLAGS.live_migration_uri % dest, mox.IgnoreArg(),
+                            None, FLAGS.live_migration_bandwidth).\
+                            AndReturn(None)
+        libvirt_conn.LibvirtConnection._conn.lookupByName(instance_ref.name).\
+            AndReturn(vdmock)
+        # below description is also ok.
+        #self.mox.StubOutWithMock(libvirt_conn.LibvirtConnection._conn, 
+        #    "lookupByName", use_mock_anything=True)
+        
+        libvirt_conn.utils.LoopingCall(f=None).AndReturn(dummyCall())
+
+
+        self.mox.ReplayAll()
+        conn = libvirt_conn.LibvirtConnection(False)
+        ret = conn._live_migration(ctxt, instance_ref, dest)
+        self.assertTrue(ret == None)
+        self.mox.UnsetStubs()
+
+    def test_live_migration_raises_exception(self):
+        """
+        _live_migration raises exception, then this testcase confirms
+        state_description/state for the instances/volumes are recovered. 
+        """
+        class Instance(models.NovaBase): 
+            id = 0
+            volumes = None
+            name = 'name'
+
+        ctxt = context.get_admin_context()
+        dest = 'desthost'
+        instance_ref = Instance()
+        instance_ref.__setitem__('id', 1)
+        instance_ref.__setitem__('volumes', [{'id':1}, {'id':2}])
+
+        try: 
+            nwmock, fwmock = self._driver_dependent_test_setup()
+        except: 
+            return 
+
+        self.mox.StubOutWithMock(libvirt_conn.LibvirtConnection, '_conn',
+                                 use_mock_anything=True)
+        vdmock = self.mox.CreateMock(libvirt.virDomain)
+        self.mox.StubOutWithMock(vdmock, "migrateToURI",
+                                 use_mock_anything=True)
+        vdmock.migrateToURI(FLAGS.live_migration_uri % dest, mox.IgnoreArg(),
+                            None, FLAGS.live_migration_bandwidth).\
+                            AndRaise(libvirt.libvirtError('ERR'))
+        libvirt_conn.LibvirtConnection._conn.lookupByName(instance_ref.name).\
+                                                          AndReturn(vdmock)
+        self.mox.StubOutWithMock(db, 'instance_set_state')
+        db.instance_set_state(ctxt, instance_ref['id'], 
+                              power_state.RUNNING, 'running')
+        self.mox.StubOutWithMock(db, 'volume_update')
+        for v in instance_ref.volumes:
+            db.volume_update(ctxt, v['id'], {'status': 'in-use'}).\
+            InAnyOrder('g1')
+
+        self.mox.ReplayAll()
+        conn = libvirt_conn.LibvirtConnection(False)
+        self.assertRaises(libvirt.libvirtError, 
+                         conn._live_migration,
+                         ctxt, instance_ref, dest)
+        self.mox.UnsetStubs()
+
+    def test_post_live_migration_working_correctly(self):
+        """_post_live_migration works as expected correctly """
+
+        dest = 'dummydest'
+        ctxt = context.get_admin_context()
+        instance_ref = {'id':1, 'hostname':'i-00000001', 'host':dest, 
+                       'fixed_ip':'dummyip', 'floating_ip':'dummyflip', 
+                       'volumes':[{'id':1}, {'id':2} ]}
+        network_ref = {'id':1, 'host':dest}
+        floating_ip_ref = {'id':1, 'address':'1.1.1.1'}
+
+        try: 
+            nwmock, fwmock = self._driver_dependent_test_setup()
+        except: 
+            return 
+        fwmock.unfilter_instance(instance_ref)
+
+        fixed_ip = instance_ref['fixed_ip']
+        self.mox.StubOutWithMock(db, 'instance_get_fixed_address')
+        db.instance_get_fixed_address(ctxt, instance_ref['id']).AndReturn(fixed_ip)
+        self.mox.StubOutWithMock(db, 'fixed_ip_update')
+        db.fixed_ip_update(ctxt, fixed_ip, {'host': dest})
+        self.mox.StubOutWithMock(db, 'fixed_ip_get_network')
+        db.fixed_ip_get_network(ctxt, fixed_ip).AndReturn(network_ref)
+        self.mox.StubOutWithMock(db, 'network_update')
+        db.network_update(ctxt, network_ref['id'], {'host': dest})
+        
+        fl_ip = instance_ref['floating_ip']
+        self.mox.StubOutWithMock(db, 'instance_get_floating_address')
+        db.instance_get_floating_address(ctxt, instance_ref['id']).AndReturn(fl_ip)
+        self.mox.StubOutWithMock(db, 'floating_ip_get_by_address')
+        db.floating_ip_get_by_address(ctxt, instance_ref['floating_ip']).\
+                                      AndReturn(floating_ip_ref)
+        self.mox.StubOutWithMock(db, 'floating_ip_update')
+        db.floating_ip_update(ctxt, floating_ip_ref['address'], {'host': dest})
+        
+        self.mox.StubOutWithMock(db, 'instance_update')
+        db.instance_update(ctxt, instance_ref['id'],
+                           {'state_description': 'running',
+                            'state': power_state.RUNNING, 'host': dest})
+        self.mox.StubOutWithMock(db, 'volume_update')
+        for v in instance_ref['volumes']:
+            db.volume_update(ctxt, v['id'], {'status': 'in-use'})
+
+        self.mox.ReplayAll()
+        conn = libvirt_conn.LibvirtConnection(False)
+        conn._post_live_migration( ctxt, instance_ref, dest)
+        self.mox.UnsetStubs()
+
+    def test_post_live_migration_no_floating_ip(self):
+        """
+        _post_live_migration works as expected correctly 
+        (in case instance doesnt have floaitng ip)
+        """
+        dest = 'dummydest'
+        ctxt = context.get_admin_context()
+        instance_ref = {'id':1, 'hostname':'i-00000001', 'host':dest, 
+                       'fixed_ip':'dummyip', 'floating_ip':'dummyflip', 
+                       'volumes':[{'id':1}, {'id':2} ]}
+        network_ref = {'id':1, 'host':dest}
+        floating_ip_ref = {'id':1, 'address':'1.1.1.1'}
+
+        try: 
+            nwmock, fwmock = self._driver_dependent_test_setup()
+        except: 
+            return 
+        fwmock.unfilter_instance(instance_ref)
+
+        fixed_ip = instance_ref['fixed_ip']
+        self.mox.StubOutWithMock(db, 'instance_get_fixed_address')
+        db.instance_get_fixed_address(ctxt, instance_ref['id']).AndReturn(fixed_ip)
+        self.mox.StubOutWithMock(db, 'fixed_ip_update')
+        db.fixed_ip_update(ctxt, fixed_ip, {'host': dest})
+        self.mox.StubOutWithMock(db, 'fixed_ip_get_network')
+        db.fixed_ip_get_network(ctxt, fixed_ip).AndReturn(network_ref)
+        self.mox.StubOutWithMock(db, 'network_update')
+        db.network_update(ctxt, network_ref['id'], {'host': dest})
+
+        self.mox.StubOutWithMock(db, 'instance_get_floating_address')
+        db.instance_get_floating_address(ctxt, instance_ref['id']).AndReturn(None)
+        self.mox.StubOutWithMock(libvirt_conn.LOG, 'info')
+        libvirt_conn.LOG.info(_('post livemigration operation is started..'))
+        libvirt_conn.LOG.info(_('floating_ip is not found for %s'), 
+                              instance_ref['hostname'])
+        # Checking last messages are ignored. may be no need to check so strictly?
+        libvirt_conn.LOG.info(mox.IgnoreArg())
+        libvirt_conn.LOG.info(mox.IgnoreArg())
+
+        self.mox.StubOutWithMock(db, 'instance_update')
+        db.instance_update(ctxt, instance_ref['id'],
+                           {'state_description': 'running',
+                            'state': power_state.RUNNING,
+                            'host': dest})
+        self.mox.StubOutWithMock(db, 'volume_update')
+        for v in instance_ref['volumes']:
+            db.volume_update(ctxt, v['id'], {'status': 'in-use'})
+
+        self.mox.ReplayAll()
+        conn = libvirt_conn.LibvirtConnection(False)
+        conn._post_live_migration( ctxt, instance_ref, dest)
+        self.mox.UnsetStubs()
+
+    def test_post_live_migration_no_floating_ip_with_exception(self):
+        """
+        _post_live_migration works as expected correctly 
+        (in case instance doesnt have floaitng ip, and raise exception)
+        """
+        dest = 'dummydest'
+        ctxt = context.get_admin_context()
+        instance_ref = {'id':1, 'hostname':'i-00000001', 'host':dest, 
+                       'fixed_ip':'dummyip', 'floating_ip':'dummyflip', 
+                       'volumes':[{'id':1}, {'id':2} ]}
+        network_ref = {'id':1, 'host':dest}
+        floating_ip_ref = {'id':1, 'address':'1.1.1.1'}
+
+        try: 
+            nwmock, fwmock = self._driver_dependent_test_setup()
+        except: 
+            return 
+        fwmock.unfilter_instance(instance_ref)
+
+        fixed_ip = instance_ref['fixed_ip']
+        self.mox.StubOutWithMock(db, 'instance_get_fixed_address')
+        db.instance_get_fixed_address(ctxt, instance_ref['id']).AndReturn(fixed_ip)
+        self.mox.StubOutWithMock(db, 'fixed_ip_update')
+        db.fixed_ip_update(ctxt, fixed_ip, {'host': dest})
+        self.mox.StubOutWithMock(db, 'fixed_ip_get_network')
+        db.fixed_ip_get_network(ctxt, fixed_ip).AndReturn(network_ref)
+        self.mox.StubOutWithMock(db, 'network_update')
+        db.network_update(ctxt, network_ref['id'], {'host': dest})
+
+        self.mox.StubOutWithMock(db, 'instance_get_floating_address')
+        db.instance_get_floating_address(ctxt, instance_ref['id']).\
+                                         AndRaise(exception.NotFound())
+        self.mox.StubOutWithMock(libvirt_conn.LOG, 'info')
+        libvirt_conn.LOG.info(_('post livemigration operation is started..'))
+        libvirt_conn.LOG.info(_('floating_ip is not found for %s'),
+                              instance_ref['hostname'])
+        # the last message is ignored. may be no need to check so strictly?
+        libvirt_conn.LOG.info(mox.IgnoreArg())
+        libvirt_conn.LOG.info(mox.IgnoreArg())
+
+        self.mox.StubOutWithMock(db, 'instance_update')
+        db.instance_update(ctxt, instance_ref['id'],
+                           {'state_description': 'running',
+                            'state': power_state.RUNNING, 'host': dest})
+        self.mox.StubOutWithMock(db, 'volume_update')
+        for v in instance_ref['volumes']:
+            db.volume_update(ctxt, v['id'], {'status': 'in-use'})
+
+        self.mox.ReplayAll()
+        conn = libvirt_conn.LibvirtConnection(False)
+        conn._post_live_migration( ctxt, instance_ref, dest)
+        self.mox.UnsetStubs()
+
     def tearDown(self):
         super(LibvirtConnTestCase, self).tearDown()
         self.manager.delete_project(self.project)
@@ -475,3 +988,4 @@ class NWFilterTestCase(test.TestCase):
         self.fw.prepare_instance_filter(instance)
         _ensure_all_called()
         self.teardown_security_group()
+
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. "<cpu>" 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.')
 
 
diff --git a/nova/volume/manager.py b/nova/volume/manager.py
index 1735d79eb..906eb86ea 100644
--- a/nova/volume/manager.py
+++ b/nova/volume/manager.py
@@ -153,6 +153,6 @@ class VolumeManager(manager.Manager):
     def check_for_export(self, context, instance_id):
         """Make sure whether volume is exported."""
         if FLAGS.volume_driver == 'nova.volume.driver.AOEDriver':
-            instance_ref = self.db.instance_get(instance_id)
+            instance_ref = self.db.instance_get(context, instance_id)
             for v in instance_ref['volumes']:
                 self.driver.check_for_export(context, v['id'])
-- 
cgit 


From 46456155d42dd8a668b370fa84972c388094e1d8 Mon Sep 17 00:00:00 2001
From: Andy Southgate <andy.southgate@citrix.com>
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')

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 <masumotok@nttdata.co.jp>
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/compute/manager.py      |  54 ++++++++++++-
 nova/db/sqlalchemy/models.py |   5 +-
 nova/rpc.py                  |   3 +
 nova/scheduler/driver.py     |  67 +++++++++++------
 nova/scheduler/manager.py    |  11 ++-
 nova/tests/test_compute.py   |  55 ++++++++++++--
 nova/tests/test_scheduler.py | 175 ++++++++++++++++++++++++++-----------------
 nova/tests/test_virt.py      |  86 ++++++++++++++++++++-
 nova/utils.py                |  18 +++++
 nova/virt/fake.py            |  22 ++++--
 nova/virt/libvirt_conn.py    |  37 +++++++--
 nova/virt/xenapi_conn.py     |  22 ++++--
 12 files changed, 429 insertions(+), 126 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 4acba7153..e3c5d24b6 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -134,9 +134,12 @@ class ComputeManager(manager.Manager):
             raise exception.Invalid(msg)
 
         # Updating host information
-        vcpu = self.driver.get_vcpu_number()
-        memory_mb = self.driver.get_memory_mb()
-        local_gb = self.driver.get_local_gb()
+        vcpu = self.driver.get_vcpu_total()
+        memory_mb = self.driver.get_memory_mb_total()
+        local_gb = self.driver.get_local_gb_total()
+        vcpu_u = self.driver.get_vcpu_used()
+        memory_mb_u = self.driver.get_memory_mb_used()
+        local_gb_u = self.driver.get_local_gb_used()
         hypervisor = self.driver.get_hypervisor_type()
         version = self.driver.get_hypervisor_version()
         cpu_info = self.driver.get_cpu_info()
@@ -146,10 +149,42 @@ class ComputeManager(manager.Manager):
                                {'vcpus': vcpu,
                                 'memory_mb': memory_mb,
                                 'local_gb': local_gb,
+                                'vcpus_used':vcpu_u,
+                                'memory_mb_used': memory_mb_u,
+                                'local_gb_used': local_gb_u,
                                 'hypervisor_type': hypervisor,
                                 'hypervisor_version': version,
                                 'cpu_info': cpu_info})
 
+    def update_available_resource(self, context):
+        """
+        update compute node specific info to DB.
+        Alghough this might be subset of update_service,
+        udpate_service() is used only nova-compute is lauched.
+        On the other hand, this method is used whenever administrators
+        request comes.
+        """
+        try:
+            service_ref = self.db.service_get_by_args(context,
+                                                      self.host,
+                                                      'nova-compute')
+        except exception.NotFound:
+            msg = _(("""Cannot update resource info."""
+                     """ Because no service record found."""))
+            raise exception.Invalid(msg)
+
+        # Updating host information
+        vcpu_u = self.driver.get_vcpu_used()
+        memory_mb_u = self.driver.get_memory_mb_used()
+        local_gb_u = self.driver.get_local_gb_used()
+
+        self.db.service_update(context,
+                               service_ref['id'],
+                               {'vcpus_used':vcpu_u,
+                                'memory_mb_used': memory_mb_u,
+                                'local_gb_used': local_gb_u})
+        return
+
     def _update_state(self, context, instance_id):
         """Update the state of an instance from the driver info."""
         # FIXME(ja): include other fields from state?
@@ -596,6 +631,19 @@ class ComputeManager(manager.Manager):
         """ Check the host cpu is compatible to a cpu given by xml."""
         return self.driver.compare_cpu(cpu_info)
 
+    def mktmpfile(self, context):
+        """make tmpfile under FLAGS.instance_path."""
+        return utils.mktmpfile(FLAGS.instances_path)
+
+    def exists(self, context, path):
+        """Confirm existence of the tmpfile given by path."""
+        if not utils.exists(path): 
+            raise exception.NotFound(_('%s not found') % path)
+
+    def remove(self, context, path):
+        """remove the tmpfile given by path."""
+        return utils.remove(path)
+
     def pre_live_migration(self, context, instance_id):
         """Any preparation for live migration at dst host."""
 
diff --git a/nova/db/sqlalchemy/models.py b/nova/db/sqlalchemy/models.py
index 7c40d5596..217b14bf7 100644
--- a/nova/db/sqlalchemy/models.py
+++ b/nova/db/sqlalchemy/models.py
@@ -164,7 +164,10 @@ class Service(BASE, NovaBase):
     vcpus = Column(Integer, nullable=True)
     memory_mb = Column(Integer, nullable=True)
     local_gb = Column(Integer, nullable=True)
-    hypervisor_type = Column(String(128), nullable=True)
+    vcpus_used = Column(Integer, nullable=True)
+    memory_mb_used = Column(Integer, nullable=True)
+    local_gb_used = Column(Integer, nullable=True)
+    hypervisor_type = Column(Text(), nullable=True)
     hypervisor_version = Column(Integer, nullable=True)
     # Note(masumotok): Expected Strings example:
     #
diff --git a/nova/rpc.py b/nova/rpc.py
index 49b11602b..cf4004079 100644
--- a/nova/rpc.py
+++ b/nova/rpc.py
@@ -250,6 +250,9 @@ def msg_reply(msg_id, reply=None, failure=None):
     try:
         publisher.send({'result': reply, 'failure': failure})
     except TypeError:
+        print '>>>>>>>>>>>>>>>>>>'
+        print reply
+        print '>>>>>>>>>>>>>>>>>>'
         publisher.send(
                 {'result': dict((k, repr(v))
                                 for k, v in reply.__dict__.iteritems()),
diff --git a/nova/scheduler/driver.py b/nova/scheduler/driver.py
index d4ad42388..937f09c6f 100644
--- a/nova/scheduler/driver.py
+++ b/nova/scheduler/driver.py
@@ -33,6 +33,7 @@ from nova.compute import power_state
 FLAGS = flags.FLAGS
 flags.DEFINE_integer('service_down_time', 60,
                      'maximum time since last checkin for up service')
+flags.DECLARE('instances_path', 'nova.compute.manager')
 
 
 class NoValidHost(exception.Error):
@@ -163,6 +164,8 @@ class Scheduler(object):
         http://wiki.libvirt.org/page/TodoPreMigrationChecks
 
         """
+        # Checking shared storage connectivity
+        self.mounted_on_same_shared_storage(context, instance_ref, dest)
 
         # Checking dest exists.
         dservice_refs = db.service_get_all_by_host(context, dest)
@@ -207,38 +210,60 @@ class Scheduler(object):
             raise e
 
     def has_enough_resource(self, context, instance_ref, dest):
-        """Check if destination host has enough resource for live migration"""
+        """
+        Check if destination host has enough resource for live migration.
+        Currently, only memory checking has been done.
+        If storage migration(block migration, meaning live-migration
+        without any shared storage) will be available, local storage
+        checking is also necessary.
+        """
 
         # Getting instance information
         ec2_id = instance_ref['hostname']
-        vcpus = instance_ref['vcpus']
         mem = instance_ref['memory_mb']
-        hdd = instance_ref['local_gb']
 
-        # Gettin host information
+        # Getting host information
         service_refs = db.service_get_all_by_host(context, dest)
         if len(service_refs) <= 0:
             raise exception.Invalid(_('%s does not exists.') % dest)
         service_ref = service_refs[0]
 
-        total_cpu = int(service_ref['vcpus'])
-        total_mem = int(service_ref['memory_mb'])
-        total_hdd = int(service_ref['local_gb'])
+        mem_total = int(service_ref['memory_mb'])
+        mem_used = int(service_ref['memory_mb_used'])
+        mem_avail = mem_total - mem_used
+        mem_inst =  instance_ref['memory_mb']
+        if mem_avail <= mem_inst:
+            msg = _('%s is not capable to migrate %s(host:%s <= instance:%s)') 
+            raise exception.NotEmpty(msg % (dest, ec2_id, mem_avail, mem_inst))
 
-        instances_refs = db.instance_get_all_by_host(context, dest)
-        for i_ref in instances_refs:
-            total_cpu -= int(i_ref['vcpus'])
-            total_mem -= int(i_ref['memory_mb'])
-            total_hdd -= int(i_ref['local_gb'])
+    def mounted_on_same_shared_storage(self, context, instance_ref, dest):
+        """
+        Check if /nova-inst-dir/insntances is mounted same storage at
+        live-migration src and dest host.
+        """
+        src = instance_ref['host']
+        dst_t = db.queue_get_for(context, FLAGS.compute_topic, dest)
+        src_t = db.queue_get_for(context, FLAGS.compute_topic, src)
 
-        # Checking host has enough information
-        logging.debug(_('host(%s) remains vcpu:%s mem:%s hdd:%s,') %
-                      (dest, total_cpu, total_mem, total_hdd))
-        logging.debug(_('instance(%s) has vcpu:%s mem:%s hdd:%s,') %
-                      (ec2_id, vcpus, mem, hdd))
+        # create tmpfile at dest host
+        try:
+            filename = rpc.call(context, dst_t, {"method": 'mktmpfile'})
+        except rpc.RemoteError, e:
+            msg = _("Cannot create tmpfile at %s to confirm shared storage.")
+            logging.error(msg % FLAGS.instance_path)
+            raise e
 
-        if total_cpu <= vcpus or total_mem <= mem or total_hdd <= hdd:
-            raise exception.NotEmpty(_('%s is not capable to migrate %s') %
-                                     (dest, ec2_id))
+        # make sure existence at src host.
+        try:
+            rpc.call(context, src_t,
+                     {"method": 'exists', "args":{'path':filename}})
+
+        except (rpc.RemoteError, exception.NotFound), e:
+            msg = (_("""Cannot comfirm %s at %s to confirm shared storage."""
+                     """Check if %s is same shared storage"""))
+            logging.error(msg % FLAGS.instance_path)
+            raise e
 
-        logging.debug(_('%s has_enough_resource() for %s') % (dest, ec2_id))
+        # then remove.
+        rpc.call(context, dst_t,
+                 {"method": 'remove', "args":{'path':filename}})
diff --git a/nova/scheduler/manager.py b/nova/scheduler/manager.py
index a181225a6..b40f46a85 100644
--- a/nova/scheduler/manager.py
+++ b/nova/scheduler/manager.py
@@ -84,7 +84,10 @@ class SchedulerManager(manager.Manager):
         # Getting physical resource information
         h_resource = {'vcpus': service_ref['vcpus'],
                      'memory_mb': service_ref['memory_mb'],
-                     'local_gb': service_ref['local_gb']}
+                     'local_gb': service_ref['local_gb'],
+                     'vcpus_used': service_ref['vcpus_used'],
+                     'memory_mb_used': service_ref['memory_mb_used'],
+                     'local_gb_used': service_ref['local_gb_used']}
 
         # Getting usage resource information
         u_resource = {}
@@ -108,8 +111,8 @@ class SchedulerManager(manager.Manager):
             hdd = db.instance_get_disk_sum_by_host_and_project(context,
                                                                host,
                                                                p_id)
-            u_resource[p_id] = {'vcpus': vcpus,
-                                'memory_mb': mem,
-                                'local_gb': hdd}
+            u_resource[p_id] = {'vcpus': int(vcpus),
+                                'memory_mb': int(mem),
+                                'local_gb': int(hdd)}
 
         return {'ret': True, 'phy_resource': h_resource, 'usage': u_resource}
diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index 344c2d2b5..8d3ac315d 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -268,7 +268,8 @@ class ComputeTestCase(test.TestCase):
         """
 
         def dic_key_check(dic): 
-            validkey = ['vcpus', 'memory_mb', 'local_gb', 
+            validkey = ['vcpus', 'memory_mb', 'local_gb',
+                        'vcpus_used', 'memory_mb_used', 'local_gb_used',
                         'hypervisor_type', 'hypervisor_version', 'cpu_info']
             return (list(set(validkey)) == list(set(dic.keys())))
 
@@ -286,13 +287,55 @@ class ComputeTestCase(test.TestCase):
 
         self.compute.db = dbmock
         self.mox.ReplayAll()
+        self.compute.update_service('dummy', host, binary)
+        self.mox.ResetAll()
+
+    def test_update_available_resource_exception(self): 
+        """a testcase of update_available_resource raises exception"""
+        host = 'foo'
+        binary = 'nova-compute'
+        ctxt = context.get_admin_context()
+        dbmock = self.mox.CreateMock(db)
+        dbmock.service_get_by_args(mox.IgnoreArg(), 
+                                   mox.StrContains(host), 
+                                   mox.StrContains(binary)).\
+                                   AndRaise(exception.NotFound())
+        self.compute.db = dbmock
+        self.compute.host = host
+        self.mox.ReplayAll()
         try: 
-            self.compute.update_service('dummy', host, binary)
+            self.compute.update_available_resource(ctxt)
         except exception.Invalid, e:
-            msg = 'Cannot insert compute manager specific info'
+            msg = 'Cannot update resource info.'
             c1 = ( 0 <= e.message.find(msg))
             self.assertTrue(c1)
-        self.mox.ResetAll()
+        self.mox.UnsetStubs()
+
+    def test_update_available_resource_success(self): 
+        """a testcase of update_available_resource finishes with no errors"""
+
+        def dic_key_check(dic): 
+            validkey = [ 'vcpus_avail', 'memory_mb_avail', 'local_gb_avail']
+            return (list(set(validkey)) == list(set(dic.keys())))
+
+        host = 'foo'
+        binary = 'nova-compute'
+        ctxt = context.get_admin_context()
+        service_ref = {'id':1, 'binary':'nova-compute', 'topic':'compute'} 
+        dbmock = self.mox.CreateMock(db)
+        dbmock.service_get_by_args(mox.IgnoreArg(), 
+                                   mox.StrContains(host), 
+                                   mox.StrContains(binary)).\
+                                   AndReturn(service_ref)
+        dbmock.service_update(mox.IgnoreArg(), 
+                              service_ref['id'], 
+                              mox.Func(dic_key_check))
+
+        self.compute.db = dbmock
+        self.compute.host = host
+        self.mox.ReplayAll()
+        self.compute.update_available_resource(ctxt)
+        self.mox.UnsetStubs()
 
     def _setup_other_managers(self):
         self.volume_manager = utils.import_object(FLAGS.volume_manager)
@@ -444,7 +487,7 @@ class ComputeTestCase(test.TestCase):
         rpc.call(c, db.queue_get_for(c, FLAGS.compute_topic, dest),
                  {"method": "pre_live_migration",
                   "args": {'instance_id': i_id}}).\
-                 InAnyOrder('g1').AndRaise(rpc.RemoteError('du', 'mm', 'y'))
+                 InAnyOrder('g1').AndRaise(rpc.RemoteError('', '', ''))
         self.mox.StubOutWithMock(compute_manager.LOG, 'error')
         compute_manager.LOG.error('Pre live migration for %s failed at %s', 
                                    instance_ref['hostname'], dest)
@@ -480,7 +523,7 @@ class ComputeTestCase(test.TestCase):
         rpc.call(c, compute_topic,
                  {"method": "pre_live_migration",
                   "args": {'instance_id': i_id}}).\
-                 AndRaise(rpc.RemoteError('du', 'mm', 'y'))
+                 AndRaise(rpc.RemoteError('', '', ''))
         self.mox.StubOutWithMock(compute_manager.LOG, 'error')
         compute_manager.LOG.error('Pre live migration for %s failed at %s', 
                                    instance_ref['hostname'], dest)
diff --git a/nova/tests/test_scheduler.py b/nova/tests/test_scheduler.py
index c62bca9b1..36d99d666 100644
--- a/nova/tests/test_scheduler.py
+++ b/nova/tests/test_scheduler.py
@@ -41,6 +41,7 @@ from nova.db.sqlalchemy import models
 FLAGS = flags.FLAGS
 flags.DECLARE('max_cores', 'nova.scheduler.simple')
 flags.DECLARE('stub_network', 'nova.compute.manager')
+flags.DECLARE('instances_path', 'nova.compute.manager')
 
 
 class TestDriver(driver.Scheduler):
@@ -111,7 +112,8 @@ class SchedulerTestCase(test.TestCase):
         scheduler = manager.SchedulerManager()
         dest = 'dummydest'
         ctxt = context.get_admin_context()
-        r0 = {'vcpus':16, 'memory_mb':32, 'local_gb':100}
+        r0 = {'vcpus':16, 'memory_mb':32, 'local_gb':100, 
+             'vcpus_used':16, 'memory_mb_used':32, 'local_gb_used':10}
         service_ref = {'id':1, 'host':dest}
         service_ref.update(r0)
 
@@ -140,7 +142,8 @@ class SchedulerTestCase(test.TestCase):
         scheduler = manager.SchedulerManager()
         dest = 'dummydest'
         ctxt = context.get_admin_context()
-        r0 = {'vcpus':16, 'memory_mb':32, 'local_gb':100}
+        r0 = {'vcpus':16, 'memory_mb':32, 'local_gb':100, 
+             'vcpus_used':16, 'memory_mb_used':32, 'local_gb_used':10}
         r1 = {'vcpus':10, 'memory_mb':4, 'local_gb':20}
         r2 = {'vcpus':10, 'memory_mb':20, 'local_gb':30}
         service_ref = {'id':1, 'host':dest}
@@ -148,7 +151,7 @@ class SchedulerTestCase(test.TestCase):
         instance_ref2 = {'id':2, 'project_id':'p-01', 'host':'dummy'}
         instance_ref2.update(r1)
         instance_ref3 = {'id':3, 'project_id':'p-02', 'host':'dummy'}
-        instance_ref3.update(r1)
+        instance_ref3.update(r2)
 
         self.mox.StubOutWithMock(manager, 'db', use_mock_anything=True)
         manager.db.service_get_all_compute_sorted(mox.IgnoreArg()).\
@@ -176,6 +179,7 @@ class SchedulerTestCase(test.TestCase):
         self.assertTrue( c1 and c2 and c3 and c4 and c5 and c6)
         self.mox.UnsetStubs()
 
+
 class ZoneSchedulerTestCase(test.TestCase):
     """Test case for zone scheduler"""
     def setUp(self):
@@ -495,7 +499,7 @@ class SimpleDriverTestCase(test.TestCase):
         ctxt = context.get_admin_context()
         topic = FLAGS.compute_topic
         i_ref = {'id':1, 'hostname':'i-00000001', 'host':'dummy',
-                       'volumes':[{'id':1}, {'id':2}]}
+                 'volumes':[{'id':1}, {'id':2}]}
         dest = 'dummydest'
 
         self.mox.StubOutWithMock(driver, 'db', use_mock_anything=True)
@@ -793,7 +797,10 @@ class SimpleDriverTestCase(test.TestCase):
         ctxt = context.get_admin_context()
         topic = FLAGS.compute_topic
         i_ref = {'id':1, 'hostname':'i-01', 'host':'dummy'}
+        driver_i = self.scheduler.driver
 
+        self.mox.StubOutWithMock(driver_i, 'mounted_on_same_shared_storage')
+        driver_i.mounted_on_same_shared_storage(mox.IgnoreArg(), i_ref, dest)
         self.mox.StubOutWithMock(driver, 'db', use_mock_anything=True)
         driver.db.service_get_all_by_host(mox.IgnoreArg(), dest).\
                                            AndReturn([])
@@ -813,6 +820,7 @@ class SimpleDriverTestCase(test.TestCase):
         Original host(an instance launched on) does not exist.
         """
         dest = 'dummydest'
+        driver_i = self.scheduler.driver
         ctxt = context.get_admin_context()
         topic = FLAGS.compute_topic
         i_ref = {'id':1, 'hostname':'i-01', 'host':'dummy', 'launched_on':'h1'}
@@ -821,6 +829,8 @@ class SimpleDriverTestCase(test.TestCase):
         service_ref.__setitem__('topic', 'compute')
         service_ref.__setitem__('host', i_ref['host'])
 
+        self.mox.StubOutWithMock(driver_i, 'mounted_on_same_shared_storage')
+        driver_i.mounted_on_same_shared_storage(mox.IgnoreArg(), i_ref, dest)
         self.mox.StubOutWithMock(driver, 'db', use_mock_anything=True)
         driver.db.service_get_all_by_host(mox.IgnoreArg(), dest).\
                                            AndReturn([service_ref])
@@ -844,6 +854,7 @@ class SimpleDriverTestCase(test.TestCase):
         Original host and dest host has different hypervisor type.
         """
         dest = 'dummydest'
+        driver_i = self.scheduler.driver
         ctxt = context.get_admin_context()
         topic = FLAGS.compute_topic
         i_ref = {'id':1, 'hostname':'i-01',
@@ -856,6 +867,8 @@ class SimpleDriverTestCase(test.TestCase):
         service_ref2.__setitem__('id', 2)
         service_ref2.__setitem__('hypervisor_type', 'xen')
 
+        self.mox.StubOutWithMock(driver_i, 'mounted_on_same_shared_storage')
+        driver_i.mounted_on_same_shared_storage(mox.IgnoreArg(), i_ref, dest)
         self.mox.StubOutWithMock(driver, 'db', use_mock_anything=True)
         driver.db.service_get_all_by_host(mox.IgnoreArg(), dest).\
                                            AndReturn([service_ref])
@@ -879,6 +892,7 @@ class SimpleDriverTestCase(test.TestCase):
         Original host and dest host has different hypervisor version.
         """
         dest = 'dummydest'
+        driver_i = self.scheduler.driver
         ctxt = context.get_admin_context()
         topic = FLAGS.compute_topic
         i_ref = {'id':1, 'hostname':'i-01',
@@ -891,6 +905,8 @@ class SimpleDriverTestCase(test.TestCase):
         service_ref2.__setitem__('id', 2)
         service_ref2.__setitem__('hypervisor_version', 12001)
 
+        self.mox.StubOutWithMock(driver_i, 'mounted_on_same_shared_storage')
+        driver_i.mounted_on_same_shared_storage(mox.IgnoreArg(), i_ref, dest)
         self.mox.StubOutWithMock(driver, 'db', use_mock_anything=True)
         driver.db.service_get_all_by_host(mox.IgnoreArg(), dest).\
                                            AndReturn([service_ref])
@@ -914,6 +930,7 @@ class SimpleDriverTestCase(test.TestCase):
         Original host and dest host has different hypervisor version.
         """
         dest = 'dummydest'
+        driver_i = self.scheduler.driver
         ctxt = context.get_admin_context()
         topic = FLAGS.compute_topic
         i_ref = {'id':1, 'hostname':'i-01',
@@ -927,6 +944,8 @@ class SimpleDriverTestCase(test.TestCase):
         service_ref2.__setitem__('hypervisor_version', 12000)
         service_ref2.__setitem__('cpuinfo', '<cpu>info</cpu>')
 
+        self.mox.StubOutWithMock(driver_i, 'mounted_on_same_shared_storage')
+        driver_i.mounted_on_same_shared_storage(mox.IgnoreArg(), i_ref, dest)
         self.mox.StubOutWithMock(driver, 'db', use_mock_anything=True)
         driver.db.service_get_all_by_host(mox.IgnoreArg(), dest).\
                                            AndReturn([service_ref])
@@ -956,6 +975,7 @@ class SimpleDriverTestCase(test.TestCase):
         The testcase make sure everything finished with no error.
         """
         dest = 'dummydest'
+        driver_i = self.scheduler.driver
         ctxt = context.get_admin_context()
         topic = FLAGS.compute_topic
         i_ref = {'id':1, 'hostname':'i-01',
@@ -969,6 +989,8 @@ class SimpleDriverTestCase(test.TestCase):
         service_ref2.__setitem__('hypervisor_version', 12000)
         service_ref2.__setitem__('cpuinfo', '<cpu>info</cpu>')
 
+        self.mox.StubOutWithMock(driver_i, 'mounted_on_same_shared_storage')
+        driver_i.mounted_on_same_shared_storage(mox.IgnoreArg(), i_ref, dest)
         self.mox.StubOutWithMock(driver, 'db', use_mock_anything=True)
         driver.db.service_get_all_by_host(mox.IgnoreArg(), dest).\
                                            AndReturn([service_ref])
@@ -988,121 +1010,134 @@ class SimpleDriverTestCase(test.TestCase):
         self.assertTrue(ret == None)
         self.mox.UnsetStubs()
 
-    def test_has_enough_resource_lack_resource_vcpu(self):
+    def test_has_enough_resource_lack_resource_memory(self):
         """
         A testcase of driver.has_enough_resource. 
-        Lack of vcpu.(boundary check)
+        Lack of memory_mb.(boundary check)
         """
         dest = 'dummydest'
         ctxt = context.get_admin_context()
         topic = FLAGS.compute_topic
-        service_ref = {'id':1, 'vcpus':16, 'memory_mb':32, 'local_gb':100}
-        i_ref1    = {'id':1, 'hostname':'i-01', 'host':'dummy', 
-                    'vcpus':6, 'memory_mb':8, 'local_gb':10}
-        i_ref2 = {'id':2, 'hostname':'i-01', 'host':'dummy', 
-                    'vcpus':5, 'memory_mb':8, 'local_gb':10}
-        i_ref3 = {'id':3, 'hostname':'i-02', 'host':'dummy', 
-                    'vcpus':5, 'memory_mb':8, 'local_gb':10}
+        service_ref = {'id':1,  'memory_mb':32, 'memory_mb_used':12, 'local_gb':100}
+        i_ref = {'id':1, 'hostname':'i-01', 'host':'dummy', 
+                     'vcpus':5, 'memory_mb':20, 'local_gb':10}
 
         self.mox.StubOutWithMock(driver, 'db', use_mock_anything=True)
         driver.db.service_get_all_by_host(mox.IgnoreArg(), dest).\
                                            AndReturn([service_ref])
-        driver.db.instance_get_all_by_host(mox.IgnoreArg(), dest).\
-                      AndReturn([i_ref2, i_ref3])
         
         self.mox.ReplayAll()
         try:
-            self.scheduler.driver.has_enough_resource(ctxt, i_ref1, dest)
+            self.scheduler.driver.has_enough_resource(ctxt, i_ref, dest)
         except exception.NotEmpty, e:
             msg = 'is not capable to migrate'
             self.assertTrue(e.message.find(msg) >= 0)
         self.mox.UnsetStubs()
+        self.mox.UnsetStubs()
 
-    def test_has_enough_resource_lack_resource_memory(self):
+    def test_has_enough_resource_works_correctly(self):
         """
-        A testcase of driver.has_enough_resource. 
-        Lack of memory_mb.(boundary check)
+        A testcase of driver.has_enough_resource 
+        to make sure everything finished with no error.
         """
         dest = 'dummydest'
         ctxt = context.get_admin_context()
         topic = FLAGS.compute_topic
-        service_ref = {'id':1, 'vcpus':16, 'memory_mb':32, 'local_gb':100}
-        i_ref1 = {'id':1, 'hostname':'i-01', 'host':'dummy', 
-                     'vcpus':5, 'memory_mb':16, 'local_gb':10}
-        i_ref2 = {'id':2, 'hostname':'i-01', 'host':'dummy', 
-                  'vcpus':5, 'memory_mb':8, 'local_gb':10}
-        i_ref3 = {'id':3, 'hostname':'i-02', 'host':'dummy', 
+        service_ref = {'id':1, 'memory_mb':120, 'memory_mb_used':32}
+        i_ref = {'id':1, 'hostname':'i-01', 'host':'dummy', 
                   'vcpus':5, 'memory_mb':8, 'local_gb':10}
 
         self.mox.StubOutWithMock(driver, 'db', use_mock_anything=True)
         driver.db.service_get_all_by_host(mox.IgnoreArg(), dest).\
                                            AndReturn([service_ref])
-        driver.db.instance_get_all_by_host(mox.IgnoreArg(), dest).\
-                      AndReturn([i_ref2, i_ref3])
         
         self.mox.ReplayAll()
-        try:
-            self.scheduler.driver.has_enough_resource(ctxt, i_ref1, dest)
-        except exception.NotEmpty, e:
-            msg = 'is not capable to migrate'
-            self.assertTrue(e.message.find(msg) >= 0)
+        ret = self.scheduler.driver.has_enough_resource(ctxt, i_ref, dest)
+        self.assertTrue(ret == None)
         self.mox.UnsetStubs()
+
+    def test_mounted_on_same_shared_storage_cannot_make_tmpfile(self):
+        """
+        A testcase of driver.mounted_on_same_shared_storage
+        checks log message when dest host cannot make tmpfile.
+        """
+        dest = 'dummydest'
+        driver_i = self.scheduler.driver
+        ctxt = context.get_admin_context()
+        topic = FLAGS.compute_topic
+        fpath = '/test/20110127120000'
+        i_ref = {'id':1, 'hostname':'i-01', 'host':'dummy'}
+
+        self.mox.StubOutWithMock(driver, 'rpc', use_mock_anything=True)
+        driver.rpc.call(mox.IgnoreArg(),
+            db.queue_get_for(ctxt, FLAGS.compute_topic, dest),
+            {"method": 'mktmpfile'}).AndRaise(rpc.RemoteError('', '', ''))
+        self.mox.StubOutWithMock(driver.logging, 'error')
+        msg = _("Cannot create tmpfile at %s to confirm shared storage.")
+        driver.logging.error(msg % FLAGS.instances_path)
+
+        self.mox.ReplayAll()
+        self.assertRaises(rpc.RemoteError, 
+                          driver_i.mounted_on_same_shared_storage, 
+                          ctxt, i_ref, dest)
         self.mox.UnsetStubs()
 
-    def test_has_enough_resource_lack_resource_disk(self):
+    def test_mounted_on_same_shared_storage_cannot_comfirm_tmpfile(self):
         """
-        A testcase of driver.has_enough_resource. 
-        Lack of local_gb.(boundary check)
+        A testcase of driver.mounted_on_same_shared_storage
+        checks log message when src host cannot comfirm tmpfile.
         """
-        scheduler = manager.SchedulerManager()
         dest = 'dummydest'
+        driver_i = self.scheduler.driver
         ctxt = context.get_admin_context()
         topic = FLAGS.compute_topic
-        service_ref = {'id':1, 'vcpus':16, 'memory_mb':32, 'local_gb':100}
-        i_ref1 = {'id':1, 'hostname':'i-01', 'host':'dummy', 
-                  'vcpus':5, 'memory_mb':8, 'local_gb':80}
-        i_ref2 = {'id':2, 'hostname':'i-01', 'host':'dummy', 
-                  'vcpus':5, 'memory_mb':8, 'local_gb':10}
-        i_ref3 = {'id':3, 'hostname':'i-02', 'host':'dummy', 
-                  'vcpus':5, 'memory_mb':8, 'local_gb':10}
+        fpath = '/test/20110127120000'
+        i_ref = {'id':1, 'hostname':'i-01', 'host':'dummy'}
+
+        self.mox.StubOutWithMock(driver, 'rpc', use_mock_anything=True)
+        driver.rpc.call(mox.IgnoreArg(),
+            db.queue_get_for(ctxt, FLAGS.compute_topic, dest),
+            {"method": 'mktmpfile'}).AndReturn(fpath)
+        driver.rpc.call(mox.IgnoreArg(), 
+            db.queue_get_for(ctxt, FLAGS.compute_topic, i_ref['host']),
+            {"method": 'exists', "args":{'path':fpath}}).\
+            AndRaise(rpc.RemoteError('','',''))
+        self.mox.StubOutWithMock(driver.logging, 'error')
+        msg = _("Cannot create tmpfile at %s to confirm shared storage.")
+        driver.logging.error(msg % FLAGS.instances_path)
 
-        self.mox.StubOutWithMock(driver, 'db', use_mock_anything=True)
-        driver.db.service_get_all_by_host(mox.IgnoreArg(), dest).\
-                                           AndReturn([service_ref])
-        driver.db.instance_get_all_by_host(mox.IgnoreArg(), dest).\
-                      AndReturn([i_ref2, i_ref3])
-        
         self.mox.ReplayAll()
-        try:
-            self.scheduler.driver.has_enough_resource(ctxt, i_ref1, dest)
-        except exception.NotEmpty, e:
-            msg = 'is not capable to migrate'
-            self.assertTrue(e.message.find(msg) >= 0)
+        self.assertRaises(rpc.RemoteError, 
+                          driver_i.mounted_on_same_shared_storage, 
+                          ctxt, i_ref, dest)
         self.mox.UnsetStubs()
 
-    def test_has_enough_resource_works_correctly(self):
+
+    def test_mounted_on_same_shared_storage_works_correctly(self):
         """
-        A testcase of driver.has_enough_resource 
+        A testcase of driver.mounted_on_same_shared_storage
         to make sure everything finished with no error.
         """
         dest = 'dummydest'
         ctxt = context.get_admin_context()
         topic = FLAGS.compute_topic
-        service_ref = {'id':1, 'vcpus':16, 'memory_mb':32, 'local_gb':100}
-        i_ref1 = {'id':1, 'hostname':'i-01', 'host':'dummy', 
-                  'vcpus':5, 'memory_mb':8, 'local_gb':10}
-        i_ref2 = {'id':2, 'hostname':'i-01', 'host':'dummy', 
-                  'vcpus':5, 'memory_mb':8, 'local_gb':10}
-        i_ref3 = {'id':3, 'hostname':'i-02', 'host':'dummy', 
-                  'vcpus':5, 'memory_mb':8, 'local_gb':10}
+        fpath = '/test/20110127120000'
+        i_ref = {'id':1, 'hostname':'i-01', 'host':'dummy'}
+
+        self.mox.StubOutWithMock(driver, 'rpc', use_mock_anything=True)
+        driver.rpc.call(mox.IgnoreArg(),
+            db.queue_get_for(mox.IgnoreArg(), FLAGS.compute_topic, dest),
+            {"method": 'mktmpfile'}).AndReturn(fpath)
+        driver.rpc.call(mox.IgnoreArg(), 
+            db.queue_get_for(mox.IgnoreArg(), FLAGS.compute_topic, i_ref['host']),
+            {"method": 'exists', "args":{'path':fpath}})
+        driver.rpc.call(mox.IgnoreArg(), 
+            db.queue_get_for(mox.IgnoreArg(), FLAGS.compute_topic, dest),
+            {"method": 'remove', "args":{'path':fpath}})
 
-        self.mox.StubOutWithMock(driver, 'db', use_mock_anything=True)
-        driver.db.service_get_all_by_host(mox.IgnoreArg(), dest).\
-                                           AndReturn([service_ref])
-        driver.db.instance_get_all_by_host(mox.IgnoreArg(), dest).\
-                      AndReturn([i_ref2, i_ref3])
-        
         self.mox.ReplayAll()
-        ret = self.scheduler.driver.has_enough_resource(ctxt, i_ref1, dest)
+        ret = self.scheduler.driver.mounted_on_same_shared_storage(ctxt,
+                                                                   i_ref,
+                                                                   dest)
         self.assertTrue(ret == None)
         self.mox.UnsetStubs()
diff --git a/nova/tests/test_virt.py b/nova/tests/test_virt.py
index 177e8f021..2828baced 100644
--- a/nova/tests/test_virt.py
+++ b/nova/tests/test_virt.py
@@ -241,11 +241,11 @@ class LibvirtConnTestCase(test.TestCase):
             uri = conn.get_uri()
             self.assertEquals(uri, testuri)
 
-    def test_get_memory_mb(self):
+    def test_get_vcpu_total(self):
         """
-        Check if get_memory_mb returns memory value
+        Check if get_vcpu_total returns appropriate cpu value 
         Connection/OS/driver differenct does not matter for this method,
-        so everyone can execute for checking.
+        everyone can execute for checking.
         """
         try: 
             self._driver_dependent_test_setup()
@@ -254,9 +254,87 @@ class LibvirtConnTestCase(test.TestCase):
 
         self.mox.ReplayAll()
         conn = libvirt_conn.LibvirtConnection(False)
-        self.assertTrue(0 < conn.get_memory_mb())
+        self.assertTrue(0 < conn.get_vcpu_total())
         self.mox.UnsetStubs()
 
+
+    def test_get_memory_mb_total(self):
+        """Check if get_memory_mb returns appropriate memory value"""
+        try: 
+            self._driver_dependent_test_setup()
+        except: 
+            return 
+
+        self.mox.ReplayAll()
+        conn = libvirt_conn.LibvirtConnection(False)
+        self.assertTrue(0 < conn.get_memory_mb_total())
+        self.mox.UnsetStubs()
+
+    def test_get_local_gb_total(self):
+        """Check if get_local_gb_total returns appropriate disk value"""
+        # Note(masumotok): cannot test b/c FLAGS.instances_path is
+        #                  inevitable for this test.. 
+        #try:
+        #    self._driver_dependent_test_setup()
+        #except:
+        #    return
+        #
+        #self.mox.ReplayAll()
+        #conn = libvirt_conn.LibvirtConnection(False)
+        #self.assertTrue(0 < conn.get_local_gb_total())
+        #self.mox.UnsetStubs()
+        pass
+
+    def test_get_vcpu_used(self):
+        """Check if get_local_gb_total returns appropriate disk value"""
+        try:
+            self._driver_dependent_test_setup()
+        except:
+            return
+
+        self.mox.StubOutWithMock(libvirt_conn.LibvirtConnection, '_conn', use_mock_anything=True)
+        libvirt_conn.LibvirtConnection._conn.listDomainsID().AndReturn([1,2])
+        vdmock = self.mox.CreateMock(libvirt.virDomain)
+        self.mox.StubOutWithMock(vdmock, "vcpus", use_mock_anything=True)
+        vdmock.vcpus().AndReturn(['', [('dummycpu'), ('dummycpu')]])
+        vdmock.vcpus().AndReturn(['', [('dummycpu'), ('dummycpu')]])
+        libvirt_conn.LibvirtConnection._conn.lookupByID(mox.IgnoreArg()).\
+            AndReturn(vdmock)
+        libvirt_conn.LibvirtConnection._conn.lookupByID(mox.IgnoreArg()).\
+            AndReturn(vdmock)
+
+        self.mox.ReplayAll()
+        conn = libvirt_conn.LibvirtConnection(False)
+        self.assertTrue( conn.get_vcpu_used() == 4)
+        self.mox.UnsetStubs()
+
+    def test_get_memory_mb_used(self):
+        """Check if get_memory_mb returns appropriate memory value"""
+        try:
+            self._driver_dependent_test_setup()
+        except:
+            return
+
+        self.mox.ReplayAll()
+        conn = libvirt_conn.LibvirtConnection(False)
+        self.assertTrue(0 < conn.get_memory_mb_used())
+        self.mox.UnsetStubs()
+
+    def test_get_local_gb_used(self):
+        """Check if get_local_gb_total returns appropriate disk value"""
+        # Note(masumotok): cannot test b/c FLAGS.instances_path is
+        #                  inevitable for this test.. 
+        #try:
+        #    self._driver_dependent_test_setup()
+        #except:
+        #    return
+
+        #self.mox.ReplayAll()
+        #conn = libvirt_conn.LibvirtConnection(False)
+        #self.assertTrue(0 < conn.get_local_gb_used())
+        #self.mox.UnsetStubs()
+        pass
+
     def test_get_cpu_info_works_correctly(self):
         """
         Check if get_cpu_info works correctly.
diff --git a/nova/utils.py b/nova/utils.py
index 6d3ddd092..e8919d7a5 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -303,6 +303,24 @@ def str_dict_replace(s, mapping):
     return s
 
 
+def mktmpfile(dir):
+    """create tmpfile under dir, and return filename."""
+    filename = datetime.datetime.utcnow().strftime('%Y%m%d%H%M%S')
+    fpath = os.path.join(dir, filename)
+    open(fpath, 'a+').write(fpath+'\n')
+    return fpath
+
+
+def exists(filename):
+    """check file path existence."""
+    return os.path.exists(filename)
+
+
+def remove(filename):
+    """remove file."""
+    return os.remove(filename)
+
+
 class LazyPluggable(object):
     """A pluggable backend loaded lazily based on some value."""
 
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 a776844e38c7e747397785a6ce6b1de1b043d850 Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Tue, 1 Feb 2011 18:34:46 -0800
Subject: initial support for dynamic instance_types: db migration and model,
 stub tests and stub methods.

---
 nova/compute/instance_types.py                     | 12 ++++
 .../sqlalchemy/migrate_repo/versions/003_cactus.py | 76 ++++++++++++++++++++++
 nova/db/sqlalchemy/models.py                       | 10 +++
 nova/tests/api/openstack/test_flavors.py           | 10 +++
 4 files changed, 108 insertions(+)
 create mode 100644 nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py

(limited to 'nova')

diff --git a/nova/compute/instance_types.py b/nova/compute/instance_types.py
index 196d6a8df..1b3d0d0eb 100644
--- a/nova/compute/instance_types.py
+++ b/nova/compute/instance_types.py
@@ -48,3 +48,15 @@ def get_by_flavor_id(flavor_id):
         if details['flavorid'] == flavor_id:
             return instance_type
     return FLAGS.default_instance_type
+
+
+def list_flavors():
+    return instance_type
+
+
+def create_flavor():
+    return instance_type
+
+
+def delete_flavor():
+    return instance_type
diff --git a/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py b/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py
new file mode 100644
index 000000000..cc4a7aec0
--- /dev/null
+++ b/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py
@@ -0,0 +1,76 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+#    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 sqlalchemy import *
+from migrate import *
+
+
+from nova import log as logging
+
+
+meta = MetaData()
+
+
+#
+# New Tables
+#
+# Here are the old static instance types
+# INSTANCE_TYPES = {
+# 'm1.tiny': dict(memory_mb=512, vcpus=1, local_gb=0, flavorid=1),
+# 'm1.small': dict(memory_mb=2048, vcpus=1, local_gb=20, flavorid=2),
+# 'm1.medium': dict(memory_mb=4096, vcpus=2, local_gb=40, flavorid=3),
+# 'm1.large': dict(memory_mb=8192, vcpus=4, local_gb=80, flavorid=4),
+# 'm1.xlarge': dict(memory_mb=16384, vcpus=8, local_gb=160, flavorid=5)}
+instance_types = Table('instance_types', meta,
+        Column('created_at', DateTime(timezone=False)),
+        Column('deleted_at', DateTime(timezone=False)),
+        Column('deleted', Boolean(create_constraint=True, name=None)),
+        Column('id', Integer(),  primary_key=True, nullable=False),
+        Column('memory_mb', Integer(),  nullable=False),
+        Column('vcpus', Integer(),  nullable=False),
+        Column('local_gb', Integer(),  nullable=False),
+        Column('flavorid', Integer(),  nullable=False),
+        )
+
+
+def upgrade(migrate_engine):
+    # Upgrade operations go here
+    # Don't create your own engine; bind migrate_engine
+    # to your metadata
+    meta.bind = migrate_engine
+    try:
+        instance_types.create()
+    except Exception:
+        logging.info(repr(table))
+        logging.exception('Exception while creating table')
+        raise
+
+    # TODO(ken-pepple) fix this to pre-populate the default EC2 types
+    #INSTANCE_TYPES = {
+    #    'm1.tiny': dict(memory_mb=512, vcpus=1, local_gb=0, flavorid=1),
+    #    'm1.small': dict(memory_mb=2048, vcpus=1, local_gb=20, flavorid=2),
+    #    'm1.medium': dict(memory_mb=4096, vcpus=2, local_gb=40, flavorid=3),
+    #    'm1.large': dict(memory_mb=8192, vcpus=4, local_gb=80, flavorid=4),
+    #    'm1.xlarge': dict(memory_mb=16384, vcpus=8, local_gb=160, flavorid=5)}
+    # for instance_type in INSTANCE_TYPES:
+    #	try:
+            # prepopulate tables with EC2 types
+
+
+def downgrade(migrate_engine):
+    # Operations to reverse the above upgrade go here.
+    #    # Operations to reverse the above upgrade go here.
+    #    for table in (instance_types):
+    #        table.drop()
+    pass
diff --git a/nova/db/sqlalchemy/models.py b/nova/db/sqlalchemy/models.py
index c54ebe3ba..762425670 100644
--- a/nova/db/sqlalchemy/models.py
+++ b/nova/db/sqlalchemy/models.py
@@ -210,6 +210,16 @@ class InstanceActions(BASE, NovaBase):
     error = Column(Text)
 
 
+class InstanceTypes(BASE, NovaBase):
+    """Represent possible instance_types or flavor of VM offered"""
+    __tablename__ = "instance_types"
+    id = Column(Integer, primary_key=True)
+    memory_mb = Column(Integer)
+    vcpus = Column(Integer)
+    local_gb = Column(Integer)
+    flavorid = Column(Integer)
+
+
 class Volume(BASE, NovaBase):
     """Represents a block storage device that can be attached to a vm."""
     __tablename__ = 'volumes'
diff --git a/nova/tests/api/openstack/test_flavors.py b/nova/tests/api/openstack/test_flavors.py
index 1bdaea161..05624c5a9 100644
--- a/nova/tests/api/openstack/test_flavors.py
+++ b/nova/tests/api/openstack/test_flavors.py
@@ -44,5 +44,15 @@ class FlavorsTest(unittest.TestCase):
     def test_get_flavor_by_id(self):
         pass
 
+    def test_create_favor(self):
+        pass
+
+    def test_delete_flavor(self):
+        pass
+
+    def test_list_flavors(self):
+        pass
+
+
 if __name__ == '__main__':
     unittest.main()
-- 
cgit 


From 6d2e2c52012abac8cab322357ce0ffd0ffc2fbaf Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Wed, 2 Feb 2011 10:49:02 -0600
Subject: Casting to the scheduler

---
 nova/compute/api.py | 10 +++++++---
 nova/rpc.py         |  2 +-
 2 files changed, 8 insertions(+), 4 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/api.py b/nova/compute/api.py
index 0faa066b5..283845709 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -404,10 +404,14 @@ class API(base.Base):
         process."""
         raise NotImplemented()
 
-    def resize(self, context, instance_id, flavor_id):
+    def resize(self, context, instance_id, flavor):
         """Resize a running instance."""
-        self._cast_compute_message('resize_instance', context, instance_id,
-                flavor_id)
+        rpc.cast(context,
+                     FLAGS.scheduler_topic,
+                     {"method": "resize_instance",
+                      "args": {"topic": FLAGS.compute_topic,
+                               "instance_id": instance_id,
+                               "flavor": flavor}})
         
     def pause(self, context, instance_id):
         """Pause the given instance."""
diff --git a/nova/rpc.py b/nova/rpc.py
index 01fc6d44b..c4c938f4d 100644
--- a/nova/rpc.py
+++ b/nova/rpc.py
@@ -119,7 +119,7 @@ class Consumer(messaging.Consumer):
                 LOG.error(_("Reconnected to queue"))
                 self.failed_connection = False
         # NOTE(vish): This is catching all errors because we really don't
-        #             exceptions to be logged 10 times a second if some
+        #             want exceptions to be logged 10 times a second if some
         #             persistent failure occurs.
         except Exception:  # pylint: disable-msg=W0703
             if not self.failed_connection:
-- 
cgit 


From 563a77fd4aa80da9bddac5cf7f8f27ed2dedb39d Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Thu, 3 Feb 2011 17:52:19 -0800
Subject: added seed data to migration

---
 .../sqlalchemy/migrate_repo/versions/003_cactus.py | 53 ++++++++++++----------
 1 file changed, 30 insertions(+), 23 deletions(-)

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py b/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py
index cc4a7aec0..c7e61dc05 100644
--- a/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py
+++ b/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py
@@ -15,9 +15,11 @@
 from sqlalchemy import *
 from migrate import *
 
-
+from nova import api
+from nova import db
 from nova import log as logging
 
+import time
 
 meta = MetaData()
 
@@ -25,17 +27,14 @@ meta = MetaData()
 #
 # New Tables
 #
-# Here are the old static instance types
-# INSTANCE_TYPES = {
-# 'm1.tiny': dict(memory_mb=512, vcpus=1, local_gb=0, flavorid=1),
-# 'm1.small': dict(memory_mb=2048, vcpus=1, local_gb=20, flavorid=2),
-# 'm1.medium': dict(memory_mb=4096, vcpus=2, local_gb=40, flavorid=3),
-# 'm1.large': dict(memory_mb=8192, vcpus=4, local_gb=80, flavorid=4),
-# 'm1.xlarge': dict(memory_mb=16384, vcpus=8, local_gb=160, flavorid=5)}
 instance_types = Table('instance_types', meta,
         Column('created_at', DateTime(timezone=False)),
+        Column('updated_at', DateTime(timezone=False)),
         Column('deleted_at', DateTime(timezone=False)),
         Column('deleted', Boolean(create_constraint=True, name=None)),
+        Column('name',
+               String(length=255, convert_unicode=False, assert_unicode=None,
+                      unicode_error=None, _warn_on_bytestring=False)),
         Column('id', Integer(),  primary_key=True, nullable=False),
         Column('memory_mb', Integer(),  nullable=False),
         Column('vcpus', Integer(),  nullable=False),
@@ -53,24 +52,32 @@ def upgrade(migrate_engine):
         instance_types.create()
     except Exception:
         logging.info(repr(table))
-        logging.exception('Exception while creating table')
+        logging.exception('Exception while creating instance_types table')
         raise
 
-    # TODO(ken-pepple) fix this to pre-populate the default EC2 types
-    #INSTANCE_TYPES = {
-    #    'm1.tiny': dict(memory_mb=512, vcpus=1, local_gb=0, flavorid=1),
-    #    'm1.small': dict(memory_mb=2048, vcpus=1, local_gb=20, flavorid=2),
-    #    'm1.medium': dict(memory_mb=4096, vcpus=2, local_gb=40, flavorid=3),
-    #    'm1.large': dict(memory_mb=8192, vcpus=4, local_gb=80, flavorid=4),
-    #    'm1.xlarge': dict(memory_mb=16384, vcpus=8, local_gb=160, flavorid=5)}
-    # for instance_type in INSTANCE_TYPES:
-    #	try:
-            # prepopulate tables with EC2 types
+    # Here are the old static instance types
+    INSTANCE_TYPES = {
+    'm1.tiny': dict(memory_mb=512, vcpus=1, local_gb=0, flavorid=1),
+    'm1.small': dict(memory_mb=2048, vcpus=1, local_gb=20, flavorid=2),
+    'm1.medium': dict(memory_mb=4096, vcpus=2, local_gb=40, flavorid=3),
+    'm1.large': dict(memory_mb=8192, vcpus=4, local_gb=80, flavorid=4),
+    'm1.xlarge': dict(memory_mb=16384, vcpus=8, local_gb=160, flavorid=5)}
+    try:
+        i = instance_types.insert()
+        for name, values in INSTANCE_TYPES.iteritems():
+            # FIXME(kpepple) should we be seeding created_at / updated_at ?
+            # the_time = time.strftime("%Y-%m-%d %H:%M:%S")
+            i.execute({'name': name, 'memory_mb': values["memory_mb"],
+                        'vcpus': values["vcpus"],
+                        'local_gb': values["local_gb"],
+                        'flavorid': values["flavorid"]})
+    except Exception:
+        logging.info(repr(table))
+        logging.exception('Exception while seeding instance_types table')
+        raise
 
 
 def downgrade(migrate_engine):
     # Operations to reverse the above upgrade go here.
-    #    # Operations to reverse the above upgrade go here.
-    #    for table in (instance_types):
-    #        table.drop()
-    pass
+    for table in (instance_types):
+        table.drop()
-- 
cgit 


From 9be0770208b0e75c7d93ba10165b82d5be11be27 Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
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/api/ec2/admin.py                    |  1 +
 nova/api/openstack/flavors.py            |  2 ++
 nova/compute/api.py                      |  2 ++
 nova/compute/instance_types.py           | 17 ++++-------------
 nova/db/api.py                           | 20 ++++++++++++++++++++
 nova/db/sqlalchemy/api.py                | 31 +++++++++++++++++++++++++++++++
 nova/db/sqlalchemy/models.py             |  1 +
 nova/tests/api/openstack/test_flavors.py | 30 +++++++++++++++++++-----------
 nova/tests/db/fakes.py                   |  1 +
 nova/tests/test_quota.py                 |  3 +++
 nova/tests/test_xenapi.py                |  1 +
 nova/virt/libvirt_conn.py                |  2 ++
 nova/virt/xenapi/vm_utils.py             |  1 +
 13 files changed, 88 insertions(+), 24 deletions(-)

(limited to 'nova')

diff --git a/nova/api/ec2/admin.py b/nova/api/ec2/admin.py
index d7e899d12..55cca1041 100644
--- a/nova/api/ec2/admin.py
+++ b/nova/api/ec2/admin.py
@@ -79,6 +79,7 @@ class AdminController(object):
     def __str__(self):
         return 'AdminController'
 
+    # FIX-ME(kpepple) for dynamic flavors
     def describe_instance_types(self, _context, **_kwargs):
         return {'instanceTypeSet': [instance_dict(n, v) for n, v in
                                     instance_types.INSTANCE_TYPES.iteritems()]}
diff --git a/nova/api/openstack/flavors.py b/nova/api/openstack/flavors.py
index f620d4107..1f5185134 100644
--- a/nova/api/openstack/flavors.py
+++ b/nova/api/openstack/flavors.py
@@ -45,6 +45,7 @@ class Controller(wsgi.Controller):
 
     def show(self, req, id):
         """Return data about the given flavor id."""
+        # FIX-ME(kpepple) for dynamic flavors
         for name, val in instance_types.INSTANCE_TYPES.iteritems():
             if val['flavorid'] == int(id):
                 item = dict(ram=val['memory_mb'], disk=val['local_gb'],
@@ -54,4 +55,5 @@ class Controller(wsgi.Controller):
 
     def _all_ids(self):
         """Return the list of all flavorids."""
+        # FIX-ME(kpepple) for dynamic flavors
         return [i['flavorid'] for i in instance_types.INSTANCE_TYPES.values()]
diff --git a/nova/compute/api.py b/nova/compute/api.py
index 1d8b9d79f..3ae722226 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -89,6 +89,8 @@ class API(base.Base):
         """Create the number of instances requested if quota and
         other arguments check out ok."""
 
+        # FIXME(kpepple) this needs to be changed from using the old constant
+        #type_data = db.instance_type_get_by_name(context.get_admin_context(), instance_type)
         type_data = instance_types.INSTANCE_TYPES[instance_type]
         num_instances = quota.allowed_instances(context, max_count, type_data)
         if num_instances < min_count:
diff --git a/nova/compute/instance_types.py b/nova/compute/instance_types.py
index 1b3d0d0eb..0594aa063 100644
--- a/nova/compute/instance_types.py
+++ b/nova/compute/instance_types.py
@@ -25,6 +25,7 @@ from nova import flags
 from nova import exception
 
 FLAGS = flags.FLAGS
+# FIX-ME(kpepple) for dynamic flavors
 INSTANCE_TYPES = {
     'm1.tiny': dict(memory_mb=512, vcpus=1, local_gb=0, flavorid=1),
     'm1.small': dict(memory_mb=2048, vcpus=1, local_gb=20, flavorid=2),
@@ -35,8 +36,9 @@ INSTANCE_TYPES = {
 
 def get_by_type(instance_type):
     """Build instance data structure and save it to the data store."""
+    # FIX-ME(kpepple) for dynamic flavors
     if instance_type is None:
-        return FLAGS.default_instance_type
+             return FLAGS.default_instance_type
     if instance_type not in INSTANCE_TYPES:
         raise exception.ApiError(_("Unknown instance type: %s"),
                                  instance_type)
@@ -44,19 +46,8 @@ def get_by_type(instance_type):
 
 
 def get_by_flavor_id(flavor_id):
+    # FIX-ME(kpepple) for dynamic flavors
     for instance_type, details in INSTANCE_TYPES.iteritems():
         if details['flavorid'] == flavor_id:
             return instance_type
     return FLAGS.default_instance_type
-
-
-def list_flavors():
-    return instance_type
-
-
-def create_flavor():
-    return instance_type
-
-
-def delete_flavor():
-    return instance_type
diff --git a/nova/db/api.py b/nova/db/api.py
index c6c03fb0e..ffb1d08ce 100644
--- a/nova/db/api.py
+++ b/nova/db/api.py
@@ -985,3 +985,23 @@ def console_get_all_by_instance(context, instance_id):
 def console_get(context, console_id, instance_id=None):
     """Get a specific console (possibly on a given instance)."""
     return IMPL.console_get(context, console_id, instance_id)
+
+
+    ##################
+
+
+def instance_type_create(context, values):
+    """Create a new instance type"""
+    return IMPL.instance_type_create(context, values)
+
+def instance_type_get_all(context):
+    """Get all instance types"""
+    return IMPL.instance_type_get_all(context)
+
+def instance_type_get_by_name(context, name):
+    """Get instance type by name"""
+    return IMPL.instance_type_get_by_name(context, name)
+
+def instance_type_destroy(context, name):
+    """Delete a instance type"""
+    return IMPL.instance_type_destroy(context,name)
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index fa060228f..aa6434b65 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -2018,3 +2018,34 @@ def console_get(context, console_id, instance_id=None):
         raise exception.NotFound(_("No console with id %(console_id)s"
                                    " %(idesc)s") % locals())
     return result
+
+
+    ##################
+
+
+@require_admin_context
+def instance_type_create(context, values):
+    instance_type_ref = models.InstanceTypes()
+    instance_type_ref.update(values)
+    instance_type_ref.save()
+    return instance_type_ref
+
+def instance_type_get_all(context):
+    session = get_session()
+    return session.query(models.InstanceTypes).\
+                    filter_by(deleted=0)
+
+def instance_type_get_by_name(context, name):
+    session = get_session()
+    return session.query(models.InstanceTypes).\
+                    filter_by(name=name).\
+                    first()
+
+@require_admin_context
+def instance_type_destroy(context,name):
+    session = get_session()
+    instance_type_ref = session.query(models.InstanceTypes).\
+                    filter_by(name=name)
+    rows = instance_type_ref.update(dict(deleted=1))
+    return instance_type_ref
+    
diff --git a/nova/db/sqlalchemy/models.py b/nova/db/sqlalchemy/models.py
index 762425670..44583861b 100644
--- a/nova/db/sqlalchemy/models.py
+++ b/nova/db/sqlalchemy/models.py
@@ -214,6 +214,7 @@ class InstanceTypes(BASE, NovaBase):
     """Represent possible instance_types or flavor of VM offered"""
     __tablename__ = "instance_types"
     id = Column(Integer, primary_key=True)
+    name = Column(String(255), unique=True)
     memory_mb = Column(Integer)
     vcpus = Column(Integer)
     local_gb = Column(Integer)
diff --git a/nova/tests/api/openstack/test_flavors.py b/nova/tests/api/openstack/test_flavors.py
index 05624c5a9..0f0ed2e84 100644
--- a/nova/tests/api/openstack/test_flavors.py
+++ b/nova/tests/api/openstack/test_flavors.py
@@ -21,6 +21,8 @@ import stubout
 import webob
 
 import nova.api
+from nova import context
+from nova import db
 from nova.api.openstack import flavors
 from nova.tests.api.openstack import fakes
 
@@ -33,6 +35,7 @@ class FlavorsTest(unittest.TestCase):
         fakes.stub_out_networking(self.stubs)
         fakes.stub_out_rate_limiting(self.stubs)
         fakes.stub_out_auth(self.stubs)
+        self.context = context.get_admin_context()
 
     def tearDown(self):
         self.stubs.UnsetAll()
@@ -41,17 +44,22 @@ class FlavorsTest(unittest.TestCase):
         req = webob.Request.blank('/v1.0/flavors')
         res = req.get_response(fakes.wsgi_app())
 
-    def test_get_flavor_by_id(self):
-        pass
-
-    def test_create_favor(self):
-        pass
-
-    def test_delete_flavor(self):
-        pass
-
-    def test_list_flavors(self):
-        pass
+    def test_create_list_delete_favor(self):
+        # create a new flavor
+        starting_flavors = db.instance_type_get_all(self.context)
+        new_instance_type = dict(name="os1.big",memory_mb=512, vcpus=1, local_gb=120, flavorid=25)
+        new_flavor = db.instance_type_create(self.context, new_instance_type)
+        self.assertEqual(new_flavor["name"], new_instance_type["name"])
+        # retrieve the newly created flavor
+        retrieved_new_flavor = db.instance_type_get_by_name(self.context, new_instance_type["name"])
+        # self.assertEqual(len(tuple(retrieved_new_flavor)),1)
+        self.assertEqual(retrieved_new_flavor["memory_mb"], new_instance_type["memory_mb"])
+        flavors = db.instance_type_get_all(self.context)
+        self.assertNotEqual(starting_flavors, flavors)
+        # delete the newly created flavor
+        delete_query = db.instance_type_destroy(self.context,new_instance_type["name"])
+        retrieve_deleted_flavor = db.instance_type_get_by_name(self.context, new_instance_type["name"])
+        self.assertEqual(retrieve_deleted_flavor["deleted"], 1)        
 
 
 if __name__ == '__main__':
diff --git a/nova/tests/db/fakes.py b/nova/tests/db/fakes.py
index 05bdd172e..6cf917d76 100644
--- a/nova/tests/db/fakes.py
+++ b/nova/tests/db/fakes.py
@@ -44,6 +44,7 @@ def stub_out_db_instance_api(stubs):
     def fake_instance_create(values):
         """ Stubs out the db.instance_create method """
 
+        # FIX-ME(kpepple) for dynamic flavors
         type_data = instance_types.INSTANCE_TYPES[values['instance_type']]
 
         base_options = {
diff --git a/nova/tests/test_quota.py b/nova/tests/test_quota.py
index 9548a8c13..f2c9c456f 100644
--- a/nova/tests/test_quota.py
+++ b/nova/tests/test_quota.py
@@ -75,15 +75,18 @@ class QuotaTestCase(test.TestCase):
 
     def test_quota_overrides(self):
         """Make sure overriding a projects quotas works"""
+        # FIX-ME(kpepple) for dynamic flavors
         num_instances = quota.allowed_instances(self.context, 100,
             instance_types.INSTANCE_TYPES['m1.small'])
         self.assertEqual(num_instances, 2)
         db.quota_create(self.context, {'project_id': self.project.id,
                                        'instances': 10})
+        # FIX-ME(kpepple) for dynamic flavors
         num_instances = quota.allowed_instances(self.context, 100,
             instance_types.INSTANCE_TYPES['m1.small'])
         self.assertEqual(num_instances, 4)
         db.quota_update(self.context, self.project.id, {'cores': 100})
+        # FIX-ME(kpepple) for dynamic flavors
         num_instances = quota.allowed_instances(self.context, 100,
             instance_types.INSTANCE_TYPES['m1.small'])
         self.assertEqual(num_instances, 10)
diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index 9f5b266f3..e38bd4dab 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -225,6 +225,7 @@ class XenAPIVMTestCase(test.TestCase):
         vm = vms[0]
 
         # Check that m1.large above turned into the right thing.
+        # FIX-ME(kpepple) for dynamic flavors
         instance_type = instance_types.INSTANCE_TYPES['m1.large']
         mem_kib = long(instance_type['memory_mb']) << 10
         mem_bytes = str(mem_kib << 10)
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 <matt.dietz@rackspace.com>
Date: Fri, 4 Feb 2011 15:13:18 -0600
Subject: Added a bunch of stubbed out functionality

---
 nova/compute/api.py          | 22 +++++++++------
 nova/compute/manager.py      | 65 ++++++++++++++++++++++++++++++++++++++------
 nova/db/api.py               | 22 ++++++++++++++-
 nova/db/sqlalchemy/api.py    | 53 ++++++++++++++++++++++++++++++++++++
 nova/db/sqlalchemy/models.py | 12 +++++++-
 nova/virt/xenapi/vmops.py    | 18 ++++++++++--
 nova/virt/xenapi_conn.py     | 11 ++++++++
 7 files changed, 183 insertions(+), 20 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/api.py b/nova/compute/api.py
index 283845709..f0d5ff2cb 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -379,6 +379,10 @@ class API(base.Base):
         kwargs = {'method': method, 'args': params}
         return rpc.call(context, queue, kwargs)
 
+    def _cast_scheduler_message(self, context, args)
+        """Generic handler for RPC calls to the scheduler"""
+        rpc.cast(context, FLAGS.scheduler_topic, args)
+
     def snapshot(self, context, instance_id, name):
         """Snapshot the given instance.
 
@@ -397,21 +401,23 @@ class API(base.Base):
 
     def revert_resize(self, context, instance_id):
         """Reverts a resize, deleting the 'new' instance in the process"""
-        raise NotImplemented()
+        instance_ref = self.db.instance_get(instance_id)
+        self._cast_compute_message('revert_resize', context, instance_id,
+                instance_ref['host'])
 
     def confirm_resize(self, context, instance_id):
         """Confirms a migration/resize, deleting the 'old' instance in the
         process."""
-        raise NotImplemented()
+        migration_ref = self.db.get_migration_by_instance_id(instance_id)
+        self._cast_compute_message('confirm_resize', context, instance_id,
+                migration_ref['source_host'])
 
     def resize(self, context, instance_id, flavor):
         """Resize a running instance."""
-        rpc.cast(context,
-                     FLAGS.scheduler_topic,
-                     {"method": "resize_instance",
-                      "args": {"topic": FLAGS.compute_topic,
-                               "instance_id": instance_id,
-                               "flavor": flavor}})
+        self._cast_scheduler_message(context,
+                    {"method": "prep_resize",
+                     "args": {"topic": FLAGS.compute_topic,
+                              "instance_id": instance_id, }},)
         
     def pause(self, context, instance_id):
         """Pause the given instance."""
diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 41ef23980..140db0d3e 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -380,18 +380,67 @@ class ComputeManager(manager.Manager):
         """Update instance state when async task completes."""
         self._update_state(context, instance_id)
 
+
     @exception.wrap_exception
     @checks_instance_lock
-    def resize_instance(self, context, instance_id, flavor_id):
-        """Moves a running instance to another host, possibly changing the RAM
-        and disk size in the process"""
+    def prep_resize(self, context, instance_id):
+        """Initiates the process of moving a running instance to another 
+        host, possibly changing the RAM and disk size in the process"""
         context = context.elevated()
         instance_ref = self.db.instance_get(context. instance_id)
-        LOG.audit(_('instance %s: migrating'), instance_id, context=context)
-        self.db.instance_set_state(context, instance_id, power_state.RUNNING,
-                'migrating')
-        self.driver.resize(instance_ref, flavor_id)
-        self._update_state(context, instance_id)
+        migration_ref = self.db.migration_create(context, 
+                { 'instance_id': instance_id,
+                  'source_host': instance_ref['host'],
+                  'dest_host':   socket.gethostbyname(socket.gethostname()),
+                  'status':      'pre-migrating' }
+        LOG.audit(_('instance %s: migrating to '), instance_id, context=context)
+        service = self.db.service_get_by_host_and_topic(context,
+                instance_ref['host'], topic)
+        topic = self.db.queue_get_for(context, topic, service['id'])
+        rpc.cast(context, topic, 
+                { 'method': 'resize_instance',
+                  'migration_id': migration_ref['id'], }
+
+    @exception.wrap_exception
+    @checks_instance_lock
+    def resize_instance(self, context, migration_id):
+        """Starts the migration of a running instance to another host"""
+        migration_ref = self.db.migration_get(context, migration_id)
+        self.db.migration_update(context, migration_id, 
+                { 'status': 'migrating', })
+        self.driver.transfer_disk(context, instance_id, 
+                                  migration_ref['dest_host'])
+        self.db.migration_update(context, migration_id, 
+                { 'status': 'post-migrating', })
+
+        self.driver.power_off(context, migration_ref['instance_id'])
+        # This is where we would update the VM record after resizing
+        
+        service = self.db.service_get_by_host_and_topic(context,
+                migration_ref['dest_host'], topic)
+        topic = self.db.queue_get_for(context, topic, service['id'])
+        rpc.cast(context, topic, 
+                { 'method': 'finish_resize',
+                  'migration_id': migration_ref['id'], }
+
+    @exception.wrap_exception
+    @checks_instance_lock
+    def finish_resize(self, context, migration_id):
+        """Completes the migration process by setting up the newly transferred
+        disk and turning on the instance on its new host machine"""
+        migration_ref = self.db.migration_get(context, migration_id)
+        instance_ref = self.db.instance_get(context,
+                migration_ref['instance_id'])
+
+        # this may get passed into the following spawn instead
+        self.driver.attach_disk(context, migration_ref['instance_id'])
+        self.driver.spawn(context, instance_ref, preexisting=True)
+
+        self.db.migration_update(context, migration_id, 
+                {'status': 'finished', }) 
+
+        # Cleans up any transferred files and unmounts things
+        self.driver.cleanup_disk_transfer(context, instance_ref['id'])
 
     @exception.wrap_exception
     @checks_instance_lock
diff --git a/nova/db/api.py b/nova/db/api.py
index 789cb8ebb..5da0e9840 100644
--- a/nova/db/api.py
+++ b/nova/db/api.py
@@ -80,10 +80,15 @@ def service_destroy(context, instance_id):
 
 
 def service_get(context, service_id):
-    """Get an service or raise if it does not exist."""
+    """Get a service or raise if it does not exist."""
     return IMPL.service_get(context, service_id)
 
 
+def service_get_by_host_and_topic(context, host, topic):
+    """Get a service by host it's on and topic it listens to"""
+    return IMPL.service_get(context, host, topic)
+
+
 def service_get_all(context, disabled=False):
     """Get all service."""
     return IMPL.service_get_all(context, None, disabled)
@@ -255,6 +260,21 @@ def floating_ip_get_by_address(context, address):
 ####################
 
 
+def migration_create(context, values):
+    """Create a migration record"""
+    return IMPL.migration_create(context, values)
+
+def migration_get(context, migration_id):
+    """Finds a migration by the id"""
+    return IMPL.migration_get(context, migration_id)
+
+def migration_get_by_instance_id(context, instance_id):
+    """Finds a migration by the instance id its migrating"""
+    return IMPL.migration_get_by_instance_id(context, instance_id)
+
+####################
+
+
 def fixed_ip_associate(context, address, instance_id):
     """Associate fixed ip to instance.
 
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 85250d56e..e94f9f4d2 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -156,6 +156,15 @@ def service_get_all_by_topic(context, topic):
                    filter_by(topic=topic).\
                    all()
 
+@require_admin_context
+def service_get_by_host_and_topic(context, host, topic):
+    session = get_session()
+    return session.query(models.Service).\
+                   filter_by(deleted=False).\
+                   filter_by(disabled=False).\
+                   filter_by(host=host).\
+                   filter_by(topic=topic).\
+                   all()
 
 @require_admin_context
 def service_get_all_by_host(context, host):
@@ -1909,6 +1918,50 @@ def host_get_networks(context, host):
                        all()
 
 
+###################
+
+
+@require_admin_context
+def migration_create(context, values):
+    migration = models.Migration()
+    migration.update(values)
+    migration.save()
+    return migration
+
+
+@require_admin_context
+def migration_update(context, migration_id, values):
+    session = get_session()
+    with session.begin():
+        migration = migration_get(context, migration_id, session=session)
+        migration.update(values)
+        return migration
+
+
+@require_admin_context
+def migration_get(context, migration_id):
+    session = get_session()
+    result = session.query(models.Migration.\
+                     filter_by(migration_id=migration_id)).
+                     first()
+    if not result:
+        raise exception.NotFound(_("No migration found with id %s") 
+                % migration_id)
+    return result
+
+
+@require_admin_context
+def migration_get_by_instance(context, instance_id):
+    session = get_session()
+    result = session.query(models.Migration.\
+                     filter_by(instance_id=instance_id)).
+                     first()
+    if not result:
+        raise exception.NotFound(_("No migration found with instance id %s") 
+                % migration_id)
+    return result
+
+
 ##################
 
 
diff --git a/nova/db/sqlalchemy/models.py b/nova/db/sqlalchemy/models.py
index 7efb36c0e..499275504 100644
--- a/nova/db/sqlalchemy/models.py
+++ b/nova/db/sqlalchemy/models.py
@@ -366,6 +366,15 @@ class KeyPair(BASE, NovaBase):
     public_key = Column(Text)
 
 
+class Migration(BASE, NovaBase):
+    """Represents a running host-to-host migration."""
+    __tablename__ = 'migrations'
+    source_host = Column(String(255))
+    dest_host = Column(String(255))
+    instance_id = Column(Integer, ForeignKey('instances.id'), nullable=True)
+    status = Column(String(255)) #TODO(_cerberus_): enum
+
+
 class Network(BASE, NovaBase):
     """Represents a network."""
     __tablename__ = 'networks'
@@ -547,7 +556,8 @@ def register_models():
               Volume, ExportDevice, IscsiTarget, FixedIp, FloatingIp,
               Network, SecurityGroup, SecurityGroupIngressRule,
               SecurityGroupInstanceAssociation, AuthToken, User,
-              Project, Certificate, ConsolePool, Console)  # , Image, Host
+              Project, Certificate, ConsolePool, Console, 
+              Migration)  # , Image, Host
     engine = create_engine(FLAGS.sql_connection, echo=False)
     for model in models:
         model.metadata.create_all(engine)
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 <ken.pepple@gmail.com>
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/api/ec2/admin.py                                 | 19 ++++++++++++++-----
 nova/api/openstack/flavors.py                         |  4 ++--
 nova/compute/api.py                                   |  3 ++-
 nova/compute/instance_types.py                        |  8 ++++----
 nova/db/api.py                                        |  5 ++++-
 nova/db/sqlalchemy/api.py                             |  9 ++++++---
 .../db/sqlalchemy/migrate_repo/versions/003_cactus.py |  2 +-
 nova/tests/api/openstack/test_flavors.py              | 18 ++++++++++++------
 nova/tests/db/fakes.py                                |  2 +-
 nova/tests/test_quota.py                              |  6 +++---
 nova/tests/test_xenapi.py                             |  2 +-
 nova/virt/libvirt_conn.py                             |  4 ++--
 nova/virt/xenapi/vm_utils.py                          |  2 +-
 13 files changed, 53 insertions(+), 31 deletions(-)

(limited to 'nova')

diff --git a/nova/api/ec2/admin.py b/nova/api/ec2/admin.py
index 55cca1041..5a9e22bf7 100644
--- a/nova/api/ec2/admin.py
+++ b/nova/api/ec2/admin.py
@@ -63,8 +63,8 @@ def host_dict(host):
         return {}
 
 
-def instance_dict(name, inst):
-    return {'name': name,
+def instance_dict(inst):
+    return {'name': inst['name'],
             'memory_mb': inst['memory_mb'],
             'vcpus': inst['vcpus'],
             'disk_gb': inst['local_gb'],
@@ -79,10 +79,19 @@ class AdminController(object):
     def __str__(self):
         return 'AdminController'
 
-    # FIX-ME(kpepple) for dynamic flavors
+    # FIXME(kpepple) this is untested code path.
     def describe_instance_types(self, _context, **_kwargs):
-        return {'instanceTypeSet': [instance_dict(n, v) for n, v in
-                                    instance_types.INSTANCE_TYPES.iteritems()]}
+        """Returns all active instance types data (vcpus, memory, etc.)"""
+        # return {'instanceTypeSet': [instance_dict(n, v) for n, v in
+        #                           instance_types.INSTANCE_TYPES.iteritems()]}
+        return {'instanceTypeSet':
+                [for i in db.instance_type_get_all(): instance_dict(i)]}
+
+    # FIXME(kpepple) this is untested code path.
+    def describe_instance_type(self, _context, name, **_kwargs):
+        """Returns a specific active instance types data"""
+        return {'instanceTypeSet':
+                [instance_dict(db.instance_type_get_by_name(name))]}
 
     def describe_user(self, _context, name, **_kwargs):
         """Returns user data, including access and secret keys."""
diff --git a/nova/api/openstack/flavors.py b/nova/api/openstack/flavors.py
index 1f5185134..2416088f9 100644
--- a/nova/api/openstack/flavors.py
+++ b/nova/api/openstack/flavors.py
@@ -45,7 +45,7 @@ class Controller(wsgi.Controller):
 
     def show(self, req, id):
         """Return data about the given flavor id."""
-        # FIX-ME(kpepple) for dynamic flavors
+        # FIXME(kpepple) for dynamic flavors
         for name, val in instance_types.INSTANCE_TYPES.iteritems():
             if val['flavorid'] == int(id):
                 item = dict(ram=val['memory_mb'], disk=val['local_gb'],
@@ -55,5 +55,5 @@ class Controller(wsgi.Controller):
 
     def _all_ids(self):
         """Return the list of all flavorids."""
-        # FIX-ME(kpepple) for dynamic flavors
+        # FIXME(kpepple) for dynamic flavors
         return [i['flavorid'] for i in instance_types.INSTANCE_TYPES.values()]
diff --git a/nova/compute/api.py b/nova/compute/api.py
index 3ae722226..78a34dff2 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -90,7 +90,8 @@ class API(base.Base):
         other arguments check out ok."""
 
         # FIXME(kpepple) this needs to be changed from using the old constant
-        #type_data = db.instance_type_get_by_name(context.get_admin_context(), instance_type)
+        #type_data = db.instance_type_get_by_name(context.get_admin_context(),
+                                                    # instance_type)
         type_data = instance_types.INSTANCE_TYPES[instance_type]
         num_instances = quota.allowed_instances(context, max_count, type_data)
         if num_instances < min_count:
diff --git a/nova/compute/instance_types.py b/nova/compute/instance_types.py
index 0594aa063..449ec1d2e 100644
--- a/nova/compute/instance_types.py
+++ b/nova/compute/instance_types.py
@@ -25,7 +25,7 @@ from nova import flags
 from nova import exception
 
 FLAGS = flags.FLAGS
-# FIX-ME(kpepple) for dynamic flavors
+# FIXME(kpepple) for dynamic flavors
 INSTANCE_TYPES = {
     'm1.tiny': dict(memory_mb=512, vcpus=1, local_gb=0, flavorid=1),
     'm1.small': dict(memory_mb=2048, vcpus=1, local_gb=20, flavorid=2),
@@ -36,9 +36,9 @@ INSTANCE_TYPES = {
 
 def get_by_type(instance_type):
     """Build instance data structure and save it to the data store."""
-    # FIX-ME(kpepple) for dynamic flavors
+    # FIXME(kpepple) for dynamic flavors
     if instance_type is None:
-             return FLAGS.default_instance_type
+        return FLAGS.default_instance_type
     if instance_type not in INSTANCE_TYPES:
         raise exception.ApiError(_("Unknown instance type: %s"),
                                  instance_type)
@@ -46,7 +46,7 @@ def get_by_type(instance_type):
 
 
 def get_by_flavor_id(flavor_id):
-    # FIX-ME(kpepple) for dynamic flavors
+    # FIXME(kpepple) for dynamic flavors
     for instance_type, details in INSTANCE_TYPES.iteritems():
         if details['flavorid'] == flavor_id:
             return instance_type
diff --git a/nova/db/api.py b/nova/db/api.py
index ffb1d08ce..d5091794b 100644
--- a/nova/db/api.py
+++ b/nova/db/api.py
@@ -994,14 +994,17 @@ def instance_type_create(context, values):
     """Create a new instance type"""
     return IMPL.instance_type_create(context, values)
 
+
 def instance_type_get_all(context):
     """Get all instance types"""
     return IMPL.instance_type_get_all(context)
 
+
 def instance_type_get_by_name(context, name):
     """Get instance type by name"""
     return IMPL.instance_type_get_by_name(context, name)
 
+
 def instance_type_destroy(context, name):
     """Delete a instance type"""
-    return IMPL.instance_type_destroy(context,name)
+    return IMPL.instance_type_destroy(context, name)
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index aa6434b65..142b1aa33 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -2030,10 +2030,13 @@ def instance_type_create(context, values):
     instance_type_ref.save()
     return instance_type_ref
 
+
 def instance_type_get_all(context):
     session = get_session()
     return session.query(models.InstanceTypes).\
-                    filter_by(deleted=0)
+                    filter_by(deleted=0).\
+                    all()
+
 
 def instance_type_get_by_name(context, name):
     session = get_session()
@@ -2041,11 +2044,11 @@ def instance_type_get_by_name(context, name):
                     filter_by(name=name).\
                     first()
 
+
 @require_admin_context
-def instance_type_destroy(context,name):
+def instance_type_destroy(context, name):
     session = get_session()
     instance_type_ref = session.query(models.InstanceTypes).\
                     filter_by(name=name)
     rows = instance_type_ref.update(dict(deleted=1))
     return instance_type_ref
-    
diff --git a/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py b/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py
index c7e61dc05..6523b6b38 100644
--- a/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py
+++ b/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py
@@ -68,7 +68,7 @@ def upgrade(migrate_engine):
             # FIXME(kpepple) should we be seeding created_at / updated_at ?
             # the_time = time.strftime("%Y-%m-%d %H:%M:%S")
             i.execute({'name': name, 'memory_mb': values["memory_mb"],
-                        'vcpus': values["vcpus"],
+                        'vcpus': values["vcpus"], 'deleted': 0,
                         'local_gb': values["local_gb"],
                         'flavorid': values["flavorid"]})
     except Exception:
diff --git a/nova/tests/api/openstack/test_flavors.py b/nova/tests/api/openstack/test_flavors.py
index 0f0ed2e84..b416e02d6 100644
--- a/nova/tests/api/openstack/test_flavors.py
+++ b/nova/tests/api/openstack/test_flavors.py
@@ -47,19 +47,25 @@ class FlavorsTest(unittest.TestCase):
     def test_create_list_delete_favor(self):
         # create a new flavor
         starting_flavors = db.instance_type_get_all(self.context)
-        new_instance_type = dict(name="os1.big",memory_mb=512, vcpus=1, local_gb=120, flavorid=25)
+        new_instance_type = dict(name="os1.big", memory_mb=512,
+                                  vcpus=1, local_gb=120, flavorid=25)
         new_flavor = db.instance_type_create(self.context, new_instance_type)
         self.assertEqual(new_flavor["name"], new_instance_type["name"])
         # retrieve the newly created flavor
-        retrieved_new_flavor = db.instance_type_get_by_name(self.context, new_instance_type["name"])
+        retrieved_new_flavor = db.instance_type_get_by_name(
+                                                    self.context,
+                                                    new_instance_type["name"])
         # self.assertEqual(len(tuple(retrieved_new_flavor)),1)
-        self.assertEqual(retrieved_new_flavor["memory_mb"], new_instance_type["memory_mb"])
+        self.assertEqual(retrieved_new_flavor["memory_mb"],
+                            new_instance_type["memory_mb"])
         flavors = db.instance_type_get_all(self.context)
         self.assertNotEqual(starting_flavors, flavors)
         # delete the newly created flavor
-        delete_query = db.instance_type_destroy(self.context,new_instance_type["name"])
-        retrieve_deleted_flavor = db.instance_type_get_by_name(self.context, new_instance_type["name"])
-        self.assertEqual(retrieve_deleted_flavor["deleted"], 1)        
+        delete_query = db.instance_type_destroy(self.context,
+                                                new_instance_type["name"])
+        deleted_flavor = db.instance_type_get_by_name(self.context,
+                                                    new_instance_type["name"])
+        self.assertEqual(deleted_flavor["deleted"], 1)
 
 
 if __name__ == '__main__':
diff --git a/nova/tests/db/fakes.py b/nova/tests/db/fakes.py
index 6cf917d76..3b47fc867 100644
--- a/nova/tests/db/fakes.py
+++ b/nova/tests/db/fakes.py
@@ -44,7 +44,7 @@ def stub_out_db_instance_api(stubs):
     def fake_instance_create(values):
         """ Stubs out the db.instance_create method """
 
-        # FIX-ME(kpepple) for dynamic flavors
+        # FIXME(kpepple) for dynamic flavors
         type_data = instance_types.INSTANCE_TYPES[values['instance_type']]
 
         base_options = {
diff --git a/nova/tests/test_quota.py b/nova/tests/test_quota.py
index f2c9c456f..c70803e05 100644
--- a/nova/tests/test_quota.py
+++ b/nova/tests/test_quota.py
@@ -75,18 +75,18 @@ class QuotaTestCase(test.TestCase):
 
     def test_quota_overrides(self):
         """Make sure overriding a projects quotas works"""
-        # FIX-ME(kpepple) for dynamic flavors
+        # FIXME(kpepple) for dynamic flavors
         num_instances = quota.allowed_instances(self.context, 100,
             instance_types.INSTANCE_TYPES['m1.small'])
         self.assertEqual(num_instances, 2)
         db.quota_create(self.context, {'project_id': self.project.id,
                                        'instances': 10})
-        # FIX-ME(kpepple) for dynamic flavors
+        # FIXME(kpepple) for dynamic flavors
         num_instances = quota.allowed_instances(self.context, 100,
             instance_types.INSTANCE_TYPES['m1.small'])
         self.assertEqual(num_instances, 4)
         db.quota_update(self.context, self.project.id, {'cores': 100})
-        # FIX-ME(kpepple) for dynamic flavors
+        # FIXME(kpepple) for dynamic flavors
         num_instances = quota.allowed_instances(self.context, 100,
             instance_types.INSTANCE_TYPES['m1.small'])
         self.assertEqual(num_instances, 10)
diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index e38bd4dab..1d42f8da3 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -225,7 +225,7 @@ class XenAPIVMTestCase(test.TestCase):
         vm = vms[0]
 
         # Check that m1.large above turned into the right thing.
-        # FIX-ME(kpepple) for dynamic flavors
+        # FIXME(kpepple) for dynamic flavors
         instance_type = instance_types.INSTANCE_TYPES['m1.large']
         mem_kib = long(instance_type['memory_mb']) << 10
         mem_bytes = str(mem_kib << 10)
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 79ea4533df3bd8c58b96177c2979fab2987a842a Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Sat, 5 Feb 2011 02:45:53 -0800
Subject: converted openstack flavors over to use instance_types table. a few
 pep changes.

---
 nova/api/openstack/flavors.py                      | 22 ++++++++++++++--------
 nova/db/api.py                                     |  5 +++++
 nova/db/sqlalchemy/api.py                          |  7 +++++++
 .../sqlalchemy/migrate_repo/versions/003_cactus.py |  4 ++--
 4 files changed, 28 insertions(+), 10 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/flavors.py b/nova/api/openstack/flavors.py
index 2416088f9..7440af0b4 100644
--- a/nova/api/openstack/flavors.py
+++ b/nova/api/openstack/flavors.py
@@ -17,6 +17,8 @@
 
 from webob import exc
 
+from nova import db 
+from nova import context
 from nova.api.openstack import faults
 from nova.api.openstack import common
 from nova.compute import instance_types
@@ -45,15 +47,19 @@ class Controller(wsgi.Controller):
 
     def show(self, req, id):
         """Return data about the given flavor id."""
-        # FIXME(kpepple) for dynamic flavors
-        for name, val in instance_types.INSTANCE_TYPES.iteritems():
-            if val['flavorid'] == int(id):
-                item = dict(ram=val['memory_mb'], disk=val['local_gb'],
-                            id=val['flavorid'], name=name)
-                return dict(flavor=item)
+        # FIXME(kpepple) do we need admin context here ?
+        ctxt = context.get_admin_context()
+        val = db.instance_type_get_by_flavor_id(ctxt, id)
+        item = dict(ram=val['memory_mb'], disk=val['local_gb'],
+                    id=val['flavorid'], name=val['name'])
+        return dict(flavor=item)
         raise faults.Fault(exc.HTTPNotFound())
 
     def _all_ids(self):
         """Return the list of all flavorids."""
-        # FIXME(kpepple) for dynamic flavors
-        return [i['flavorid'] for i in instance_types.INSTANCE_TYPES.values()]
+        # FIXME(kpepple) do we need admin context here ?
+        ctxt = context.get_admin_context()
+        flavor_ids = []
+        for i in db.instance_type_get_all(ctxt):
+            flavor_ids.append(i['flavorid'])
+        return flavor_ids
diff --git a/nova/db/api.py b/nova/db/api.py
index d5091794b..2f1903ade 100644
--- a/nova/db/api.py
+++ b/nova/db/api.py
@@ -1005,6 +1005,11 @@ def instance_type_get_by_name(context, name):
     return IMPL.instance_type_get_by_name(context, name)
 
 
+def instance_type_get_by_flavor_id(context, id):
+    """Get instance type by name"""
+    return IMPL.instance_type_get_by_flavor_id(context, id)
+
+
 def instance_type_destroy(context, name):
     """Delete a instance type"""
     return IMPL.instance_type_destroy(context, name)
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 142b1aa33..6c9af6e19 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -2045,6 +2045,13 @@ def instance_type_get_by_name(context, name):
                     first()
 
 
+def instance_type_get_by_flavor_id(context, id):
+    session = get_session()
+    return session.query(models.InstanceTypes).\
+                    filter_by(flavorid=int(id)).\
+                    first()
+
+
 @require_admin_context
 def instance_type_destroy(context, name):
     session = get_session()
diff --git a/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py b/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py
index 6523b6b38..c5ae9ea72 100644
--- a/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py
+++ b/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py
@@ -19,7 +19,7 @@ from nova import api
 from nova import db
 from nova import log as logging
 
-import time
+import datetime
 
 meta = MetaData()
 
@@ -66,7 +66,7 @@ def upgrade(migrate_engine):
         i = instance_types.insert()
         for name, values in INSTANCE_TYPES.iteritems():
             # FIXME(kpepple) should we be seeding created_at / updated_at ?
-            # the_time = time.strftime("%Y-%m-%d %H:%M:%S")
+            # now = datetime.datatime.utcnow()
             i.execute({'name': name, 'memory_mb': values["memory_mb"],
                         'vcpus': values["vcpus"], 'deleted': 0,
                         'local_gb': values["local_gb"],
-- 
cgit 


From fcd0a7b245470054718c94adf0da6a528a01f173 Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Sat, 5 Feb 2011 13:49:38 -0800
Subject: corrected db.instance_types to return expect dict instead of lists.
 updated openstack flavors to expect dicts instead of lists. added deleted
 column to returned dict.

---
 nova/api/openstack/flavors.py            | 12 +++++----
 nova/db/sqlalchemy/api.py                | 42 ++++++++++++++++++++++++++++----
 nova/tests/api/openstack/test_flavors.py |  5 ++--
 3 files changed, 46 insertions(+), 13 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/flavors.py b/nova/api/openstack/flavors.py
index 7440af0b4..da38dd34d 100644
--- a/nova/api/openstack/flavors.py
+++ b/nova/api/openstack/flavors.py
@@ -17,7 +17,7 @@
 
 from webob import exc
 
-from nova import db 
+from nova import db
 from nova import context
 from nova.api.openstack import faults
 from nova.api.openstack import common
@@ -50,8 +50,9 @@ class Controller(wsgi.Controller):
         # FIXME(kpepple) do we need admin context here ?
         ctxt = context.get_admin_context()
         val = db.instance_type_get_by_flavor_id(ctxt, id)
-        item = dict(ram=val['memory_mb'], disk=val['local_gb'],
-                    id=val['flavorid'], name=val['name'])
+        v = val.values()[0]
+        item = dict(ram=v['memory_mb'], disk=v['local_gb'],
+                    id=v['flavorid'], name=val.keys()[0])
         return dict(flavor=item)
         raise faults.Fault(exc.HTTPNotFound())
 
@@ -60,6 +61,7 @@ class Controller(wsgi.Controller):
         # FIXME(kpepple) do we need admin context here ?
         ctxt = context.get_admin_context()
         flavor_ids = []
-        for i in db.instance_type_get_all(ctxt):
-            flavor_ids.append(i['flavorid'])
+        inst_types = db.instance_type_get_all(ctxt)
+        for i in inst_types.keys():
+            flavor_ids.append(inst_types[i]['flavorid'])
         return flavor_ids
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 6c9af6e19..83c88a3a0 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -2032,24 +2032,56 @@ def instance_type_create(context, values):
 
 
 def instance_type_get_all(context):
+    """Returns a dict of all instance_types:
+        { 'm1.tiny': dict(memory_mb=512, vcpus=1, local_gb=0, flavorid=1),
+          'm1.small': dict(memory_mb=2048, vcpus=1, local_gb=20, flavorid=2),
+          'm1.medium': dict(memory_mb=4096, vcpus=2, local_gb=40, flavorid=3)}
+    """
     session = get_session()
-    return session.query(models.InstanceTypes).\
+    inst_types = session.query(models.InstanceTypes).\
                     filter_by(deleted=0).\
                     all()
+    inst_dict = {}
+    for i in inst_types:
+        inst_dict[i['name']] = dict(memory_mb=i['memory_mb'],
+                                    vcpus=i['vcpus'],
+                                    local_gb=i['local_gb'],
+                                    flavorid=i['flavorid'],
+                                    deleted=i['deleted'])
+
+    return inst_dict
 
 
 def instance_type_get_by_name(context, name):
+    """
+    Returns a dict of specific instance_type:
+        {'m1.tiny': dict(memory_mb=512, vcpus=1, local_gb=0, flavorid=1)}
+    """
     session = get_session()
-    return session.query(models.InstanceTypes).\
+    inst_type = session.query(models.InstanceTypes).\
                     filter_by(name=name).\
                     first()
+    return {inst_type['name']: dict(memory_mb=inst_type['memory_mb'],
+                                    vcpus=inst_type['vcpus'],
+                                    local_gb=inst_type['local_gb'],
+                                    flavorid=inst_type['flavorid'],
+                                    deleted=inst_type['deleted'])}
 
 
 def instance_type_get_by_flavor_id(context, id):
+    """
+    Returns a dict of specific flavor_id:
+        {'m1.tiny': dict(memory_mb=512, vcpus=1, local_gb=0, flavorid=1)}
+    """
     session = get_session()
-    return session.query(models.InstanceTypes).\
-                    filter_by(flavorid=int(id)).\
-                    first()
+    inst_type = session.query(models.InstanceTypes).\
+                                    filter_by(flavorid=int(id)).\
+                                    first()
+    return {inst_type['name']: dict(memory_mb=inst_type['memory_mb'],
+                                    vcpus=inst_type['vcpus'],
+                                    local_gb=inst_type['local_gb'],
+                                    flavorid=inst_type['flavorid'],
+                                    deleted=inst_type['deleted'])}
 
 
 @require_admin_context
diff --git a/nova/tests/api/openstack/test_flavors.py b/nova/tests/api/openstack/test_flavors.py
index b416e02d6..9287e8adf 100644
--- a/nova/tests/api/openstack/test_flavors.py
+++ b/nova/tests/api/openstack/test_flavors.py
@@ -55,8 +55,7 @@ class FlavorsTest(unittest.TestCase):
         retrieved_new_flavor = db.instance_type_get_by_name(
                                                     self.context,
                                                     new_instance_type["name"])
-        # self.assertEqual(len(tuple(retrieved_new_flavor)),1)
-        self.assertEqual(retrieved_new_flavor["memory_mb"],
+        self.assertEqual(retrieved_new_flavor.values()[0]["memory_mb"],
                             new_instance_type["memory_mb"])
         flavors = db.instance_type_get_all(self.context)
         self.assertNotEqual(starting_flavors, flavors)
@@ -65,7 +64,7 @@ class FlavorsTest(unittest.TestCase):
                                                 new_instance_type["name"])
         deleted_flavor = db.instance_type_get_by_name(self.context,
                                                     new_instance_type["name"])
-        self.assertEqual(deleted_flavor["deleted"], 1)
+        self.assertEqual(deleted_flavor.values()[0]["deleted"], 1)
 
 
 if __name__ == '__main__':
-- 
cgit 


From 5cd5d4e9682848cba60a8dec352fe0f74aaa9eac Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Sat, 5 Feb 2011 18:23:01 -0800
Subject: flavorid and name need to be unique in the database for the ec2 and
 openstack apis, repectively

---
 nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py b/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py
index c5ae9ea72..f95996042 100644
--- a/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py
+++ b/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py
@@ -34,12 +34,13 @@ instance_types = Table('instance_types', meta,
         Column('deleted', Boolean(create_constraint=True, name=None)),
         Column('name',
                String(length=255, convert_unicode=False, assert_unicode=None,
-                      unicode_error=None, _warn_on_bytestring=False)),
+                      unicode_error=None, _warn_on_bytestring=False),
+                      unique=True),
         Column('id', Integer(),  primary_key=True, nullable=False),
         Column('memory_mb', Integer(),  nullable=False),
         Column('vcpus', Integer(),  nullable=False),
         Column('local_gb', Integer(),  nullable=False),
-        Column('flavorid', Integer(),  nullable=False),
+        Column('flavorid', Integer(),  nullable=False, unique=True),
         )
 
 
-- 
cgit 


From d5a5324fee480152fd4e77f19fce5b025e1b4987 Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Sat, 5 Feb 2011 18:26:53 -0800
Subject: instance_types should return in predicatable order (by name
 currently)

---
 nova/db/sqlalchemy/api.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 83c88a3a0..0e2675a9f 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -2040,6 +2040,7 @@ def instance_type_get_all(context):
     session = get_session()
     inst_types = session.query(models.InstanceTypes).\
                     filter_by(deleted=0).\
+                    order_by("name").\
                     all()
     inst_dict = {}
     for i in inst_types:
@@ -2090,4 +2091,4 @@ def instance_type_destroy(context, name):
     instance_type_ref = session.query(models.InstanceTypes).\
                     filter_by(name=name)
     rows = instance_type_ref.update(dict(deleted=1))
-    return instance_type_ref
+    return rows
-- 
cgit 


From 2acc31a293b067644f26877dc52bacb7ef9e9bd1 Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Sat, 5 Feb 2011 18:28:26 -0800
Subject: added preliminary testing for bin/nova-manage while i am somewhat
 conflicted about the path these tests have taken, i think it is better than
 no tests at all

---
 nova/tests/test_nova_manage.py | 72 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 72 insertions(+)
 create mode 100644 nova/tests/test_nova_manage.py

(limited to 'nova')

diff --git a/nova/tests/test_nova_manage.py b/nova/tests/test_nova_manage.py
new file mode 100644
index 000000000..09ed8163b
--- /dev/null
+++ b/nova/tests/test_nova_manage.py
@@ -0,0 +1,72 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+#    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.
+"""
+Tests For Nova-Manage
+"""
+
+import os
+import subprocess
+
+from nova import test
+
+
+class NovaManageTestCase(test.TestCase):
+    """Test case for nova-manage"""
+    def setUp(self):
+        super(NovaManageTestCase, self).setUp()
+
+    def teardown(self):
+        fnull.close()
+
+    def test_create_and_delete_instance_types(self):
+        fnull = open(os.devnull, 'w')
+        retcode = subprocess.call(["bin/nova-manage", "instance_type",\
+                                    "create", "test", "256", "1",\
+                                    "120", "99"], stdout=fnull)
+        self.assertEqual(0, retcode)
+        retcode = subprocess.call(["bin/nova-manage", "instance_type",\
+                                    "delete", "test"], stdout=fnull)
+        self.assertEqual(0, retcode)
+
+    def test_list_instance_types(self):
+        fnull = open(os.devnull, 'w')
+        retcode = subprocess.call(["bin/nova-manage", "instance_type", \
+                                    "list"], stdout=fnull)
+        self.assertEqual(0, retcode)
+
+    def test_list_specific_instance_type(self):
+        fnull = open(os.devnull, 'w')
+        retcode = subprocess.call(["bin/nova-manage", "instance_type", "list",
+                                    "m1.medium"], stdout=fnull)
+        self.assertEqual(0, retcode)
+
+    def test_should_raise_on_bad_create_args(self):
+        fnull = open(os.devnull, 'w')
+        retcode = subprocess.call(["bin/nova-manage", "instance_type",\
+                                    "create", "test", "256", "0",\
+                                    "120", "99"], stdout=fnull)
+        self.assertEqual(1, retcode)
+
+    def test_should_fail_on_duplicate_flavorid(self):
+        fnull = open(os.devnull, 'w')
+        retcode = subprocess.call(["bin/nova-manage", "instance_type",\
+                                    "create", "test", "256", "1",\
+                                    "120", "1"], stdout=fnull)
+        self.assertEqual(1, retcode)
+
+    def test_instance_type_delete_should_fail_without_valid_name(self):
+        fnull = open(os.devnull, 'w')
+        retcode = subprocess.call(["bin/nova-manage", "instance_type",\
+                                    "delete", "saefasff"], stdout=fnull)
+        self.assertEqual(1, retcode)
-- 
cgit 


From 555e5b5a0d3ae30f5d8b77d6b2dc47a953b4a81b Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Sat, 5 Feb 2011 18:54:56 -0800
Subject: updated api.create to use instance_type table

---
 nova/compute/api.py       | 7 +++----
 nova/db/sqlalchemy/api.py | 2 ++
 2 files changed, 5 insertions(+), 4 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/api.py b/nova/compute/api.py
index 78a34dff2..006db880e 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -89,10 +89,9 @@ class API(base.Base):
         """Create the number of instances requested if quota and
         other arguments check out ok."""
 
-        # FIXME(kpepple) this needs to be changed from using the old constant
-        #type_data = db.instance_type_get_by_name(context.get_admin_context(),
-                                                    # instance_type)
-        type_data = instance_types.INSTANCE_TYPES[instance_type]
+        # FIXME(kpepple) this needs to be factored for api.py:2065 refactor
+        type_data = db.instance_type_get_by_name(context,\
+                                                instance_type)[instance_type]
         num_instances = quota.allowed_instances(context, max_count, type_data)
         if num_instances < min_count:
             pid = context.project_id
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 0e2675a9f..eff03aa02 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -2062,6 +2062,7 @@ def instance_type_get_by_name(context, name):
     inst_type = session.query(models.InstanceTypes).\
                     filter_by(name=name).\
                     first()
+    # FIXME(kpepple) this needs to be refactored to just return dict
     return {inst_type['name']: dict(memory_mb=inst_type['memory_mb'],
                                     vcpus=inst_type['vcpus'],
                                     local_gb=inst_type['local_gb'],
@@ -2078,6 +2079,7 @@ def instance_type_get_by_flavor_id(context, id):
     inst_type = session.query(models.InstanceTypes).\
                                     filter_by(flavorid=int(id)).\
                                     first()
+    # FIXME(kpepple) this needs to be refactored to just return dict
     return {inst_type['name']: dict(memory_mb=inst_type['memory_mb'],
                                     vcpus=inst_type['vcpus'],
                                     local_gb=inst_type['local_gb'],
-- 
cgit 


From ea5271ed69d72dcab8189c3bfc66220c7ff60862 Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Sun, 6 Feb 2011 10:56:05 -0800
Subject: refactor to remove ugly code in flavors

---
 nova/api/openstack/flavors.py | 9 ++++-----
 nova/tests/db/fakes.py        | 2 ++
 2 files changed, 6 insertions(+), 5 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/flavors.py b/nova/api/openstack/flavors.py
index da38dd34d..3124c26b2 100644
--- a/nova/api/openstack/flavors.py
+++ b/nova/api/openstack/flavors.py
@@ -47,9 +47,10 @@ class Controller(wsgi.Controller):
 
     def show(self, req, id):
         """Return data about the given flavor id."""
-        # FIXME(kpepple) do we need admin context here ?
+        # FIXME(kpepple) do we really need admin context here ?
         ctxt = context.get_admin_context()
         val = db.instance_type_get_by_flavor_id(ctxt, id)
+        # FIXME(kpepple) refactor db call to return dict
         v = val.values()[0]
         item = dict(ram=v['memory_mb'], disk=v['local_gb'],
                     id=v['flavorid'], name=val.keys()[0])
@@ -58,10 +59,8 @@ class Controller(wsgi.Controller):
 
     def _all_ids(self):
         """Return the list of all flavorids."""
-        # FIXME(kpepple) do we need admin context here ?
+        # FIXME(kpepple) do we really need admin context here ?
         ctxt = context.get_admin_context()
-        flavor_ids = []
         inst_types = db.instance_type_get_all(ctxt)
-        for i in inst_types.keys():
-            flavor_ids.append(inst_types[i]['flavorid'])
+        flavor_ids = [inst_types[i]['flavorid'] for i in inst_types.keys()]
         return flavor_ids
diff --git a/nova/tests/db/fakes.py b/nova/tests/db/fakes.py
index 3b47fc867..859ed6edc 100644
--- a/nova/tests/db/fakes.py
+++ b/nova/tests/db/fakes.py
@@ -46,6 +46,8 @@ def stub_out_db_instance_api(stubs):
 
         # FIXME(kpepple) for dynamic flavors
         type_data = instance_types.INSTANCE_TYPES[values['instance_type']]
+        # type_data = db.instance_type_get_by_name(context,\
+        #                                                 instance_type)[instance_type]
 
         base_options = {
             'name': values['name'],
-- 
cgit 


From 7dcdbcc546248c3384bd15975a721413e1d1f507 Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Sun, 6 Feb 2011 13:28:07 -0800
Subject: simplified instance_types db calls to return entire row - we may need
 these extra columns for some features and there seems to be little downside
 in including them. still need to fix testing calls.

---
 nova/api/ec2/admin.py                    |  5 ++--
 nova/api/openstack/flavors.py            | 10 ++++----
 nova/compute/api.py                      |  2 +-
 nova/db/sqlalchemy/api.py                | 41 +++++++++-----------------------
 nova/tests/api/openstack/test_flavors.py | 22 -----------------
 nova/tests/db/fakes.py                   |  2 +-
 6 files changed, 21 insertions(+), 61 deletions(-)

(limited to 'nova')

diff --git a/nova/api/ec2/admin.py b/nova/api/ec2/admin.py
index 5a9e22bf7..4c0628e21 100644
--- a/nova/api/ec2/admin.py
+++ b/nova/api/ec2/admin.py
@@ -84,8 +84,9 @@ class AdminController(object):
         """Returns all active instance types data (vcpus, memory, etc.)"""
         # return {'instanceTypeSet': [instance_dict(n, v) for n, v in
         #                           instance_types.INSTANCE_TYPES.iteritems()]}
-        return {'instanceTypeSet':
-                [for i in db.instance_type_get_all(): instance_dict(i)]}
+        # return {'instanceTypeSet':
+        #         [for i in db.instance_type_get_all(): instance_dict(i)]}
+        return {'instanceTypeSet': [db.instance_type_get_all(_context)]}
 
     # FIXME(kpepple) this is untested code path.
     def describe_instance_type(self, _context, name, **_kwargs):
diff --git a/nova/api/openstack/flavors.py b/nova/api/openstack/flavors.py
index 3124c26b2..9b674afbd 100644
--- a/nova/api/openstack/flavors.py
+++ b/nova/api/openstack/flavors.py
@@ -49,12 +49,12 @@ class Controller(wsgi.Controller):
         """Return data about the given flavor id."""
         # FIXME(kpepple) do we really need admin context here ?
         ctxt = context.get_admin_context()
-        val = db.instance_type_get_by_flavor_id(ctxt, id)
+        values = db.instance_type_get_by_flavor_id(ctxt, id)
         # FIXME(kpepple) refactor db call to return dict
-        v = val.values()[0]
-        item = dict(ram=v['memory_mb'], disk=v['local_gb'],
-                    id=v['flavorid'], name=val.keys()[0])
-        return dict(flavor=item)
+        # v = val.values()[0]
+        # item = dict(ram=v['memory_mb'], disk=v['local_gb'],
+        #             id=v['flavorid'], name=val.keys()[0])
+        return dict(flavor=values)
         raise faults.Fault(exc.HTTPNotFound())
 
     def _all_ids(self):
diff --git a/nova/compute/api.py b/nova/compute/api.py
index 006db880e..fc18765f6 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -91,7 +91,7 @@ class API(base.Base):
 
         # FIXME(kpepple) this needs to be factored for api.py:2065 refactor
         type_data = db.instance_type_get_by_name(context,\
-                                                instance_type)[instance_type]
+                                                instance_type)
         num_instances = quota.allowed_instances(context, max_count, type_data)
         if num_instances < min_count:
             pid = context.project_id
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index eff03aa02..f4e021ac8 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -2032,10 +2032,11 @@ def instance_type_create(context, values):
 
 
 def instance_type_get_all(context):
-    """Returns a dict of all instance_types:
-        { 'm1.tiny': dict(memory_mb=512, vcpus=1, local_gb=0, flavorid=1),
-          'm1.small': dict(memory_mb=2048, vcpus=1, local_gb=20, flavorid=2),
-          'm1.medium': dict(memory_mb=4096, vcpus=2, local_gb=40, flavorid=3)}
+    """
+    Returns a dict describing all instance_types with name as key:
+        {'m1.tiny': dict(memory_mb=512, vcpus=1, local_gb=0, flavorid=1),
+         'm1.small': dict(memory_mb=2048, vcpus=1, local_gb=20, flavorid=2),
+         'm1.medium': dict(memory_mb=4096, vcpus=2, local_gb=40, flavorid=3)}
     """
     session = get_session()
     inst_types = session.query(models.InstanceTypes).\
@@ -2044,51 +2045,31 @@ def instance_type_get_all(context):
                     all()
     inst_dict = {}
     for i in inst_types:
-        inst_dict[i['name']] = dict(memory_mb=i['memory_mb'],
-                                    vcpus=i['vcpus'],
-                                    local_gb=i['local_gb'],
-                                    flavorid=i['flavorid'],
-                                    deleted=i['deleted'])
-
+        inst_dict[i['name']] = dict(i)
     return inst_dict
 
 
 def instance_type_get_by_name(context, name):
-    """
-    Returns a dict of specific instance_type:
-        {'m1.tiny': dict(memory_mb=512, vcpus=1, local_gb=0, flavorid=1)}
-    """
+    """Returns a dict describing specific instance_type"""
     session = get_session()
     inst_type = session.query(models.InstanceTypes).\
                     filter_by(name=name).\
                     first()
-    # FIXME(kpepple) this needs to be refactored to just return dict
-    return {inst_type['name']: dict(memory_mb=inst_type['memory_mb'],
-                                    vcpus=inst_type['vcpus'],
-                                    local_gb=inst_type['local_gb'],
-                                    flavorid=inst_type['flavorid'],
-                                    deleted=inst_type['deleted'])}
+    return dict(inst_type)
 
 
 def instance_type_get_by_flavor_id(context, id):
-    """
-    Returns a dict of specific flavor_id:
-        {'m1.tiny': dict(memory_mb=512, vcpus=1, local_gb=0, flavorid=1)}
-    """
+    """Returns a dict describing specific flavor_id"""
     session = get_session()
     inst_type = session.query(models.InstanceTypes).\
                                     filter_by(flavorid=int(id)).\
                                     first()
-    # FIXME(kpepple) this needs to be refactored to just return dict
-    return {inst_type['name']: dict(memory_mb=inst_type['memory_mb'],
-                                    vcpus=inst_type['vcpus'],
-                                    local_gb=inst_type['local_gb'],
-                                    flavorid=inst_type['flavorid'],
-                                    deleted=inst_type['deleted'])}
+    return dict(inst_type)
 
 
 @require_admin_context
 def instance_type_destroy(context, name):
+    """ Marks specific instance_type as deleted"""
     session = get_session()
     instance_type_ref = session.query(models.InstanceTypes).\
                     filter_by(name=name)
diff --git a/nova/tests/api/openstack/test_flavors.py b/nova/tests/api/openstack/test_flavors.py
index 9287e8adf..532b34e1b 100644
--- a/nova/tests/api/openstack/test_flavors.py
+++ b/nova/tests/api/openstack/test_flavors.py
@@ -44,28 +44,6 @@ class FlavorsTest(unittest.TestCase):
         req = webob.Request.blank('/v1.0/flavors')
         res = req.get_response(fakes.wsgi_app())
 
-    def test_create_list_delete_favor(self):
-        # create a new flavor
-        starting_flavors = db.instance_type_get_all(self.context)
-        new_instance_type = dict(name="os1.big", memory_mb=512,
-                                  vcpus=1, local_gb=120, flavorid=25)
-        new_flavor = db.instance_type_create(self.context, new_instance_type)
-        self.assertEqual(new_flavor["name"], new_instance_type["name"])
-        # retrieve the newly created flavor
-        retrieved_new_flavor = db.instance_type_get_by_name(
-                                                    self.context,
-                                                    new_instance_type["name"])
-        self.assertEqual(retrieved_new_flavor.values()[0]["memory_mb"],
-                            new_instance_type["memory_mb"])
-        flavors = db.instance_type_get_all(self.context)
-        self.assertNotEqual(starting_flavors, flavors)
-        # delete the newly created flavor
-        delete_query = db.instance_type_destroy(self.context,
-                                                new_instance_type["name"])
-        deleted_flavor = db.instance_type_get_by_name(self.context,
-                                                    new_instance_type["name"])
-        self.assertEqual(deleted_flavor.values()[0]["deleted"], 1)
-
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/nova/tests/db/fakes.py b/nova/tests/db/fakes.py
index 859ed6edc..3aa7fcd22 100644
--- a/nova/tests/db/fakes.py
+++ b/nova/tests/db/fakes.py
@@ -47,7 +47,7 @@ def stub_out_db_instance_api(stubs):
         # FIXME(kpepple) for dynamic flavors
         type_data = instance_types.INSTANCE_TYPES[values['instance_type']]
         # type_data = db.instance_type_get_by_name(context,\
-        #                                                 instance_type)[instance_type]
+        #                                                 instance_type)
 
         base_options = {
             'name': values['name'],
-- 
cgit 


From ea5ba79802321bb25f03dfb24fd7fb01866d9921 Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Sun, 6 Feb 2011 13:48:03 -0800
Subject: aliased flavor to instance_types in nova-manage. will probably need
 to make flavor a full fledged class as users will want to list flavors by
 flavor name

---
 nova/tests/test_nova_manage.py | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/test_nova_manage.py b/nova/tests/test_nova_manage.py
index 09ed8163b..487f172ff 100644
--- a/nova/tests/test_nova_manage.py
+++ b/nova/tests/test_nova_manage.py
@@ -39,11 +39,12 @@ class NovaManageTestCase(test.TestCase):
                                     "delete", "test"], stdout=fnull)
         self.assertEqual(0, retcode)
 
-    def test_list_instance_types(self):
+    def test_list_instance_types_or_flavors(self):
         fnull = open(os.devnull, 'w')
-        retcode = subprocess.call(["bin/nova-manage", "instance_type", \
-                                    "list"], stdout=fnull)
-        self.assertEqual(0, retcode)
+        for c in ["instance_type", "flavor"]:
+            retcode = subprocess.call(["bin/nova-manage", c, \
+                                        "list"], stdout=fnull)
+            self.assertEqual(0, retcode)
 
     def test_list_specific_instance_type(self):
         fnull = open(os.devnull, 'w')
-- 
cgit 


From 2458d674807d951a6b58c28cd334cd8d097822a9 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Mon, 7 Feb 2011 10:20:49 -0600
Subject: A few changes

---
 nova/compute/manager.py | 24 ++++++++++++++++++++----
 1 file changed, 20 insertions(+), 4 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 140db0d3e..485efc047 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -380,6 +380,20 @@ class ComputeManager(manager.Manager):
         """Update instance state when async task completes."""
         self._update_state(context, instance_id)
 
+    @exception.wrap_exception
+    @checks_instance_lock
+    def confirm_resize(self, context, instance_id):
+        """Destroys the old instance on the source machine"""
+        pass
+
+    @exception.wrap_exception
+    @echecks_instance_lock
+    def revert_resize(self, context, instance_id):
+        """Destroys the new instance on the destination machine, 
+        reverts the model changes, and powers on the old 
+        instance on the source machine"""
+        pass
+    
 
     @exception.wrap_exception
     @checks_instance_lock
@@ -395,8 +409,9 @@ class ComputeManager(manager.Manager):
                   'status':      'pre-migrating' }
         LOG.audit(_('instance %s: migrating to '), instance_id, context=context)
         service = self.db.service_get_by_host_and_topic(context,
-                instance_ref['host'], topic)
-        topic = self.db.queue_get_for(context, topic, service['id'])
+                instance_ref['host'], FLAGS.compute_topic)
+        topic = self.db.queue_get_for(context, FLAGS.compute_topic, 
+                service['id'])
         rpc.cast(context, topic, 
                 { 'method': 'resize_instance',
                   'migration_id': migration_ref['id'], }
@@ -417,8 +432,9 @@ class ComputeManager(manager.Manager):
         # This is where we would update the VM record after resizing
         
         service = self.db.service_get_by_host_and_topic(context,
-                migration_ref['dest_host'], topic)
-        topic = self.db.queue_get_for(context, topic, service['id'])
+                migration_ref['dest_host'], FLAGS.compute_topic)
+        topic = self.db.queue_get_for(context, FLAGS.compute_topic, 
+                service['id'])
         rpc.cast(context, topic, 
                 { 'method': 'finish_resize',
                   'migration_id': migration_ref['id'], }
-- 
cgit 


From 5a5e96ae90187e1ebfe93262df47ec2c4be23ef1 Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Mon, 7 Feb 2011 13:00:39 -0800
Subject: require user context for most flavor/instance_type read calls

---
 nova/db/sqlalchemy/api.py | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index f4e021ac8..6065af9ca 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -2031,6 +2031,7 @@ def instance_type_create(context, values):
     return instance_type_ref
 
 
+@require_context
 def instance_type_get_all(context):
     """
     Returns a dict describing all instance_types with name as key:
@@ -2049,6 +2050,7 @@ def instance_type_get_all(context):
     return inst_dict
 
 
+@require_context
 def instance_type_get_by_name(context, name):
     """Returns a dict describing specific instance_type"""
     session = get_session()
@@ -2058,6 +2060,7 @@ def instance_type_get_by_name(context, name):
     return dict(inst_type)
 
 
+@require_context
 def instance_type_get_by_flavor_id(context, id):
     """Returns a dict describing specific flavor_id"""
     session = get_session()
-- 
cgit 


From 346087804dd923bcaa0faf433dc1f83a2f193815 Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Mon, 7 Feb 2011 13:32:25 -0800
Subject: fixed instance_types methods to use database backend

---
 nova/compute/instance_types.py | 37 +++++++++++++++++++++++++++++--------
 1 file changed, 29 insertions(+), 8 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/instance_types.py b/nova/compute/instance_types.py
index 449ec1d2e..d38d76ded 100644
--- a/nova/compute/instance_types.py
+++ b/nova/compute/instance_types.py
@@ -21,6 +21,8 @@
 The built-in instance properties.
 """
 
+from nova import context
+from nova import db
 from nova import flags
 from nova import exception
 
@@ -34,20 +36,39 @@ INSTANCE_TYPES = {
     'm1.xlarge': dict(memory_mb=16384, vcpus=8, local_gb=160, flavorid=5)}
 
 
+def get_all_types():
+    """retrieves all instance_types"""
+    return db.instance_type_get_all()
+
+
+def get_all_flavors():
+    """retrieves all flavors. alias for instance_types.get_all_types()"""
+    return get_all_types()
+
+
 def get_by_type(instance_type):
-    """Build instance data structure and save it to the data store."""
+    """retrieve instance_type details"""
     # FIXME(kpepple) for dynamic flavors
     if instance_type is None:
         return FLAGS.default_instance_type
-    if instance_type not in INSTANCE_TYPES:
+    try:
+        ctxt = context.get_admin_context()
+        inst_type = db.instance_type_get_by_name(ctxt, instance_type)
+    except Exception, e:
+        print e
         raise exception.ApiError(_("Unknown instance type: %s"),
                                  instance_type)
-    return instance_type
+    return inst_type['name']
 
 
 def get_by_flavor_id(flavor_id):
-    # FIXME(kpepple) for dynamic flavors
-    for instance_type, details in INSTANCE_TYPES.iteritems():
-        if details['flavorid'] == flavor_id:
-            return instance_type
-    return FLAGS.default_instance_type
+    """retrieve instance_type's name by flavor_id"""
+    if flavor_id is None:
+        return FLAGS.default_instance_type
+    try:
+        ctxt = context.get_admin_context()
+        flavor = db.instance_type_get_by_flavor_id(ctxt, flavor_id)
+    except Exception, e:
+        raise exception.ApiError(_("Unknown flavor: %s"),
+                                 flavor_id)
+    return flavor['name']
-- 
cgit 


From e59c62efe5492e59fcc26b7b74f6ac2daa0caabe Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
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')

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 <ken.pepple@gmail.com>
Date: Mon, 7 Feb 2011 15:04:26 -0800
Subject: added INSTANCE_TYPES to test for compatibility with current tests

---
 nova/compute/instance_types.py | 12 ++++++------
 nova/test.py                   |  8 ++++++++
 nova/tests/db/fakes.py         |  6 ++----
 nova/tests/test_quota.py       |  9 +++------
 nova/tests/test_xenapi.py      |  3 +--
 nova/virt/libvirt_conn.py      |  7 +++----
 nova/virt/xenapi/vm_utils.py   |  4 ++--
 7 files changed, 25 insertions(+), 24 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/instance_types.py b/nova/compute/instance_types.py
index d38d76ded..0e20982e3 100644
--- a/nova/compute/instance_types.py
+++ b/nova/compute/instance_types.py
@@ -28,12 +28,12 @@ from nova import exception
 
 FLAGS = flags.FLAGS
 # FIXME(kpepple) for dynamic flavors
-INSTANCE_TYPES = {
-    'm1.tiny': dict(memory_mb=512, vcpus=1, local_gb=0, flavorid=1),
-    'm1.small': dict(memory_mb=2048, vcpus=1, local_gb=20, flavorid=2),
-    'm1.medium': dict(memory_mb=4096, vcpus=2, local_gb=40, flavorid=3),
-    'm1.large': dict(memory_mb=8192, vcpus=4, local_gb=80, flavorid=4),
-    'm1.xlarge': dict(memory_mb=16384, vcpus=8, local_gb=160, flavorid=5)}
+# INSTANCE_TYPES = {
+#     'm1.tiny': dict(memory_mb=512, vcpus=1, local_gb=0, flavorid=1),
+#     'm1.small': dict(memory_mb=2048, vcpus=1, local_gb=20, flavorid=2),
+#     'm1.medium': dict(memory_mb=4096, vcpus=2, local_gb=40, flavorid=3),
+#     'm1.large': dict(memory_mb=8192, vcpus=4, local_gb=80, flavorid=4),
+#     'm1.xlarge': dict(memory_mb=16384, vcpus=8, local_gb=160, flavorid=5)}
 
 
 def get_all_types():
diff --git a/nova/test.py b/nova/test.py
index 881baccd5..cd049f007 100644
--- a/nova/test.py
+++ b/nova/test.py
@@ -44,6 +44,14 @@ flags.DEFINE_bool('fake_tests', True,
                   'should we use everything for testing')
 
 
+INSTANCE_TYPES = {
+    'm1.tiny': dict(memory_mb=512, vcpus=1, local_gb=0, flavorid=1),
+    'm1.small': dict(memory_mb=2048, vcpus=1, local_gb=20, flavorid=2),
+    'm1.medium': dict(memory_mb=4096, vcpus=2, local_gb=40, flavorid=3),
+    'm1.large': dict(memory_mb=8192, vcpus=4, local_gb=80, flavorid=4),
+    'm1.xlarge': dict(memory_mb=16384, vcpus=8, local_gb=160, flavorid=5)}
+
+
 def skip_if_fake(func):
     """Decorator that skips a test if running in fake mode"""
     def _skipper(*args, **kw):
diff --git a/nova/tests/db/fakes.py b/nova/tests/db/fakes.py
index 3aa7fcd22..d9a5032ee 100644
--- a/nova/tests/db/fakes.py
+++ b/nova/tests/db/fakes.py
@@ -20,6 +20,7 @@
 import time
 
 from nova import db
+from nova import test
 from nova import utils
 from nova.compute import instance_types
 
@@ -44,10 +45,7 @@ def stub_out_db_instance_api(stubs):
     def fake_instance_create(values):
         """ Stubs out the db.instance_create method """
 
-        # FIXME(kpepple) for dynamic flavors
-        type_data = instance_types.INSTANCE_TYPES[values['instance_type']]
-        # type_data = db.instance_type_get_by_name(context,\
-        #                                                 instance_type)
+        type_data = test.INSTANCE_TYPES[values['instance_type']]
 
         base_options = {
             'name': values['name'],
diff --git a/nova/tests/test_quota.py b/nova/tests/test_quota.py
index c70803e05..4206ca416 100644
--- a/nova/tests/test_quota.py
+++ b/nova/tests/test_quota.py
@@ -75,20 +75,17 @@ class QuotaTestCase(test.TestCase):
 
     def test_quota_overrides(self):
         """Make sure overriding a projects quotas works"""
-        # FIXME(kpepple) for dynamic flavors
         num_instances = quota.allowed_instances(self.context, 100,
-            instance_types.INSTANCE_TYPES['m1.small'])
+            test.INSTANCE_TYPES['m1.small'])
         self.assertEqual(num_instances, 2)
         db.quota_create(self.context, {'project_id': self.project.id,
                                        'instances': 10})
-        # FIXME(kpepple) for dynamic flavors
         num_instances = quota.allowed_instances(self.context, 100,
-            instance_types.INSTANCE_TYPES['m1.small'])
+            test.INSTANCE_TYPES['m1.small'])
         self.assertEqual(num_instances, 4)
         db.quota_update(self.context, self.project.id, {'cores': 100})
-        # FIXME(kpepple) for dynamic flavors
         num_instances = quota.allowed_instances(self.context, 100,
-            instance_types.INSTANCE_TYPES['m1.small'])
+            test.INSTANCE_TYPES['m1.small'])
         self.assertEqual(num_instances, 10)
         db.quota_destroy(self.context, self.project.id)
 
diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index 1d42f8da3..d8611ea10 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -225,8 +225,7 @@ class XenAPIVMTestCase(test.TestCase):
         vm = vms[0]
 
         # Check that m1.large above turned into the right thing.
-        # FIXME(kpepple) for dynamic flavors
-        instance_type = instance_types.INSTANCE_TYPES['m1.large']
+        instance_type = test.INSTANCE_TYPES['m1.large']
         mem_kib = long(instance_type['memory_mb']) << 10
         mem_bytes = str(mem_kib << 10)
         vcpus = instance_type['vcpus']
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 <matt.dietz@rackspace.com>
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')

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 <matt.dietz@rackspace.com>
Date: Mon, 7 Feb 2011 17:39:53 -0600
Subject: blargh

---
 nova/compute/api.py       | 2 +-
 nova/virt/xenapi/vmops.py | 8 ++++++++
 nova/virt/xenapi_conn.py  | 2 +-
 3 files changed, 10 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/api.py b/nova/compute/api.py
index f0d5ff2cb..6b2628378 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -379,7 +379,7 @@ class API(base.Base):
         kwargs = {'method': method, 'args': params}
         return rpc.call(context, queue, kwargs)
 
-    def _cast_scheduler_message(self, context, args)
+    def _cast_scheduler_message(self, context, args):
         """Generic handler for RPC calls to the scheduler"""
         rpc.cast(context, FLAGS.scheduler_topic, args)
 
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 <matt.dietz@rackspace.com>
Date: Tue, 8 Feb 2011 10:47:23 -0600
Subject: Changes and bug fixes

---
 nova/compute/manager.py                            |  8 ++--
 nova/db/sqlalchemy/api.py                          |  6 +--
 .../sqlalchemy/migrate_repo/versions/003_cactus.py | 46 ++++++++++++++++++++++
 nova/db/sqlalchemy/migration.py                    |  2 +-
 nova/virt/xenapi/vmops.py                          |  2 +-
 5 files changed, 54 insertions(+), 10 deletions(-)
 create mode 100644 nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 485efc047..4189c49a4 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -387,7 +387,7 @@ class ComputeManager(manager.Manager):
         pass
 
     @exception.wrap_exception
-    @echecks_instance_lock
+    @checks_instance_lock
     def revert_resize(self, context, instance_id):
         """Destroys the new instance on the destination machine, 
         reverts the model changes, and powers on the old 
@@ -406,7 +406,7 @@ class ComputeManager(manager.Manager):
                 { 'instance_id': instance_id,
                   'source_host': instance_ref['host'],
                   'dest_host':   socket.gethostbyname(socket.gethostname()),
-                  'status':      'pre-migrating' }
+                  'status':      'pre-migrating' })
         LOG.audit(_('instance %s: migrating to '), instance_id, context=context)
         service = self.db.service_get_by_host_and_topic(context,
                 instance_ref['host'], FLAGS.compute_topic)
@@ -414,7 +414,7 @@ class ComputeManager(manager.Manager):
                 service['id'])
         rpc.cast(context, topic, 
                 { 'method': 'resize_instance',
-                  'migration_id': migration_ref['id'], }
+                  'migration_id': migration_ref['id'], })
 
     @exception.wrap_exception
     @checks_instance_lock
@@ -437,7 +437,7 @@ class ComputeManager(manager.Manager):
                 service['id'])
         rpc.cast(context, topic, 
                 { 'method': 'finish_resize',
-                  'migration_id': migration_ref['id'], }
+                  'migration_id': migration_ref['id'], })
 
     @exception.wrap_exception
     @checks_instance_lock
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index e94f9f4d2..ece1cd373 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -1942,8 +1942,7 @@ def migration_update(context, migration_id, values):
 def migration_get(context, migration_id):
     session = get_session()
     result = session.query(models.Migration.\
-                     filter_by(migration_id=migration_id)).
-                     first()
+                     filter_by(migration_id=migration_id)).first()
     if not result:
         raise exception.NotFound(_("No migration found with id %s") 
                 % migration_id)
@@ -1954,8 +1953,7 @@ def migration_get(context, migration_id):
 def migration_get_by_instance(context, instance_id):
     session = get_session()
     result = session.query(models.Migration.\
-                     filter_by(instance_id=instance_id)).
-                     first()
+                     filter_by(instance_id=instance_id)).first()
     if not result:
         raise exception.NotFound(_("No migration found with instance id %s") 
                 % migration_id)
diff --git a/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py b/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py
new file mode 100644
index 000000000..bbe5cbcb0
--- /dev/null
+++ b/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py
@@ -0,0 +1,46 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 OpenStack LLC.
+# 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.from sqlalchemy import *
+
+from migrate import *
+
+from nova import log as logging
+
+
+meta = MetaData()
+
+#
+# New Tables
+#
+
+migrations = Table('migrations', meta,
+          Column('source_host', String(255))
+          Column('dest_host', String(255))
+          Column('instance_id', Integer, ForeignKey('instances.id'), nullable=True)
+          Column('status', String(255))
+      )
+
+def upgrade(migrate_engine):
+    # Upgrade operations go here. Don't create your own engine;
+    # bind migrate_engine to your metadata
+    meta.bind = migrate_engine
+    for table in (migrations):
+        try:
+            table.create()
+        except Exception:
+            logging.info(repr(table))
+            logging.exception('Exception while creating table')
+            raise
diff --git a/nova/db/sqlalchemy/migration.py b/nova/db/sqlalchemy/migration.py
index 2a13c5466..644e3e45e 100644
--- a/nova/db/sqlalchemy/migration.py
+++ b/nova/db/sqlalchemy/migration.py
@@ -50,7 +50,7 @@ def db_version():
                           'key_pairs', 'networks', 'projects', 'quotas',
                           'security_group_instance_association',
                           'security_group_rules', 'security_groups',
-                          'services',
+                          'services', 'migrations',
                           'users', 'user_project_association',
                           'user_project_role_association',
                           'user_role_association',
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 49e07d0581317daf1bb605d56575c62743a210be Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Tue, 8 Feb 2011 11:07:03 -0600
Subject: Commas help

---
 nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py b/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py
index bbe5cbcb0..dc384fbc3 100644
--- a/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py
+++ b/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py
@@ -27,10 +27,11 @@ meta = MetaData()
 #
 
 migrations = Table('migrations', meta,
-          Column('source_host', String(255))
-          Column('dest_host', String(255))
-          Column('instance_id', Integer, ForeignKey('instances.id'), nullable=True)
-          Column('status', String(255))
+            Column('source_host', String(255)),
+            Column('dest_host', String(255)),
+            Column('instance_id', Integer, ForeignKey('instances.id'),
+                nullable=True),
+            Column('status', String(255))
       )
 
 def upgrade(migrate_engine):
-- 
cgit 


From 089286802db0dca22cd67e46f26fab3ab0a3a73b Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Tue, 8 Feb 2011 13:12:21 -0600
Subject: Typos and primary keys

---
 nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py b/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py
index dc384fbc3..4d01cd874 100644
--- a/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py
+++ b/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py
@@ -27,6 +27,7 @@ meta = MetaData()
 #
 
 migrations = Table('migrations', meta,
+            Column('id', Integer(), primary_key=True, nullable=False),
             Column('source_host', String(255)),
             Column('dest_host', String(255)),
             Column('instance_id', Integer, ForeignKey('instances.id'),
@@ -38,7 +39,7 @@ def upgrade(migrate_engine):
     # Upgrade operations go here. Don't create your own engine;
     # bind migrate_engine to your metadata
     meta.bind = migrate_engine
-    for table in (migrations):
+    for table in (migrations, ):
         try:
             table.create()
         except Exception:
-- 
cgit 


From ffc788fb41bf5a4bcb85cfa80b3437ed94d46291 Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Tue, 8 Feb 2011 11:24:05 -0800
Subject: additional error checking for nova-manage instance_type

---
 nova/db/sqlalchemy/api.py | 26 +++++++++++++++++++-------
 1 file changed, 19 insertions(+), 7 deletions(-)

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 6065af9ca..f084423e1 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -2044,10 +2044,13 @@ def instance_type_get_all(context):
                     filter_by(deleted=0).\
                     order_by("name").\
                     all()
-    inst_dict = {}
-    for i in inst_types:
-        inst_dict[i['name']] = dict(i)
-    return inst_dict
+    if inst_types:
+        inst_dict = {}
+        for i in inst_types:
+            inst_dict[i['name']] = dict(i)
+        return inst_dict
+    else:
+        raise exception.NotFound
 
 
 @require_context
@@ -2057,7 +2060,10 @@ def instance_type_get_by_name(context, name):
     inst_type = session.query(models.InstanceTypes).\
                     filter_by(name=name).\
                     first()
-    return dict(inst_type)
+    if not inst_type:
+        raise exception.NotFound(_("No instance type with name %s") % name)
+    else:
+        return dict(inst_type)
 
 
 @require_context
@@ -2067,7 +2073,10 @@ def instance_type_get_by_flavor_id(context, id):
     inst_type = session.query(models.InstanceTypes).\
                                     filter_by(flavorid=int(id)).\
                                     first()
-    return dict(inst_type)
+    if not inst_type:
+        raise exception.NotFound(_("No flavor with name %s") % id)
+    else:
+        return dict(inst_type)
 
 
 @require_admin_context
@@ -2077,4 +2086,7 @@ def instance_type_destroy(context, name):
     instance_type_ref = session.query(models.InstanceTypes).\
                     filter_by(name=name)
     rows = instance_type_ref.update(dict(deleted=1))
-    return rows
+    if not rows:
+        raise exception.NotFound(_("Couldn't delete instance type %s") % name)
+    else:
+        return rows
-- 
cgit 


From 2f5d8a25c99875838a08ed06728bcd9d68cdd7f1 Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Tue, 8 Feb 2011 11:31:20 -0800
Subject: added testing for nova-manage instance_type

---
 nova/tests/test_nova_manage.py | 11 +++++++++++
 1 file changed, 11 insertions(+)

(limited to 'nova')

diff --git a/nova/tests/test_nova_manage.py b/nova/tests/test_nova_manage.py
index 487f172ff..5645bf97e 100644
--- a/nova/tests/test_nova_manage.py
+++ b/nova/tests/test_nova_manage.py
@@ -66,6 +66,17 @@ class NovaManageTestCase(test.TestCase):
                                     "120", "1"], stdout=fnull)
         self.assertEqual(1, retcode)
 
+    def test_should_fail_on_duplicate_name(self):
+        fnull = open(os.devnull, 'w')
+        retcode = subprocess.call(["bin/nova-manage", "instance_type",\
+                                    "create", "fsfsfsdfsdf", "256", "1",\
+                                    "120", "189"], stdout=fnull)
+        self.assertEqual(0, retcode)
+        retcode = subprocess.call(["bin/nova-manage", "instance_type",\
+                                    "create", "fsfsfsdfsdf", "256", "1",\
+                                    "120", "190"], stdout=fnull)
+        self.assertEqual(1, retcode)
+
     def test_instance_type_delete_should_fail_without_valid_name(self):
         fnull = open(os.devnull, 'w')
         retcode = subprocess.call(["bin/nova-manage", "instance_type",\
-- 
cgit 


From cf562efb7441a761fcebf0653e4a886655826a10 Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Tue, 8 Feb 2011 15:03:35 -0800
Subject: added create and delete methods to instance_types in preparation to
 call them from nova-manage

---
 nova/compute/instance_types.py | 39 ++++++++++++++++++++++++++-------------
 1 file changed, 26 insertions(+), 13 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/instance_types.py b/nova/compute/instance_types.py
index 0e20982e3..af097672e 100644
--- a/nova/compute/instance_types.py
+++ b/nova/compute/instance_types.py
@@ -27,13 +27,28 @@ from nova import flags
 from nova import exception
 
 FLAGS = flags.FLAGS
-# FIXME(kpepple) for dynamic flavors
-# INSTANCE_TYPES = {
-#     'm1.tiny': dict(memory_mb=512, vcpus=1, local_gb=0, flavorid=1),
-#     'm1.small': dict(memory_mb=2048, vcpus=1, local_gb=20, flavorid=2),
-#     'm1.medium': dict(memory_mb=4096, vcpus=2, local_gb=40, flavorid=3),
-#     'm1.large': dict(memory_mb=8192, vcpus=4, local_gb=80, flavorid=4),
-#     'm1.xlarge': dict(memory_mb=16384, vcpus=8, local_gb=160, flavorid=5)}
+
+
+def create(name, memory, vcpus, local_gb, flavorid):
+    """Creates instance types / flavors
+       arguments: name memory_mb vcpus local_gb"""
+    for option in [memory, flavorid, local_gb, vcpus]:
+        if (option <= 0) or (option.__class__ == int):
+            raise InvalidParameters
+    db.instance_type_create(context.get_admin_context(),
+                            dict(name=name, memory_mb=memory,
+                            vcpus=vcpus, local_gb=local_gb,
+                            flavorid=flavorid))
+
+
+def delete(name):
+    """Marks instance types / flavors as deleted
+    arguments: name"""
+    if name == None:
+        raise InvalidParameters
+    else:
+        records = db.instance_type_destroy(context.get_admin_context(),
+                                            name)
 
 
 def get_all_types():
@@ -48,17 +63,15 @@ def get_all_flavors():
 
 def get_by_type(instance_type):
     """retrieve instance_type details"""
-    # FIXME(kpepple) for dynamic flavors
     if instance_type is None:
         return FLAGS.default_instance_type
     try:
         ctxt = context.get_admin_context()
         inst_type = db.instance_type_get_by_name(ctxt, instance_type)
-    except Exception, e:
-        print e
+        return inst_type['name']
+    except exception.DBError:
         raise exception.ApiError(_("Unknown instance type: %s"),
                                  instance_type)
-    return inst_type['name']
 
 
 def get_by_flavor_id(flavor_id):
@@ -68,7 +81,7 @@ def get_by_flavor_id(flavor_id):
     try:
         ctxt = context.get_admin_context()
         flavor = db.instance_type_get_by_flavor_id(ctxt, flavor_id)
-    except Exception, e:
+        return flavor['name']
+    except exception.DBError:
         raise exception.ApiError(_("Unknown flavor: %s"),
                                  flavor_id)
-    return flavor['name']
-- 
cgit 


From dd2544345e1686ee1ed020fd8f14607d10d8b3d1 Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Tue, 8 Feb 2011 19:24:14 -0800
Subject: added testing for instance_types.py and refactored nova-manage to use
 instance_types.py instead of going directly to db.

---
 nova/compute/instance_types.py    | 31 ++++++++++++++----
 nova/db/sqlalchemy/api.py         |  9 ++++--
 nova/tests/test_instance_types.py | 67 +++++++++++++++++++++++++++++++++++++++
 nova/tests/test_nova_manage.py    |  4 +--
 4 files changed, 99 insertions(+), 12 deletions(-)
 create mode 100644 nova/tests/test_instance_types.py

(limited to 'nova')

diff --git a/nova/compute/instance_types.py b/nova/compute/instance_types.py
index af097672e..b97a0da25 100644
--- a/nova/compute/instance_types.py
+++ b/nova/compute/instance_types.py
@@ -32,33 +32,50 @@ FLAGS = flags.FLAGS
 def create(name, memory, vcpus, local_gb, flavorid):
     """Creates instance types / flavors
        arguments: name memory_mb vcpus local_gb"""
-    for option in [memory, flavorid, local_gb, vcpus]:
-        if (option <= 0) or (option.__class__ == int):
-            raise InvalidParameters
+    for option in [memory, flavorid, vcpus]:
+        if option <= 0:
+            raise exception.InvalidInputException("Parameters incorrect")
     db.instance_type_create(context.get_admin_context(),
                             dict(name=name, memory_mb=memory,
                             vcpus=vcpus, local_gb=local_gb,
                             flavorid=flavorid))
 
 
-def delete(name):
+def destroy(name):
     """Marks instance types / flavors as deleted
     arguments: name"""
     if name == None:
-        raise InvalidParameters
+        raise exception.InvalidInputException
     else:
         records = db.instance_type_destroy(context.get_admin_context(),
                                             name)
+    if records == 0:
+        raise exception.NotFound("Cannot find instance type named %s" % name)
+    else:
+        return records
 
 
 def get_all_types():
     """retrieves all instance_types"""
-    return db.instance_type_get_all()
+    return db.instance_type_get_all(context.get_admin_context())
 
 
 def get_all_flavors():
     """retrieves all flavors. alias for instance_types.get_all_types()"""
-    return get_all_types()
+    return get_all_types(context.get_admin_context())
+
+
+def get_instance_type(name):
+    """Retrieves single instance type by name"""
+    if name is None:
+        return FLAGS.default_instance_type
+    try:
+        ctxt = context.get_admin_context()
+        inst_type = db.instance_type_get_by_name(ctxt, name)
+        return inst_type
+    except exception.DBError:
+        raise exception.ApiError(_("Unknown instance type: %s"),
+                                 instance_type)
 
 
 def get_by_type(instance_type):
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index f084423e1..e5afb8eac 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -2025,9 +2025,12 @@ def console_get(context, console_id, instance_id=None):
 
 @require_admin_context
 def instance_type_create(context, values):
-    instance_type_ref = models.InstanceTypes()
-    instance_type_ref.update(values)
-    instance_type_ref.save()
+    try:
+        instance_type_ref = models.InstanceTypes()
+        instance_type_ref.update(values)
+        instance_type_ref.save()
+    except:
+        raise exception.DBError
     return instance_type_ref
 
 
diff --git a/nova/tests/test_instance_types.py b/nova/tests/test_instance_types.py
new file mode 100644
index 000000000..819431763
--- /dev/null
+++ b/nova/tests/test_instance_types.py
@@ -0,0 +1,67 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+#    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.
+"""
+Unit Tests for instance types code
+"""
+import datetime
+
+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 test
+from nova import utils
+from nova.compute import instance_types
+from nova.db.sqlalchemy.session import get_session
+from nova.db.sqlalchemy import models
+
+FLAGS = flags.FLAGS
+LOG = logging.getLogger('nova.tests.compute')
+
+
+class InstanceTypeTestCase(test.TestCase):
+    """Test cases for instance type code"""
+    def setUp(self):
+        super(InstanceTypeTestCase, self).setUp()
+        session = get_session()
+        max_flavorid = session.query(models.InstanceTypes).\
+                                     order_by("flavorid desc").first()
+        self.flavorid = max_flavorid["flavorid"] + 1
+        self.name = str(datetime.datetime.utcnow())
+
+    def tearDown(self):
+        pass
+
+    def test_instance_type_create_then_delete(self):
+        """Ensure instance types can be created"""
+        starting_inst_list = instance_types.get_all_types()
+        instance_types.create(self.name, 256, 1, 120, self.flavorid)
+        new = instance_types.get_all_types()
+        self.assertNotEqual(len(starting_inst_list),
+                            len(new),
+                            'instance was not created')
+        rows = instance_types.destroy(self.name)
+        self.assertEqual(rows, 1)
+        self.assertEqual(1,
+                    instance_types.get_instance_type(self.name)["deleted"])
+        self.assertEqual(starting_inst_list, instance_types.get_all_types())
+
+    def test_get_all_instance_types(self):
+        """Ensures that all instance types can be retrieved"""
+        session = get_session()
+        total_instance_types = session.query(models.InstanceTypes).\
+                                            count()
+        inst_types = instance_types.get_all_types()
+        self.assertEqual(total_instance_types, len(inst_types))
diff --git a/nova/tests/test_nova_manage.py b/nova/tests/test_nova_manage.py
index 5645bf97e..a2fa919a0 100644
--- a/nova/tests/test_nova_manage.py
+++ b/nova/tests/test_nova_manage.py
@@ -31,8 +31,8 @@ class NovaManageTestCase(test.TestCase):
 
     def test_create_and_delete_instance_types(self):
         fnull = open(os.devnull, 'w')
-        retcode = subprocess.call(["bin/nova-manage", "instance_type",\
-                                    "create", "test", "256", "1",\
+        retcode = subprocess.call(["bin/nova-manage", "instance_type",
+                                    "create", "test", "256", "1",
                                     "120", "99"], stdout=fnull)
         self.assertEqual(0, retcode)
         retcode = subprocess.call(["bin/nova-manage", "instance_type",\
-- 
cgit 


From 99a02a7d68416c72675f7b6c554df9b682771e04 Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Wed, 9 Feb 2011 11:36:45 -0800
Subject: added support to pull list of ALL instance types even those that are
 marked deleted

---
 nova/compute/instance_types.py | 14 ++++++++------
 nova/db/api.py                 |  4 ++--
 nova/db/sqlalchemy/api.py      |  6 +++---
 3 files changed, 13 insertions(+), 11 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/instance_types.py b/nova/compute/instance_types.py
index b97a0da25..b13ccda43 100644
--- a/nova/compute/instance_types.py
+++ b/nova/compute/instance_types.py
@@ -55,13 +55,15 @@ def destroy(name):
         return records
 
 
-def get_all_types():
-    """retrieves all instance_types"""
-    return db.instance_type_get_all(context.get_admin_context())
+def get_all_types(inactive=0):
+    """Retrieves non-deleted instance_types.
+    Pass true as argument if you want deleted instance types returned also."""
+    return db.instance_type_get_all(context.get_admin_context(), inactive)
 
 
 def get_all_flavors():
-    """retrieves all flavors. alias for instance_types.get_all_types()"""
+    """retrieves non-deleted flavors. alias for instance_types.get_all_types().
+    Pass true as argument if you want deleted instance types returned also."""
     return get_all_types(context.get_admin_context())
 
 
@@ -79,7 +81,7 @@ def get_instance_type(name):
 
 
 def get_by_type(instance_type):
-    """retrieve instance_type details"""
+    """retrieve instance type name"""
     if instance_type is None:
         return FLAGS.default_instance_type
     try:
@@ -92,7 +94,7 @@ def get_by_type(instance_type):
 
 
 def get_by_flavor_id(flavor_id):
-    """retrieve instance_type's name by flavor_id"""
+    """retrieve instance type's name by flavor_id"""
     if flavor_id is None:
         return FLAGS.default_instance_type
     try:
diff --git a/nova/db/api.py b/nova/db/api.py
index 2f1903ade..69f577764 100644
--- a/nova/db/api.py
+++ b/nova/db/api.py
@@ -995,9 +995,9 @@ def instance_type_create(context, values):
     return IMPL.instance_type_create(context, values)
 
 
-def instance_type_get_all(context):
+def instance_type_get_all(context, inactive=0):
     """Get all instance types"""
-    return IMPL.instance_type_get_all(context)
+    return IMPL.instance_type_get_all(context, inactive)
 
 
 def instance_type_get_by_name(context, name):
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index e5afb8eac..1e13e4d2d 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -2035,16 +2035,16 @@ def instance_type_create(context, values):
 
 
 @require_context
-def instance_type_get_all(context):
+def instance_type_get_all(context, inactive=0):
     """
-    Returns a dict describing all instance_types with name as key:
+    Returns a dict describing all non-deleted instance_types with name as key:
         {'m1.tiny': dict(memory_mb=512, vcpus=1, local_gb=0, flavorid=1),
          'm1.small': dict(memory_mb=2048, vcpus=1, local_gb=20, flavorid=2),
          'm1.medium': dict(memory_mb=4096, vcpus=2, local_gb=40, flavorid=3)}
     """
     session = get_session()
     inst_types = session.query(models.InstanceTypes).\
-                    filter_by(deleted=0).\
+                    filter_by(deleted=inactive).\
                     order_by("name").\
                     all()
     if inst_types:
-- 
cgit 


From ce5e3bdd30712aa6704926e6cdeb5ae73ae8200b Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Wed, 9 Feb 2011 15:26:37 -0600
Subject: A lot of stuff

---
 nova/compute/manager.py      |  8 +++----
 nova/db/sqlalchemy/models.py |  1 +
 nova/virt/xenapi/vmops.py    | 53 +++++++++++++++++++++++++++++++++++---------
 nova/virt/xenapi_conn.py     |  8 ++++++-
 4 files changed, 54 insertions(+), 16 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 4189c49a4..ac09f7c8c 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -423,12 +423,12 @@ class ComputeManager(manager.Manager):
         migration_ref = self.db.migration_get(context, migration_id)
         self.db.migration_update(context, migration_id, 
                 { 'status': 'migrating', })
-        self.driver.transfer_disk(context, instance_id, 
+
+        self.driver.migrate_disk_and_power_off(context, instance, 
                                   migration_ref['dest_host'])
+    
         self.db.migration_update(context, migration_id, 
                 { 'status': 'post-migrating', })
-
-        self.driver.power_off(context, migration_ref['instance_id'])
         # This is where we would update the VM record after resizing
         
         service = self.db.service_get_by_host_and_topic(context,
@@ -449,7 +449,7 @@ class ComputeManager(manager.Manager):
                 migration_ref['instance_id'])
 
         # this may get passed into the following spawn instead
-        self.driver.attach_disk(context, migration_ref['instance_id'])
+        self.driver.attach_disk(context, instance_ref)
         self.driver.spawn(context, instance_ref, preexisting=True)
 
         self.db.migration_update(context, migration_id, 
diff --git a/nova/db/sqlalchemy/models.py b/nova/db/sqlalchemy/models.py
index 499275504..ebf3a382b 100644
--- a/nova/db/sqlalchemy/models.py
+++ b/nova/db/sqlalchemy/models.py
@@ -369,6 +369,7 @@ class KeyPair(BASE, NovaBase):
 class Migration(BASE, NovaBase):
     """Represents a running host-to-host migration."""
     __tablename__ = 'migrations'
+    id = Column(Integer, primary_key=True, nullable=False)
     source_host = Column(String(255))
     dest_host = Column(String(255))
     instance_id = Column(Integer, ForeignKey('instances.id'), nullable=True)
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 <ken.pepple@gmail.com>
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')

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 <matt.dietz@rackspace.com>
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')

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 1a9225d945bdc9b94473c1dd4ad5b9e4b7624571 Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Wed, 9 Feb 2011 15:48:31 -0800
Subject: forgot to register new instance_types table

---
 nova/db/sqlalchemy/models.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/models.py b/nova/db/sqlalchemy/models.py
index 44583861b..3f418392c 100644
--- a/nova/db/sqlalchemy/models.py
+++ b/nova/db/sqlalchemy/models.py
@@ -550,7 +550,7 @@ def register_models():
     connection is lost and needs to be reestablished.
     """
     from sqlalchemy import create_engine
-    models = (Service, Instance, InstanceActions,
+    models = (Service, Instance, InstanceActions, InstanceTypes,
               Volume, ExportDevice, IscsiTarget, FixedIp, FloatingIp,
               Network, SecurityGroup, SecurityGroupIngressRule,
               SecurityGroupInstanceAssociation, AuthToken, User,
-- 
cgit 


From 493d4d73ce427a686a674e00a2090d5aaec55a46 Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Thu, 10 Feb 2011 10:20:33 -0800
Subject: refactored api call to use instance_types

---
 nova/compute/api.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/api.py b/nova/compute/api.py
index fc18765f6..9c83cfd16 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -90,8 +90,9 @@ class API(base.Base):
         other arguments check out ok."""
 
         # FIXME(kpepple) this needs to be factored for api.py:2065 refactor
-        type_data = db.instance_type_get_by_name(context,\
-                                                instance_type)
+        type_data = instance_types.get_instance_type(instance_type)
+        # type_data = db.instance_type_get_by_name(context,\
+        #                                         instance_type)
         num_instances = quota.allowed_instances(context, max_count, type_data)
         if num_instances < min_count:
             pid = context.project_id
-- 
cgit 


From d601471f54de5db95cf06f4a558362f90cc65c6b Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Thu, 10 Feb 2011 10:28:52 -0800
Subject: typo

---
 nova/compute/api.py | 3 ---
 1 file changed, 3 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/api.py b/nova/compute/api.py
index 9c83cfd16..5d6a42a6b 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -89,10 +89,7 @@ class API(base.Base):
         """Create the number of instances requested if quota and
         other arguments check out ok."""
 
-        # FIXME(kpepple) this needs to be factored for api.py:2065 refactor
         type_data = instance_types.get_instance_type(instance_type)
-        # type_data = db.instance_type_get_by_name(context,\
-        #                                         instance_type)
         num_instances = quota.allowed_instances(context, max_count, type_data)
         if num_instances < min_count:
             pid = context.project_id
-- 
cgit 


From 9029d89d26b9115cad282c6f3f9ee11c47a28444 Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Thu, 10 Feb 2011 11:19:02 -0800
Subject: flavorid needs to unique in model

---
 nova/db/sqlalchemy/models.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/models.py b/nova/db/sqlalchemy/models.py
index 3f418392c..955d373fd 100644
--- a/nova/db/sqlalchemy/models.py
+++ b/nova/db/sqlalchemy/models.py
@@ -218,7 +218,7 @@ class InstanceTypes(BASE, NovaBase):
     memory_mb = Column(Integer)
     vcpus = Column(Integer)
     local_gb = Column(Integer)
-    flavorid = Column(Integer)
+    flavorid = Column(Integer, unique=True)
 
 
 class Volume(BASE, NovaBase):
-- 
cgit 


From fd915e3db7f1006e67342b034eb8db0384c87d34 Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Thu, 10 Feb 2011 11:21:53 -0800
Subject: testing refactor

---
 nova/compute/instance_types.py    |  6 +++---
 nova/tests/test_instance_types.py | 10 ++++------
 nova/tests/test_nova_manage.py    | 32 ++++++++++++++++++++++----------
 3 files changed, 29 insertions(+), 19 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/instance_types.py b/nova/compute/instance_types.py
index b13ccda43..fcd4d8973 100644
--- a/nova/compute/instance_types.py
+++ b/nova/compute/instance_types.py
@@ -32,9 +32,9 @@ FLAGS = flags.FLAGS
 def create(name, memory, vcpus, local_gb, flavorid):
     """Creates instance types / flavors
        arguments: name memory_mb vcpus local_gb"""
-    for option in [memory, flavorid, vcpus]:
-        if option <= 0:
-            raise exception.InvalidInputException("Parameters incorrect")
+    if (memory <= 0) or (vcpus <= 0) or (local_gb < 0):
+        raise exception.InvalidInputException
+
     db.instance_type_create(context.get_admin_context(),
                             dict(name=name, memory_mb=memory,
                             vcpus=vcpus, local_gb=local_gb,
diff --git a/nova/tests/test_instance_types.py b/nova/tests/test_instance_types.py
index 819431763..283f0bce8 100644
--- a/nova/tests/test_instance_types.py
+++ b/nova/tests/test_instance_types.py
@@ -14,7 +14,7 @@
 """
 Unit Tests for instance types code
 """
-import datetime
+import time
 
 from nova import context
 from nova import db
@@ -37,12 +37,10 @@ class InstanceTypeTestCase(test.TestCase):
         super(InstanceTypeTestCase, self).setUp()
         session = get_session()
         max_flavorid = session.query(models.InstanceTypes).\
-                                     order_by("flavorid desc").first()
+                                     order_by("flavorid desc").\
+                                     first()
         self.flavorid = max_flavorid["flavorid"] + 1
-        self.name = str(datetime.datetime.utcnow())
-
-    def tearDown(self):
-        pass
+        self.name = str(int(time.time()))
 
     def test_instance_type_create_then_delete(self):
         """Ensure instance types can be created"""
diff --git a/nova/tests/test_nova_manage.py b/nova/tests/test_nova_manage.py
index a2fa919a0..d2c24e8b0 100644
--- a/nova/tests/test_nova_manage.py
+++ b/nova/tests/test_nova_manage.py
@@ -15,16 +15,25 @@
 Tests For Nova-Manage
 """
 
+import time
 import os
 import subprocess
 
 from nova import test
+from nova.db.sqlalchemy.session import get_session
+from nova.db.sqlalchemy import models
 
 
 class NovaManageTestCase(test.TestCase):
     """Test case for nova-manage"""
     def setUp(self):
         super(NovaManageTestCase, self).setUp()
+        session = get_session()
+        max_flavorid = session.query(models.InstanceTypes).\
+                                     order_by("flavorid desc").first()
+        self.flavorid = str(max_flavorid["flavorid"] + 1)
+        # self.flavorid = str(self.flavorid)
+        self.name = str(int(time.time()))
 
     def teardown(self):
         fnull.close()
@@ -32,11 +41,11 @@ class NovaManageTestCase(test.TestCase):
     def test_create_and_delete_instance_types(self):
         fnull = open(os.devnull, 'w')
         retcode = subprocess.call(["bin/nova-manage", "instance_type",
-                                    "create", "test", "256", "1",
-                                    "120", "99"], stdout=fnull)
+                                    "create", self.name, "256", "1",
+                                    "120", self.flavorid], stdout=fnull)
         self.assertEqual(0, retcode)
         retcode = subprocess.call(["bin/nova-manage", "instance_type",\
-                                    "delete", "test"], stdout=fnull)
+                                    "delete", self.name], stdout=fnull)
         self.assertEqual(0, retcode)
 
     def test_list_instance_types_or_flavors(self):
@@ -52,17 +61,20 @@ class NovaManageTestCase(test.TestCase):
                                     "m1.medium"], stdout=fnull)
         self.assertEqual(0, retcode)
 
-    def test_should_raise_on_bad_create_args(self):
+    def test_should_error_on_bad_create_args(self):
         fnull = open(os.devnull, 'w')
+        # shouldn't be able to create instance type with 0 vcpus
         retcode = subprocess.call(["bin/nova-manage", "instance_type",\
-                                    "create", "test", "256", "0",\
-                                    "120", "99"], stdout=fnull)
-        self.assertEqual(1, retcode)
+                                    "create", self.name, "256", "0",\
+                                    "120", self.flavorid], stdout=fnull)
+        # self.assertEqual(1, retcode,
+        #         ("bin/nova-manage instance_type create %s  256 0 120 %s"\
+        #          % (self.name, self.flavorid)))
 
     def test_should_fail_on_duplicate_flavorid(self):
         fnull = open(os.devnull, 'w')
         retcode = subprocess.call(["bin/nova-manage", "instance_type",\
-                                    "create", "test", "256", "1",\
+                                    "create", self.name, "256", "1",\
                                     "120", "1"], stdout=fnull)
         self.assertEqual(1, retcode)
 
@@ -70,11 +82,11 @@ class NovaManageTestCase(test.TestCase):
         fnull = open(os.devnull, 'w')
         retcode = subprocess.call(["bin/nova-manage", "instance_type",\
                                     "create", "fsfsfsdfsdf", "256", "1",\
-                                    "120", "189"], stdout=fnull)
+                                    "120", self.flavorid], stdout=fnull)
         self.assertEqual(0, retcode)
         retcode = subprocess.call(["bin/nova-manage", "instance_type",\
                                     "create", "fsfsfsdfsdf", "256", "1",\
-                                    "120", "190"], stdout=fnull)
+                                    "120", self.flavorid], stdout=fnull)
         self.assertEqual(1, retcode)
 
     def test_instance_type_delete_should_fail_without_valid_name(self):
-- 
cgit 


From d8a7a76cd4fd22a6ad9fc1a7b879a8dbffcede5f Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Thu, 10 Feb 2011 13:42:57 -0600
Subject: Some more cleanup

---
 nova/compute/manager.py   | 7 ++++---
 nova/virt/xenapi/vmops.py | 3 ++-
 nova/virt/xenapi_conn.py  | 5 +----
 3 files changed, 7 insertions(+), 8 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index ac09f7c8c..54c3412f4 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -429,7 +429,8 @@ class ComputeManager(manager.Manager):
     
         self.db.migration_update(context, migration_id, 
                 { 'status': 'post-migrating', })
-        # This is where we would update the VM record after resizing
+        #TODO(mdietz): This is where we would update the VM record 
+        #after resizing
         
         service = self.db.service_get_by_host_and_topic(context,
                 migration_ref['dest_host'], FLAGS.compute_topic)
@@ -449,8 +450,8 @@ class ComputeManager(manager.Manager):
                 migration_ref['instance_id'])
 
         # this may get passed into the following spawn instead
-        self.driver.attach_disk(context, instance_ref)
-        self.driver.spawn(context, instance_ref, preexisting=True)
+        disk_info = self.driver.attach_disk(context, instance_ref)
+        self.driver.spawn(context, instance_ref, disk_info=disk_info)
 
         self.db.migration_update(context, migration_id, 
                 {'status': 'finished', }) 
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 <matt.dietz@rackspace.com>
Date: Thu, 10 Feb 2011 13:59:54 -0600
Subject: Spawn from disk

---
 nova/compute/manager.py   |  2 +-
 nova/virt/xenapi/vmops.py | 47 ++++++++++++++++++++++++++---------------------
 nova/virt/xenapi_conn.py  |  4 ++--
 3 files changed, 29 insertions(+), 24 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 54c3412f4..5f7d070af 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -451,7 +451,7 @@ class ComputeManager(manager.Manager):
 
         # this may get passed into the following spawn instead
         disk_info = self.driver.attach_disk(context, instance_ref)
-        self.driver.spawn(context, instance_ref, disk_info=disk_info)
+        self.driver.spawn(context, instance_ref, disk=disk_info)
 
         self.db.migration_update(context, migration_id, 
                 {'status': 'finished', }) 
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 a70ac6609713f2b610923a7ae382208f4d46b74a Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Thu, 10 Feb 2011 15:01:38 -0600
Subject: Typo fixes and some stupidity about the models

---
 nova/api/openstack/servers.py                          | 11 +++++------
 nova/compute/manager.py                                |  2 +-
 nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py |  4 ++++
 nova/virt/xenapi/vmops.py                              |  2 +-
 4 files changed, 11 insertions(+), 8 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 61dd3be36..06a40e92c 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -207,27 +207,26 @@ class Controller(wsgi.Controller):
         return faults.Fault(exc.HTTPNotImplemented())
 
     def _action_confirm_resize(self, input_dict, req, id):
-        return fault.Fault(exc.HTTPNotImplemented())
+        return faults.Fault(exc.HTTPNotImplemented())
 
     def _action_revert_resize(self, input_dict, req, id):
-        return fault.Fault(exc.HTTPNotImplemented())
+        return faults.Fault(exc.HTTPNotImplemented())
 
     def _action_rebuild(self, input_dict, req, id):
-        return fault.Fault(exc.HTTPNotImplemented())
+        return faults.Fault(exc.HTTPNotImplemented())
 
     def _action_resize(self, input_dict, req, id):
         """ Resizes a given instance to the flavor size requested """
         try:
-            resize_flavor = input_dict['resize']['flavorId']
+            flavor_id = input_dict['resize']['flavorId']
             self.compute_api.resize(req.environ['nova.context'], id,
                     flavor_id)
         except:
             return faults.Fault(exc.HTTPUnprocessableEntity())
-        return fault.Fault(exc.HTTPAccepted())
+        return faults.Fault(exc.HTTPAccepted())
 
 
     def _action_reboot(self, input_dict, req, id):
-        #TODO(sandy): rebuild/resize not supported.
         try:
             reboot_type = input_dict['reboot']['type']
         except Exception:
diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 5f7d070af..9e8361563 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -401,7 +401,7 @@ class ComputeManager(manager.Manager):
         """Initiates the process of moving a running instance to another 
         host, possibly changing the RAM and disk size in the process"""
         context = context.elevated()
-        instance_ref = self.db.instance_get(context. instance_id)
+        instance_ref = self.db.instance_get(context, instance_id)
         migration_ref = self.db.migration_create(context, 
                 { 'instance_id': instance_id,
                   'source_host': instance_ref['host'],
diff --git a/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py b/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py
index 4d01cd874..499465fce 100644
--- a/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py
+++ b/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py
@@ -27,6 +27,10 @@ meta = MetaData()
 #
 
 migrations = Table('migrations', meta,
+            Column('created_at', DateTime(timezone=False)),
+            Column('updated_at', DateTime(timezone=False)),
+            Column('deleted_at', DateTime(timezone=False)),
+            Column('deleted', Boolean(create_constraint=True, name=None)),
             Column('id', Integer(), primary_key=True, nullable=False),
             Column('source_host', String(255)),
             Column('dest_host', String(255)),
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 3fc68b805bb5326ef4fa2b8a51a58862ec23a6a4 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Thu, 10 Feb 2011 15:04:06 -0600
Subject: Forgot the metadata includes

---
 nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py | 1 +
 1 file changed, 1 insertion(+)

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py b/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py
index 499465fce..38b711775 100644
--- a/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py
+++ b/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py
@@ -15,6 +15,7 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.from sqlalchemy import *
 
+from sqlalchemy import *
 from migrate import *
 
 from nova import log as logging
-- 
cgit 


From 68b7ae27036e1a9b16ceb835c5dc6b934e3b964a Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Thu, 10 Feb 2011 15:06:27 -0600
Subject: Forgot the metadata includes

---
 nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py | 6 ++++++
 1 file changed, 6 insertions(+)

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py b/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py
index 38b711775..02d9177bd 100644
--- a/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py
+++ b/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py
@@ -23,6 +23,12 @@ from nova import log as logging
 
 meta = MetaData()
 
+# Just for the ForeignKey and column creation to succeed, these are not the
+# actual definitions of instances or services.
+instances = Table('instances', meta,
+        Column('id', Integer(),  primary_key=True, nullable=False),
+        )
+
 #
 # New Tables
 #
-- 
cgit 


From 363371ddc6bbe008a536bda06da016385850a98a Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Thu, 10 Feb 2011 17:20:10 -0600
Subject: Forgot the metadata includes

---
 nova/db/api.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/db/api.py b/nova/db/api.py
index 5da0e9840..03232385c 100644
--- a/nova/db/api.py
+++ b/nova/db/api.py
@@ -86,7 +86,7 @@ def service_get(context, service_id):
 
 def service_get_by_host_and_topic(context, host, topic):
     """Get a service by host it's on and topic it listens to"""
-    return IMPL.service_get(context, host, topic)
+    return IMPL.service_get_by_host_and_topic(context, host, topic)
 
 
 def service_get_all(context, disabled=False):
-- 
cgit 


From 8ac02818a514716fa4899d633831877a388239c0 Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Thu, 10 Feb 2011 16:29:25 -0800
Subject: fixed destroy calls

---
 nova/compute/instance_types.py    |  7 +------
 nova/db/sqlalchemy/api.py         | 14 +++++++-------
 nova/tests/test_instance_types.py |  3 +--
 nova/tests/test_nova_manage.py    | 10 +++++-----
 4 files changed, 14 insertions(+), 20 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/instance_types.py b/nova/compute/instance_types.py
index fcd4d8973..c6887795a 100644
--- a/nova/compute/instance_types.py
+++ b/nova/compute/instance_types.py
@@ -47,12 +47,7 @@ def destroy(name):
     if name == None:
         raise exception.InvalidInputException
     else:
-        records = db.instance_type_destroy(context.get_admin_context(),
-                                            name)
-    if records == 0:
-        raise exception.NotFound("Cannot find instance type named %s" % name)
-    else:
-        return records
+        db.instance_type_destroy(context.get_admin_context(), name)
 
 
 def get_all_types(inactive=0):
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 1e13e4d2d..f8b0559d2 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -2086,10 +2086,10 @@ def instance_type_get_by_flavor_id(context, id):
 def instance_type_destroy(context, name):
     """ Marks specific instance_type as deleted"""
     session = get_session()
-    instance_type_ref = session.query(models.InstanceTypes).\
-                    filter_by(name=name)
-    rows = instance_type_ref.update(dict(deleted=1))
-    if not rows:
-        raise exception.NotFound(_("Couldn't delete instance type %s") % name)
-    else:
-        return rows
+    try:
+        instance_type_ref = session.query(models.InstanceTypes).\
+                                          filter_by(name=name)
+        instance_type_ref.update(dict(deleted=1))
+    except:
+        raise exception.DBError
+    return instance_type_ref
diff --git a/nova/tests/test_instance_types.py b/nova/tests/test_instance_types.py
index 283f0bce8..36c29d336 100644
--- a/nova/tests/test_instance_types.py
+++ b/nova/tests/test_instance_types.py
@@ -50,8 +50,7 @@ class InstanceTypeTestCase(test.TestCase):
         self.assertNotEqual(len(starting_inst_list),
                             len(new),
                             'instance was not created')
-        rows = instance_types.destroy(self.name)
-        self.assertEqual(rows, 1)
+        instance_types.destroy(self.name)
         self.assertEqual(1,
                     instance_types.get_instance_type(self.name)["deleted"])
         self.assertEqual(starting_inst_list, instance_types.get_all_types())
diff --git a/nova/tests/test_nova_manage.py b/nova/tests/test_nova_manage.py
index d2c24e8b0..c1ef8cae9 100644
--- a/nova/tests/test_nova_manage.py
+++ b/nova/tests/test_nova_manage.py
@@ -89,8 +89,8 @@ class NovaManageTestCase(test.TestCase):
                                     "120", self.flavorid], stdout=fnull)
         self.assertEqual(1, retcode)
 
-    def test_instance_type_delete_should_fail_without_valid_name(self):
-        fnull = open(os.devnull, 'w')
-        retcode = subprocess.call(["bin/nova-manage", "instance_type",\
-                                    "delete", "saefasff"], stdout=fnull)
-        self.assertEqual(1, retcode)
+    # def test_instance_type_delete_should_fail_without_valid_name(self):
+    #     fnull = open(os.devnull, 'w')
+    #     retcode = subprocess.call(["bin/nova-manage", "instance_type",\
+    #                                 "delete", "saefasff"], stdout=fnull)
+    #     self.assertEqual(1, retcode)
-- 
cgit 


From a36b67d192eb619963494896928efffef5dae4b6 Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
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')

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 42bd44db235ed2b2fb10e05d70de8d04b0fa869d Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Fri, 11 Feb 2011 11:14:51 -0600
Subject: First, not all

---
 nova/db/sqlalchemy/api.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 98be39506..a6be844f8 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -164,7 +164,7 @@ def service_get_by_host_and_topic(context, host, topic):
                    filter_by(disabled=False).\
                    filter_by(host=host).\
                    filter_by(topic=topic).\
-                   all()
+                   first()
 
 @require_admin_context
 def service_get_all_by_host(context, host):
-- 
cgit 


From 4a058908db774bfebce4ece814534225e123345c Mon Sep 17 00:00:00 2001
From: Josh Kearney <josh.kearney@rackspace.com>
Date: Fri, 11 Feb 2011 15:04:49 -0600
Subject: Added more columns to instance_types tables

---
 nova/compute/instance_types.py                     | 28 ++++++++++---
 .../sqlalchemy/migrate_repo/versions/003_cactus.py |  4 +-
 nova/db/sqlalchemy/models.py                       |  3 ++
 nova/tests/test_nova_manage.py                     | 48 ++++++++++++++++++----
 4 files changed, 67 insertions(+), 16 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/instance_types.py b/nova/compute/instance_types.py
index c6887795a..01abee584 100644
--- a/nova/compute/instance_types.py
+++ b/nova/compute/instance_types.py
@@ -29,16 +29,32 @@ from nova import exception
 FLAGS = flags.FLAGS
 
 
-def create(name, memory, vcpus, local_gb, flavorid):
+def create(
+        name,
+        memory,
+        vcpus,
+        local_gb,
+        flavorid,
+        swap=0,
+        rxtx_quota=0,
+        rxtx_cap=0):
     """Creates instance types / flavors
-       arguments: name memory_mb vcpus local_gb"""
+       arguments: name memory vcpus local_gb flavorid swap rxtx_quota rxtx_cap
+    """
     if (memory <= 0) or (vcpus <= 0) or (local_gb < 0):
         raise exception.InvalidInputException
 
-    db.instance_type_create(context.get_admin_context(),
-                            dict(name=name, memory_mb=memory,
-                            vcpus=vcpus, local_gb=local_gb,
-                            flavorid=flavorid))
+    db.instance_type_create(
+        context.get_admin_context(),
+        dict(
+            name=name,
+            memory_mb=memory,
+            vcpus=vcpus,
+            local_gb=local_gb,
+            flavorid=flavorid,
+            swap=swap,
+            rxtx_quota=rxtx_quota,
+            rxtx_cap=rxtx_cap))
 
 
 def destroy(name):
diff --git a/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py b/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py
index f95996042..fec191214 100644
--- a/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py
+++ b/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py
@@ -41,7 +41,9 @@ instance_types = Table('instance_types', meta,
         Column('vcpus', Integer(),  nullable=False),
         Column('local_gb', Integer(),  nullable=False),
         Column('flavorid', Integer(),  nullable=False, unique=True),
-        )
+        Column('swap', Integer(),  nullable=False, default=0),
+        Column('rxtx_quota', Integer(),  nullable=False, default=0),
+        Column('rxtx_cap', Integer(),  nullable=False, default=0))
 
 
 def upgrade(migrate_engine):
diff --git a/nova/db/sqlalchemy/models.py b/nova/db/sqlalchemy/models.py
index 955d373fd..8ee3e3532 100644
--- a/nova/db/sqlalchemy/models.py
+++ b/nova/db/sqlalchemy/models.py
@@ -219,6 +219,9 @@ class InstanceTypes(BASE, NovaBase):
     vcpus = Column(Integer)
     local_gb = Column(Integer)
     flavorid = Column(Integer, unique=True)
+    swap = Column(Integer, nullable=False, default=0)
+    rxtx_quota = Column(Integer, nullable=False, default=0)
+    rxtx_cap = Column(Integer, nullable=False, default=0)
 
 
 class Volume(BASE, NovaBase):
diff --git a/nova/tests/test_nova_manage.py b/nova/tests/test_nova_manage.py
index c1ef8cae9..5a6e1287f 100644
--- a/nova/tests/test_nova_manage.py
+++ b/nova/tests/test_nova_manage.py
@@ -40,9 +40,19 @@ class NovaManageTestCase(test.TestCase):
 
     def test_create_and_delete_instance_types(self):
         fnull = open(os.devnull, 'w')
-        retcode = subprocess.call(["bin/nova-manage", "instance_type",
-                                    "create", self.name, "256", "1",
-                                    "120", self.flavorid], stdout=fnull)
+        retcode = subprocess.call([
+            "bin/nova-manage",
+            "instance_type",
+            "create",
+            self.name,
+            "256",
+            "1",
+            "120",
+            self.flavorid,
+            "2",
+            "10",
+            "10"],
+            stdout=fnull)
         self.assertEqual(0, retcode)
         retcode = subprocess.call(["bin/nova-manage", "instance_type",\
                                     "delete", self.name], stdout=fnull)
@@ -80,13 +90,33 @@ class NovaManageTestCase(test.TestCase):
 
     def test_should_fail_on_duplicate_name(self):
         fnull = open(os.devnull, 'w')
-        retcode = subprocess.call(["bin/nova-manage", "instance_type",\
-                                    "create", "fsfsfsdfsdf", "256", "1",\
-                                    "120", self.flavorid], stdout=fnull)
+        retcode = subprocess.call([
+            "bin/nova-manage",
+            "instance_type",
+            "create",
+            "fsfsfsdfsdf",
+            "256",
+            "1",
+            "120",
+            self.flavorid,
+            "2",
+            "10",
+            "10"],
+            stdout=fnull)
         self.assertEqual(0, retcode)
-        retcode = subprocess.call(["bin/nova-manage", "instance_type",\
-                                    "create", "fsfsfsdfsdf", "256", "1",\
-                                    "120", self.flavorid], stdout=fnull)
+        retcode = subprocess.call([
+            "bin/nova-manage",
+            "instance_type",
+            "create",
+            "fsfsfsdfsdf",
+            "256",
+            "1",
+            "120",
+            self.flavorid,
+            "2",
+            "10",
+            "10"],
+            stdout=fnull)
         self.assertEqual(1, retcode)
 
     # def test_instance_type_delete_should_fail_without_valid_name(self):
-- 
cgit 


From e4061a0f5d06dfd6136c5dda94945214cc9a2cf5 Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Fri, 11 Feb 2011 13:11:28 -0800
Subject: more error checking on inputs and better errors returned

---
 nova/compute/instance_types.py | 38 ++++++++++++++++++++++++++------------
 1 file changed, 26 insertions(+), 12 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/instance_types.py b/nova/compute/instance_types.py
index c6887795a..0cec4812e 100644
--- a/nova/compute/instance_types.py
+++ b/nova/compute/instance_types.py
@@ -32,22 +32,36 @@ FLAGS = flags.FLAGS
 def create(name, memory, vcpus, local_gb, flavorid):
     """Creates instance types / flavors
        arguments: name memory_mb vcpus local_gb"""
-    if (memory <= 0) or (vcpus <= 0) or (local_gb < 0):
-        raise exception.InvalidInputException
-
-    db.instance_type_create(context.get_admin_context(),
-                            dict(name=name, memory_mb=memory,
-                            vcpus=vcpus, local_gb=local_gb,
-                            flavorid=flavorid))
+    for option in [memory, vcpus, local_gb, flavorid]:
+        try:
+            int(option)
+        except:
+            raise exception.InvalidInputException(
+                    _("create arguments must be positive integers"))
+    if (int(memory) <= 0) or (int(vcpus) <= 0) or (int(local_gb) < 0):
+        raise exception.InvalidInputException(
+                _("create arguments must be positive integers"))
+    try:
+        db.instance_type_create(context.get_admin_context(),
+                                dict(name=name, memory_mb=memory,
+                                vcpus=vcpus, local_gb=local_gb,
+                                flavorid=flavorid))
+    except exception.DBError:
+        raise exception.ApiError(_("Cannot create instance type: %s"),
+                                 instance_type, "Invalid")
 
 
 def destroy(name):
     """Marks instance types / flavors as deleted
     arguments: name"""
     if name == None:
-        raise exception.InvalidInputException
+        raise exception.InvalidInputException(_("No instance type specified"))
     else:
-        db.instance_type_destroy(context.get_admin_context(), name)
+        try:
+            db.instance_type_destroy(context.get_admin_context(), name)
+        except exception.DBError:
+            raise exception.ApiError(_("Unknown instance type: %s"),
+                                     instance_type, "Invalid")
 
 
 def get_all_types(inactive=0):
@@ -72,7 +86,7 @@ def get_instance_type(name):
         return inst_type
     except exception.DBError:
         raise exception.ApiError(_("Unknown instance type: %s"),
-                                 instance_type)
+                                 instance_type, "Invalid")
 
 
 def get_by_type(instance_type):
@@ -85,7 +99,7 @@ def get_by_type(instance_type):
         return inst_type['name']
     except exception.DBError:
         raise exception.ApiError(_("Unknown instance type: %s"),
-                                 instance_type)
+                                 instance_type, "Invalid")
 
 
 def get_by_flavor_id(flavor_id):
@@ -98,4 +112,4 @@ def get_by_flavor_id(flavor_id):
         return flavor['name']
     except exception.DBError:
         raise exception.ApiError(_("Unknown flavor: %s"),
-                                 flavor_id)
+                                 flavor_id, "Invalid")
-- 
cgit 


From 40ec6d45a25bf997ae62dbbf08494aa39f047e33 Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Fri, 11 Feb 2011 13:53:54 -0800
Subject: updated tests and added more error checking

---
 nova/compute/instance_types.py    | 12 ++++++------
 nova/db/sqlalchemy/api.py         | 14 +++++++-------
 nova/tests/test_instance_types.py | 17 +++++++++++++++++
 nova/tests/test_nova_manage.py    | 21 +++++++++------------
 4 files changed, 39 insertions(+), 25 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/instance_types.py b/nova/compute/instance_types.py
index 0cec4812e..f0b3fe473 100644
--- a/nova/compute/instance_types.py
+++ b/nova/compute/instance_types.py
@@ -48,7 +48,7 @@ def create(name, memory, vcpus, local_gb, flavorid):
                                 flavorid=flavorid))
     except exception.DBError:
         raise exception.ApiError(_("Cannot create instance type: %s"),
-                                 instance_type, "Invalid")
+                                 name)
 
 
 def destroy(name):
@@ -59,9 +59,9 @@ def destroy(name):
     else:
         try:
             db.instance_type_destroy(context.get_admin_context(), name)
-        except exception.DBError:
+        except exception.NotFound:
             raise exception.ApiError(_("Unknown instance type: %s"),
-                                     instance_type, "Invalid")
+                                     name)
 
 
 def get_all_types(inactive=0):
@@ -86,7 +86,7 @@ def get_instance_type(name):
         return inst_type
     except exception.DBError:
         raise exception.ApiError(_("Unknown instance type: %s"),
-                                 instance_type, "Invalid")
+                                 name)
 
 
 def get_by_type(instance_type):
@@ -99,7 +99,7 @@ def get_by_type(instance_type):
         return inst_type['name']
     except exception.DBError:
         raise exception.ApiError(_("Unknown instance type: %s"),
-                                 instance_type, "Invalid")
+                                 instance_type)
 
 
 def get_by_flavor_id(flavor_id):
@@ -112,4 +112,4 @@ def get_by_flavor_id(flavor_id):
         return flavor['name']
     except exception.DBError:
         raise exception.ApiError(_("Unknown flavor: %s"),
-                                 flavor_id, "Invalid")
+                                 flavor_id)
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index f8b0559d2..323f9b965 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -2086,10 +2086,10 @@ def instance_type_get_by_flavor_id(context, id):
 def instance_type_destroy(context, name):
     """ Marks specific instance_type as deleted"""
     session = get_session()
-    try:
-        instance_type_ref = session.query(models.InstanceTypes).\
-                                          filter_by(name=name)
-        instance_type_ref.update(dict(deleted=1))
-    except:
-        raise exception.DBError
-    return instance_type_ref
+    instance_type_ref = session.query(models.InstanceTypes).\
+                                      filter_by(name=name)
+    records = instance_type_ref.update(dict(deleted=1))
+    if records == 0:
+        raise exception.NotFound
+    else:
+        return instance_type_ref
diff --git a/nova/tests/test_instance_types.py b/nova/tests/test_instance_types.py
index 36c29d336..68ca3b842 100644
--- a/nova/tests/test_instance_types.py
+++ b/nova/tests/test_instance_types.py
@@ -62,3 +62,20 @@ class InstanceTypeTestCase(test.TestCase):
                                             count()
         inst_types = instance_types.get_all_types()
         self.assertEqual(total_instance_types, len(inst_types))
+
+    def test_invalid_create_args_should_fail(self):
+        """Ensures that instance type creation fails with invalid args"""
+        self.assertRaises(
+                exception.InvalidInputException,
+                instance_types.create, self.name, 0, 1, 120, self.flavorid)
+        self.assertRaises(
+                exception.InvalidInputException,
+                instance_types.create, self.name, 256, -1, 120, self.flavorid)
+        self.assertRaises(
+                exception.InvalidInputException,
+                instance_types.create, self.name, 256, 1, "aa", self.flavorid)
+
+    def test_non_existant_inst_type_shouldnt_delete(self):
+        """Ensures that instance type creation fails with invalid args"""
+        self.assertRaises(exception.ApiError,
+                          instance_types.destroy, "sfsfsdfdfs")
diff --git a/nova/tests/test_nova_manage.py b/nova/tests/test_nova_manage.py
index c1ef8cae9..8ab23ba2b 100644
--- a/nova/tests/test_nova_manage.py
+++ b/nova/tests/test_nova_manage.py
@@ -32,7 +32,6 @@ class NovaManageTestCase(test.TestCase):
         max_flavorid = session.query(models.InstanceTypes).\
                                      order_by("flavorid desc").first()
         self.flavorid = str(max_flavorid["flavorid"] + 1)
-        # self.flavorid = str(self.flavorid)
         self.name = str(int(time.time()))
 
     def teardown(self):
@@ -42,7 +41,7 @@ class NovaManageTestCase(test.TestCase):
         fnull = open(os.devnull, 'w')
         retcode = subprocess.call(["bin/nova-manage", "instance_type",
                                     "create", self.name, "256", "1",
-                                    "120", self.flavorid], stdout=fnull)
+                                    "10", self.flavorid], stdout=fnull)
         self.assertEqual(0, retcode)
         retcode = subprocess.call(["bin/nova-manage", "instance_type",\
                                     "delete", self.name], stdout=fnull)
@@ -67,16 +66,14 @@ class NovaManageTestCase(test.TestCase):
         retcode = subprocess.call(["bin/nova-manage", "instance_type",\
                                     "create", self.name, "256", "0",\
                                     "120", self.flavorid], stdout=fnull)
-        # self.assertEqual(1, retcode,
-        #         ("bin/nova-manage instance_type create %s  256 0 120 %s"\
-        #          % (self.name, self.flavorid)))
+        self.assertEqual(1, retcode)
 
     def test_should_fail_on_duplicate_flavorid(self):
         fnull = open(os.devnull, 'w')
         retcode = subprocess.call(["bin/nova-manage", "instance_type",\
                                     "create", self.name, "256", "1",\
                                     "120", "1"], stdout=fnull)
-        self.assertEqual(1, retcode)
+        self.assertEqual(3, retcode)
 
     def test_should_fail_on_duplicate_name(self):
         fnull = open(os.devnull, 'w')
@@ -87,10 +84,10 @@ class NovaManageTestCase(test.TestCase):
         retcode = subprocess.call(["bin/nova-manage", "instance_type",\
                                     "create", "fsfsfsdfsdf", "256", "1",\
                                     "120", self.flavorid], stdout=fnull)
-        self.assertEqual(1, retcode)
+        self.assertEqual(3, retcode)
 
-    # def test_instance_type_delete_should_fail_without_valid_name(self):
-    #     fnull = open(os.devnull, 'w')
-    #     retcode = subprocess.call(["bin/nova-manage", "instance_type",\
-    #                                 "delete", "saefasff"], stdout=fnull)
-    #     self.assertEqual(1, retcode)
+    def test_instance_type_delete_should_fail_without_valid_name(self):
+        fnull = open(os.devnull, 'w')
+        retcode = subprocess.call(["bin/nova-manage", "instance_type",\
+                                    "delete", "doesntexist"], stdout=fnull)
+        self.assertEqual(1, retcode)
-- 
cgit 


From b03d6f523a0dda7c942c298ac75bc46331085056 Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Fri, 11 Feb 2011 14:06:33 -0800
Subject: added instance_type_purge() to actually remove records from db

---
 nova/db/api.py                    |  7 +++++++
 nova/db/sqlalchemy/api.py         | 15 +++++++++++++++
 nova/tests/test_instance_types.py |  1 +
 3 files changed, 23 insertions(+)

(limited to 'nova')

diff --git a/nova/db/api.py b/nova/db/api.py
index 69f577764..4e53a8eee 100644
--- a/nova/db/api.py
+++ b/nova/db/api.py
@@ -1013,3 +1013,10 @@ def instance_type_get_by_flavor_id(context, id):
 def instance_type_destroy(context, name):
     """Delete a instance type"""
     return IMPL.instance_type_destroy(context, name)
+
+
+def instance_type_purge(context, name):
+    """Purges (removes) an instance type from DB
+       Use instance_type_destroy for most cases
+    """
+    return IMPL.instance_type_purge(context, name)
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 323f9b965..a8ce22922 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -2093,3 +2093,18 @@ def instance_type_destroy(context, name):
         raise exception.NotFound
     else:
         return instance_type_ref
+
+
+@require_admin_context
+def instance_type_purge(context, name):
+    """ Removes specific instance_type from DB
+        Usually instance_type_destroy should be used
+    """
+    session = get_session()
+    instance_type_ref = session.query(models.InstanceTypes).\
+                                      filter_by(name=name)
+    records = instance_type_ref.delete()
+    if records == 0:
+        raise exception.NotFound
+    else:
+        return instance_type_ref
diff --git a/nova/tests/test_instance_types.py b/nova/tests/test_instance_types.py
index 68ca3b842..0d54cc283 100644
--- a/nova/tests/test_instance_types.py
+++ b/nova/tests/test_instance_types.py
@@ -54,6 +54,7 @@ class InstanceTypeTestCase(test.TestCase):
         self.assertEqual(1,
                     instance_types.get_instance_type(self.name)["deleted"])
         self.assertEqual(starting_inst_list, instance_types.get_all_types())
+        db.instance_type_purge(context.get_admin_context(), self.name)
 
     def test_get_all_instance_types(self):
         """Ensures that all instance types can be retrieved"""
-- 
cgit 


From f181051ac04084f2937438b61c988804fc2ef845 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Fri, 11 Feb 2011 17:39:04 -0600
Subject: Cast to host

---
 nova/compute/manager.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 9e8361563..63632b538 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -411,7 +411,7 @@ class ComputeManager(manager.Manager):
         service = self.db.service_get_by_host_and_topic(context,
                 instance_ref['host'], FLAGS.compute_topic)
         topic = self.db.queue_get_for(context, FLAGS.compute_topic, 
-                service['id'])
+                service['host'])
         rpc.cast(context, topic, 
                 { 'method': 'resize_instance',
                   'migration_id': migration_ref['id'], })
@@ -435,7 +435,7 @@ class ComputeManager(manager.Manager):
         service = self.db.service_get_by_host_and_topic(context,
                 migration_ref['dest_host'], FLAGS.compute_topic)
         topic = self.db.queue_get_for(context, FLAGS.compute_topic, 
-                service['id'])
+                service['host'])
         rpc.cast(context, topic, 
                 { 'method': 'finish_resize',
                   'migration_id': migration_ref['id'], })
-- 
cgit 


From 66365ece306023c1cf848d452d5af2c418e4e14c Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Fri, 11 Feb 2011 18:04:00 -0600
Subject: More typos

---
 nova/compute/manager.py   | 12 ++++++++++--
 nova/db/sqlalchemy/api.py |  4 ++--
 2 files changed, 12 insertions(+), 4 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 63632b538..9aa163b73 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -414,7 +414,11 @@ class ComputeManager(manager.Manager):
                 service['host'])
         rpc.cast(context, topic, 
                 { 'method': 'resize_instance',
-                  'migration_id': migration_ref['id'], })
+                  'args': {
+                        'migration_id': migration_ref['id'], 
+                        'instance_id': instance_id,
+                  }, 
+                })
 
     @exception.wrap_exception
     @checks_instance_lock
@@ -438,7 +442,11 @@ class ComputeManager(manager.Manager):
                 service['host'])
         rpc.cast(context, topic, 
                 { 'method': 'finish_resize',
-                  'migration_id': migration_ref['id'], })
+                  'args': {
+                        'migration_id': migration_ref['id'], 
+                        'instance_id': instance_id,
+                  }, 
+                })
 
     @exception.wrap_exception
     @checks_instance_lock
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index a6be844f8..af343bc56 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -1941,7 +1941,7 @@ def migration_update(context, migration_id, values):
 @require_admin_context
 def migration_get(context, migration_id):
     session = get_session()
-    result = session.query(models.Migration.\
+    result = session.query(models.Migration).\
                      filter_by(migration_id=migration_id)).first()
     if not result:
         raise exception.NotFound(_("No migration found with id %s") 
@@ -1952,7 +1952,7 @@ def migration_get(context, migration_id):
 @require_admin_context
 def migration_get_by_instance(context, instance_id):
     session = get_session()
-    result = session.query(models.Migration.\
+    result = session.query(models.Migration).\
                      filter_by(instance_id=instance_id)).first()
     if not result:
         raise exception.NotFound(_("No migration found with instance id %s") 
-- 
cgit 


From 384a5aff50926784590ad66b92919b4d0408319d Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Fri, 11 Feb 2011 18:05:02 -0600
Subject: More typos

---
 nova/db/sqlalchemy/api.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index af343bc56..6d52790a5 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -1942,7 +1942,7 @@ def migration_update(context, migration_id, values):
 def migration_get(context, migration_id):
     session = get_session()
     result = session.query(models.Migration).\
-                     filter_by(migration_id=migration_id)).first()
+                     filter_by(migration_id=migration_id).first()
     if not result:
         raise exception.NotFound(_("No migration found with id %s") 
                 % migration_id)
@@ -1953,7 +1953,7 @@ def migration_get(context, migration_id):
 def migration_get_by_instance(context, instance_id):
     session = get_session()
     result = session.query(models.Migration).\
-                     filter_by(instance_id=instance_id)).first()
+                     filter_by(instance_id=instance_id).first()
     if not result:
         raise exception.NotFound(_("No migration found with instance id %s") 
                 % migration_id)
-- 
cgit 


From f3b25fc06e3eff6f1b0e8fed4a0bf90612bf0230 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Fri, 11 Feb 2011 18:07:34 -0600
Subject: More typos

---
 nova/compute/manager.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 9aa163b73..7c9e918fb 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -422,7 +422,7 @@ class ComputeManager(manager.Manager):
 
     @exception.wrap_exception
     @checks_instance_lock
-    def resize_instance(self, context, migration_id):
+    def resize_instance(self, context, instance_id, migration_id):
         """Starts the migration of a running instance to another host"""
         migration_ref = self.db.migration_get(context, migration_id)
         self.db.migration_update(context, migration_id, 
@@ -443,14 +443,14 @@ class ComputeManager(manager.Manager):
         rpc.cast(context, topic, 
                 { 'method': 'finish_resize',
                   'args': {
-                        'migration_id': migration_ref['id'], 
+                        'migration_id': migration_id, 
                         'instance_id': instance_id,
                   }, 
                 })
 
     @exception.wrap_exception
     @checks_instance_lock
-    def finish_resize(self, context, migration_id):
+    def finish_resize(self, context, instance_id, migration_id):
         """Completes the migration process by setting up the newly transferred
         disk and turning on the instance on its new host machine"""
         migration_ref = self.db.migration_get(context, migration_id)
-- 
cgit 


From 520b1b50bc2b1d039ad2f89d791bba21b7a35f05 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Fri, 11 Feb 2011 18:09:11 -0600
Subject: More typos

---
 nova/db/sqlalchemy/api.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 6d52790a5..8566bb91f 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -1930,19 +1930,19 @@ def migration_create(context, values):
 
 
 @require_admin_context
-def migration_update(context, migration_id, values):
+def migration_update(context, id, values):
     session = get_session()
     with session.begin():
-        migration = migration_get(context, migration_id, session=session)
+        migration = migration_get(context, id, session=session)
         migration.update(values)
         return migration
 
 
 @require_admin_context
-def migration_get(context, migration_id):
+def migration_get(context, id):
     session = get_session()
     result = session.query(models.Migration).\
-                     filter_by(migration_id=migration_id).first()
+                     filter_by(id=id).first()
     if not result:
         raise exception.NotFound(_("No migration found with id %s") 
                 % migration_id)
-- 
cgit 


From 252ebfe9a039fb883e3e88eda8feafae037e750e Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Fri, 11 Feb 2011 18:12:18 -0600
Subject: More typos

---
 nova/db/api.py | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'nova')

diff --git a/nova/db/api.py b/nova/db/api.py
index 03232385c..887f57885 100644
--- a/nova/db/api.py
+++ b/nova/db/api.py
@@ -259,6 +259,9 @@ def floating_ip_get_by_address(context, address):
 
 ####################
 
+def migration_update(context, id, values):
+    """Update a migration instance""" 
+    return IMPL.migration_update(context, id, values)
 
 def migration_create(context, values):
     """Create a migration record"""
-- 
cgit 


From 875c4e1bab5e364a23695e46df69f1b21d9a8200 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Mon, 14 Feb 2011 12:44:07 -0600
Subject: Derp

---
 nova/db/sqlalchemy/api.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 8566bb91f..861d13716 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -1933,7 +1933,7 @@ def migration_create(context, values):
 def migration_update(context, id, values):
     session = get_session()
     with session.begin():
-        migration = migration_get(context, id, session=session)
+        migration = migration_get(context, id)
         migration.update(values)
         return migration
 
-- 
cgit 


From 4f23e417bb5ac3db8ac28dfb4b032a3e233c9821 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Mon, 14 Feb 2011 12:50:54 -0600
Subject: More fixes

---
 nova/compute/manager.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 7c9e918fb..3fd37d831 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -425,10 +425,11 @@ class ComputeManager(manager.Manager):
     def resize_instance(self, context, instance_id, migration_id):
         """Starts the migration of a running instance to another host"""
         migration_ref = self.db.migration_get(context, migration_id)
+        instance_ref = self.db.instance_get(context, instance_id)
         self.db.migration_update(context, migration_id, 
                 { 'status': 'migrating', })
 
-        self.driver.migrate_disk_and_power_off(context, instance, 
+        self.driver.migrate_disk_and_power_off(instance_ref, 
                                   migration_ref['dest_host'])
     
         self.db.migration_update(context, migration_id, 
-- 
cgit 


From 1631196f3f277608fb0569c7242a7d8391605d0d Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
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')

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 <matt.dietz@rackspace.com>
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')

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 <matt.dietz@rackspace.com>
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')

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 <matt.dietz@rackspace.com>
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')

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 <matt.dietz@rackspace.com>
Date: Mon, 14 Feb 2011 15:26:08 -0600
Subject: Some refactoring

---
 nova/compute/manager.py      |  4 ++--
 nova/virt/xenapi/vm_utils.py | 12 ++++++++----
 nova/virt/xenapi/vmops.py    | 13 ++++++++-----
 nova/virt/xenapi_conn.py     |  2 +-
 4 files changed, 19 insertions(+), 12 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 3fd37d831..0b0966324 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -405,7 +405,7 @@ class ComputeManager(manager.Manager):
         migration_ref = self.db.migration_create(context, 
                 { 'instance_id': instance_id,
                   'source_host': instance_ref['host'],
-                  'dest_host':   socket.gethostbyname(socket.gethostname()),
+                  'dest_host':   socket.gethostname(),
                   'status':      'pre-migrating' })
         LOG.audit(_('instance %s: migrating to '), instance_id, context=context)
         service = self.db.service_get_by_host_and_topic(context,
@@ -459,7 +459,7 @@ class ComputeManager(manager.Manager):
                 migration_ref['instance_id'])
 
         # this may get passed into the following spawn instead
-        disk_info = self.driver.attach_disk(context, instance_ref)
+        disk_info = self.driver.attach_disk(instance_ref)
         self.driver.spawn(context, instance_ref, disk=disk_info)
 
         self.db.migration_update(context, migration_id, 
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 <matt.dietz@rackspace.com>
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')

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 <matt.dietz@rackspace.com>
Date: Mon, 14 Feb 2011 16:24:51 -0600
Subject: Typo fixes

---
 nova/compute/manager.py      | 2 +-
 nova/virt/xenapi/vm_utils.py | 2 +-
 nova/virt/xenapi/vmops.py    | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 0b0966324..23d2b80ac 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -460,7 +460,7 @@ class ComputeManager(manager.Manager):
 
         # this may get passed into the following spawn instead
         disk_info = self.driver.attach_disk(instance_ref)
-        self.driver.spawn(context, instance_ref, disk=disk_info)
+        self.driver.spawn(instance_ref, disk=disk_info)
 
         self.db.migration_update(context, migration_id, 
                 {'status': 'finished', }) 
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 <rick.harris@rackspace.com>
Date: Mon, 14 Feb 2011 23:12:34 +0000
Subject: First cut on XenServer unified-images

---
 nova/api/openstack/servers.py |  6 +++++-
 nova/virt/xenapi/vm_utils.py  | 47 +++++++++++++++++++++++++++++++++++++++----
 2 files changed, 48 insertions(+), 5 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 17c5519a1..1c9dcd9a6 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -140,7 +140,11 @@ class Controller(wsgi.Controller):
 
         image_id = str(image_id)
         image = self._image_service.show(req.environ['nova.context'], image_id)
-        return lookup('kernel_id'), lookup('ramdisk_id')
+        disk_format = image['properties'].get('disk_format', None)
+        if disk_format == "vhd":
+            return None, None
+        else:
+            return lookup('kernel_id'), lookup('ramdisk_id')
 
     def create(self, req):
         """ Creates a new server for a given user """
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 <matt.dietz@rackspace.com>
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')

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 <matt.dietz@rackspace.com>
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')

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 <rick.harris@rackspace.com>
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')

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 <matt.dietz@rackspace.com>
Date: Mon, 14 Feb 2011 23:22:37 -0600
Subject: Refactored

---
 nova/compute/manager.py   |  9 +++++----
 nova/virt/xenapi/vmops.py | 50 ++++++++++++++++++++++++++---------------------
 nova/virt/xenapi_conn.py  |  2 +-
 3 files changed, 34 insertions(+), 27 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 23d2b80ac..2308c8315 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -429,14 +429,15 @@ class ComputeManager(manager.Manager):
         self.db.migration_update(context, migration_id, 
                 { 'status': 'migrating', })
 
-        self.driver.migrate_disk_and_power_off(instance_ref, 
+        disk_info = self.driver.migrate_disk_and_power_off(instance_ref, 
                                   migration_ref['dest_host'])
     
         self.db.migration_update(context, migration_id, 
                 { 'status': 'post-migrating', })
+
         #TODO(mdietz): This is where we would update the VM record 
         #after resizing
-        
+
         service = self.db.service_get_by_host_and_topic(context,
                 migration_ref['dest_host'], FLAGS.compute_topic)
         topic = self.db.queue_get_for(context, FLAGS.compute_topic, 
@@ -451,7 +452,7 @@ class ComputeManager(manager.Manager):
 
     @exception.wrap_exception
     @checks_instance_lock
-    def finish_resize(self, context, instance_id, migration_id):
+    def finish_resize(self, context, instance_id, migration_id, disk_info):
         """Completes the migration process by setting up the newly transferred
         disk and turning on the instance on its new host machine"""
         migration_ref = self.db.migration_get(context, migration_id)
@@ -459,7 +460,7 @@ class ComputeManager(manager.Manager):
                 migration_ref['instance_id'])
 
         # this may get passed into the following spawn instead
-        disk_info = self.driver.attach_disk(instance_ref)
+        new_disk_info = self.driver.attach_disk(instance_ref, disk_info)
         self.driver.spawn(instance_ref, disk=disk_info)
 
         self.db.migration_update(context, migration_id, 
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 <matt.dietz@rackspace.com>
Date: Mon, 14 Feb 2011 23:58:21 -0600
Subject: Tons o loggin

---
 nova/compute/manager.py  | 1 +
 nova/virt/xenapi_conn.py | 4 ++--
 2 files changed, 3 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 2308c8315..6a87bb6f1 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -447,6 +447,7 @@ class ComputeManager(manager.Manager):
                   'args': {
                         'migration_id': migration_id, 
                         'instance_id': instance_id,
+                        'disk_info': disk_info,
                   }, 
                 })
 
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 <andy.southgate@citrix.com>
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')

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 <matt.dietz@rackspace.com>
Date: Tue, 15 Feb 2011 11:05:20 -0600
Subject: Better host acquisition

---
 nova/compute/manager.py                                | 7 ++++---
 nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py | 3 ++-
 nova/db/sqlalchemy/models.py                           | 3 ++-
 nova/virt/xenapi_conn.py                               | 4 ++++
 4 files changed, 12 insertions(+), 5 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 6a87bb6f1..7e929d715 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -404,12 +404,13 @@ class ComputeManager(manager.Manager):
         instance_ref = self.db.instance_get(context, instance_id)
         migration_ref = self.db.migration_create(context, 
                 { 'instance_id': instance_id,
-                  'source_host': instance_ref['host'],
-                  'dest_host':   socket.gethostname(),
+                  'source_compute': instance_ref['host'],
+                  'dest_compute': socket.gethostname(),
+                  'dest_host':   self.driver.get_host_ip_addr(),
                   'status':      'pre-migrating' })
         LOG.audit(_('instance %s: migrating to '), instance_id, context=context)
         service = self.db.service_get_by_host_and_topic(context,
-                instance_ref['host'], FLAGS.compute_topic)
+                migration_ref['source_compute'], FLAGS.compute_topic)
         topic = self.db.queue_get_for(context, FLAGS.compute_topic, 
                 service['host'])
         rpc.cast(context, topic, 
diff --git a/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py b/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py
index 02d9177bd..4aab5bdc6 100644
--- a/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py
+++ b/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py
@@ -39,7 +39,8 @@ migrations = Table('migrations', meta,
             Column('deleted_at', DateTime(timezone=False)),
             Column('deleted', Boolean(create_constraint=True, name=None)),
             Column('id', Integer(), primary_key=True, nullable=False),
-            Column('source_host', String(255)),
+            Column('source_compute', String(255)),
+            Column('dest_compute', String(255)),
             Column('dest_host', String(255)),
             Column('instance_id', Integer, ForeignKey('instances.id'),
                 nullable=True),
diff --git a/nova/db/sqlalchemy/models.py b/nova/db/sqlalchemy/models.py
index ebf3a382b..1c84e15dd 100644
--- a/nova/db/sqlalchemy/models.py
+++ b/nova/db/sqlalchemy/models.py
@@ -370,7 +370,8 @@ class Migration(BASE, NovaBase):
     """Represents a running host-to-host migration."""
     __tablename__ = 'migrations'
     id = Column(Integer, primary_key=True, nullable=False)
-    source_host = Column(String(255))
+    source_compute = Column(String(255))
+    dest_compute = Column(String(255))
     dest_host = Column(String(255))
     instance_id = Column(Integer, ForeignKey('instances.id'), nullable=True)
     status = Column(String(255)) #TODO(_cerberus_): enum
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 <matt.dietz@rackspace.com>
Date: Tue, 15 Feb 2011 11:19:27 -0600
Subject: derp

---
 nova/compute/manager.py  | 2 +-
 nova/virt/xenapi_conn.py | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 7e929d715..546d07a09 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -440,7 +440,7 @@ class ComputeManager(manager.Manager):
         #after resizing
 
         service = self.db.service_get_by_host_and_topic(context,
-                migration_ref['dest_host'], FLAGS.compute_topic)
+                migration_ref['dest_compute'], FLAGS.compute_topic)
         topic = self.db.queue_get_for(context, FLAGS.compute_topic, 
                 service['host'])
         rpc.cast(context, topic, 
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 <rick.harris@rackspace.com>
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')

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 <rick.harris@rackspace.com>
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')

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 <rick.harris@rackspace.com>
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')

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 0020f14f43aa6f024d9aab7dc67c79caaaeb8257 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Tue, 15 Feb 2011 11:15:59 -0800
Subject: zone/info works

---
 nova/api/openstack/__init__.py | 6 +++---
 nova/api/openstack/zones.py    | 7 ++++++-
 nova/flags.py                  | 5 +++++
 3 files changed, 14 insertions(+), 4 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/__init__.py b/nova/api/openstack/__init__.py
index 33d040ab3..95fce7f84 100644
--- a/nova/api/openstack/__init__.py
+++ b/nova/api/openstack/__init__.py
@@ -76,13 +76,13 @@ class APIRouter(wsgi.Router):
             LOG.debug(_("Including admin operations in API."))
             server_members['pause'] = 'POST'
             server_members['unpause'] = 'POST'
-            server_members["diagnostics"] = "GET"
-            server_members["actions"] = "GET"
+            server_members['diagnostics'] = 'GET'
+            server_members['actions'] = 'GET'
             server_members['suspend'] = 'POST'
             server_members['resume'] = 'POST'
 
             mapper.resource("zone", "zones", controller=zones.Controller(),
-                        collection={'detail': 'GET'})
+                        collection={'detail': 'GET', 'info': 'GET'}),
 
         mapper.resource("server", "servers", controller=servers.Controller(),
                         collection={'detail': 'GET'},
diff --git a/nova/api/openstack/zones.py b/nova/api/openstack/zones.py
index 830464ffd..16e5e366b 100644
--- a/nova/api/openstack/zones.py
+++ b/nova/api/openstack/zones.py
@@ -42,7 +42,7 @@ class Controller(wsgi.Controller):
     _serialization_metadata = {
         'application/xml': {
             "attributes": {
-                "zone": ["id", "api_url"]}}}
+                "zone": ["id", "api_url", "name", "capabilities"]}}}
 
     def index(self, req):
         """Return all zones in brief"""
@@ -55,6 +55,11 @@ class Controller(wsgi.Controller):
         """Return all zones in detail"""
         return self.index(req)
 
+    def info(self, req):
+        """Return name and capabilities for this zone."""
+        return dict(zone=dict(name=FLAGS.zone_name, 
+                    capabilities=FLAGS.zone_capabilities))
+
     def show(self, req, id):
         """Return data about the given zone id"""
         zone_id = int(id)
diff --git a/nova/flags.py b/nova/flags.py
index 3ba3fe6fa..0a45499f3 100644
--- a/nova/flags.py
+++ b/nova/flags.py
@@ -312,3 +312,8 @@ DEFINE_string('host', socket.gethostname(),
 
 DEFINE_string('node_availability_zone', 'nova',
               'availability zone of this node')
+
+DEFINE_string('zone_name', 'nova', 'name of this zone')
+DEFINE_string('zone_capabilities', 'xen, linux', 
+              'comma-delimited list of tags which represent boolean'
+              ' capabilities of this zone')
-- 
cgit 


From acf95a640cfeb0812a55577b6a08bff972ad523b Mon Sep 17 00:00:00 2001
From: Rick Harris <rick.harris@rackspace.com>
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')

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 <matt.dietz@rackspace.com>
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')

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 1d72b9d3ddc835d788ba1fec1a937c2788e94b38 Mon Sep 17 00:00:00 2001
From: Rick Harris <rick.harris@rackspace.com>
Date: Tue, 15 Feb 2011 21:36:13 +0000
Subject: Using Nova style nokernel

---
 nova/api/openstack/servers.py | 8 +-------
 nova/compute/api.py           | 2 ++
 2 files changed, 3 insertions(+), 7 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 1c9dcd9a6..cd0cea235 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -138,13 +138,7 @@ class Controller(wsgi.Controller):
                     _("%(param)s property not found for image %(_image_id)s") %
                       locals())
 
-        image_id = str(image_id)
-        image = self._image_service.show(req.environ['nova.context'], image_id)
-        disk_format = image['properties'].get('disk_format', None)
-        if disk_format == "vhd":
-            return None, None
-        else:
-            return lookup('kernel_id'), lookup('ramdisk_id')
+        return lookup('kernel_id'), lookup('ramdisk_id')
 
     def create(self, req):
         """ Creates a new server for a given user """
diff --git a/nova/compute/api.py b/nova/compute/api.py
index ac02dbcfa..6d28e376c 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -106,6 +106,8 @@ class API(base.Base):
                 kernel_id = image.get('kernelId', None)
             if ramdisk_id is None:
                 ramdisk_id = image.get('ramdiskId', None)
+
+            # FIXME(sirp): is there a way we can remove null_kernel?
             # No kernel and ramdisk for raw images
             if kernel_id == str(FLAGS.null_kernel):
                 kernel_id = None
-- 
cgit 


From 5afc1f05d303cd58fb0bf94e5d35e5bc28b9d75c Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Tue, 15 Feb 2011 13:40:54 -0800
Subject: polling working

---
 nova/scheduler/manager.py | 55 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 55 insertions(+)

(limited to 'nova')

diff --git a/nova/scheduler/manager.py b/nova/scheduler/manager.py
index e9b47512e..00cab60cf 100644
--- a/nova/scheduler/manager.py
+++ b/nova/scheduler/manager.py
@@ -22,6 +22,9 @@ Scheduler Service
 """
 
 import functools
+import novatools
+
+from datetime import datetime
 
 from nova import db
 from nova import flags
@@ -35,20 +38,72 @@ FLAGS = flags.FLAGS
 flags.DEFINE_string('scheduler_driver',
                     'nova.scheduler.chance.ChanceScheduler',
                     'Driver to use for the scheduler')
+flags.DEFINE_integer('zone_db_check_interval',
+                    60,
+                    'Seconds between getting fresh zone info from db.')
+
+
+class ZoneState(object):
+    """Holds the state of all connected child zones."""
+    def __init__(self):
+       self.is_active = True
+       self.name = None
+       self.capabilities = None
+       self.retry = 0
+       self.last_seen = datetime.min
+
+    def update(self, zone):
+       self.zone_id = zone.id
+       self.api_url = zone.api_url
+       self.username = zone.username
+       self.password = zone.password
 
 
+class ZoneManager(object):
+    """Keeps the zone states updated."""
+    def __init__(self):
+        self.last_zone_db_check = datetime.min
+        self.zone_states = {}
+
+    def _refresh_from_db(self, context):
+        zones = db.zone_get_all(context)
+        existing = self.zone_states.keys()
+        for zone in zones:
+            if zone.id not in existing:
+                self.zone_state[zone.id] = ZoneState()
+            self.zone_state[zones.id].update(zone)
+ 
+    def _poll_zones(self, context):
+        pass
+
+    def ping(self, context=None):
+        """Ping should be called periodically to update zone status."""
+        logging.debug("ZoneManager PING")
+        diff = datetime.now() - self.last_zone_db_check
+        if diff.seconds >=  FLAGS.zone_db_check_interval:
+            logging.debug("ZoneManager RECHECKING DB ")
+            self.last_zone_db_check = datetime.now()
+            self._refresh_from_db(context)
+        self._poll_zones(context)
+            
+
 class SchedulerManager(manager.Manager):
     """Chooses a host to run instances on."""
     def __init__(self, scheduler_driver=None, *args, **kwargs):
         if not scheduler_driver:
             scheduler_driver = FLAGS.scheduler_driver
         self.driver = utils.import_object(scheduler_driver)
+        self.zone_manager = ZoneManager()
         super(SchedulerManager, self).__init__(*args, **kwargs)
 
     def __getattr__(self, key):
         """Converts all method calls to use the schedule method"""
         return functools.partial(self._schedule, key)
 
+    def periodic_tasks(self, context=None):
+        """Poll child zones periodically to get status."""
+        self.zone_manager.ping(context)
+
     def _schedule(self, method, context, topic, *args, **kwargs):
         """Tries to call schedule_* method on the driver to retrieve host.
 
-- 
cgit 


From c33378fbbe0fd76e807530522715ba4175af18d8 Mon Sep 17 00:00:00 2001
From: Rick Harris <rick.harris@rackspace.com>
Date: Tue, 15 Feb 2011 21:54:42 +0000
Subject: Fixing typo

---
 nova/api/openstack/servers.py | 11 ++++++++---
 nova/virt/xenapi/vm_utils.py  | 14 +++++++++++++-
 2 files changed, 21 insertions(+), 4 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index cd0cea235..c15e499a0 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -129,8 +129,12 @@ class Controller(wsgi.Controller):
         Machine images are associated with Kernels and Ramdisk images via
         metadata stored in Glance as 'image_properties'
         """
-        def lookup(param):
-            _image_id = image_id
+        # FIXME(sirp): Currently Nova requires us to specify the `null_kernel`
+        # identifier ('nokernel') to indicate a RAW (or VHD) image.  It would
+        # be better if we could omit the kernel_id and ramdisk_id properties
+        # on the image
+        def lookup(image, param):
+            _image_id = image.id
             try:
                 return image['properties'][param]
             except KeyError:
@@ -138,7 +142,8 @@ class Controller(wsgi.Controller):
                     _("%(param)s property not found for image %(_image_id)s") %
                       locals())
 
-        return lookup('kernel_id'), lookup('ramdisk_id')
+        image = self._image_service.show(req.environ['nova.context'], image_id)
+        return lookup(image, 'kernel_id'), lookup(image, 'ramdisk_id')
 
     def create(self, req):
         """ Creates a new server for a given user """
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 <rick.harris@rackspace.com>
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')

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 <rick.harris@rackspace.com>
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')

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 21a3d77fee681d05c465c74e40177ae022bc24af Mon Sep 17 00:00:00 2001
From: Rick Harris <rick.harris@rackspace.com>
Date: Tue, 15 Feb 2011 22:41:27 +0000
Subject: Fixing test by adding stub for get_image_meta

---
 nova/tests/glance/stubs.py | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/glance/stubs.py b/nova/tests/glance/stubs.py
index f182b857a..4cd5c357f 100644
--- a/nova/tests/glance/stubs.py
+++ b/nova/tests/glance/stubs.py
@@ -29,9 +29,10 @@ class FakeGlance(object):
     def __init__(self, host, port=None, use_ssl=False):
         pass
 
-    def get_image(self, image):
-        meta = {
-            'size': 0,
-            }
+    def get_image_meta(self, image_id):
+        return {'size': 0, 'properties': {}}
+
+    def get_image(self, image_id):
+        meta = self.get_image_meta(image_id)
         image_file = StringIO.StringIO('')
         return meta, image_file
-- 
cgit 


From f6bf7e8c1e2481e870ed4baa9f2a6aa8001b5514 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Tue, 15 Feb 2011 16:46:17 -0600
Subject: fail

---
 nova/compute/manager.py | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 546d07a09..19e1d9f46 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -402,10 +402,14 @@ class ComputeManager(manager.Manager):
         host, possibly changing the RAM and disk size in the process"""
         context = context.elevated()
         instance_ref = self.db.instance_get(context, instance_id)
+        if instance_ref['host'] == FLAGS.host:
+            raise exception.Error(_(
+                    'Migration error: destination same as source!'))
+
         migration_ref = self.db.migration_create(context, 
                 { 'instance_id': instance_id,
                   'source_compute': instance_ref['host'],
-                  'dest_compute': socket.gethostname(),
+                  'dest_compute': FLAGS.host,
                   'dest_host':   self.driver.get_host_ip_addr(),
                   'status':      'pre-migrating' })
         LOG.audit(_('instance %s: migrating to '), instance_id, context=context)
@@ -463,7 +467,7 @@ class ComputeManager(manager.Manager):
 
         # this may get passed into the following spawn instead
         new_disk_info = self.driver.attach_disk(instance_ref, disk_info)
-        self.driver.spawn(instance_ref, disk=disk_info)
+        self.driver.spawn(instance_ref, disk=new_disk_info)
 
         self.db.migration_update(context, migration_id, 
                 {'status': 'finished', }) 
-- 
cgit 


From a6ea6759450aab7eb021e202c68e5301667c74a9 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
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')

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 <matt.dietz@rackspace.com>
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')

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 98b038c6878772f6b272cb169b1c74bd7c9838b8 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Tue, 15 Feb 2011 23:56:00 -0600
Subject: Foo

---
 nova/api/openstack/servers.py | 12 ++++++++++--
 nova/compute/api.py           | 20 +++++++++++++++-----
 nova/compute/manager.py       | 16 +++-------------
 nova/db/sqlalchemy/api.py     |  1 +
 4 files changed, 29 insertions(+), 20 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 06a40e92c..83b421127 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -207,10 +207,18 @@ class Controller(wsgi.Controller):
         return faults.Fault(exc.HTTPNotImplemented())
 
     def _action_confirm_resize(self, input_dict, req, id):
-        return faults.Fault(exc.HTTPNotImplemented())
+        try:
+            self.compute_api.confirm_resize(req.environ['nova.context'], id)
+        except:
+            return faults.Fault(exc.HTTPBadRequest())
+        return exc.HTTPNoContent()
 
     def _action_revert_resize(self, input_dict, req, id):
-        return faults.Fault(exc.HTTPNotImplemented())
+        try:
+            self.compute_api.confirm_resize(req.environ['nova.context'], id)
+        except:
+            return faults.Fault(exc.HTTPBadRequest())
+        return exc.HTTPAccepted()
 
     def _action_rebuild(self, input_dict, req, id):
         return faults.Fault(exc.HTTPNotImplemented())
diff --git a/nova/compute/api.py b/nova/compute/api.py
index 6b2628378..b8c4a8597 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -401,16 +401,26 @@ class API(base.Base):
 
     def revert_resize(self, context, instance_id):
         """Reverts a resize, deleting the 'new' instance in the process"""
+        context = context.elevated()
         instance_ref = self.db.instance_get(instance_id)
-        self._cast_compute_message('revert_resize', context, instance_id,
-                instance_ref['host'])
+        self._cast_compute_message('revert_resize', context, instance_id)
 
     def confirm_resize(self, context, instance_id):
         """Confirms a migration/resize, deleting the 'old' instance in the
         process."""
-        migration_ref = self.db.get_migration_by_instance_id(instance_id)
-        self._cast_compute_message('confirm_resize', context, instance_id,
-                migration_ref['source_host'])
+        context = context.elevated()
+        migration_ref = self.db.migration_get_by_instance_id(context, 
+                instance_id)
+        if migration_ref['status'] != 'finished':
+            raise exception.Error(_("Migration has incorrect status %s" %
+                    migration_ref['status']))
+        instance_ref = self.db.instance_get(context, instance_id)
+        
+        self._cast_compute_message('terminate_instance', context, instance_id,
+                migration_ref['source_compute'])
+
+        self.db.instance_update(context, instance_id,
+                {'host': migration_ref['dest_compute'], })
 
     def resize(self, context, instance_id, flavor):
         """Resize a running instance."""
diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 19e1d9f46..169509163 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -379,12 +379,7 @@ class ComputeManager(manager.Manager):
     def _update_state_callback(self, context, instance_id, result):
         """Update instance state when async task completes."""
         self._update_state(context, instance_id)
-
-    @exception.wrap_exception
-    @checks_instance_lock
-    def confirm_resize(self, context, instance_id):
-        """Destroys the old instance on the source machine"""
-        pass
+     
 
     @exception.wrap_exception
     @checks_instance_lock
@@ -413,10 +408,8 @@ class ComputeManager(manager.Manager):
                   'dest_host':   self.driver.get_host_ip_addr(),
                   'status':      'pre-migrating' })
         LOG.audit(_('instance %s: migrating to '), instance_id, context=context)
-        service = self.db.service_get_by_host_and_topic(context,
-                migration_ref['source_compute'], FLAGS.compute_topic)
         topic = self.db.queue_get_for(context, FLAGS.compute_topic, 
-                service['host'])
+                instance_ref['host'])
         rpc.cast(context, topic, 
                 { 'method': 'resize_instance',
                   'args': {
@@ -446,7 +439,7 @@ class ComputeManager(manager.Manager):
         service = self.db.service_get_by_host_and_topic(context,
                 migration_ref['dest_compute'], FLAGS.compute_topic)
         topic = self.db.queue_get_for(context, FLAGS.compute_topic, 
-                service['host'])
+                migration_ref['dest_compute'])
         rpc.cast(context, topic, 
                 { 'method': 'finish_resize',
                   'args': {
@@ -472,9 +465,6 @@ class ComputeManager(manager.Manager):
         self.db.migration_update(context, migration_id, 
                 {'status': 'finished', }) 
 
-        # Cleans up any transferred files and unmounts things
-        self.driver.cleanup_disk_transfer(context, instance_ref['id'])
-
     @exception.wrap_exception
     @checks_instance_lock
     def pause_instance(self, context, instance_id):
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 861d13716..1b6eaf138 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -1935,6 +1935,7 @@ def migration_update(context, id, values):
     with session.begin():
         migration = migration_get(context, id)
         migration.update(values)
+        migration.save()
         return migration
 
 
-- 
cgit 


From 8e536500e83b311bf8d006ca23234c50962dc6aa Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Wed, 16 Feb 2011 00:06:29 -0600
Subject: I fail at sessions

---
 nova/compute/manager.py   | 1 -
 nova/db/sqlalchemy/api.py | 9 +++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 169509163..b405e3763 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -435,7 +435,6 @@ class ComputeManager(manager.Manager):
 
         #TODO(mdietz): This is where we would update the VM record 
         #after resizing
-
         service = self.db.service_get_by_host_and_topic(context,
                 migration_ref['dest_compute'], FLAGS.compute_topic)
         topic = self.db.queue_get_for(context, FLAGS.compute_topic, 
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 1b6eaf138..f96430e67 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -1933,15 +1933,16 @@ def migration_create(context, values):
 def migration_update(context, id, values):
     session = get_session()
     with session.begin():
-        migration = migration_get(context, id)
+        migration = migration_get(context, id, session=session)
         migration.update(values)
-        migration.save()
+        migration.save(session=session)
         return migration
 
 
 @require_admin_context
-def migration_get(context, id):
-    session = get_session()
+def migration_get(context, id, session=None):
+    if not session:
+        session = get_session()
     result = session.query(models.Migration).\
                      filter_by(id=id).first()
     if not result:
-- 
cgit 


From c735796e0668b2bf7c45eeef6396a3fb33d22d6e Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Wed, 16 Feb 2011 00:14:26 -0600
Subject: I fail at sessions

---
 nova/compute/api.py | 2 +-
 nova/db/api.py      | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/api.py b/nova/compute/api.py
index b8c4a8597..3fb852ab0 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -409,7 +409,7 @@ class API(base.Base):
         """Confirms a migration/resize, deleting the 'old' instance in the
         process."""
         context = context.elevated()
-        migration_ref = self.db.migration_get_by_instance_id(context, 
+        migration_ref = self.db.migration_get_by_instance(context, 
                 instance_id)
         if migration_ref['status'] != 'finished':
             raise exception.Error(_("Migration has incorrect status %s" %
diff --git a/nova/db/api.py b/nova/db/api.py
index 887f57885..9ed5efedb 100644
--- a/nova/db/api.py
+++ b/nova/db/api.py
@@ -271,9 +271,9 @@ def migration_get(context, migration_id):
     """Finds a migration by the id"""
     return IMPL.migration_get(context, migration_id)
 
-def migration_get_by_instance_id(context, instance_id):
+def migration_get_by_instance(context, instance_id):
     """Finds a migration by the instance id its migrating"""
-    return IMPL.migration_get_by_instance_id(context, instance_id)
+    return IMPL.migration_get_by_instance(context, instance_id)
 
 ####################
 
-- 
cgit 


From 163e81ac2bc2f9945273b0659ceb473767e5b19f Mon Sep 17 00:00:00 2001
From: Naveed Massjouni <naveedm9@gmail.com>
Date: Wed, 16 Feb 2011 11:53:50 -0500
Subject: This implements the blueprint 'Openstack API support for hostId':
 https://blueprints.launchpad.net/nova/+spec/openstack-api-hostid Now
 instances will have a unique hostId which for now is just a hash of the host.
 If the instance does not have a host yet, the hostId will be ''.

---
 nova/api/openstack/servers.py            |  7 +++++-
 nova/tests/api/openstack/test_servers.py | 41 +++++++++++++++++++++++++++++---
 2 files changed, 44 insertions(+), 4 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 17c5519a1..58eda53b9 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -15,6 +15,7 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+import hashlib
 import json
 import traceback
 
@@ -65,7 +66,11 @@ def _translate_detail_keys(inst):
     inst_dict['status'] = power_mapping[inst_dict['status']]
     inst_dict['addresses'] = dict(public=[], private=[])
     inst_dict['metadata'] = {}
-    inst_dict['hostId'] = ''
+
+    if inst['host']:
+        inst_dict['hostId'] = hashlib.sha224(inst['host']).hexdigest()
+    else:
+        inst_dict['hostId'] = ''
 
     return dict(server=inst_dict)
 
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 724f14f19..e615141ff 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -43,6 +43,10 @@ def return_servers(context, user_id=1):
     return [stub_instance(i, user_id) for i in xrange(5)]
 
 
+def return_servers_with_host(context, user_id=1):
+    return [stub_instance(i, user_id, 1) for i in xrange(5)]
+
+
 def return_security_group(context, instance_id, security_group_id):
     pass
 
@@ -55,9 +59,13 @@ def instance_address(context, instance_id):
     return None
 
 
-def stub_instance(id, user_id=1):
-    return Instance(id=id, state=0, image_id=10, user_id=user_id,
-                    display_name='server%s' % id)
+def stub_instance(id, user_id=1, with_hosts=False):
+    if with_hosts:
+        return Instance(id=id, state=0, image_id=10, user_id=user_id,
+                        display_name='server%s' % id, host='host%s' % (id % 2))
+    else:
+        return Instance(id=id, state=0, image_id=10, user_id=user_id,
+                        display_name='server%s' % id)
 
 
 def fake_compute_api(cls, req, id):
@@ -229,6 +237,33 @@ class ServersTest(unittest.TestCase):
         i = 0
         for s in res_dict['servers']:
             self.assertEqual(s['id'], i)
+            self.assertEqual(s['hostId'], '')
+            self.assertEqual(s['name'], 'server%d' % i)
+            self.assertEqual(s['imageId'], 10)
+            i += 1
+
+    def test_get_all_server_details_with_host(self):
+        '''
+        We want to make sure that if two instances are on the same host, then
+        they return the same hostId. If two instances are on different hosts,
+        they should return different hostId's. In this test, we get 5 instances
+        back where 2 are on one host and 3 are on another.
+        '''
+        self.stubs.Set(nova.db.api, 'instance_get_all_by_user',
+                       return_servers_with_host)
+        req = webob.Request.blank('/v1.0/servers/detail')
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+
+        server_list = res_dict['servers']
+        host_ids = [server_list[0]['hostId'], server_list[1]['hostId']]
+        self.assertTrue(host_ids[0])
+        self.assertTrue(host_ids[1])
+        self.assertTrue(host_ids[0] != host_ids[1])
+        i = 0
+        for s in res_dict['servers']:
+            self.assertEqual(s['id'], i)
+            self.assertEqual(s['hostId'], host_ids[i % 2])
             self.assertEqual(s['name'], 'server%d' % i)
             self.assertEqual(s['imageId'], 10)
             i += 1
-- 
cgit 


From 4375069b6635d6ccd87231cb7d9f5b17708ffb1a Mon Sep 17 00:00:00 2001
From: Josh Kearney <josh.kearney@rackspace.com>
Date: Wed, 16 Feb 2011 11:11:49 -0600
Subject: Stubbed out flavor create/delete API calls

---
 nova/api/openstack/flavors.py            |  9 ++++++++-
 nova/tests/api/openstack/test_flavors.py | 10 ++++++++++
 2 files changed, 18 insertions(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/api/openstack/flavors.py b/nova/api/openstack/flavors.py
index 9b674afbd..215f0b8a6 100644
--- a/nova/api/openstack/flavors.py
+++ b/nova/api/openstack/flavors.py
@@ -42,7 +42,6 @@ class Controller(wsgi.Controller):
     def detail(self, req):
         """Return all flavors in detail."""
         items = [self.show(req, id)['flavor'] for id in self._all_ids()]
-        items = common.limited(items, req)
         return dict(flavors=items)
 
     def show(self, req, id):
@@ -57,6 +56,14 @@ class Controller(wsgi.Controller):
         return dict(flavor=values)
         raise faults.Fault(exc.HTTPNotFound())
 
+    def create(self, req):
+        """Create a flavor."""
+        print "CREATE! %s" % req
+
+    def delete(self, req, id):
+        """Delete a flavor."""
+        print "DELETE! %s %s" % (req, id)
+
     def _all_ids(self):
         """Return the list of all flavorids."""
         # FIXME(kpepple) do we really need admin context here ?
diff --git a/nova/tests/api/openstack/test_flavors.py b/nova/tests/api/openstack/test_flavors.py
index 532b34e1b..7bfc46e0b 100644
--- a/nova/tests/api/openstack/test_flavors.py
+++ b/nova/tests/api/openstack/test_flavors.py
@@ -43,7 +43,17 @@ class FlavorsTest(unittest.TestCase):
     def test_get_flavor_list(self):
         req = webob.Request.blank('/v1.0/flavors')
         res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
 
+    def test_create_flavor(self):
+        req = webob.Request.blank("/v1.0/flavors/create/test")
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
+
+    def test_delete_flavor(self):
+        req = webob.Request.blank("/v1.0/flavors/delete/test")
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
 
 if __name__ == '__main__':
     unittest.main()
-- 
cgit 


From 585ba4d6cf25eabf83b1b33a6de794ce671c0c98 Mon Sep 17 00:00:00 2001
From: Rick Harris <rick.harris@rackspace.com>
Date: Wed, 16 Feb 2011 18:43:55 +0000
Subject: Putting glance plugin under pep8 control

---
 nova/compute/api.py | 3 ---
 1 file changed, 3 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/api.py b/nova/compute/api.py
index 8a16baf45..ea81c7ff0 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -104,11 +104,8 @@ class API(base.Base):
             image = self.image_service.show(context, image_id)
             if kernel_id is None:
                 kernel_id = image.get('kernel_id', None)
-                # FIXME(sirp): which one to use?
-                #kernel_id = image.get('kernelId', None)
             if ramdisk_id is None:
                 ramdisk_id = image.get('ramdisk_id', None)
-                #ramdisk_id = image.get('ramdiskId', None)
 
             # FIXME(sirp): is there a way we can remove null_kernel?
             # No kernel and ramdisk for raw images
-- 
cgit 


From 89a2ee5ee5ea7dc3d9fed4a2d5aa2fe2faed9f2b Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Wed, 16 Feb 2011 11:04:48 -0800
Subject: novatools call to child zones done

---
 nova/scheduler/manager.py | 51 +++++++++++++++++++++++++++++++++++------------
 1 file changed, 38 insertions(+), 13 deletions(-)

(limited to 'nova')

diff --git a/nova/scheduler/manager.py b/nova/scheduler/manager.py
index 00cab60cf..693f8cb4b 100644
--- a/nova/scheduler/manager.py
+++ b/nova/scheduler/manager.py
@@ -23,8 +23,10 @@ Scheduler Service
 
 import functools
 import novatools
+import thread
 
 from datetime import datetime
+from eventlet.greenpool import GreenPool
 
 from nova import db
 from nova import flags
@@ -46,17 +48,28 @@ flags.DEFINE_integer('zone_db_check_interval',
 class ZoneState(object):
     """Holds the state of all connected child zones."""
     def __init__(self):
-       self.is_active = True
-       self.name = None
-       self.capabilities = None
-       self.retry = 0
-       self.last_seen = datetime.min
-
+        self.is_active = True
+        self.name = None
+        self.capabilities = None
+        self.retry = 0
+        self.last_seen = datetime.min
+ 
     def update(self, zone):
-       self.zone_id = zone.id
-       self.api_url = zone.api_url
-       self.username = zone.username
-       self.password = zone.password
+        """Update zone credentials from db"""
+        self.zone_id = zone.id
+        self.api_url = zone.api_url
+        self.username = zone.username
+        self.password = zone.password
+ 
+
+def _poll_zone(zone):
+    """Eventlet worker to poll a zone."""
+    logging.debug("_POLL_ZONE: STARTING")
+    os = novatools.OpenStack(zone.username, zone.password, zone.api_url)
+    zone_metadata = os.zones.info()
+    logging.debug("_POLL_ZONE: GOT %s" % zone_metadata._info)
+
+    # Stuff this in our cache.
 
 
 class ZoneManager(object):
@@ -66,15 +79,27 @@ class ZoneManager(object):
         self.zone_states = {}
 
     def _refresh_from_db(self, context):
+        """Make our zone state map match the db."""
+        # Add/update existing zones ...
         zones = db.zone_get_all(context)
         existing = self.zone_states.keys()
+        db_keys = []
         for zone in zones:
+            db_keys.append(zone.id)
             if zone.id not in existing:
-                self.zone_state[zone.id] = ZoneState()
-            self.zone_state[zones.id].update(zone)
+                self.zone_states[zone.id] = ZoneState()
+            self.zone_states[zone.id].update(zone)
+
+        # Cleanup zones removed from db ...
+        for zone_id in self.zone_states.keys():
+            if zone_id not in db_keys:
+                del self.zone_states[zone_id]
  
     def _poll_zones(self, context):
-        pass
+        """Try to connect to each child zone and get update."""
+
+        green_pool = GreenPool()
+        green_pool.imap(_poll_zone, self.zone_states.values())
 
     def ping(self, context=None):
         """Ping should be called periodically to update zone status."""
-- 
cgit 


From ec39332356d204d14c8910bf72056efd9e943dd0 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Wed, 16 Feb 2011 11:05:03 -0800
Subject: novatools call to child zones done

---
 nova/scheduler/zone_manager.py | 126 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 126 insertions(+)
 create mode 100644 nova/scheduler/zone_manager.py

(limited to 'nova')

diff --git a/nova/scheduler/zone_manager.py b/nova/scheduler/zone_manager.py
new file mode 100644
index 000000000..dd910eb09
--- /dev/null
+++ b/nova/scheduler/zone_manager.py
@@ -0,0 +1,126 @@
+# Copyright (c) 2010 Openstack, LLC.
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# 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.
+
+"""
+ZoneManager oversees all communications with child Zones.
+"""
+
+import novatools
+import thread
+
+from datetime import datetime
+from eventlet.greenpool import GreenPool
+
+from nova import db
+from nova import flags
+from nova import log as logging
+
+FLAGS = flags.FLAGS
+flags.DEFINE_integer('zone_db_check_interval', 60,
+                    'Seconds between getting fresh zone info from db.')
+flags.DEFINE_integer('zone_failures_to_offline', 3,
+             'Number of consecutive errors before marking zone offline')
+
+
+class ZoneState(object):
+    """Holds the state of all connected child zones."""
+    def __init__(self):
+        self.is_active = True
+        self.name = None
+        self.capabilities = None
+        self.attempt = 0
+        self.last_seen = datetime.min
+        self.last_exception = None
+        self.last_exception_time = None
+ 
+    def update_credentials(self, zone):
+        """Update zone credentials from db"""
+        self.zone_id = zone.id
+        self.api_url = zone.api_url
+        self.username = zone.username
+        self.password = zone.password
+ 
+    def update_metadata(self, zone_metadata):
+        """Update zone metadata after successful communications with
+           child zone."""
+        self.last_seen = datetime.now()
+        self.attempt = 0
+        self.name = zone_metadata["name"]
+        self.capabilities = zone_metadata["capabilities"]
+        self.is_active = True
+
+    def log_error(self, exception):
+        """Something went wrong. Check to see if zone should be
+           marked as offline."""
+        self.last_exception = exception
+        self.last_exception_time = datetime.now()
+        logging.warning(_("%s error talking to zone %s") % (exception,
+            zone.api_url, FLAGS.zone_failures_to_offline))
+
+       self.attempt += 1
+        if self.attempt >= FLAGS.zone_failures_to_offline:
+           self.is_active = False
+           logging.error(_("No answer from zone %s after %d "
+               "attempts. Marking inactive.") % (zone.api_url,
+               FLAGS.zone_failures_to_offline))
+
+def _poll_zone(zone):
+    """Eventlet worker to poll a zone."""
+    logging.debug("_POLL_ZONE: STARTING")
+    os = novatools.OpenStack(zone.username, zone.password, zone.api_url)
+    try:
+        zone.update_metadata(os.zones.info()._info)
+    except Exception, e:
+        zone.log_error(e)
+
+class ZoneManager(object):
+    """Keeps the zone states updated."""
+    def __init__(self):
+        self.last_zone_db_check = datetime.min
+        self.zone_states = {}
+
+    def _refresh_from_db(self, context):
+        """Make our zone state map match the db."""
+        # Add/update existing zones ...
+        zones = db.zone_get_all(context)
+        existing = self.zone_states.keys()
+        db_keys = []
+        for zone in zones:
+            db_keys.append(zone.id)
+            if zone.id not in existing:
+                self.zone_states[zone.id] = ZoneState()
+            self.zone_states[zone.id].update_credentials(zone)
+
+        # Cleanup zones removed from db ...
+        for zone_id in self.zone_states.keys():
+            if zone_id not in db_keys:
+                del self.zone_states[zone_id]
+ 
+    def _poll_zones(self, context):
+        """Try to connect to each child zone and get update."""
+        green_pool = GreenPool()
+        green_pool.imap(_poll_zone, self.zone_states.values())
+
+    def ping(self, context=None):
+        """Ping should be called periodically to update zone status."""
+        logging.debug("ZoneManager PING")
+        diff = datetime.now() - self.last_zone_db_check
+        if diff.seconds >=  FLAGS.zone_db_check_interval:
+            logging.debug("ZoneManager RECHECKING DB ")
+            self.last_zone_db_check = datetime.now()
+            self._refresh_from_db(context)
+        self._poll_zones(context)
-- 
cgit 


From 552875913e263d0e44be4613f0a07d3b53067e96 Mon Sep 17 00:00:00 2001
From: Andy Southgate <andy.southgate@citrix.com>
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')

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 879845496a50477ebc2709291c159ae1e8d5aa2a Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Wed, 16 Feb 2011 13:47:14 -0600
Subject: Derp

---
 nova/compute/api.py       | 26 +++++++++++++++++---------
 nova/compute/manager.py   | 32 +++++++++++++++++++++++++++++---
 nova/db/sqlalchemy/api.py |  5 +++--
 3 files changed, 49 insertions(+), 14 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/api.py b/nova/compute/api.py
index 3fb852ab0..58dea5db6 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -402,22 +402,30 @@ class API(base.Base):
     def revert_resize(self, context, instance_id):
         """Reverts a resize, deleting the 'new' instance in the process"""
         context = context.elevated()
-        instance_ref = self.db.instance_get(instance_id)
-        self._cast_compute_message('revert_resize', context, instance_id)
+        migration_ref = self.db.migration_get_by_instance_and_status(context,
+                instance_id, 'finished')
+        if not migration_ref:
+            raise exception.Error(_("No finished migrations found for
+                    instance"))
+
+        params = { 'migration_id': migration_ref['id'])
+        self._cast_compute_message('revert_resize', context, instance_id,
+                migration_ref['dest_compute'], params=params)
 
     def confirm_resize(self, context, instance_id):
         """Confirms a migration/resize, deleting the 'old' instance in the
         process."""
         context = context.elevated()
-        migration_ref = self.db.migration_get_by_instance(context, 
-                instance_id)
-        if migration_ref['status'] != 'finished':
-            raise exception.Error(_("Migration has incorrect status %s" %
-                    migration_ref['status']))
+        migration_ref = self.db.migration_get_by_instance_and_status(context,
+                instance_id, 'finished')
+        if not migration_ref:
+            raise exception.Error(_("No finished migrations found for
+                    instance"))
         instance_ref = self.db.instance_get(context, instance_id)
         
-        self._cast_compute_message('terminate_instance', context, instance_id,
-                migration_ref['source_compute'])
+        params = { 'migration_id': migration_ref['id'])
+        self._cast_compute_message('confirm_resize', context, instance_id,
+                migration_ref['source_compute'], params=param)
 
         self.db.instance_update(context, instance_id,
                 {'host': migration_ref['dest_compute'], })
diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index b405e3763..c05edd140 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -380,15 +380,41 @@ class ComputeManager(manager.Manager):
         """Update instance state when async task completes."""
         self._update_state(context, instance_id)
      
+    @exception.wrap_exception
+    @echecks_instance_lock
+    def confirm_resize(self, context, instance_id, migration_id):
+        """ Destroys the source instance """
+        context = context.elevated()
+        instance_ref = self.db.instance_get(context, instance_id)
+        migration_ref = self.db.migration_get(context, migration_id)
+        self.driver.destroy(instance_ref)
+        self.db.migration_update(context, migration_id, 
+                { 'status': 'confirmed' })
 
     @exception.wrap_exception
     @checks_instance_lock
-    def revert_resize(self, context, instance_id):
+    def revert_resize(self, context, instance_id, migration_id):
         """Destroys the new instance on the destination machine, 
         reverts the model changes, and powers on the old 
         instance on the source machine"""
-        pass
-    
+        instance_ref = self.db.instance_get(context, instance_id)
+        migration_ref = self.db.migration_get(context, migration_id)
+
+        if migration_ref['source_compute'] == instance_ref['host']:
+            self.driver.power_on(instance_ref)
+            self.db.migration_update(context, migration_id, 
+                    { 'status': 'reverted' })
+        else:
+            self.driver.destroy(instance_ref)
+            topic = self.db.queue_get_for(context, FLAGS.compute_topic, 
+                    instance_ref['host'])
+            rpc.cast(context, topic, 
+                    { 'method': 'resize_instance',
+                      'args': {
+                            'migration_id': migration_ref['id'], 
+                            'instance_id': instance_id,
+                      }, 
+                    })
 
     @exception.wrap_exception
     @checks_instance_lock
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index f96430e67..62484805c 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -1952,10 +1952,11 @@ def migration_get(context, id, session=None):
 
 
 @require_admin_context
-def migration_get_by_instance(context, instance_id):
+def migration_get_by_instance_and_status(context, instance_id, status):
     session = get_session()
     result = session.query(models.Migration).\
-                     filter_by(instance_id=instance_id).first()
+                     filter_by(instance_id=instance_id).
+                     filter_by(status=status).first()
     if not result:
         raise exception.NotFound(_("No migration found with instance id %s") 
                 % migration_id)
-- 
cgit 


From 905cf54f06f6dde95039599ae5ea30d2f070f398 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Wed, 16 Feb 2011 13:53:47 -0600
Subject: Typos

---
 nova/compute/api.py       | 8 ++++----
 nova/compute/manager.py   | 2 +-
 nova/db/sqlalchemy/api.py | 2 +-
 3 files changed, 6 insertions(+), 6 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/api.py b/nova/compute/api.py
index 4262a771b..2f39b8b47 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -405,10 +405,10 @@ class API(base.Base):
         migration_ref = self.db.migration_get_by_instance_and_status(context,
                 instance_id, 'finished')
         if not migration_ref:
-            raise exception.Error(_("No finished migrations found for
+            raise exception.Error(_("No finished migrations found for \
                     instance"))
 
-        params = { 'migration_id': migration_ref['id'])
+        params = { 'migration_id': migration_ref['id'] }
         self._cast_compute_message('revert_resize', context, instance_id,
                 migration_ref['dest_compute'], params=params)
 
@@ -419,11 +419,11 @@ class API(base.Base):
         migration_ref = self.db.migration_get_by_instance_and_status(context,
                 instance_id, 'finished')
         if not migration_ref:
-            raise exception.Error(_("No finished migrations found for
+            raise exception.Error(_("No finished migrations found for \
                     instance"))
         instance_ref = self.db.instance_get(context, instance_id)
         
-        params = { 'migration_id': migration_ref['id'])
+        params = { 'migration_id': migration_ref['id'] }
         self._cast_compute_message('confirm_resize', context, instance_id,
                 migration_ref['source_compute'], params=param)
 
diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index d78318bec..4bab7081a 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -381,7 +381,7 @@ class ComputeManager(manager.Manager):
         self._update_state(context, instance_id)
      
     @exception.wrap_exception
-    @echecks_instance_lock
+    @checks_instance_lock
     def confirm_resize(self, context, instance_id, migration_id):
         """ Destroys the source instance """
         context = context.elevated()
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index b6fb57df7..f4dc8a630 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -1961,7 +1961,7 @@ def migration_get(context, id, session=None):
 def migration_get_by_instance_and_status(context, instance_id, status):
     session = get_session()
     result = session.query(models.Migration).\
-                     filter_by(instance_id=instance_id).
+                     filter_by(instance_id=instance_id).\
                      filter_by(status=status).first()
     if not result:
         raise exception.NotFound(_("No migration found with instance id %s") 
-- 
cgit 


From 49a7e430ca30768a68a111223068652c781206fe Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Wed, 16 Feb 2011 13:17:42 -0800
Subject: zone manager tests

---
 nova/scheduler/zone_manager.py |   2 +-
 nova/tests/test_zones.py       | 132 +++++++++++++++++++++++++++++++++++++++++
 2 files changed, 133 insertions(+), 1 deletion(-)
 create mode 100644 nova/tests/test_zones.py

(limited to 'nova')

diff --git a/nova/scheduler/zone_manager.py b/nova/scheduler/zone_manager.py
index dd910eb09..0974f271b 100644
--- a/nova/scheduler/zone_manager.py
+++ b/nova/scheduler/zone_manager.py
@@ -71,7 +71,7 @@ class ZoneState(object):
         logging.warning(_("%s error talking to zone %s") % (exception,
             zone.api_url, FLAGS.zone_failures_to_offline))
 
-       self.attempt += 1
+        self.attempt += 1
         if self.attempt >= FLAGS.zone_failures_to_offline:
            self.is_active = False
            logging.error(_("No answer from zone %s after %d "
diff --git a/nova/tests/test_zones.py b/nova/tests/test_zones.py
new file mode 100644
index 000000000..b4c8815d5
--- /dev/null
+++ b/nova/tests/test_zones.py
@@ -0,0 +1,132 @@
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# 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.
+"""
+Tests For ZoneManager
+"""
+
+import datetime
+import mox
+
+from nova import context
+from nova import db
+from nova import flags
+from nova import service
+from nova import test
+from nova import rpc
+from nova import utils
+from nova.auth import manager as auth_manager
+from nova.scheduler import zone_manager
+
+
+class FakeZone:
+    """Represents a fake zone from the db"""
+    def __init__(self, *args, **kwargs):
+        for k, v in kwargs.iteritems():
+            setattr(self, k, v)
+
+
+class ZoneManagerTestCase(test.TestCase):
+    """Test case for zone manager"""
+    def test_ping(self):
+        zm = zone_manager.ZoneManager()
+        self.mox.StubOutWithMock(zm, '_refresh_from_db')
+        self.mox.StubOutWithMock(zm, '_poll_zones')
+        zm._refresh_from_db(mox.IgnoreArg())
+        zm._poll_zones(mox.IgnoreArg())
+
+        self.mox.ReplayAll()
+        zm.ping(None)
+        self.mox.VerifyAll()
+
+    def test_refresh_from_db_new(self):
+        zm = zone_manager.ZoneManager()
+
+        self.mox.StubOutWithMock(db, 'zone_get_all')
+        db.zone_get_all(mox.IgnoreArg()).AndReturn([
+               FakeZone(id=1, api_url='http://foo.com', username='user1',
+                    password='pass1'),
+            ])
+        
+        self.assertEquals(len(zm.zone_states), 0)
+
+        self.mox.ReplayAll()
+        zm._refresh_from_db(None)
+        self.mox.VerifyAll()
+
+        self.assertEquals(len(zm.zone_states), 1)
+        self.assertEquals(zm.zone_states[1].username, 'user1')
+
+    def test_refresh_from_db_replace_existing(self):
+        zm = zone_manager.ZoneManager()
+        zone_state = zone_manager.ZoneState()
+        zone_state.update_credentials(FakeZone(id=1, api_url='http://foo.com',
+                        username='user1', password='pass1'))
+        zm.zone_states[1] = zone_state
+
+        self.mox.StubOutWithMock(db, 'zone_get_all')
+        db.zone_get_all(mox.IgnoreArg()).AndReturn([
+               FakeZone(id=1, api_url='http://foo.com', username='user2',
+                    password='pass2'),
+            ])
+        
+        self.assertEquals(len(zm.zone_states), 1)
+
+        self.mox.ReplayAll()
+        zm._refresh_from_db(None)
+        self.mox.VerifyAll()
+
+        self.assertEquals(len(zm.zone_states), 1)
+        self.assertEquals(zm.zone_states[1].username, 'user2')
+
+    def test_refresh_from_db_missing(self):
+        zm = zone_manager.ZoneManager()
+        zone_state = zone_manager.ZoneState()
+        zone_state.update_credentials(FakeZone(id=1, api_url='http://foo.com',
+                        username='user1', password='pass1'))
+        zm.zone_states[1] = zone_state
+
+        self.mox.StubOutWithMock(db, 'zone_get_all')
+        db.zone_get_all(mox.IgnoreArg()).AndReturn([ ])
+        
+        self.assertEquals(len(zm.zone_states), 1)
+
+        self.mox.ReplayAll()
+        zm._refresh_from_db(None)
+        self.mox.VerifyAll()
+
+        self.assertEquals(len(zm.zone_states), 0)
+
+    def test_refresh_from_db_add_and_delete(self):
+        zm = zone_manager.ZoneManager()
+        zone_state = zone_manager.ZoneState()
+        zone_state.update_credentials(FakeZone(id=1, api_url='http://foo.com',
+                        username='user1', password='pass1'))
+        zm.zone_states[1] = zone_state
+
+        self.mox.StubOutWithMock(db, 'zone_get_all')
+        
+        db.zone_get_all(mox.IgnoreArg()).AndReturn([
+               FakeZone(id=2, api_url='http://foo.com', username='user2',
+                    password='pass2'),
+            ])
+        self.assertEquals(len(zm.zone_states), 1)
+
+        self.mox.ReplayAll()
+        zm._refresh_from_db(None)
+        self.mox.VerifyAll()
+
+        self.assertEquals(len(zm.zone_states), 1)
+        self.assertEquals(zm.zone_states[2].username, 'user2')
-- 
cgit 


From 8f206774ee75c2d96c15dd2c604ae5da9601d91f Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Wed, 16 Feb 2011 17:02:57 -0600
Subject: Better exceptions

---
 nova/api/openstack/servers.py | 15 +++++++++------
 nova/db/api.py                |  2 +-
 2 files changed, 10 insertions(+), 7 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 83b421127..2fc105d07 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -209,15 +209,17 @@ class Controller(wsgi.Controller):
     def _action_confirm_resize(self, input_dict, req, id):
         try:
             self.compute_api.confirm_resize(req.environ['nova.context'], id)
-        except:
-            return faults.Fault(exc.HTTPBadRequest())
+        except Exception, e:
+            LOG.exception(_("Error in confirm-resize %s"), e)
+            return faults.Fault(exc.HTTPBadRequest(e))
         return exc.HTTPNoContent()
 
     def _action_revert_resize(self, input_dict, req, id):
         try:
             self.compute_api.confirm_resize(req.environ['nova.context'], id)
-        except:
-            return faults.Fault(exc.HTTPBadRequest())
+        except Exception, e:
+            LOG.exception(_("Error in revert-resize %s"), e)
+            return faults.Fault(exc.HTTPBadRequest(e))
         return exc.HTTPAccepted()
 
     def _action_rebuild(self, input_dict, req, id):
@@ -229,8 +231,9 @@ class Controller(wsgi.Controller):
             flavor_id = input_dict['resize']['flavorId']
             self.compute_api.resize(req.environ['nova.context'], id,
                     flavor_id)
-        except:
-            return faults.Fault(exc.HTTPUnprocessableEntity())
+        except Exception, e:
+            LOG.exception(_("Error in resize %s"), e)
+            return faults.Fault(exc.HTTPUnprocessableEntity(e))
         return faults.Fault(exc.HTTPAccepted())
 
 
diff --git a/nova/db/api.py b/nova/db/api.py
index 9ed5efedb..295d1a90a 100644
--- a/nova/db/api.py
+++ b/nova/db/api.py
@@ -271,7 +271,7 @@ def migration_get(context, migration_id):
     """Finds a migration by the id"""
     return IMPL.migration_get(context, migration_id)
 
-def migration_get_by_instance(context, instance_id):
+def migration_get_by_instance_and_status(context, instance_id, status):
     """Finds a migration by the instance id its migrating"""
     return IMPL.migration_get_by_instance(context, instance_id)
 
-- 
cgit 


From a5ec2be709d28267075ddc9616c5c29b62622af5 Mon Sep 17 00:00:00 2001
From: Rick Harris <rick.harris@rackspace.com>
Date: Wed, 16 Feb 2011 23:07:43 +0000
Subject: Adding basic test

---
 nova/tests/glance/stubs.py | 22 ++++++++++++++++++----
 nova/tests/test_xenapi.py  |  4 ++++
 nova/tests/xenapi/stubs.py |  6 ++++++
 3 files changed, 28 insertions(+), 4 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/glance/stubs.py b/nova/tests/glance/stubs.py
index 4cd5c357f..fc120e523 100644
--- a/nova/tests/glance/stubs.py
+++ b/nova/tests/glance/stubs.py
@@ -26,13 +26,27 @@ def stubout_glance_client(stubs, cls):
 
 
 class FakeGlance(object):
+    IMAGE_FIXTURES = {
+        1: {'image_meta': {'name': 'fakemachine', 'size': 0,
+                           'properties': {}},
+            'image_data': StringIO.StringIO('') },
+        2: {'image_meta': {'name': 'fakekernel', 'size': 0,
+                           'properties': {}},
+            'image_data': StringIO.StringIO('') },
+        3: {'image_meta': {'name': 'fakekernel', 'size': 0,
+                           'properties': {}},
+            'image_data': StringIO.StringIO('') },
+        4: {'image_meta': {'name': 'fakekernel', 'size': 0,
+                           'properties': {'disk_format': 'vhd'}},
+            'image_data': StringIO.StringIO('') },
+    }
+
     def __init__(self, host, port=None, use_ssl=False):
         pass
 
     def get_image_meta(self, image_id):
-        return {'size': 0, 'properties': {}}
+        return self.IMAGE_FIXTURES[image_id]['image_meta']
 
     def get_image(self, image_id):
-        meta = self.get_image_meta(image_id)
-        image_file = StringIO.StringIO('')
-        return meta, image_file
+        image = self.IMAGE_FIXTURES[image_id]
+        return image['image_meta'], image['image_data']
diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index d5660c5d1..75387e7f5 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -279,6 +279,10 @@ class XenAPIVMTestCase(test.TestCase):
         FLAGS.xenapi_image_service = 'glance'
         self._test_spawn(1, None, None)
 
+    def test_spawn_vhd_glance(self):
+        FLAGS.xenapi_image_service = 'glance'
+        self._test_spawn(4, None, None)
+
     def test_spawn_glance(self):
         FLAGS.xenapi_image_service = 'glance'
         self._test_spawn(1, 2, 3)
diff --git a/nova/tests/xenapi/stubs.py b/nova/tests/xenapi/stubs.py
index 624995ada..2e3b62a77 100644
--- a/nova/tests/xenapi/stubs.py
+++ b/nova/tests/xenapi/stubs.py
@@ -171,6 +171,12 @@ class FakeSessionForVMTests(fake.SessionBase):
     def VM_destroy(self, session_ref, vm_ref):
         fake.destroy_vm(vm_ref)
 
+    def SR_scan(self, session_ref, sr_ref):
+        pass
+
+    def VDI_set_name_label(self, session_ref, vdi_ref, name_label):
+        pass
+
 
 class FakeSessionForVolumeTests(fake.SessionBase):
     """ Stubs out a XenAPISession for Volume tests """
-- 
cgit 


From c56b1814cfae7a9c814b2d37388aff5e772771b6 Mon Sep 17 00:00:00 2001
From: Rick Harris <rick.harris@rackspace.com>
Date: Wed, 16 Feb 2011 23:39:12 +0000
Subject: Pep8 fixes

---
 nova/tests/glance/stubs.py   | 8 ++++----
 nova/virt/xenapi/vm_utils.py | 8 +++++---
 2 files changed, 9 insertions(+), 7 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/glance/stubs.py b/nova/tests/glance/stubs.py
index fc120e523..c58357962 100644
--- a/nova/tests/glance/stubs.py
+++ b/nova/tests/glance/stubs.py
@@ -29,16 +29,16 @@ class FakeGlance(object):
     IMAGE_FIXTURES = {
         1: {'image_meta': {'name': 'fakemachine', 'size': 0,
                            'properties': {}},
-            'image_data': StringIO.StringIO('') },
+            'image_data': StringIO.StringIO('')},
         2: {'image_meta': {'name': 'fakekernel', 'size': 0,
                            'properties': {}},
-            'image_data': StringIO.StringIO('') },
+            'image_data': StringIO.StringIO('')},
         3: {'image_meta': {'name': 'fakekernel', 'size': 0,
                            'properties': {}},
-            'image_data': StringIO.StringIO('') },
+            'image_data': StringIO.StringIO('')},
         4: {'image_meta': {'name': 'fakekernel', 'size': 0,
                            'properties': {'disk_format': 'vhd'}},
-            'image_data': StringIO.StringIO('') },
+            'image_data': StringIO.StringIO('')},
     }
 
     def __init__(self, host, port=None, use_ssl=False):
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 c01519112245f5e991ab438fe983bf9331d4e952 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Wed, 16 Feb 2011 17:51:43 -0600
Subject: fixed

---
 nova/compute/api.py     | 5 ++++-
 nova/compute/manager.py | 2 --
 nova/db/api.py          | 3 ++-
 3 files changed, 6 insertions(+), 4 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/api.py b/nova/compute/api.py
index 2f39b8b47..635632b73 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -425,7 +425,10 @@ class API(base.Base):
         
         params = { 'migration_id': migration_ref['id'] }
         self._cast_compute_message('confirm_resize', context, instance_id,
-                migration_ref['source_compute'], params=param)
+                migration_ref['source_compute'], params=params)
+
+        self.db.migration_update(context, migration_id, 
+                { 'status': 'confirmed' })
 
         self.db.instance_update(context, instance_id,
                 {'host': migration_ref['dest_compute'], })
diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 4bab7081a..33fad50fd 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -388,8 +388,6 @@ class ComputeManager(manager.Manager):
         instance_ref = self.db.instance_get(context, instance_id)
         migration_ref = self.db.migration_get(context, migration_id)
         self.driver.destroy(instance_ref)
-        self.db.migration_update(context, migration_id, 
-                { 'status': 'confirmed' })
 
     @exception.wrap_exception
     @checks_instance_lock
diff --git a/nova/db/api.py b/nova/db/api.py
index 295d1a90a..ab871c67e 100644
--- a/nova/db/api.py
+++ b/nova/db/api.py
@@ -273,7 +273,8 @@ def migration_get(context, migration_id):
 
 def migration_get_by_instance_and_status(context, instance_id, status):
     """Finds a migration by the instance id its migrating"""
-    return IMPL.migration_get_by_instance(context, instance_id)
+    return IMPL.migration_get_by_instance_and_status(context, instance_id,
+            status)
 
 ####################
 
-- 
cgit 


From ce847afcc1e24463d7aa522f227a08193c72fcc0 Mon Sep 17 00:00:00 2001
From: Naveed Massjouni <naveedm9@gmail.com>
Date: Wed, 16 Feb 2011 19:12:44 -0500
Subject: Moved definition of return_servers_with_host stub to inside the
 test_get_all_server_details_with_host test.

---
 nova/api/openstack/servers.py            |  3 +--
 nova/tests/api/openstack/test_servers.py | 29 ++++++++++++++---------------
 2 files changed, 15 insertions(+), 17 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 58eda53b9..323e6fda6 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -67,10 +67,9 @@ def _translate_detail_keys(inst):
     inst_dict['addresses'] = dict(public=[], private=[])
     inst_dict['metadata'] = {}
 
+    inst_dict['hostId'] = ''
     if inst['host']:
         inst_dict['hostId'] = hashlib.sha224(inst['host']).hexdigest()
-    else:
-        inst_dict['hostId'] = ''
 
     return dict(server=inst_dict)
 
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index e615141ff..6c91b3f5b 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -43,10 +43,6 @@ def return_servers(context, user_id=1):
     return [stub_instance(i, user_id) for i in xrange(5)]
 
 
-def return_servers_with_host(context, user_id=1):
-    return [stub_instance(i, user_id, 1) for i in xrange(5)]
-
-
 def return_security_group(context, instance_id, security_group_id):
     pass
 
@@ -60,12 +56,8 @@ def instance_address(context, instance_id):
 
 
 def stub_instance(id, user_id=1, with_hosts=False):
-    if with_hosts:
-        return Instance(id=id, state=0, image_id=10, user_id=user_id,
-                        display_name='server%s' % id, host='host%s' % (id % 2))
-    else:
-        return Instance(id=id, state=0, image_id=10, user_id=user_id,
-                        display_name='server%s' % id)
+    return Instance(id=id, state=0, image_id=10, user_id=user_id,
+                    display_name='server%s' % id)
 
 
 def fake_compute_api(cls, req, id):
@@ -246,20 +238,27 @@ class ServersTest(unittest.TestCase):
         '''
         We want to make sure that if two instances are on the same host, then
         they return the same hostId. If two instances are on different hosts,
-        they should return different hostId's. In this test, we get 5 instances
-        back where 2 are on one host and 3 are on another.
+        they should return different hostId's. In this test, there are 5
+        instances - 2 on one host and 3 on another.
         '''
+
+        def return_servers_with_host(context, user_id=1):
+            return [
+                Instance(id=i, state=0, image_id=10, user_id=user_id,
+                    display_name='server%s' % i, host='host%s' % (i % 2))
+                for i in xrange(5)]
         self.stubs.Set(nova.db.api, 'instance_get_all_by_user',
-                       return_servers_with_host)
+            return_servers_with_host)
+
         req = webob.Request.blank('/v1.0/servers/detail')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
 
         server_list = res_dict['servers']
         host_ids = [server_list[0]['hostId'], server_list[1]['hostId']]
-        self.assertTrue(host_ids[0])
-        self.assertTrue(host_ids[1])
+        self.assertTrue(host_ids[0] and host_ids[1])
         self.assertTrue(host_ids[0] != host_ids[1])
+
         i = 0
         for s in res_dict['servers']:
             self.assertEqual(s['id'], i)
-- 
cgit 


From 56ad2a63f1dcf4a900fa4464671015dbaac05fdc Mon Sep 17 00:00:00 2001
From: Naveed Massjouni <naveedm9@gmail.com>
Date: Wed, 16 Feb 2011 19:37:28 -0500
Subject: Minor change. Adding a helper function stub_instance() inside the
 test test_get_all_server_details_with_host for readability.

---
 nova/tests/api/openstack/test_servers.py | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 6c91b3f5b..630e1e5eb 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -55,7 +55,7 @@ def instance_address(context, instance_id):
     return None
 
 
-def stub_instance(id, user_id=1, with_hosts=False):
+def stub_instance(id, user_id=1):
     return Instance(id=id, state=0, image_id=10, user_id=user_id,
                     display_name='server%s' % id)
 
@@ -242,11 +242,13 @@ class ServersTest(unittest.TestCase):
         instances - 2 on one host and 3 on another.
         '''
 
+        def stub_instance(id, user_id=1):
+            return Instance(id=id, state=0, image_id=10, user_id=user_id,
+                display_name='server%s' % id, host='host%s' % (id % 2))
+
         def return_servers_with_host(context, user_id=1):
-            return [
-                Instance(id=i, state=0, image_id=10, user_id=user_id,
-                    display_name='server%s' % i, host='host%s' % (i % 2))
-                for i in xrange(5)]
+            return [stub_instance(i) for i in xrange(5)]
+
         self.stubs.Set(nova.db.api, 'instance_get_all_by_user',
             return_servers_with_host)
 
-- 
cgit 


From 04e29f6dc4b13b6fd0cbe5013cf241a727eb56ac Mon Sep 17 00:00:00 2001
From: Rick Harris <rick.harris@rackspace.com>
Date: Thu, 17 Feb 2011 01:24:31 +0000
Subject: Use glance image type to determine disk type

---
 nova/tests/glance/stubs.py   | 12 ++++----
 nova/virt/xenapi/vm_utils.py | 68 +++++++++++++++++++++++---------------------
 nova/virt/xenapi/vmops.py    |  9 ++++--
 3 files changed, 48 insertions(+), 41 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/glance/stubs.py b/nova/tests/glance/stubs.py
index c58357962..1a5fb7ffb 100644
--- a/nova/tests/glance/stubs.py
+++ b/nova/tests/glance/stubs.py
@@ -28,16 +28,16 @@ def stubout_glance_client(stubs, cls):
 class FakeGlance(object):
     IMAGE_FIXTURES = {
         1: {'image_meta': {'name': 'fakemachine', 'size': 0,
-                           'properties': {}},
+                           'type': 'machine'},
             'image_data': StringIO.StringIO('')},
         2: {'image_meta': {'name': 'fakekernel', 'size': 0,
-                           'properties': {}},
+                           'type': 'kernel'},
             'image_data': StringIO.StringIO('')},
-        3: {'image_meta': {'name': 'fakekernel', 'size': 0,
-                           'properties': {}},
+        3: {'image_meta': {'name': 'fakeramdisk', 'size': 0,
+                           'type': 'ramdisk'},
             'image_data': StringIO.StringIO('')},
-        4: {'image_meta': {'name': 'fakekernel', 'size': 0,
-                           'properties': {'disk_format': 'vhd'}},
+        4: {'image_meta': {'name': 'fakevhd', 'size': 0,
+                           'type': 'vhd'},
             'image_data': StringIO.StringIO('')},
     }
 
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 719dbda7f8b856af334744de4807036e6ee704c1 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Wed, 16 Feb 2011 18:30:56 -0800
Subject: polling tests

---
 nova/scheduler/zone_manager.py | 15 ++++++++++-----
 nova/tests/test_zones.py       | 41 +++++++++++++++++++++++++++++++++++++++++
 2 files changed, 51 insertions(+), 5 deletions(-)

(limited to 'nova')

diff --git a/nova/scheduler/zone_manager.py b/nova/scheduler/zone_manager.py
index 0974f271b..a6bbc2ebd 100644
--- a/nova/scheduler/zone_manager.py
+++ b/nova/scheduler/zone_manager.py
@@ -68,22 +68,27 @@ class ZoneState(object):
            marked as offline."""
         self.last_exception = exception
         self.last_exception_time = datetime.now()
-        logging.warning(_("%s error talking to zone %s") % (exception,
-            zone.api_url, FLAGS.zone_failures_to_offline))
+        logging.warning(_("'%s' error talking to zone %s") % (exception,
+            self.api_url))
 
         self.attempt += 1
         if self.attempt >= FLAGS.zone_failures_to_offline:
            self.is_active = False
            logging.error(_("No answer from zone %s after %d "
-               "attempts. Marking inactive.") % (zone.api_url,
+               "attempts. Marking inactive.") % (self.api_url,
                FLAGS.zone_failures_to_offline))
 
+
+def _call_novatools(zone):
+    """Call novatools. Broken out for testing purposes."""
+    os = novatools.OpenStack(zone.username, zone.password, zone.api_url)
+    return os.zones.info()._info
+
 def _poll_zone(zone):
     """Eventlet worker to poll a zone."""
     logging.debug("_POLL_ZONE: STARTING")
-    os = novatools.OpenStack(zone.username, zone.password, zone.api_url)
     try:
-        zone.update_metadata(os.zones.info()._info)
+        zone.update_metadata(_call_novatools(zone))
     except Exception, e:
         zone.log_error(e)
 
diff --git a/nova/tests/test_zones.py b/nova/tests/test_zones.py
index b4c8815d5..2cb070aca 100644
--- a/nova/tests/test_zones.py
+++ b/nova/tests/test_zones.py
@@ -19,6 +19,7 @@ Tests For ZoneManager
 
 import datetime
 import mox
+import novatools
 
 from nova import context
 from nova import db
@@ -30,6 +31,8 @@ from nova import utils
 from nova.auth import manager as auth_manager
 from nova.scheduler import zone_manager
 
+FLAGS = flags.FLAGS
+
 
 class FakeZone:
     """Represents a fake zone from the db"""
@@ -38,6 +41,11 @@ class FakeZone:
             setattr(self, k, v)
 
 
+def exploding_novatools(zone):
+    """Used when we want to simulate a novatools call failing."""
+    raise Exception("kaboom")
+
+
 class ZoneManagerTestCase(test.TestCase):
     """Test case for zone manager"""
     def test_ping(self):
@@ -130,3 +138,36 @@ class ZoneManagerTestCase(test.TestCase):
 
         self.assertEquals(len(zm.zone_states), 1)
         self.assertEquals(zm.zone_states[2].username, 'user2')
+
+    def test_poll_zone(self):
+        self.mox.StubOutWithMock(zone_manager, '_call_novatools')
+        zone_manager._call_novatools(mox.IgnoreArg()).AndReturn(
+                        dict(name='zohan', capabilities='hairdresser'))
+
+        zone_state = zone_manager.ZoneState()
+        zone_state.update_credentials(FakeZone(id=2,
+                       api_url='http://foo.com', username='user2',
+                       password='pass2'))
+        zone_state.attempt = 1
+
+        self.mox.ReplayAll()
+        zone_manager._poll_zone(zone_state)
+        self.mox.VerifyAll()
+        self.assertEquals(zone_state.attempt, 0)
+        self.assertEquals(zone_state.name, 'zohan')
+
+    def test_poll_zone_fails(self):
+        self.stubs.Set(zone_manager, "_call_novatools", exploding_novatools)
+
+        zone_state = zone_manager.ZoneState()
+        zone_state.update_credentials(FakeZone(id=2,
+                       api_url='http://foo.com', username='user2',
+                       password='pass2'))
+        zone_state.attempt = FLAGS.zone_failures_to_offline - 1
+
+        self.mox.ReplayAll()
+        zone_manager._poll_zone(zone_state)
+        self.mox.VerifyAll()
+        self.assertEquals(zone_state.attempt, 3)
+        self.assertFalse(zone_state.is_active)
+        self.assertEquals(zone_state.name, None)
-- 
cgit 


From 984db08a205bdd9196c3e1cc3415873a853c33ba Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Wed, 16 Feb 2011 18:35:43 -0800
Subject: style cleanup

---
 nova/scheduler/zone_manager.py | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/scheduler/zone_manager.py b/nova/scheduler/zone_manager.py
index a6bbc2ebd..a35acb000 100644
--- a/nova/scheduler/zone_manager.py
+++ b/nova/scheduler/zone_manager.py
@@ -84,14 +84,16 @@ def _call_novatools(zone):
     os = novatools.OpenStack(zone.username, zone.password, zone.api_url)
     return os.zones.info()._info
 
+
 def _poll_zone(zone):
     """Eventlet worker to poll a zone."""
-    logging.debug("_POLL_ZONE: STARTING")
+    logging.debug(_("Polling zone: %s") % zone.api_url)
     try:
         zone.update_metadata(_call_novatools(zone))
     except Exception, e:
         zone.log_error(e)
 
+
 class ZoneManager(object):
     """Keeps the zone states updated."""
     def __init__(self):
@@ -122,10 +124,9 @@ class ZoneManager(object):
 
     def ping(self, context=None):
         """Ping should be called periodically to update zone status."""
-        logging.debug("ZoneManager PING")
         diff = datetime.now() - self.last_zone_db_check
         if diff.seconds >=  FLAGS.zone_db_check_interval:
-            logging.debug("ZoneManager RECHECKING DB ")
+            logging.debug("Updating zone cache from db.")
             self.last_zone_db_check = datetime.now()
             self._refresh_from_db(context)
         self._poll_zones(context)
-- 
cgit 


From 923a4938b73b84aa8a31f08a7c7b983cc82959fe Mon Sep 17 00:00:00 2001
From: Rick Harris <rick.harris@rackspace.com>
Date: Thu, 17 Feb 2011 07:29:50 +0000
Subject: Adding tests

---
 nova/tests/glance/stubs.py   | 25 ++++++++++++----
 nova/tests/test_xenapi.py    | 70 ++++++++++++++++++++++++++++++++++++++++++--
 nova/tests/xenapi/stubs.py   | 10 +++++++
 nova/virt/xenapi/vm_utils.py |  4 +++
 4 files changed, 100 insertions(+), 9 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/glance/stubs.py b/nova/tests/glance/stubs.py
index 1a5fb7ffb..3ff8d7ce5 100644
--- a/nova/tests/glance/stubs.py
+++ b/nova/tests/glance/stubs.py
@@ -26,20 +26,33 @@ def stubout_glance_client(stubs, cls):
 
 
 class FakeGlance(object):
+    IMAGE_MACHINE = 1
+    IMAGE_KERNEL = 2
+    IMAGE_RAMDISK = 3
+    IMAGE_RAW = 4
+    IMAGE_VHD = 5
+
     IMAGE_FIXTURES = {
-        1: {'image_meta': {'name': 'fakemachine', 'size': 0,
+        IMAGE_MACHINE: {
+            'image_meta': {'name': 'fakemachine', 'size': 0,
                            'type': 'machine'},
             'image_data': StringIO.StringIO('')},
-        2: {'image_meta': {'name': 'fakekernel', 'size': 0,
+        IMAGE_KERNEL: {
+            'image_meta': {'name': 'fakekernel', 'size': 0,
                            'type': 'kernel'},
             'image_data': StringIO.StringIO('')},
-        3: {'image_meta': {'name': 'fakeramdisk', 'size': 0,
+        IMAGE_RAMDISK: {
+            'image_meta': {'name': 'fakeramdisk', 'size': 0,
                            'type': 'ramdisk'},
             'image_data': StringIO.StringIO('')},
-        4: {'image_meta': {'name': 'fakevhd', 'size': 0,
-                           'type': 'vhd'},
+        IMAGE_RAW: {
+            'image_meta': {'name': 'fakeraw', 'size': 0,
+                           'type': 'raw'},
             'image_data': StringIO.StringIO('')},
-    }
+        IMAGE_VHD: {
+            'image_meta': {'name': 'fakevhd', 'size': 0,
+                           'type': 'vhd'},
+            'image_data': StringIO.StringIO('')}}
 
     def __init__(self, host, port=None, use_ssl=False):
         pass
diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index 75387e7f5..f8a3d72c4 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -31,6 +31,7 @@ from nova.compute import power_state
 from nova.virt import xenapi_conn
 from nova.virt.xenapi import fake as xenapi_fake
 from nova.virt.xenapi import volume_utils
+from nova.virt.xenapi import vm_utils
 from nova.virt.xenapi.vmops import SimpleDH
 from nova.tests.db import fakes as db_fakes
 from nova.tests.xenapi import stubs
@@ -162,6 +163,7 @@ class XenAPIVMTestCase(test.TestCase):
         stubs.stubout_session(self.stubs, stubs.FakeSessionForVMTests)
         stubs.stubout_get_this_vm_uuid(self.stubs)
         stubs.stubout_stream_disk(self.stubs)
+        stubs.stubout_lookup_image(self.stubs)
         glance_stubs.stubout_glance_client(self.stubs,
                                            glance_stubs.FakeGlance)
         self.conn = xenapi_conn.get_connection(False)
@@ -277,15 +279,17 @@ class XenAPIVMTestCase(test.TestCase):
 
     def test_spawn_raw_glance(self):
         FLAGS.xenapi_image_service = 'glance'
-        self._test_spawn(1, None, None)
+        self._test_spawn(glance_stubs.FakeGlance.IMAGE_RAW, None, None)
 
     def test_spawn_vhd_glance(self):
         FLAGS.xenapi_image_service = 'glance'
-        self._test_spawn(4, None, None)
+        self._test_spawn(glance_stubs.FakeGlance.IMAGE_VHD, None, None)
 
     def test_spawn_glance(self):
         FLAGS.xenapi_image_service = 'glance'
-        self._test_spawn(1, 2, 3)
+        self._test_spawn(glance_stubs.FakeGlance.IMAGE_MACHINE,
+                         glance_stubs.FakeGlance.IMAGE_KERNEL,
+                         glance_stubs.FakeGlance.IMAGE_RAMDISK)
 
     def tearDown(self):
         super(XenAPIVMTestCase, self).tearDown()
@@ -334,3 +338,63 @@ class XenAPIDiffieHellmanTestCase(test.TestCase):
 
     def tearDown(self):
         super(XenAPIDiffieHellmanTestCase, self).tearDown()
+
+
+class XenAPIDetermineDiskImageTestCase(test.TestCase):
+    """
+    Unit tests for code that detects the ImageType
+    """
+    def setUp(self):
+        super(XenAPIDetermineDiskImageTestCase, self).setUp()
+        glance_stubs.stubout_glance_client(self.stubs,
+                                           glance_stubs.FakeGlance)
+
+        class FakeInstance(object):
+            pass
+
+        self.fake_instance = FakeInstance()
+        self.fake_instance.id = 42
+
+    def assert_disk_type(self, disk_type):
+        dt = vm_utils.VMHelper.determine_disk_image_type(
+            self.fake_instance)
+        self.assertEqual(disk_type, dt)
+
+    def test_instance_disk(self):
+        """
+        If a kernel is specified then the image type is DISK (aka machine)
+        """
+        FLAGS.xenapi_image_service = 'objectstore'
+        self.fake_instance.image_id = glance_stubs.FakeGlance.IMAGE_MACHINE
+        self.fake_instance.kernel_id = glance_stubs.FakeGlance.IMAGE_KERNEL
+        self.assert_disk_type(vm_utils.ImageType.DISK)
+
+    def test_instance_disk_raw(self):
+        """
+        If the kernel isn't specified, and we're not using Glance, then
+        DISK_RAW is assumed.
+        """
+        FLAGS.xenapi_image_service = 'objectstore'
+        self.fake_instance.image_id = glance_stubs.FakeGlance.IMAGE_RAW
+        self.fake_instance.kernel_id = None
+        self.assert_disk_type(vm_utils.ImageType.DISK_RAW)
+
+    def test_glance_disk_raw(self):
+        """
+        If we're using Glance, then defer to the image_type field, which in
+        this case will be 'raw'.
+        """
+        FLAGS.xenapi_image_service = 'glance'
+        self.fake_instance.image_id = glance_stubs.FakeGlance.IMAGE_RAW
+        self.fake_instance.kernel_id = None
+        self.assert_disk_type(vm_utils.ImageType.DISK_RAW)
+
+    def test_glance_disk_vhd(self):
+        """
+        If we're using Glance, then defer to the image_type field, which in
+        this case will be 'vhd'.
+        """
+        FLAGS.xenapi_image_service = 'glance'
+        self.fake_instance.image_id = glance_stubs.FakeGlance.IMAGE_VHD
+        self.fake_instance.kernel_id = None
+        self.assert_disk_type(vm_utils.ImageType.DISK_VHD)
diff --git a/nova/tests/xenapi/stubs.py b/nova/tests/xenapi/stubs.py
index 2e3b62a77..1e6758a33 100644
--- a/nova/tests/xenapi/stubs.py
+++ b/nova/tests/xenapi/stubs.py
@@ -130,6 +130,16 @@ def stubout_stream_disk(stubs):
     stubs.Set(vm_utils, '_stream_disk', f)
 
 
+def stubout_lookup_image(stubs):
+    @classmethod
+    def fake_lookup_image(cls, session, instance_id, vdi_ref):
+        # NOTE(sirp): pretending each image is paravirtualized for now
+        is_pv = True
+        return is_pv
+
+    stubs.Set(vm_utils.VMHelper, 'lookup_image', fake_lookup_image)
+
+
 class FakeSessionForVMTests(fake.SessionBase):
     """ Stubs out a XenAPISession for VM tests """
     def __init__(self, uri):
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 <sateesh.chodapuneedi@citrix.com>
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')

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("<ZSI.FaultException> in"
+                           " %s:" % (attr_name), excep)
+                except ZSI.EvaluateException, excep:
+                    raise SessionFaultyException("<ZSI.EvaluateException> 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=<VMware ESX Host IP> 
+  --vmwareapi_host_username=<VMware ESX Username>
+  --vmwareapi_host_password=<VMware ESX Password>
+   
+Other flags
+-----------
+::
+  --network_manager=nova.network.manager.FlatManager
+  --flat_network_bridge=<ESX Virtual Machine Port Group>
+  --image_service=nova.image.glance.GlanceImageService
+  --glance_host=<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 <sateesh.chodapuneedi@citrix.com>
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')

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 9d056b6fadcefed9ef9573bd89125b00af5e2726 Mon Sep 17 00:00:00 2001
From: Josh Kearney <josh.kearney@rackspace.com>
Date: Thu, 17 Feb 2011 10:50:49 -0600
Subject: More testing

---
 nova/api/openstack/__init__.py           |  1 +
 nova/api/openstack/flavors.py            | 14 ++++++++++++--
 nova/tests/api/openstack/test_flavors.py |  6 ++++--
 3 files changed, 17 insertions(+), 4 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/__init__.py b/nova/api/openstack/__init__.py
index 056c7dd27..1fafebe37 100644
--- a/nova/api/openstack/__init__.py
+++ b/nova/api/openstack/__init__.py
@@ -73,6 +73,7 @@ class APIRouter(wsgi.Router):
         server_members = {'action': 'POST'}
         if FLAGS.allow_admin_api:
             LOG.debug(_("Including admin operations in API."))
+
             server_members['pause'] = 'POST'
             server_members['unpause'] = 'POST'
             server_members["diagnostics"] = "GET"
diff --git a/nova/api/openstack/flavors.py b/nova/api/openstack/flavors.py
index 215f0b8a6..a3a664506 100644
--- a/nova/api/openstack/flavors.py
+++ b/nova/api/openstack/flavors.py
@@ -58,11 +58,21 @@ class Controller(wsgi.Controller):
 
     def create(self, req):
         """Create a flavor."""
+        instance_types.create(
+            name,
+            memory,
+            vcpus,
+            local_gb,
+            flavor_id,
+            swap,
+            rxtx_quota,
+            rxtx_cap)
         print "CREATE! %s" % req
 
-    def delete(self, req, id):
+    def delete(self, req, name):
         """Delete a flavor."""
-        print "DELETE! %s %s" % (req, id)
+        instance_type.destroy(name)
+        print "DELETE! %s %s" % (req, name)
 
     def _all_ids(self):
         """Return the list of all flavorids."""
diff --git a/nova/tests/api/openstack/test_flavors.py b/nova/tests/api/openstack/test_flavors.py
index 7bfc46e0b..209ace0f8 100644
--- a/nova/tests/api/openstack/test_flavors.py
+++ b/nova/tests/api/openstack/test_flavors.py
@@ -46,12 +46,14 @@ class FlavorsTest(unittest.TestCase):
         self.assertEqual(res.status_int, 200)
 
     def test_create_flavor(self):
-        req = webob.Request.blank("/v1.0/flavors/create/test")
+        req = webob.Request.blank("/v1.0/flavors")
+        req.method = "POST"
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 200)
 
     def test_delete_flavor(self):
-        req = webob.Request.blank("/v1.0/flavors/delete/test")
+        req = webob.Request.blank("/v1.0/flavors/1")
+        req.method = "DELETE"
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 200)
 
-- 
cgit 


From e67927c181a1f24df35a6df5663e397e260979cf Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Thu, 17 Feb 2011 13:28:39 -0600
Subject: Foo

---
 nova/api/openstack/servers.py | 2 +-
 nova/compute/manager.py       | 3 ++-
 2 files changed, 3 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 2fc105d07..5f369463d 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -216,7 +216,7 @@ class Controller(wsgi.Controller):
 
     def _action_revert_resize(self, input_dict, req, id):
         try:
-            self.compute_api.confirm_resize(req.environ['nova.context'], id)
+            self.compute_api.revert_resize(req.environ['nova.context'], id)
         except Exception, e:
             LOG.exception(_("Error in revert-resize %s"), e)
             return faults.Fault(exc.HTTPBadRequest(e))
diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 33fad50fd..4e6532ef4 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -398,7 +398,8 @@ class ComputeManager(manager.Manager):
         instance_ref = self.db.instance_get(context, instance_id)
         migration_ref = self.db.migration_get(context, migration_id)
 
-        if migration_ref['source_compute'] == instance_ref['host']:
+        #TODO(mdietz): we may want to split these into separate methods.
+        if migration_ref['source_compute'] == FLAGS.host:
             self.driver.power_on(instance_ref)
             self.db.migration_update(context, migration_id, 
                     { 'status': 'reverted' })
-- 
cgit 


From b1fe9a64143505235eb2e3dbe6a6c0966a85ae76 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Thu, 17 Feb 2011 14:10:08 -0600
Subject: Stop blowing away the ramdisk

---
 nova/compute/manager.py   |  2 +-
 nova/virt/xenapi/vmops.py | 29 ++++++++++++++++-------------
 2 files changed, 17 insertions(+), 14 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 4e6532ef4..e81ee3148 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -408,7 +408,7 @@ class ComputeManager(manager.Manager):
             topic = self.db.queue_get_for(context, FLAGS.compute_topic, 
                     instance_ref['host'])
             rpc.cast(context, topic, 
-                    { 'method': 'resize_instance',
+                    { 'method': 'revert_resize',
                       'args': {
                             'migration_id': migration_ref['id'], 
                             'instance_id': instance_id,
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 aa71a25c9f9bf5df3aea781138fa8d69654f06d9 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Thu, 17 Feb 2011 12:12:19 -0800
Subject: zone list now comes from scheduler zonemanager

---
 nova/api/openstack/zones.py    | 32 +++++++++++++++--
 nova/scheduler/manager.py      | 82 ++++--------------------------------------
 nova/scheduler/zone_manager.py | 11 +++++-
 3 files changed, 46 insertions(+), 79 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/zones.py b/nova/api/openstack/zones.py
index 16e5e366b..bd2c488d9 100644
--- a/nova/api/openstack/zones.py
+++ b/nova/api/openstack/zones.py
@@ -19,6 +19,7 @@ import logging
 from nova import flags
 from nova import wsgi
 from nova import db
+from nova import rpc
 
 
 FLAGS = flags.FLAGS
@@ -33,6 +34,10 @@ def _filter_keys(item, keys):
     return dict((k, v) for k, v in item.iteritems() if k in keys)
 
 
+def _exclude_keys(item, keys):
+    return dict((k, v) for k, v in item.iteritems() if k not in keys)
+
+
 def _scrub_zone(zone):
     return _filter_keys(zone, ('id', 'api_url'))
 
@@ -44,11 +49,34 @@ class Controller(wsgi.Controller):
             "attributes": {
                 "zone": ["id", "api_url", "name", "capabilities"]}}}
 
+    def _call_scheduler(self, method, context, params=None):
+        """Generic handler for RPC calls to the scheduler.
+
+        :param params: Optional dictionary of arguments to be passed to the
+                       scheduler worker
+
+        :retval: Result returned by scheduler worker
+        """
+        if not params:
+            params = {}
+        queue = FLAGS.scheduler_topic
+        kwargs = {'method': method, 'args': params}
+        return rpc.call(context, queue, kwargs)
+
     def index(self, req):
         """Return all zones in brief"""
-        items = db.zone_get_all(req.environ['nova.context'])
+        # Ask the ZoneManager in the Scheduler for most recent data.
+        items = self._call_scheduler('get_zone_list', 
+                          req.environ['nova.context'])
+        for item in items:
+            item['api_url'] = item['api_url'].replace('\\/', '/')
+
+        # Or fall-back to the database ...
+        if len(items) == 0:
+            items = db.zone_get_all(req.environ['nova.context'])
         items = common.limited(items, req)
-        items = [_scrub_zone(item) for item in items]
+        items = [_exclude_keys(item, ['username', 'password']) 
+                      for item in items]
         return dict(zones=items)
 
     def detail(self, req):
diff --git a/nova/scheduler/manager.py b/nova/scheduler/manager.py
index 693f8cb4b..00a0f4100 100644
--- a/nova/scheduler/manager.py
+++ b/nova/scheduler/manager.py
@@ -22,11 +22,6 @@ Scheduler Service
 """
 
 import functools
-import novatools
-import thread
-
-from datetime import datetime
-from eventlet.greenpool import GreenPool
 
 from nova import db
 from nova import flags
@@ -34,83 +29,14 @@ from nova import log as logging
 from nova import manager
 from nova import rpc
 from nova import utils
+from nova.scheduler.zone_manager import ZoneManager
 
 LOG = logging.getLogger('nova.scheduler.manager')
 FLAGS = flags.FLAGS
 flags.DEFINE_string('scheduler_driver',
                     'nova.scheduler.chance.ChanceScheduler',
                     'Driver to use for the scheduler')
-flags.DEFINE_integer('zone_db_check_interval',
-                    60,
-                    'Seconds between getting fresh zone info from db.')
-
-
-class ZoneState(object):
-    """Holds the state of all connected child zones."""
-    def __init__(self):
-        self.is_active = True
-        self.name = None
-        self.capabilities = None
-        self.retry = 0
-        self.last_seen = datetime.min
- 
-    def update(self, zone):
-        """Update zone credentials from db"""
-        self.zone_id = zone.id
-        self.api_url = zone.api_url
-        self.username = zone.username
-        self.password = zone.password
- 
-
-def _poll_zone(zone):
-    """Eventlet worker to poll a zone."""
-    logging.debug("_POLL_ZONE: STARTING")
-    os = novatools.OpenStack(zone.username, zone.password, zone.api_url)
-    zone_metadata = os.zones.info()
-    logging.debug("_POLL_ZONE: GOT %s" % zone_metadata._info)
-
-    # Stuff this in our cache.
-
-
-class ZoneManager(object):
-    """Keeps the zone states updated."""
-    def __init__(self):
-        self.last_zone_db_check = datetime.min
-        self.zone_states = {}
-
-    def _refresh_from_db(self, context):
-        """Make our zone state map match the db."""
-        # Add/update existing zones ...
-        zones = db.zone_get_all(context)
-        existing = self.zone_states.keys()
-        db_keys = []
-        for zone in zones:
-            db_keys.append(zone.id)
-            if zone.id not in existing:
-                self.zone_states[zone.id] = ZoneState()
-            self.zone_states[zone.id].update(zone)
-
-        # Cleanup zones removed from db ...
-        for zone_id in self.zone_states.keys():
-            if zone_id not in db_keys:
-                del self.zone_states[zone_id]
- 
-    def _poll_zones(self, context):
-        """Try to connect to each child zone and get update."""
-
-        green_pool = GreenPool()
-        green_pool.imap(_poll_zone, self.zone_states.values())
-
-    def ping(self, context=None):
-        """Ping should be called periodically to update zone status."""
-        logging.debug("ZoneManager PING")
-        diff = datetime.now() - self.last_zone_db_check
-        if diff.seconds >=  FLAGS.zone_db_check_interval:
-            logging.debug("ZoneManager RECHECKING DB ")
-            self.last_zone_db_check = datetime.now()
-            self._refresh_from_db(context)
-        self._poll_zones(context)
-            
+           
 
 class SchedulerManager(manager.Manager):
     """Chooses a host to run instances on."""
@@ -129,6 +55,10 @@ class SchedulerManager(manager.Manager):
         """Poll child zones periodically to get status."""
         self.zone_manager.ping(context)
 
+    def get_zone_list(self, context=None):
+        """Get a list of zones from the ZoneManager."""
+        return self.zone_manager.get_zone_list()
+
     def _schedule(self, method, context, topic, *args, **kwargs):
         """Tries to call schedule_* method on the driver to retrieve host.
 
diff --git a/nova/scheduler/zone_manager.py b/nova/scheduler/zone_manager.py
index a35acb000..4fa528973 100644
--- a/nova/scheduler/zone_manager.py
+++ b/nova/scheduler/zone_manager.py
@@ -21,6 +21,7 @@ ZoneManager oversees all communications with child Zones.
 
 import novatools
 import thread
+import traceback
 
 from datetime import datetime
 from eventlet.greenpool import GreenPool
@@ -63,6 +64,11 @@ class ZoneState(object):
         self.capabilities = zone_metadata["capabilities"]
         self.is_active = True
 
+    def to_dict(self):
+        return dict(name=self.name, capabilities=self.capabilities,
+                    is_active=self.is_active, api_url=self.api_url,
+                    id=self.zone_id)
+
     def log_error(self, exception):
         """Something went wrong. Check to see if zone should be
            marked as offline."""
@@ -91,7 +97,7 @@ def _poll_zone(zone):
     try:
         zone.update_metadata(_call_novatools(zone))
     except Exception, e:
-        zone.log_error(e)
+        zone.log_error(traceback.format_exc())
 
 
 class ZoneManager(object):
@@ -100,6 +106,9 @@ class ZoneManager(object):
         self.last_zone_db_check = datetime.min
         self.zone_states = {}
 
+    def get_zone_list(self):
+        return [ zone.to_dict() for zone in self.zone_states.values() ]
+
     def _refresh_from_db(self, context):
         """Make our zone state map match the db."""
         # Add/update existing zones ...
-- 
cgit 


From e77f8751dd59e5d650d047a6711c3d137947dda7 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Thu, 17 Feb 2011 16:18:03 -0400
Subject: fixup

---
 nova/api/openstack/zones.py    |  6 +++---
 nova/flags.py                  |  2 +-
 nova/scheduler/manager.py      |  2 +-
 nova/scheduler/zone_manager.py | 18 +++++++++---------
 nova/tests/test_zones.py       | 10 +++++-----
 5 files changed, 19 insertions(+), 19 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/zones.py b/nova/api/openstack/zones.py
index bd2c488d9..f75176824 100644
--- a/nova/api/openstack/zones.py
+++ b/nova/api/openstack/zones.py
@@ -66,7 +66,7 @@ class Controller(wsgi.Controller):
     def index(self, req):
         """Return all zones in brief"""
         # Ask the ZoneManager in the Scheduler for most recent data.
-        items = self._call_scheduler('get_zone_list', 
+        items = self._call_scheduler('get_zone_list',
                           req.environ['nova.context'])
         for item in items:
             item['api_url'] = item['api_url'].replace('\\/', '/')
@@ -75,7 +75,7 @@ class Controller(wsgi.Controller):
         if len(items) == 0:
             items = db.zone_get_all(req.environ['nova.context'])
         items = common.limited(items, req)
-        items = [_exclude_keys(item, ['username', 'password']) 
+        items = [_exclude_keys(item, ['username', 'password'])
                       for item in items]
         return dict(zones=items)
 
@@ -85,7 +85,7 @@ class Controller(wsgi.Controller):
 
     def info(self, req):
         """Return name and capabilities for this zone."""
-        return dict(zone=dict(name=FLAGS.zone_name, 
+        return dict(zone=dict(name=FLAGS.zone_name,
                     capabilities=FLAGS.zone_capabilities))
 
     def show(self, req, id):
diff --git a/nova/flags.py b/nova/flags.py
index 0a45499f3..60d7cdd06 100644
--- a/nova/flags.py
+++ b/nova/flags.py
@@ -314,6 +314,6 @@ DEFINE_string('node_availability_zone', 'nova',
               'availability zone of this node')
 
 DEFINE_string('zone_name', 'nova', 'name of this zone')
-DEFINE_string('zone_capabilities', 'xen, linux', 
+DEFINE_string('zone_capabilities', 'xen, linux',
               'comma-delimited list of tags which represent boolean'
               ' capabilities of this zone')
diff --git a/nova/scheduler/manager.py b/nova/scheduler/manager.py
index 00a0f4100..7ced33b9c 100644
--- a/nova/scheduler/manager.py
+++ b/nova/scheduler/manager.py
@@ -36,7 +36,7 @@ FLAGS = flags.FLAGS
 flags.DEFINE_string('scheduler_driver',
                     'nova.scheduler.chance.ChanceScheduler',
                     'Driver to use for the scheduler')
-           
+
 
 class SchedulerManager(manager.Manager):
     """Chooses a host to run instances on."""
diff --git a/nova/scheduler/zone_manager.py b/nova/scheduler/zone_manager.py
index 4fa528973..e7c37a9a6 100644
--- a/nova/scheduler/zone_manager.py
+++ b/nova/scheduler/zone_manager.py
@@ -47,14 +47,14 @@ class ZoneState(object):
         self.last_seen = datetime.min
         self.last_exception = None
         self.last_exception_time = None
- 
+
     def update_credentials(self, zone):
         """Update zone credentials from db"""
         self.zone_id = zone.id
         self.api_url = zone.api_url
         self.username = zone.username
         self.password = zone.password
- 
+
     def update_metadata(self, zone_metadata):
         """Update zone metadata after successful communications with
            child zone."""
@@ -79,10 +79,10 @@ class ZoneState(object):
 
         self.attempt += 1
         if self.attempt >= FLAGS.zone_failures_to_offline:
-           self.is_active = False
-           logging.error(_("No answer from zone %s after %d "
-               "attempts. Marking inactive.") % (self.api_url,
-               FLAGS.zone_failures_to_offline))
+            self.is_active = False
+            logging.error(_("No answer from zone %s after %d "
+                "attempts. Marking inactive.") % (self.api_url,
+                FLAGS.zone_failures_to_offline))
 
 
 def _call_novatools(zone):
@@ -107,7 +107,7 @@ class ZoneManager(object):
         self.zone_states = {}
 
     def get_zone_list(self):
-        return [ zone.to_dict() for zone in self.zone_states.values() ]
+        return [zone.to_dict() for zone in self.zone_states.values()]
 
     def _refresh_from_db(self, context):
         """Make our zone state map match the db."""
@@ -125,7 +125,7 @@ class ZoneManager(object):
         for zone_id in self.zone_states.keys():
             if zone_id not in db_keys:
                 del self.zone_states[zone_id]
- 
+
     def _poll_zones(self, context):
         """Try to connect to each child zone and get update."""
         green_pool = GreenPool()
@@ -134,7 +134,7 @@ class ZoneManager(object):
     def ping(self, context=None):
         """Ping should be called periodically to update zone status."""
         diff = datetime.now() - self.last_zone_db_check
-        if diff.seconds >=  FLAGS.zone_db_check_interval:
+        if diff.seconds >= FLAGS.zone_db_check_interval:
             logging.debug("Updating zone cache from db.")
             self.last_zone_db_check = datetime.now()
             self._refresh_from_db(context)
diff --git a/nova/tests/test_zones.py b/nova/tests/test_zones.py
index 2cb070aca..7036ebe58 100644
--- a/nova/tests/test_zones.py
+++ b/nova/tests/test_zones.py
@@ -67,7 +67,7 @@ class ZoneManagerTestCase(test.TestCase):
                FakeZone(id=1, api_url='http://foo.com', username='user1',
                     password='pass1'),
             ])
-        
+
         self.assertEquals(len(zm.zone_states), 0)
 
         self.mox.ReplayAll()
@@ -89,7 +89,7 @@ class ZoneManagerTestCase(test.TestCase):
                FakeZone(id=1, api_url='http://foo.com', username='user2',
                     password='pass2'),
             ])
-        
+
         self.assertEquals(len(zm.zone_states), 1)
 
         self.mox.ReplayAll()
@@ -107,8 +107,8 @@ class ZoneManagerTestCase(test.TestCase):
         zm.zone_states[1] = zone_state
 
         self.mox.StubOutWithMock(db, 'zone_get_all')
-        db.zone_get_all(mox.IgnoreArg()).AndReturn([ ])
-        
+        db.zone_get_all(mox.IgnoreArg()).AndReturn([])
+
         self.assertEquals(len(zm.zone_states), 1)
 
         self.mox.ReplayAll()
@@ -125,7 +125,7 @@ class ZoneManagerTestCase(test.TestCase):
         zm.zone_states[1] = zone_state
 
         self.mox.StubOutWithMock(db, 'zone_get_all')
-        
+
         db.zone_get_all(mox.IgnoreArg()).AndReturn([
                FakeZone(id=2, api_url='http://foo.com', username='user2',
                     password='pass2'),
-- 
cgit 


From 3dd6e369c0aa2e3092eaa32a6b04cbba712ba5ad Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
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')

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 aa53c9476ed37f0a1359413d4a710eb08c997b06 Mon Sep 17 00:00:00 2001
From: Josh Kearney <josh.kearney@rackspace.com>
Date: Thu, 17 Feb 2011 14:42:01 -0600
Subject: Finished flavor OS API stubs

---
 nova/api/openstack/flavors.py | 28 +++++++++++++++-------------
 1 file changed, 15 insertions(+), 13 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/flavors.py b/nova/api/openstack/flavors.py
index a3a664506..375e12b18 100644
--- a/nova/api/openstack/flavors.py
+++ b/nova/api/openstack/flavors.py
@@ -58,21 +58,23 @@ class Controller(wsgi.Controller):
 
     def create(self, req):
         """Create a flavor."""
-        instance_types.create(
-            name,
-            memory,
-            vcpus,
-            local_gb,
-            flavor_id,
-            swap,
-            rxtx_quota,
-            rxtx_cap)
-        print "CREATE! %s" % req
+        #TODO(jk0): Finish this later
+        #instance_types.create(
+        #    name,
+        #    memory,
+        #    vcpus,
+        #    local_gb,
+        #    flavor_id,
+        #    swap,
+        #    rxtx_quota,
+        #    rxtx_cap)
+        return "CREATE! %s" % req
 
-    def delete(self, req, name):
+    def delete(self, req, id):
         """Delete a flavor."""
-        instance_type.destroy(name)
-        print "DELETE! %s %s" % (req, name)
+        #TODO(jk0): Finish this later
+        #instance_type.destroy(name)
+        return "DELETE! %s %s" % (req, id)
 
     def _all_ids(self):
         """Return the list of all flavorids."""
-- 
cgit 


From b48201be9a5fa08ce21ef241052071800e5777ca Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Thu, 17 Feb 2011 12:43:22 -0800
Subject: fixed zone list tests

---
 nova/tests/api/openstack/test_zones.py | 32 +++++++++++++++++++++++++++++---
 1 file changed, 29 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/test_zones.py b/nova/tests/api/openstack/test_zones.py
index 5542a1cf3..6c06fa8b8 100644
--- a/nova/tests/api/openstack/test_zones.py
+++ b/nova/tests/api/openstack/test_zones.py
@@ -52,7 +52,20 @@ def zone_delete(context, zone_id):
     pass
 
 
-def zone_get_all(context):
+def zone_get_all_scheduler(x, y, z):
+    return [
+        dict(id=1, api_url='http://foo.com', username='bob',
+                 password='xxx'),
+        dict(id=2, api_url='http://blah.com', username='alice',
+                 password='qwerty')
+    ]
+
+
+def zone_get_all_scheduler_empty(x, y, z):
+    return [] 
+
+
+def zone_get_all_db(context):
     return [
         dict(id=1, api_url='http://foo.com', username='bob',
                  password='xxx'),
@@ -74,7 +87,6 @@ class ZonesTest(unittest.TestCase):
         FLAGS.allow_admin_api = True
 
         self.stubs.Set(nova.db, 'zone_get', zone_get)
-        self.stubs.Set(nova.db, 'zone_get_all', zone_get_all)
         self.stubs.Set(nova.db, 'zone_update', zone_update)
         self.stubs.Set(nova.db, 'zone_create', zone_create)
         self.stubs.Set(nova.db, 'zone_delete', zone_delete)
@@ -83,7 +95,9 @@ class ZonesTest(unittest.TestCase):
         self.stubs.UnsetAll()
         FLAGS.allow_admin_api = self.allow_admin
 
-    def test_get_zone_list(self):
+    def test_get_zone_list_scheduler(self):
+        self.stubs.Set(zones.Controller, '_call_scheduler',
+                            zone_get_all_scheduler)
         req = webob.Request.blank('/v1.0/zones')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
@@ -91,6 +105,18 @@ class ZonesTest(unittest.TestCase):
         self.assertEqual(res.status_int, 200)
         self.assertEqual(len(res_dict['zones']), 2)
 
+    def test_get_zone_list_db(self):
+        self.stubs.Set(zones.Controller, '_call_scheduler', 
+            zone_get_all_scheduler_empty)
+        self.stubs.Set(nova.db, 'zone_get_all', zone_get_all_db)
+        req = webob.Request.blank('/v1.0/zones')
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+
+        self.assertEqual(res.status_int, 200)
+        self.assertEqual(len(res_dict['zones']), 2)
+
+
     def test_get_zone_by_id(self):
         req = webob.Request.blank('/v1.0/zones/1')
         res = req.get_response(fakes.wsgi_app())
-- 
cgit 


From 8da339d53b4039c3a8e5e8a15ccf1434eeda5fa2 Mon Sep 17 00:00:00 2001
From: Josh Kearney <josh.kearney@rackspace.com>
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')

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 <soren@linux2go.dk>
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')

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 b9a03524d03c0ce7fa98fab5531db720941bbfdb Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Thu, 17 Feb 2011 13:23:56 -0800
Subject: multi positional string fix

---
 nova/scheduler/zone_manager.py | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

(limited to 'nova')

diff --git a/nova/scheduler/zone_manager.py b/nova/scheduler/zone_manager.py
index e7c37a9a6..af0b90f9f 100644
--- a/nova/scheduler/zone_manager.py
+++ b/nova/scheduler/zone_manager.py
@@ -74,15 +74,17 @@ class ZoneState(object):
            marked as offline."""
         self.last_exception = exception
         self.last_exception_time = datetime.now()
-        logging.warning(_("'%s' error talking to zone %s") % (exception,
-            self.api_url))
+        api_url = self.api_url
+        logging.warning(_("'%(exception)s' error talking to "
+                          "zone %(api_url)s") % locals())
 
+        max_errors = FLAGS.zone_failures_to_offline:
         self.attempt += 1
-        if self.attempt >= FLAGS.zone_failures_to_offline:
+        if self.attempt >= max_errors:
             self.is_active = False
-            logging.error(_("No answer from zone %s after %d "
-                "attempts. Marking inactive.") % (self.api_url,
-                FLAGS.zone_failures_to_offline))
+            logging.error(_("No answer from zone %(api_url)s "
+                            "after %(max_errors)d "
+                            "attempts. Marking inactive.") % locals())
 
 
 def _call_novatools(zone):
-- 
cgit 


From a33f5495fe261641713131901fee1e83ccc4890f Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Thu, 17 Feb 2011 13:29:19 -0800
Subject: fixed strings

---
 nova/scheduler/zone_manager.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/scheduler/zone_manager.py b/nova/scheduler/zone_manager.py
index af0b90f9f..4bf6e36c6 100644
--- a/nova/scheduler/zone_manager.py
+++ b/nova/scheduler/zone_manager.py
@@ -78,7 +78,7 @@ class ZoneState(object):
         logging.warning(_("'%(exception)s' error talking to "
                           "zone %(api_url)s") % locals())
 
-        max_errors = FLAGS.zone_failures_to_offline:
+        max_errors = FLAGS.zone_failures_to_offline
         self.attempt += 1
         if self.attempt >= max_errors:
             self.is_active = False
-- 
cgit 


From 46269872192b843c80d72206a05c8b759c9f66a8 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Thu, 17 Feb 2011 17:32:25 -0400
Subject: merge from dev

---
 nova/tests/api/openstack/test_zones.py | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/test_zones.py b/nova/tests/api/openstack/test_zones.py
index 6c06fa8b8..65cc1c023 100644
--- a/nova/tests/api/openstack/test_zones.py
+++ b/nova/tests/api/openstack/test_zones.py
@@ -62,7 +62,7 @@ def zone_get_all_scheduler(x, y, z):
 
 
 def zone_get_all_scheduler_empty(x, y, z):
-    return [] 
+    return []
 
 
 def zone_get_all_db(context):
@@ -106,7 +106,7 @@ class ZonesTest(unittest.TestCase):
         self.assertEqual(len(res_dict['zones']), 2)
 
     def test_get_zone_list_db(self):
-        self.stubs.Set(zones.Controller, '_call_scheduler', 
+        self.stubs.Set(zones.Controller, '_call_scheduler',
             zone_get_all_scheduler_empty)
         self.stubs.Set(nova.db, 'zone_get_all', zone_get_all_db)
         req = webob.Request.blank('/v1.0/zones')
@@ -116,7 +116,6 @@ class ZonesTest(unittest.TestCase):
         self.assertEqual(res.status_int, 200)
         self.assertEqual(len(res_dict['zones']), 2)
 
-
     def test_get_zone_by_id(self):
         req = webob.Request.blank('/v1.0/zones/1')
         res = req.get_response(fakes.wsgi_app())
-- 
cgit 


From 273119957fb3f6cfa72d4357054f6ad1743704e8 Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Thu, 17 Feb 2011 13:49:36 -0800
Subject: moved 003_cactus.py migration file to 004_add_instance_types.py to
 avoid naming collision with new trunk migration

---
 .../sqlalchemy/migrate_repo/versions/003_cactus.py | 86 ----------------------
 .../versions/004_add_instance_types.py             | 86 ++++++++++++++++++++++
 2 files changed, 86 insertions(+), 86 deletions(-)
 delete mode 100644 nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py
 create mode 100644 nova/db/sqlalchemy/migrate_repo/versions/004_add_instance_types.py

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py b/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py
deleted file mode 100644
index fec191214..000000000
--- a/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py
+++ /dev/null
@@ -1,86 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-#    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 sqlalchemy import *
-from migrate import *
-
-from nova import api
-from nova import db
-from nova import log as logging
-
-import datetime
-
-meta = MetaData()
-
-
-#
-# New Tables
-#
-instance_types = Table('instance_types', meta,
-        Column('created_at', DateTime(timezone=False)),
-        Column('updated_at', DateTime(timezone=False)),
-        Column('deleted_at', DateTime(timezone=False)),
-        Column('deleted', Boolean(create_constraint=True, name=None)),
-        Column('name',
-               String(length=255, convert_unicode=False, assert_unicode=None,
-                      unicode_error=None, _warn_on_bytestring=False),
-                      unique=True),
-        Column('id', Integer(),  primary_key=True, nullable=False),
-        Column('memory_mb', Integer(),  nullable=False),
-        Column('vcpus', Integer(),  nullable=False),
-        Column('local_gb', Integer(),  nullable=False),
-        Column('flavorid', Integer(),  nullable=False, unique=True),
-        Column('swap', Integer(),  nullable=False, default=0),
-        Column('rxtx_quota', Integer(),  nullable=False, default=0),
-        Column('rxtx_cap', Integer(),  nullable=False, default=0))
-
-
-def upgrade(migrate_engine):
-    # Upgrade operations go here
-    # Don't create your own engine; bind migrate_engine
-    # to your metadata
-    meta.bind = migrate_engine
-    try:
-        instance_types.create()
-    except Exception:
-        logging.info(repr(table))
-        logging.exception('Exception while creating instance_types table')
-        raise
-
-    # Here are the old static instance types
-    INSTANCE_TYPES = {
-    'm1.tiny': dict(memory_mb=512, vcpus=1, local_gb=0, flavorid=1),
-    'm1.small': dict(memory_mb=2048, vcpus=1, local_gb=20, flavorid=2),
-    'm1.medium': dict(memory_mb=4096, vcpus=2, local_gb=40, flavorid=3),
-    'm1.large': dict(memory_mb=8192, vcpus=4, local_gb=80, flavorid=4),
-    'm1.xlarge': dict(memory_mb=16384, vcpus=8, local_gb=160, flavorid=5)}
-    try:
-        i = instance_types.insert()
-        for name, values in INSTANCE_TYPES.iteritems():
-            # FIXME(kpepple) should we be seeding created_at / updated_at ?
-            # now = datetime.datatime.utcnow()
-            i.execute({'name': name, 'memory_mb': values["memory_mb"],
-                        'vcpus': values["vcpus"], 'deleted': 0,
-                        'local_gb': values["local_gb"],
-                        'flavorid': values["flavorid"]})
-    except Exception:
-        logging.info(repr(table))
-        logging.exception('Exception while seeding instance_types table')
-        raise
-
-
-def downgrade(migrate_engine):
-    # Operations to reverse the above upgrade go here.
-    for table in (instance_types):
-        table.drop()
diff --git a/nova/db/sqlalchemy/migrate_repo/versions/004_add_instance_types.py b/nova/db/sqlalchemy/migrate_repo/versions/004_add_instance_types.py
new file mode 100644
index 000000000..fec191214
--- /dev/null
+++ b/nova/db/sqlalchemy/migrate_repo/versions/004_add_instance_types.py
@@ -0,0 +1,86 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+#    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 sqlalchemy import *
+from migrate import *
+
+from nova import api
+from nova import db
+from nova import log as logging
+
+import datetime
+
+meta = MetaData()
+
+
+#
+# New Tables
+#
+instance_types = Table('instance_types', meta,
+        Column('created_at', DateTime(timezone=False)),
+        Column('updated_at', DateTime(timezone=False)),
+        Column('deleted_at', DateTime(timezone=False)),
+        Column('deleted', Boolean(create_constraint=True, name=None)),
+        Column('name',
+               String(length=255, convert_unicode=False, assert_unicode=None,
+                      unicode_error=None, _warn_on_bytestring=False),
+                      unique=True),
+        Column('id', Integer(),  primary_key=True, nullable=False),
+        Column('memory_mb', Integer(),  nullable=False),
+        Column('vcpus', Integer(),  nullable=False),
+        Column('local_gb', Integer(),  nullable=False),
+        Column('flavorid', Integer(),  nullable=False, unique=True),
+        Column('swap', Integer(),  nullable=False, default=0),
+        Column('rxtx_quota', Integer(),  nullable=False, default=0),
+        Column('rxtx_cap', Integer(),  nullable=False, default=0))
+
+
+def upgrade(migrate_engine):
+    # Upgrade operations go here
+    # Don't create your own engine; bind migrate_engine
+    # to your metadata
+    meta.bind = migrate_engine
+    try:
+        instance_types.create()
+    except Exception:
+        logging.info(repr(table))
+        logging.exception('Exception while creating instance_types table')
+        raise
+
+    # Here are the old static instance types
+    INSTANCE_TYPES = {
+    'm1.tiny': dict(memory_mb=512, vcpus=1, local_gb=0, flavorid=1),
+    'm1.small': dict(memory_mb=2048, vcpus=1, local_gb=20, flavorid=2),
+    'm1.medium': dict(memory_mb=4096, vcpus=2, local_gb=40, flavorid=3),
+    'm1.large': dict(memory_mb=8192, vcpus=4, local_gb=80, flavorid=4),
+    'm1.xlarge': dict(memory_mb=16384, vcpus=8, local_gb=160, flavorid=5)}
+    try:
+        i = instance_types.insert()
+        for name, values in INSTANCE_TYPES.iteritems():
+            # FIXME(kpepple) should we be seeding created_at / updated_at ?
+            # now = datetime.datatime.utcnow()
+            i.execute({'name': name, 'memory_mb': values["memory_mb"],
+                        'vcpus': values["vcpus"], 'deleted': 0,
+                        'local_gb': values["local_gb"],
+                        'flavorid': values["flavorid"]})
+    except Exception:
+        logging.info(repr(table))
+        logging.exception('Exception while seeding instance_types table')
+        raise
+
+
+def downgrade(migrate_engine):
+    # Operations to reverse the above upgrade go here.
+    for table in (instance_types):
+        table.drop()
-- 
cgit 


From e5d979596ff8c588c7bbe82b7f1cb90de8af041a Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Thu, 17 Feb 2011 18:49:30 -0400
Subject: missing docstring and fixed copyrights

---
 nova/scheduler/zone_manager.py | 3 +--
 nova/tests/test_zones.py       | 1 -
 2 files changed, 1 insertion(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/scheduler/zone_manager.py b/nova/scheduler/zone_manager.py
index 4bf6e36c6..3e7c1eba8 100644
--- a/nova/scheduler/zone_manager.py
+++ b/nova/scheduler/zone_manager.py
@@ -1,6 +1,4 @@
 # Copyright (c) 2010 Openstack, LLC.
-# Copyright 2010 United States Government as represented by the
-# Administrator of the National Aeronautics and Space Administration.
 # All Rights Reserved.
 #
 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
@@ -109,6 +107,7 @@ class ZoneManager(object):
         self.zone_states = {}
 
     def get_zone_list(self):
+        """Return the list of zones we know about."""
         return [zone.to_dict() for zone in self.zone_states.values()]
 
     def _refresh_from_db(self, context):
diff --git a/nova/tests/test_zones.py b/nova/tests/test_zones.py
index 7036ebe58..c273230a9 100644
--- a/nova/tests/test_zones.py
+++ b/nova/tests/test_zones.py
@@ -1,5 +1,4 @@
 # Copyright 2010 United States Government as represented by the
-# Administrator of the National Aeronautics and Space Administration.
 # All Rights Reserved.
 #
 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
-- 
cgit 


From 3f3dddee0245cb143004dfb8c20204c511bec658 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Thu, 17 Feb 2011 16:52:31 -0600
Subject: a few changes and a bunch of unit tests

---
 nova/api/openstack/servers.py                      | 16 ++--
 .../sqlalchemy/migrate_repo/versions/003_cactus.py | 60 -------------
 .../versions/004_add_instance_migrations.py        | 60 +++++++++++++
 nova/tests/api/openstack/common.py                 | 30 +++++++
 nova/tests/api/openstack/test_servers.py           | 98 +++++++++++++++++++++-
 5 files changed, 197 insertions(+), 67 deletions(-)
 delete mode 100644 nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py
 create mode 100644 nova/db/sqlalchemy/migrate_repo/versions/004_add_instance_migrations.py
 create mode 100644 nova/tests/api/openstack/common.py

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index fd6b10d5b..a719f5e15 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -227,7 +227,7 @@ class Controller(wsgi.Controller):
             self.compute_api.confirm_resize(req.environ['nova.context'], id)
         except Exception, e:
             LOG.exception(_("Error in confirm-resize %s"), e)
-            return faults.Fault(exc.HTTPBadRequest(e))
+            return faults.Fault(exc.HTTPBadRequest())
         return exc.HTTPNoContent()
 
     def _action_revert_resize(self, input_dict, req, id):
@@ -235,7 +235,7 @@ class Controller(wsgi.Controller):
             self.compute_api.revert_resize(req.environ['nova.context'], id)
         except Exception, e:
             LOG.exception(_("Error in revert-resize %s"), e)
-            return faults.Fault(exc.HTTPBadRequest(e))
+            return faults.Fault(exc.HTTPBadRequest())
         return exc.HTTPAccepted()
 
     def _action_rebuild(self, input_dict, req, id):
@@ -244,12 +244,16 @@ class Controller(wsgi.Controller):
     def _action_resize(self, input_dict, req, id):
         """ Resizes a given instance to the flavor size requested """
         try:
-            flavor_id = input_dict['resize']['flavorId']
-            self.compute_api.resize(req.environ['nova.context'], id,
-                    flavor_id)
+            if 'resize' in input_dict and 'flavorId' in input_dict['resize']:
+                flavor_id = input_dict['resize']['flavorId']
+                self.compute_api.resize(req.environ['nova.context'], id,
+                        flavor_id)
+            else:
+                LOG.exception(_("Missing arguments for resize"))
+                return faults.Fault(exc.HTTPUnprocessableEntity())
         except Exception, e:
             LOG.exception(_("Error in resize %s"), e)
-            return faults.Fault(exc.HTTPUnprocessableEntity(e))
+            return faults.Fault(exc.HTTPBadRequest())
         return faults.Fault(exc.HTTPAccepted())
 
 
diff --git a/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py b/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py
deleted file mode 100644
index 4aab5bdc6..000000000
--- a/nova/db/sqlalchemy/migrate_repo/versions/003_cactus.py
+++ /dev/null
@@ -1,60 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 OpenStack LLC.
-# 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.from sqlalchemy import *
-
-from sqlalchemy import *
-from migrate import *
-
-from nova import log as logging
-
-
-meta = MetaData()
-
-# Just for the ForeignKey and column creation to succeed, these are not the
-# actual definitions of instances or services.
-instances = Table('instances', meta,
-        Column('id', Integer(),  primary_key=True, nullable=False),
-        )
-
-#
-# New Tables
-#
-
-migrations = Table('migrations', meta,
-            Column('created_at', DateTime(timezone=False)),
-            Column('updated_at', DateTime(timezone=False)),
-            Column('deleted_at', DateTime(timezone=False)),
-            Column('deleted', Boolean(create_constraint=True, name=None)),
-            Column('id', Integer(), primary_key=True, nullable=False),
-            Column('source_compute', String(255)),
-            Column('dest_compute', String(255)),
-            Column('dest_host', String(255)),
-            Column('instance_id', Integer, ForeignKey('instances.id'),
-                nullable=True),
-            Column('status', String(255))
-      )
-
-def upgrade(migrate_engine):
-    # Upgrade operations go here. Don't create your own engine;
-    # bind migrate_engine to your metadata
-    meta.bind = migrate_engine
-    for table in (migrations, ):
-        try:
-            table.create()
-        except Exception:
-            logging.info(repr(table))
-            logging.exception('Exception while creating table')
-            raise
diff --git a/nova/db/sqlalchemy/migrate_repo/versions/004_add_instance_migrations.py b/nova/db/sqlalchemy/migrate_repo/versions/004_add_instance_migrations.py
new file mode 100644
index 000000000..4aab5bdc6
--- /dev/null
+++ b/nova/db/sqlalchemy/migrate_repo/versions/004_add_instance_migrations.py
@@ -0,0 +1,60 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 OpenStack LLC.
+# 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.from sqlalchemy import *
+
+from sqlalchemy import *
+from migrate import *
+
+from nova import log as logging
+
+
+meta = MetaData()
+
+# Just for the ForeignKey and column creation to succeed, these are not the
+# actual definitions of instances or services.
+instances = Table('instances', meta,
+        Column('id', Integer(),  primary_key=True, nullable=False),
+        )
+
+#
+# New Tables
+#
+
+migrations = Table('migrations', meta,
+            Column('created_at', DateTime(timezone=False)),
+            Column('updated_at', DateTime(timezone=False)),
+            Column('deleted_at', DateTime(timezone=False)),
+            Column('deleted', Boolean(create_constraint=True, name=None)),
+            Column('id', Integer(), primary_key=True, nullable=False),
+            Column('source_compute', String(255)),
+            Column('dest_compute', String(255)),
+            Column('dest_host', String(255)),
+            Column('instance_id', Integer, ForeignKey('instances.id'),
+                nullable=True),
+            Column('status', String(255))
+      )
+
+def upgrade(migrate_engine):
+    # Upgrade operations go here. Don't create your own engine;
+    # bind migrate_engine to your metadata
+    meta.bind = migrate_engine
+    for table in (migrations, ):
+        try:
+            table.create()
+        except Exception:
+            logging.info(repr(table))
+            logging.exception('Exception while creating table')
+            raise
diff --git a/nova/tests/api/openstack/common.py b/nova/tests/api/openstack/common.py
new file mode 100644
index 000000000..b55d3087b
--- /dev/null
+++ b/nova/tests/api/openstack/common.py
@@ -0,0 +1,30 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# 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.
+
+import json
+
+import webob
+
+def webob_factory(url):
+    base_url = url
+    def web_request(url, method, body=None):
+        req = webob.Request.blank("%s%s" % (base_url, url)) 
+        req.method = method
+        req.body = json.dumps(body)
+        return req
+    return web_request
+    
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index a7be0796e..878b62f85 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -1,6 +1,6 @@
 # vim: tabstop=4 shiftwidth=4 softtabstop=4
 
-# Copyright 2010 OpenStack LLC.
+# Copyright 2010-2011 OpenStack LLC.
 # All Rights Reserved.
 #
 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
@@ -29,6 +29,7 @@ from nova.api.openstack import servers
 import nova.db.api
 from nova.db.sqlalchemy.models import Instance
 import nova.rpc
+from nova.tests.api.openstack import common
 from nova.tests.api.openstack import fakes
 
 
@@ -138,6 +139,8 @@ class ServersTest(unittest.TestCase):
         self.stubs.Set(nova.compute.API, "get_actions", fake_compute_api)
         self.allow_admin = FLAGS.allow_admin_api
 
+        self.webreq = common.webob_factor('/v1.0/servers')
+
     def tearDown(self):
         self.stubs.UnsetAll()
         FLAGS.allow_admin_api = self.allow_admin
@@ -411,6 +414,99 @@ class ServersTest(unittest.TestCase):
         self.assertEqual(res.status, '202 Accepted')
         self.assertEqual(self.server_delete_called, True)
 
+    def test_resize_server(self):
+        req = self.webreq('/1/action', 'POST', dict(resize={flavorId=3}}))
+        res = req.get_response(fakes.wsgi_app())
+
+        self.resize_called = False
+        def resize_mock(context, inst_id, flavor):
+            self.resize_called = True 
+
+        self.stubs.Set(nova.compute.api, 'resize_instance', resize_mock)
+        self.assertEqual(res.status_int, 202)
+        self.assertEqual(self.resize_called, True)
+
+    def test_resize_bad_param_fails(self):
+        req = self.webreq('/1/action', 'POST', dict('ferp'))
+        res = req.get_response(fakes.wsgi_app())
+
+        self.resize_called = False
+        def resize_mock(context, inst_id, flavor):
+            self.resize_called = True 
+
+        self.stubs.Set(nova.compute.api, 'resize_instance', resize_mock)
+        self.assertEqual(res.status_int, 422)
+        self.assertEqual(self.resize_called, False)
+
+    def test_resize_bad_flavor_fails(self):
+        req = self.webreq('/1/action', 'POST', dict(resize={derp=3}))
+        res = req.get_response(fakes.wsgi_app())
+
+        self.resize_called = False
+        def resize_mock(context, inst_id, flavor):
+            self.resize_called = True 
+
+        self.stubs.Set(nova.compute.api, 'resize_instance', resize_mock)
+        self.assertEqual(res.status_int, 422)
+        self.assertEqual(self.resize_called, False)
+
+    def test_resize_raises_fails(self):
+        req = self.webreq('/1/action', 'POST', dict(resize={flavorId=3}))
+        res = req.get_response(fakes.wsgi_app())
+
+        def resize_mock(context, inst_id, flavor):
+            raise Exception, 'hurr durr'
+
+        self.stubs.Set(nova.compute.api, 'resize_instance', resize_mock)
+        self.assertEqual(res.status_int, 500)
+
+    def test_confirm_resize_server(self):
+        req = self.webreq('/1/action', 'POST', dict(confirmResize=None))
+        res = req.get_response(fakes.wsgi_app())
+
+        self.resize_called = False
+        def confirm_resize_mock(context, inst_id):
+            self.resize_called = True 
+
+        self.stubs.Set(nova.compute.api, 'confirm_resize', 
+                confirm_resize_mock)
+        self.assertEqual(res.status_int, 202)
+        self.assertEqual(self.resize_called, True)
+
+    def test_confirm_resize_server_fails(self):
+        req = self.webreq('/1/action', 'POST', dict(confirmResize=None))
+        res = req.get_response(fakes.wsgi_app())
+
+        def confirm_resize_mock(context, inst_id):
+            raise Exception, 'hurr durr'
+
+        self.stubs.Set(nova.compute.api, 'confirm_resize', 
+                confirm_resize_mock)
+        self.assertEqual(res.status_int, 500)
+
+    def test_revert_resize_server(self):
+        req = self.webreq('/1/action', 'POST', dict(revertResize=None))
+        res = req.get_response(fakes.wsgi_app())
+
+        self.resize_called = False
+        def revert_resize_mock(context, inst_id):
+            self.resize_called = True
+
+        self.stubs.Set(nova.compute.api, 'revert_resize', 
+                confirm_resize_mock)
+        self.assertEqual(res.status_int, 202)
+        self.assertEqual(self.resize_called, True)
+
+    def test_revert_resize_server_fails(self):
+        req = self.webreq('/1/action', 'POST', dict(confirmResize=None))
+        res = req.get_response(fakes.wsgi_app())
+
+        def revert_resize_mock(context, inst_id):
+            raise Exception, 'hurr durr'
+
+        self.stubs.Set(nova.compute.api, 'revert_resize', 
+                confirm_resize_mock)
+        self.assertEqual(res.status_int, 500)
 
 if __name__ == "__main__":
     unittest.main()
-- 
cgit 


From 94f5a5748158e61bde43327970dd8e513ca36575 Mon Sep 17 00:00:00 2001
From: Nirmal Ranganathan <nirmal.ranganathan@rackspace.com>
Date: Thu, 17 Feb 2011 17:13:59 -0600
Subject: Always compare incoming flavor_id as an int

---
 nova/compute/instance_types.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/compute/instance_types.py b/nova/compute/instance_types.py
index 309313fd0..7a2a5baa3 100644
--- a/nova/compute/instance_types.py
+++ b/nova/compute/instance_types.py
@@ -45,6 +45,6 @@ def get_by_type(instance_type):
 
 def get_by_flavor_id(flavor_id):
     for instance_type, details in INSTANCE_TYPES.iteritems():
-        if details['flavorid'] == flavor_id:
+        if details['flavorid'] == int(flavor_id):
             return instance_type
     return FLAGS.default_instance_type
-- 
cgit 


From 88aa545b53d96c25da01218c79e8be8c1ae3370f Mon Sep 17 00:00:00 2001
From: "matt.dietz@rackspace.com" <>
Date: Thu, 17 Feb 2011 23:55:56 +0000
Subject: Test changes

---
 nova/tests/api/openstack/test_servers.py | 82 +++++++++++++++-----------------
 1 file changed, 39 insertions(+), 43 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 878b62f85..665551c55 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -26,6 +26,7 @@ from nova import db
 from nova import flags
 import nova.api.openstack
 from nova.api.openstack import servers
+import nova.compute.api
 import nova.db.api
 from nova.db.sqlalchemy.models import Instance
 import nova.rpc
@@ -139,7 +140,7 @@ class ServersTest(unittest.TestCase):
         self.stubs.Set(nova.compute.API, "get_actions", fake_compute_api)
         self.allow_admin = FLAGS.allow_admin_api
 
-        self.webreq = common.webob_factor('/v1.0/servers')
+        self.webreq = common.webob_factory('/v1.0/servers')
 
     def tearDown(self):
         self.stubs.UnsetAll()
@@ -415,98 +416,93 @@ class ServersTest(unittest.TestCase):
         self.assertEqual(self.server_delete_called, True)
 
     def test_resize_server(self):
-        req = self.webreq('/1/action', 'POST', dict(resize={flavorId=3}}))
-        res = req.get_response(fakes.wsgi_app())
+        req = self.webreq('/1/action', 'POST', dict(resize=dict(flavorId=3)))
 
         self.resize_called = False
-        def resize_mock(context, inst_id, flavor):
+        def resize_mock(*args):
             self.resize_called = True 
 
-        self.stubs.Set(nova.compute.api, 'resize_instance', resize_mock)
+        self.stubs.Set(nova.compute.api.API, 'resize', resize_mock)
+
+        res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 202)
         self.assertEqual(self.resize_called, True)
 
-    def test_resize_bad_param_fails(self):
-        req = self.webreq('/1/action', 'POST', dict('ferp'))
-        res = req.get_response(fakes.wsgi_app())
+    def test_resize_bad_flavor_fails(self):
+        req = self.webreq('/1/action', 'POST', dict(resize=dict(derp=3)))
 
         self.resize_called = False
-        def resize_mock(context, inst_id, flavor):
+        def resize_mock(*args):
             self.resize_called = True 
 
-        self.stubs.Set(nova.compute.api, 'resize_instance', resize_mock)
-        self.assertEqual(res.status_int, 422)
-        self.assertEqual(self.resize_called, False)
+        self.stubs.Set(nova.compute.api.API, 'resize', resize_mock)
 
-    def test_resize_bad_flavor_fails(self):
-        req = self.webreq('/1/action', 'POST', dict(resize={derp=3}))
         res = req.get_response(fakes.wsgi_app())
-
-        self.resize_called = False
-        def resize_mock(context, inst_id, flavor):
-            self.resize_called = True 
-
-        self.stubs.Set(nova.compute.api, 'resize_instance', resize_mock)
         self.assertEqual(res.status_int, 422)
         self.assertEqual(self.resize_called, False)
 
     def test_resize_raises_fails(self):
-        req = self.webreq('/1/action', 'POST', dict(resize={flavorId=3}))
-        res = req.get_response(fakes.wsgi_app())
+        req = self.webreq('/1/action', 'POST', dict(resize=dict(flavorId=3)))
 
-        def resize_mock(context, inst_id, flavor):
+        def resize_mock(*args):
             raise Exception, 'hurr durr'
 
-        self.stubs.Set(nova.compute.api, 'resize_instance', resize_mock)
-        self.assertEqual(res.status_int, 500)
+        self.stubs.Set(nova.compute.api.API, 'resize', resize_mock)
+
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 400)
 
     def test_confirm_resize_server(self):
         req = self.webreq('/1/action', 'POST', dict(confirmResize=None))
-        res = req.get_response(fakes.wsgi_app())
 
         self.resize_called = False
-        def confirm_resize_mock(context, inst_id):
+        def confirm_resize_mock(*args):
             self.resize_called = True 
 
-        self.stubs.Set(nova.compute.api, 'confirm_resize', 
+        self.stubs.Set(nova.compute.api.API, 'confirm_resize', 
                 confirm_resize_mock)
-        self.assertEqual(res.status_int, 202)
+
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 204)
         self.assertEqual(self.resize_called, True)
 
     def test_confirm_resize_server_fails(self):
         req = self.webreq('/1/action', 'POST', dict(confirmResize=None))
-        res = req.get_response(fakes.wsgi_app())
 
-        def confirm_resize_mock(context, inst_id):
+        def confirm_resize_mock(*args):
             raise Exception, 'hurr durr'
 
-        self.stubs.Set(nova.compute.api, 'confirm_resize', 
+        self.stubs.Set(nova.compute.api.API, 'confirm_resize', 
                 confirm_resize_mock)
-        self.assertEqual(res.status_int, 500)
+
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 400)
 
     def test_revert_resize_server(self):
         req = self.webreq('/1/action', 'POST', dict(revertResize=None))
-        res = req.get_response(fakes.wsgi_app())
 
         self.resize_called = False
-        def revert_resize_mock(context, inst_id):
+        def revert_resize_mock(*args):
             self.resize_called = True
 
-        self.stubs.Set(nova.compute.api, 'revert_resize', 
-                confirm_resize_mock)
+        self.stubs.Set(nova.compute.api.API, 'revert_resize', 
+                revert_resize_mock)
+
+        res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 202)
         self.assertEqual(self.resize_called, True)
 
     def test_revert_resize_server_fails(self):
-        req = self.webreq('/1/action', 'POST', dict(confirmResize=None))
-        res = req.get_response(fakes.wsgi_app())
+        req = self.webreq('/1/action', 'POST', dict(revertResize=None))
 
-        def revert_resize_mock(context, inst_id):
+        def revert_resize_mock(*args):
             raise Exception, 'hurr durr'
 
-        self.stubs.Set(nova.compute.api, 'revert_resize', 
-                confirm_resize_mock)
-        self.assertEqual(res.status_int, 500)
+        self.stubs.Set(nova.compute.api.API, 'revert_resize', 
+                revert_resize_mock)
+
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 400)
 
 if __name__ == "__main__":
     unittest.main()
-- 
cgit 


From ff0ef603fd3f87ad9294260d13ea3c122bab387f Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Thu, 17 Feb 2011 16:22:04 -0800
Subject: changed migration to 006 for trunk compatibility

---
 .../versions/004_add_instance_types.py             | 86 ----------------------
 .../versions/006_add_instance_types.py             | 86 ++++++++++++++++++++++
 2 files changed, 86 insertions(+), 86 deletions(-)
 delete mode 100644 nova/db/sqlalchemy/migrate_repo/versions/004_add_instance_types.py
 create mode 100644 nova/db/sqlalchemy/migrate_repo/versions/006_add_instance_types.py

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/migrate_repo/versions/004_add_instance_types.py b/nova/db/sqlalchemy/migrate_repo/versions/004_add_instance_types.py
deleted file mode 100644
index fec191214..000000000
--- a/nova/db/sqlalchemy/migrate_repo/versions/004_add_instance_types.py
+++ /dev/null
@@ -1,86 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-#    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 sqlalchemy import *
-from migrate import *
-
-from nova import api
-from nova import db
-from nova import log as logging
-
-import datetime
-
-meta = MetaData()
-
-
-#
-# New Tables
-#
-instance_types = Table('instance_types', meta,
-        Column('created_at', DateTime(timezone=False)),
-        Column('updated_at', DateTime(timezone=False)),
-        Column('deleted_at', DateTime(timezone=False)),
-        Column('deleted', Boolean(create_constraint=True, name=None)),
-        Column('name',
-               String(length=255, convert_unicode=False, assert_unicode=None,
-                      unicode_error=None, _warn_on_bytestring=False),
-                      unique=True),
-        Column('id', Integer(),  primary_key=True, nullable=False),
-        Column('memory_mb', Integer(),  nullable=False),
-        Column('vcpus', Integer(),  nullable=False),
-        Column('local_gb', Integer(),  nullable=False),
-        Column('flavorid', Integer(),  nullable=False, unique=True),
-        Column('swap', Integer(),  nullable=False, default=0),
-        Column('rxtx_quota', Integer(),  nullable=False, default=0),
-        Column('rxtx_cap', Integer(),  nullable=False, default=0))
-
-
-def upgrade(migrate_engine):
-    # Upgrade operations go here
-    # Don't create your own engine; bind migrate_engine
-    # to your metadata
-    meta.bind = migrate_engine
-    try:
-        instance_types.create()
-    except Exception:
-        logging.info(repr(table))
-        logging.exception('Exception while creating instance_types table')
-        raise
-
-    # Here are the old static instance types
-    INSTANCE_TYPES = {
-    'm1.tiny': dict(memory_mb=512, vcpus=1, local_gb=0, flavorid=1),
-    'm1.small': dict(memory_mb=2048, vcpus=1, local_gb=20, flavorid=2),
-    'm1.medium': dict(memory_mb=4096, vcpus=2, local_gb=40, flavorid=3),
-    'm1.large': dict(memory_mb=8192, vcpus=4, local_gb=80, flavorid=4),
-    'm1.xlarge': dict(memory_mb=16384, vcpus=8, local_gb=160, flavorid=5)}
-    try:
-        i = instance_types.insert()
-        for name, values in INSTANCE_TYPES.iteritems():
-            # FIXME(kpepple) should we be seeding created_at / updated_at ?
-            # now = datetime.datatime.utcnow()
-            i.execute({'name': name, 'memory_mb': values["memory_mb"],
-                        'vcpus': values["vcpus"], 'deleted': 0,
-                        'local_gb': values["local_gb"],
-                        'flavorid': values["flavorid"]})
-    except Exception:
-        logging.info(repr(table))
-        logging.exception('Exception while seeding instance_types table')
-        raise
-
-
-def downgrade(migrate_engine):
-    # Operations to reverse the above upgrade go here.
-    for table in (instance_types):
-        table.drop()
diff --git a/nova/db/sqlalchemy/migrate_repo/versions/006_add_instance_types.py b/nova/db/sqlalchemy/migrate_repo/versions/006_add_instance_types.py
new file mode 100644
index 000000000..fec191214
--- /dev/null
+++ b/nova/db/sqlalchemy/migrate_repo/versions/006_add_instance_types.py
@@ -0,0 +1,86 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+#    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 sqlalchemy import *
+from migrate import *
+
+from nova import api
+from nova import db
+from nova import log as logging
+
+import datetime
+
+meta = MetaData()
+
+
+#
+# New Tables
+#
+instance_types = Table('instance_types', meta,
+        Column('created_at', DateTime(timezone=False)),
+        Column('updated_at', DateTime(timezone=False)),
+        Column('deleted_at', DateTime(timezone=False)),
+        Column('deleted', Boolean(create_constraint=True, name=None)),
+        Column('name',
+               String(length=255, convert_unicode=False, assert_unicode=None,
+                      unicode_error=None, _warn_on_bytestring=False),
+                      unique=True),
+        Column('id', Integer(),  primary_key=True, nullable=False),
+        Column('memory_mb', Integer(),  nullable=False),
+        Column('vcpus', Integer(),  nullable=False),
+        Column('local_gb', Integer(),  nullable=False),
+        Column('flavorid', Integer(),  nullable=False, unique=True),
+        Column('swap', Integer(),  nullable=False, default=0),
+        Column('rxtx_quota', Integer(),  nullable=False, default=0),
+        Column('rxtx_cap', Integer(),  nullable=False, default=0))
+
+
+def upgrade(migrate_engine):
+    # Upgrade operations go here
+    # Don't create your own engine; bind migrate_engine
+    # to your metadata
+    meta.bind = migrate_engine
+    try:
+        instance_types.create()
+    except Exception:
+        logging.info(repr(table))
+        logging.exception('Exception while creating instance_types table')
+        raise
+
+    # Here are the old static instance types
+    INSTANCE_TYPES = {
+    'm1.tiny': dict(memory_mb=512, vcpus=1, local_gb=0, flavorid=1),
+    'm1.small': dict(memory_mb=2048, vcpus=1, local_gb=20, flavorid=2),
+    'm1.medium': dict(memory_mb=4096, vcpus=2, local_gb=40, flavorid=3),
+    'm1.large': dict(memory_mb=8192, vcpus=4, local_gb=80, flavorid=4),
+    'm1.xlarge': dict(memory_mb=16384, vcpus=8, local_gb=160, flavorid=5)}
+    try:
+        i = instance_types.insert()
+        for name, values in INSTANCE_TYPES.iteritems():
+            # FIXME(kpepple) should we be seeding created_at / updated_at ?
+            # now = datetime.datatime.utcnow()
+            i.execute({'name': name, 'memory_mb': values["memory_mb"],
+                        'vcpus': values["vcpus"], 'deleted': 0,
+                        'local_gb': values["local_gb"],
+                        'flavorid': values["flavorid"]})
+    except Exception:
+        logging.info(repr(table))
+        logging.exception('Exception while seeding instance_types table')
+        raise
+
+
+def downgrade(migrate_engine):
+    # Operations to reverse the above upgrade go here.
+    for table in (instance_types):
+        table.drop()
-- 
cgit 


From 2da6494d20624177c0077d0709e1fdb0e5f8f03c Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Thu, 17 Feb 2011 17:42:49 -0800
Subject: pep8

---
 nova/tests/api/openstack/test_zones.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/test_zones.py b/nova/tests/api/openstack/test_zones.py
index 5542a1cf3..df497ef1b 100644
--- a/nova/tests/api/openstack/test_zones.py
+++ b/nova/tests/api/openstack/test_zones.py
@@ -57,8 +57,7 @@ def zone_get_all(context):
         dict(id=1, api_url='http://foo.com', username='bob',
                  password='xxx'),
         dict(id=2, api_url='http://blah.com', username='alice',
-                 password='qwerty')
-    ]
+                 password='qwerty')]
 
 
 class ZonesTest(unittest.TestCase):
-- 
cgit 


From 4b51ec3e9bca7421c66816c77c43396e51e68ea6 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Thu, 17 Feb 2011 23:09:06 -0600
Subject: Tests

---
 nova/tests/api/openstack/common.py |  8 +++++---
 nova/tests/test_compute.py         |  7 +++++++
 nova/virt/fake.py                  | 13 +++++++++++++
 nova/virt/xenapi_conn.py           |  8 --------
 4 files changed, 25 insertions(+), 11 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/common.py b/nova/tests/api/openstack/common.py
index b55d3087b..66207cddc 100644
--- a/nova/tests/api/openstack/common.py
+++ b/nova/tests/api/openstack/common.py
@@ -21,10 +21,12 @@ import webob
 
 def webob_factory(url):
     base_url = url
-    def web_request(url, method, body=None):
+    def web_request(url, method=None, body=None):
         req = webob.Request.blank("%s%s" % (base_url, url)) 
-        req.method = method
-        req.body = json.dumps(body)
+        if method:
+            req.method = method
+        if body:
+            req.body = json.dumps(body)
         return req
     return web_request
     
diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index 2aa0690e7..e27e08827 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -258,3 +258,10 @@ class ComputeTestCase(test.TestCase):
         self.assertEqual(ret_val, None)
 
         self.compute.terminate_instance(self.context, instance_id)
+
+    def test_resize_instance(self):
+        """Ensure instance can be migrated/resized"""
+        instance_id = self._create_instance()
+        self.compute.run_instnce(self.context, instance_id)
+        self.compute.prep_resize(self.context, instance_id)
+
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 <masumotok@nttdata.co.jp>
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/compute/api.py                                   |  4 ++--
 nova/compute/manager.py                               | 15 ++++++++++-----
 nova/db/sqlalchemy/migrate_repo/versions/002_bexar.py |  9 ---------
 nova/image/s3.py                                      |  2 +-
 nova/scheduler/manager.py                             |  1 -
 nova/utils.py                                         | 18 ------------------
 nova/virt/disk.py                                     |  1 -
 nova/virt/libvirt_conn.py                             |  2 +-
 8 files changed, 14 insertions(+), 38 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/api.py b/nova/compute/api.py
index ac02dbcfa..740dd3935 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -103,9 +103,9 @@ class API(base.Base):
         if not is_vpn:
             image = self.image_service.show(context, image_id)
             if kernel_id is None:
-                kernel_id = image.get('kernelId', None)
+                kernel_id = image.get('kernel_id', None)
             if ramdisk_id is None:
-                ramdisk_id = image.get('ramdiskId', None)
+                ramdisk_id = image.get('ramdisk_id', None)
             # No kernel and ramdisk for raw images
             if kernel_id == str(FLAGS.null_kernel):
                 kernel_id = None
diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index cae95dd93..47dd5fd5e 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -38,6 +38,8 @@ import datetime
 import random
 import string
 import socket
+import os
+import tempfile
 import time
 import functools
 
@@ -577,14 +579,17 @@ class ComputeManager(manager.Manager):
     @exception.wrap_exception
     def mktmpfile(self, context):
         """make tmpfile under FLAGS.instance_path."""
-        return utils.mktmpfile(FLAGS.instances_path)
+        fd, name = tempfile.mkstemp(dir=FLAGS.instances_path)
+        # No essential reason to write dateinfo. just for debugging reason.
+        os.fdopen(fd, 'w').write(str(datetime.datetime.utcnow()))
+        return name
 
     @exception.wrap_exception
     def confirm_tmpfile(self, context, path):
         """Confirm existence of the tmpfile given by path."""
-        if not utils.exists(path):
+        if not os.path.exists(path):
             raise exception.NotFound(_('%s not found') % path)
-        return utils.remove(path)
+        return os.remove(path)
 
     @exception.wrap_exception
     def update_available_resource(self, context):
@@ -683,7 +688,7 @@ class ComputeManager(manager.Manager):
         Post operations for live migration.
         Mainly, database updating.
         """
-        LOG.info('post_live_migration() is started..')
+        LOG.info(_('post_live_migration() is started..'))
         instance_id = instance_ref['id']
 
         # Detaching volumes.
@@ -705,7 +710,7 @@ class ComputeManager(manager.Manager):
         # 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 ' % i_name)
+            LOG.warn(_('fixed_ip is not found for %s.') % i_name)
         self.db.fixed_ip_update(ctxt, fixed_ip, {'host': dest})
 
         try:
diff --git a/nova/db/sqlalchemy/migrate_repo/versions/002_bexar.py b/nova/db/sqlalchemy/migrate_repo/versions/002_bexar.py
index 38210db85..699b837f8 100644
--- a/nova/db/sqlalchemy/migrate_repo/versions/002_bexar.py
+++ b/nova/db/sqlalchemy/migrate_repo/versions/002_bexar.py
@@ -229,12 +229,3 @@ def upgrade(migrate_engine):
     networks.create_column(networks_cidr_v6)
     networks.create_column(networks_ra_server)
     services.create_column(services_availability_zone)
-    #services.create_column(services_vcpus)
-    #services.create_column(services_memory_mb)
-    #services.create_column(services_local_gb)
-    #services.create_column(services_vcpus_used)
-    #services.create_column(services_memory_mb_used)
-    #services.create_column(services_local_gb_used)
-    #services.create_column(services_hypervisor_type)
-    #services.create_column(services_hypervisor_version)
-    #services.create_column(services_cpu_info)
diff --git a/nova/image/s3.py b/nova/image/s3.py
index 71304cdd6..14135a1ee 100644
--- a/nova/image/s3.py
+++ b/nova/image/s3.py
@@ -94,7 +94,7 @@ class S3ImageService(service.BaseImageService):
         if FLAGS.connection_type == 'fake':
             return {'imageId': 'bar'}
         result = self.index(context)
-        result = [i for i in result if i['imageId'] == image_id]
+        result = [i for i in result if i['id'] == image_id]
         if not result:
             raise exception.NotFound(_('Image %s could not be found')
                                      % image_id)
diff --git a/nova/scheduler/manager.py b/nova/scheduler/manager.py
index af54c72be..ea7ae7bd2 100644
--- a/nova/scheduler/manager.py
+++ b/nova/scheduler/manager.py
@@ -60,7 +60,6 @@ class SchedulerManager(manager.Manager):
             host = getattr(self.driver, driver_method)(elevated, *args,
                                                        **kwargs)
         except AttributeError, e:
-            print 'manager.attrerr', e
             host = self.driver.schedule(elevated, topic, *args, **kwargs)
 
         rpc.cast(context,
diff --git a/nova/utils.py b/nova/utils.py
index 966dde667..8d7ff1f64 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -337,24 +337,6 @@ def str_dict_replace(s, mapping):
     return s
 
 
-def mktmpfile(dir):
-    """create tmpfile under dir, and return filename."""
-    filename = datetime.datetime.utcnow().strftime('%Y%m%d%H%M%S')
-    fpath = os.path.join(dir, filename)
-    open(fpath, 'a+').write(fpath + '\n')
-    return fpath
-
-
-def exists(filename):
-    """check file path existence."""
-    return os.path.exists(filename)
-
-
-def remove(filename):
-    """remove file."""
-    return os.remove(filename)
-
-
 class LazyPluggable(object):
     """A pluggable backend loaded lazily based on some value."""
 
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/tests/test_compute.py | 24 +++++++++++++++++++++---
 nova/virt/fake.py          |  6 ++++++
 2 files changed, 27 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index e27e08827..3f2e64c87 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -56,7 +56,7 @@ class ComputeTestCase(test.TestCase):
         self.manager.delete_project(self.project)
         super(ComputeTestCase, self).tearDown()
 
-    def _create_instance(self):
+    def _create_instance(self, params={}):
         """Create a test instance"""
         inst = {}
         inst['image_id'] = 'ami-test'
@@ -67,6 +67,7 @@ class ComputeTestCase(test.TestCase):
         inst['instance_type'] = 'm1.tiny'
         inst['mac_address'] = utils.generate_mac()
         inst['ami_launch_index'] = 0
+        inst.update(params)
         return db.instance_create(self.context, inst)['id']
 
     def _create_group(self):
@@ -262,6 +263,23 @@ class ComputeTestCase(test.TestCase):
     def test_resize_instance(self):
         """Ensure instance can be migrated/resized"""
         instance_id = self._create_instance()
-        self.compute.run_instnce(self.context, instance_id)
-        self.compute.prep_resize(self.context, instance_id)
+        context = self.context.elevated()
+        self.compute.run_instance(self.context, instance_id)
+        db.instance_update(self.context, instance_id, {'host':'foo'})
+
+        self.compute.prep_resize(context, instance_id)
+        migration_ref = db.migration_get_by_instance_and_status(context,
+                instance_id, 'pre-migrating')
+        self.compute.resize_instance(context, instance_id,
+                migration_ref['id'])
+        self.compute.terminate_instance(context, instance_id)
+
+    def test_resize_same_source_fails(self):
+        """Ensure instance fails to migrate when source and destination are
+        the same host"""
+        instance_id = self._create_instance()
+        self.compute.run_instance(self.context, instance_id)
+        self.assertRaises(exception.Error, self.compute.prep_resize, 
+                self.context, instance_id)
 
+        self.compute.terminate_instance(self.context, instance_id)
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 4673afddcb5a1069f75fb3493e43498ed1de11f9 Mon Sep 17 00:00:00 2001
From: Naveed Massjouni <naveedm9@gmail.com>
Date: Fri, 18 Feb 2011 02:23:30 -0500
Subject: Incorporating minor cleanups suggested by Rick Harris: * Use
 assertNotEqual instead of assertTrue * Use enumerate function instead of
 maintaining a counter

---
 nova/tests/api/openstack/test_servers.py | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 630e1e5eb..4ed13022b 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -259,15 +259,13 @@ class ServersTest(unittest.TestCase):
         server_list = res_dict['servers']
         host_ids = [server_list[0]['hostId'], server_list[1]['hostId']]
         self.assertTrue(host_ids[0] and host_ids[1])
-        self.assertTrue(host_ids[0] != host_ids[1])
+        self.assertNotEqual(host_ids[0], host_ids[1])
 
-        i = 0
-        for s in res_dict['servers']:
+        for i, s in enumerate(res_dict['servers']):
             self.assertEqual(s['id'], i)
             self.assertEqual(s['hostId'], host_ids[i % 2])
             self.assertEqual(s['name'], 'server%d' % i)
             self.assertEqual(s['imageId'], 10)
-            i += 1
 
     def test_server_pause(self):
         FLAGS.allow_admin_api = True
-- 
cgit 


From 205810c3da4652fd0f5203f53299cd998ac7cf82 Mon Sep 17 00:00:00 2001
From: Christian Berendt <berendt@b1-systems.de>
Date: Fri, 18 Feb 2011 11:44:06 +0100
Subject: added functionality to list only fixed ip addresses of one node and
 added exception handling to list method

# nova-manage fixed list XXXX
network           	IP address     	MAC address      	hostname       	host
10.xx.xx.0/24     	10.xx.xx.5     	02:16:3e:3f:33:b6	i-00000547     	XXXX
10.xx.xx.0/24     	10.xx.xx.9     	02:16:3e:14:03:d6	i-00000548     	XXXX
10.xx.xx.0/24     	10.xx.xx.12    	02:16:3e:20:1b:e7	i-00000549     	XXXX
---
 nova/db/api.py            |  5 +++++
 nova/db/sqlalchemy/api.py | 22 ++++++++++++++++++++++
 2 files changed, 27 insertions(+)

(limited to 'nova')

diff --git a/nova/db/api.py b/nova/db/api.py
index d7f3746d2..6053c0352 100644
--- a/nova/db/api.py
+++ b/nova/db/api.py
@@ -293,6 +293,11 @@ def fixed_ip_get_all(context):
     return IMPL.fixed_ip_get_all(context)
 
 
+def fixed_ip_get_all_by_host(context, host):
+    """Get all defined fixed ips used by a host."""
+    return IMPL.fixed_ip_get_all_by_host(context, host)
+
+
 def fixed_ip_get_by_address(context, address):
     """Get a fixed ip by address or raise if it does not exist."""
     return IMPL.fixed_ip_get_by_address(context, address)
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 2697fac73..d07c53759 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -594,6 +594,28 @@ def fixed_ip_get_all(context, session=None):
     return result
 
 
+@require_admin_context
+def fixed_ip_get_all_by_host(context, host=None):
+    session = get_session()
+
+    # FIXME: I'm sure that SQLAlchemy can handle this in a nicer way
+    instances = session.query(models.Instance).\
+                     filter_by(state=1).\
+                     filter_by(host=host).\
+                     all()
+
+    result = []
+    for instance in instances:
+        result.append(session.query(models.FixedIp).\
+                       filter_by(instance_id=instance['id']).\
+                       first())
+
+    if not result:
+        raise exception.NotFound(_('No fixed ips for this host defined'))
+
+    return result
+
+
 @require_context
 def fixed_ip_get_by_address(context, address, session=None):
     if not session:
-- 
cgit 


From c884064e7a9af04b2ebdbbb9ee32318a00716412 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Fri, 18 Feb 2011 12:08:35 -0400
Subject: fixups backed on merge comments

---
 nova/api/openstack/zones.py            | 30 +++++----------------
 nova/flags.py                          |  5 ++--
 nova/scheduler/api.py                  | 49 ++++++++++++++++++++++++++++++++++
 nova/scheduler/zone_manager.py         | 15 ++++++-----
 nova/tests/api/openstack/test_zones.py | 33 +++++++++++------------
 5 files changed, 82 insertions(+), 50 deletions(-)
 create mode 100644 nova/scheduler/api.py

(limited to 'nova')

diff --git a/nova/api/openstack/zones.py b/nova/api/openstack/zones.py
index f75176824..24a4444f7 100644
--- a/nova/api/openstack/zones.py
+++ b/nova/api/openstack/zones.py
@@ -1,4 +1,4 @@
-# Copyright 2010 OpenStack LLC.
+# Copyright 2011 OpenStack LLC.
 # All Rights Reserved.
 #
 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
@@ -20,6 +20,7 @@ from nova import flags
 from nova import wsgi
 from nova import db
 from nova import rpc
+from nova.scheduler.api import API
 
 
 FLAGS = flags.FLAGS
@@ -49,31 +50,14 @@ class Controller(wsgi.Controller):
             "attributes": {
                 "zone": ["id", "api_url", "name", "capabilities"]}}}
 
-    def _call_scheduler(self, method, context, params=None):
-        """Generic handler for RPC calls to the scheduler.
-
-        :param params: Optional dictionary of arguments to be passed to the
-                       scheduler worker
-
-        :retval: Result returned by scheduler worker
-        """
-        if not params:
-            params = {}
-        queue = FLAGS.scheduler_topic
-        kwargs = {'method': method, 'args': params}
-        return rpc.call(context, queue, kwargs)
-
     def index(self, req):
         """Return all zones in brief"""
-        # Ask the ZoneManager in the Scheduler for most recent data.
-        items = self._call_scheduler('get_zone_list',
-                          req.environ['nova.context'])
-        for item in items:
-            item['api_url'] = item['api_url'].replace('\\/', '/')
-
-        # Or fall-back to the database ...
-        if len(items) == 0:
+        # Ask the ZoneManager in the Scheduler for most recent data,
+        # or fall-back to the database ...
+        items = API().get_zone_list(req.environ['nova.context'])
+        if not items:
             items = db.zone_get_all(req.environ['nova.context'])
+
         items = common.limited(items, req)
         items = [_exclude_keys(item, ['username', 'password'])
                       for item in items]
diff --git a/nova/flags.py b/nova/flags.py
index 7e4919d6e..41f01fcd7 100644
--- a/nova/flags.py
+++ b/nova/flags.py
@@ -316,6 +316,5 @@ DEFINE_string('node_availability_zone', 'nova',
               'availability zone of this node')
 
 DEFINE_string('zone_name', 'nova', 'name of this zone')
-DEFINE_string('zone_capabilities', 'xen, linux',
-              'comma-delimited list of tags which represent boolean'
-              ' capabilities of this zone')
+DEFINE_string('zone_capabilities', 'kypervisor:xenserver;os:linux',
+              'Key/Value tags which represent capabilities of this zone')
diff --git a/nova/scheduler/api.py b/nova/scheduler/api.py
new file mode 100644
index 000000000..8491bf3a9
--- /dev/null
+++ b/nova/scheduler/api.py
@@ -0,0 +1,49 @@
+# Copyright (c) 2011 Openstack, LLC.
+# 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.
+
+"""
+Handles all requests relating to schedulers.
+"""
+
+from nova import flags
+from nova import log as logging
+from nova import rpc
+
+FLAGS = flags.FLAGS
+LOG = logging.getLogger('nova.scheduler.api')
+
+
+class API:
+    """API for interacting with the scheduler."""
+
+    def _call_scheduler(self, method, context, params=None):
+        """Generic handler for RPC calls to the scheduler.
+
+        :param params: Optional dictionary of arguments to be passed to the
+                       scheduler worker
+
+        :retval: Result returned by scheduler worker
+        """
+        if not params:
+            params = {}
+        queue = FLAGS.scheduler_topic
+        kwargs = {'method': method, 'args': params}
+        return rpc.call(context, queue, kwargs)
+
+    def get_zone_list(self, context):
+        items = self._call_scheduler('get_zone_list', context)
+        for item in items:
+            item['api_url'] = item['api_url'].replace('\\/', '/')
+        return items
diff --git a/nova/scheduler/zone_manager.py b/nova/scheduler/zone_manager.py
index 3e7c1eba8..783783d06 100644
--- a/nova/scheduler/zone_manager.py
+++ b/nova/scheduler/zone_manager.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2010 Openstack, LLC.
+# Copyright (c) 2011 Openstack, LLC.
 # All Rights Reserved.
 #
 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
@@ -87,8 +87,8 @@ class ZoneState(object):
 
 def _call_novatools(zone):
     """Call novatools. Broken out for testing purposes."""
-    os = novatools.OpenStack(zone.username, zone.password, zone.api_url)
-    return os.zones.info()._info
+    client = novatools.OpenStack(zone.username, zone.password, zone.api_url)
+    return client.zones.info()._info
 
 
 def _poll_zone(zone):
@@ -105,6 +105,7 @@ class ZoneManager(object):
     def __init__(self):
         self.last_zone_db_check = datetime.min
         self.zone_states = {}
+        self.green_pool = GreenPool()
 
     def get_zone_list(self):
         """Return the list of zones we know about."""
@@ -123,20 +124,20 @@ class ZoneManager(object):
             self.zone_states[zone.id].update_credentials(zone)
 
         # Cleanup zones removed from db ...
-        for zone_id in self.zone_states.keys():
+        keys = self.zone_states.keys()  # since we're deleting
+        for zone_id in keys:
             if zone_id not in db_keys:
                 del self.zone_states[zone_id]
 
     def _poll_zones(self, context):
         """Try to connect to each child zone and get update."""
-        green_pool = GreenPool()
-        green_pool.imap(_poll_zone, self.zone_states.values())
+        self.green_pool.imap(_poll_zone, self.zone_states.values())
 
     def ping(self, context=None):
         """Ping should be called periodically to update zone status."""
         diff = datetime.now() - self.last_zone_db_check
         if diff.seconds >= FLAGS.zone_db_check_interval:
-            logging.debug("Updating zone cache from db.")
+            logging.debug(_("Updating zone cache from db."))
             self.last_zone_db_check = datetime.now()
             self._refresh_from_db(context)
         self._poll_zones(context)
diff --git a/nova/tests/api/openstack/test_zones.py b/nova/tests/api/openstack/test_zones.py
index 65cc1c023..4df7c7feb 100644
--- a/nova/tests/api/openstack/test_zones.py
+++ b/nova/tests/api/openstack/test_zones.py
@@ -1,4 +1,4 @@
-# Copyright 2010 OpenStack LLC.
+# Copyright 2011 OpenStack LLC.
 # All Rights Reserved.
 #
 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
@@ -24,6 +24,7 @@ from nova import context
 from nova import flags
 from nova.api.openstack import zones
 from nova.tests.api.openstack import fakes
+from nova.scheduler.api import API
 
 
 FLAGS = flags.FLAGS
@@ -31,7 +32,7 @@ FLAGS.verbose = True
 
 
 def zone_get(context, zone_id):
-    return dict(id=1, api_url='http://foo.com', username='bob',
+    return dict(id=1, api_url='http://example.com', username='bob',
                 password='xxx')
 
 
@@ -42,7 +43,7 @@ def zone_create(context, values):
 
 
 def zone_update(context, zone_id, values):
-    zone = dict(id=zone_id, api_url='http://foo.com', username='bob',
+    zone = dict(id=zone_id, api_url='http://example.com', username='bob',
                 password='xxx')
     zone.update(values)
     return zone
@@ -52,24 +53,24 @@ def zone_delete(context, zone_id):
     pass
 
 
-def zone_get_all_scheduler(x, y, z):
+def zone_get_all_scheduler(*args):
     return [
-        dict(id=1, api_url='http://foo.com', username='bob',
+        dict(id=1, api_url='http://example.com', username='bob',
                  password='xxx'),
-        dict(id=2, api_url='http://blah.com', username='alice',
+        dict(id=2, api_url='http://example.org', username='alice',
                  password='qwerty')
     ]
 
 
-def zone_get_all_scheduler_empty(x, y, z):
+def zone_get_all_scheduler_empty(*args):
     return []
 
 
 def zone_get_all_db(context):
     return [
-        dict(id=1, api_url='http://foo.com', username='bob',
+        dict(id=1, api_url='http://example.com', username='bob',
                  password='xxx'),
-        dict(id=2, api_url='http://blah.com', username='alice',
+        dict(id=2, api_url='http://example.org', username='alice',
                  password='qwerty')
     ]
 
@@ -96,8 +97,7 @@ class ZonesTest(unittest.TestCase):
         FLAGS.allow_admin_api = self.allow_admin
 
     def test_get_zone_list_scheduler(self):
-        self.stubs.Set(zones.Controller, '_call_scheduler',
-                            zone_get_all_scheduler)
+        self.stubs.Set(API, '_call_scheduler', zone_get_all_scheduler)
         req = webob.Request.blank('/v1.0/zones')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
@@ -106,8 +106,7 @@ class ZonesTest(unittest.TestCase):
         self.assertEqual(len(res_dict['zones']), 2)
 
     def test_get_zone_list_db(self):
-        self.stubs.Set(zones.Controller, '_call_scheduler',
-            zone_get_all_scheduler_empty)
+        self.stubs.Set(API, '_call_scheduler', zone_get_all_scheduler_empty)
         self.stubs.Set(nova.db, 'zone_get_all', zone_get_all_db)
         req = webob.Request.blank('/v1.0/zones')
         res = req.get_response(fakes.wsgi_app())
@@ -122,7 +121,7 @@ class ZonesTest(unittest.TestCase):
         res_dict = json.loads(res.body)
 
         self.assertEqual(res_dict['zone']['id'], 1)
-        self.assertEqual(res_dict['zone']['api_url'], 'http://foo.com')
+        self.assertEqual(res_dict['zone']['api_url'], 'http://example.com')
         self.assertFalse('password' in res_dict['zone'])
         self.assertEqual(res.status_int, 200)
 
@@ -133,7 +132,7 @@ class ZonesTest(unittest.TestCase):
         self.assertEqual(res.status_int, 200)
 
     def test_zone_create(self):
-        body = dict(zone=dict(api_url='http://blah.zoo', username='fred',
+        body = dict(zone=dict(api_url='http://example.com', username='fred',
                         password='fubar'))
         req = webob.Request.blank('/v1.0/zones')
         req.method = 'POST'
@@ -144,7 +143,7 @@ class ZonesTest(unittest.TestCase):
 
         self.assertEqual(res.status_int, 200)
         self.assertEqual(res_dict['zone']['id'], 1)
-        self.assertEqual(res_dict['zone']['api_url'], 'http://blah.zoo')
+        self.assertEqual(res_dict['zone']['api_url'], 'http://example.com')
         self.assertFalse('username' in res_dict['zone'])
 
     def test_zone_update(self):
@@ -158,7 +157,7 @@ class ZonesTest(unittest.TestCase):
 
         self.assertEqual(res.status_int, 200)
         self.assertEqual(res_dict['zone']['id'], 1)
-        self.assertEqual(res_dict['zone']['api_url'], 'http://foo.com')
+        self.assertEqual(res_dict['zone']['api_url'], 'http://example.com')
         self.assertFalse('username' in res_dict['zone'])
 
 
-- 
cgit 


From cd533e160e9c98a0c14b4e0bc32a6e94c7ab8657 Mon Sep 17 00:00:00 2001
From: Nirmal Ranganathan <nirmal.ranganathan@rackspace.coom>
Date: Fri, 18 Feb 2011 11:44:38 -0600
Subject: Added Author and tests

---
 nova/tests/test_compute.py | 9 +++++++++
 1 file changed, 9 insertions(+)

(limited to 'nova')

diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index b049ac943..e338a7cfa 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -30,6 +30,7 @@ from nova import log as logging
 from nova import test
 from nova import utils
 from nova.auth import manager
+from nova.compute import instance_types
 
 
 LOG = logging.getLogger('nova.tests.compute')
@@ -266,3 +267,11 @@ class ComputeTestCase(test.TestCase):
         self.assertEqual(ret_val, None)
 
         self.compute.terminate_instance(self.context, instance_id)
+
+    def test_get_by_flavor_id(self):
+        type = instance_types.get_by_flavor_id(1)
+        self.assertEqual(type, 'm1.tiny')
+
+        type = instance_types.get_by_flavor_id("1")
+        self.assertEqual(type, 'm1.tiny')
+
-- 
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/tests/test_xenapi.py  | 34 ++++++++++++++++++++++++++++++++++
 nova/tests/xenapi/stubs.py | 25 +++++++++++++++++++++++--
 nova/virt/xenapi/fake.py   |  2 +-
 3 files changed, 58 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index 6b8efc9d8..ee4c68e6c 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -336,3 +336,37 @@ class XenAPIDiffieHellmanTestCase(test.TestCase):
 
     def tearDown(self):
         super(XenAPIDiffieHellmanTestCase, self).tearDown()
+
+class XenAPIMigrateInstance(test.TestCase):
+    """
+    Unit test for verifying migration-related actions
+    """
+    def setUp(self):
+        super(XenAPIMigrateInstance, self).setUp()
+        self.stubs = stubout.StubOutForTesting()
+        FLAGS.target_host = '127.0.0.1'
+        FLAGS.xenapi_connection_url = 'test_url'
+        FLAGS.xenapi_connection_password = 'test_pass'
+        db_fakes.stub_out_db_instance_api(self.stubs)
+        stubs.stub_out_get_target(self.stubs)
+        xenapi_fake.reset()
+        self.values = {'name': 1, 'id': 1,
+                  'project_id': 'fake',
+                  'user_id': 'fake',
+                  'image_id': 1,
+                  'kernel_id': 2,
+                  'ramdisk_id': 3,
+                  'instance_type': 'm1.large',
+                  'mac_address': 'aa:bb:cc:dd:ee:ff',
+                  }
+        stubs.stub_out_migration_methods(self.stubs)
+
+    def test_migrate_disk_and_power_off(self):
+        FLAGS.target_host = '127.0.0.1'
+        FLAGS.xenapi_connection_url = 'test_url'
+        FLAGS.xenapi_connection_password = 'test_pass'   
+        destination = '127.0.0.1'
+        instance = db.instance_create(self.values)
+        stubs.stubout_session(self.stubs, stubs.FakeSessionForMigrationTests)
+        conn = xenapi_conn.get_connection(False)
+        conn.migrate_disk_and_power_off(instance, destination)
diff --git a/nova/tests/xenapi/stubs.py b/nova/tests/xenapi/stubs.py
index 624995ada..d1c367475 100644
--- a/nova/tests/xenapi/stubs.py
+++ b/nova/tests/xenapi/stubs.py
@@ -20,6 +20,7 @@ from nova.virt import xenapi_conn
 from nova.virt.xenapi import fake
 from nova.virt.xenapi import volume_utils
 from nova.virt.xenapi import vm_utils
+from nova.virt.xenapi import vmops
 
 
 def stubout_instance_snapshot(stubs):
@@ -170,8 +171,8 @@ class FakeSessionForVMTests(fake.SessionBase):
 
     def VM_destroy(self, session_ref, vm_ref):
         fake.destroy_vm(vm_ref)
-
-
+    
+    
 class FakeSessionForVolumeTests(fake.SessionBase):
     """ Stubs out a XenAPISession for Volume tests """
     def __init__(self, uri):
@@ -205,3 +206,23 @@ class FakeSessionForVolumeFailedTests(FakeSessionForVolumeTests):
 
     def SR_forget(self, _1, ref):
         pass
+
+class FakeSessionForMigrationTests(fake.SessionBase):
+    """ Stubs out a XenAPISession for Migration tests """
+    def __init__(self, uri):
+        super(FakeSessionForMigrationTests, self).__init__(uri)
+
+
+class FakeSnapshot(vmops.VMOps):
+    def __getattr__(self, key):
+        return 'fake'
+
+    def __exit__(self, type, value, traceback)
+        pass
+
+def fake_get_snapshot(self, instance):
+     return FakeSnapshot()
+
+def stub_out_migration_methods(stubs):
+    stubs.Set(vmops.VMOps, '_get_snapshot', 
+            fake_get_snapshot)
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 <soren@linux2go.dk>
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/network/linux_net.py  | 287 ++++++++++++++++++++++++++++-----------------
 nova/tests/test_network.py |  59 ++++++++++
 nova/utils.py              |  61 ++++++----
 nova/virt/libvirt_conn.py  |  28 +++--
 4 files changed, 287 insertions(+), 148 deletions(-)

(limited to 'nova')

diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index c1cbff7d8..3d267d941 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -17,6 +17,7 @@
 Implements vlans, bridges, and iptables rules using linux utilities.
 """
 
+import inspect
 import os
 
 from nova import db
@@ -25,7 +26,6 @@ from nova import flags
 from nova import log as logging
 from nova import utils
 
-
 LOG = logging.getLogger("nova.linux_net")
 
 
@@ -63,73 +63,168 @@ flags.DEFINE_string('dmz_cidr', '10.128.0.0/24',
                     'dmz range that should be accepted')
 
 
+binary_name = os.path.basename(inspect.stack()[-1][1])
+
+
+class IptablesRule(object):
+    def __init__(self, chain, rule, wrap=True):
+        self.chain = chain
+        self.rule = rule
+        self.wrap = wrap
+
+    def __eq__(self, other):
+        return ((self.chain == other.chain) and
+                (self.rule == other.rule) and
+                (self.wrap == other.wrap))
+
+    def __ne__(self, other):
+        return ((self.chain != other.chain) or
+                (self.rule != other.rule) or
+                (self.wrap != other.wrap))
+
+    def __str__(self):
+        if self.wrap:
+            chain = '%s-%s' % (binary_name, self.chain)
+        else:
+            chain = self.chain
+        return '-A %s %s' % (chain, self.rule)
+
+
+class IptablesTable(object):
+    def __init__(self):
+        self.rules = []
+        self.chains = set()
+
+    def add_chain(self, name):
+        self.chains.add(name)
+
+    def remove_chain(self, name):
+        self.chains.remove(name)
+
+    def add_rule(self, chain, rule, wrap=True):
+        if wrap and chain not in self.chains:
+            raise ValueError(_("Unknown chain: %r") % chain)
+
+        self.rules.append(IptablesRule(chain, rule, wrap))
+
+    def remove_rule(self, chain, rule):
+        self.rules.remove(IptablesRule(chain, rule))
+
+class IptablesManager(object):
+    def __init__(self, execute=None):
+        if not execute:
+            if FLAGS.fake_network:
+                self.execute = lambda *args, **kwargs: ('', '')
+            else:
+                self.execute = utils.execute
+        else:
+            self.execute = execute
+
+        self.ipv4 = { 'filter': IptablesTable(),
+                      'nat': IptablesTable() }
+        self.ipv6 = { 'filter': IptablesTable(),
+                      'nat': IptablesTable() }
+
+        self.ipv4['nat'].add_chain('SNATTING')
+        self.ipv4['nat'].add_rule('POSTROUTING',
+                                  '-j %s-SNATTING' % (binary_name,),
+                                  wrap=False)
+
+        self.ipv4['filter'].add_chain('local')
+        self.ipv4['filter'].add_rule('FORWARD',
+                                    '-j %s-local' % (binary_name,),
+                                    wrap=False)
+
+        # Wrap the builtin chains
+        builtin_chains = {'filter': ['INPUT', 'OUTPUT', 'FORWARD'],
+                          'nat': ['PREROUTING', 'INPUT',
+                                  'OUTPUT', 'POSTROUTING']}
+
+        for table, chains in builtin_chains.iteritems():
+            for chain in chains:
+                self.ipv4[table].add_chain(chain)
+                self.ipv4[table].add_rule(chain,
+                                          '-j %s-%s' % (binary_name, chain),
+                                          wrap=False)
+
+
+    def apply(self):
+        s = [('iptables', self.ipv4)]
+        if FLAGS.use_ipv6:
+            s += [('ip6tables', self.ipv6)]
+
+        for cmd, tables in s:
+            for table in tables:
+                current_filter, _ = self.execute('sudo %s-save -t %s' %
+                                                 (cmd, table), attempts=5)
+                current_lines = current_filter.split('\n')
+                new_filter = self.modify_rules(current_lines, tables[table])
+                self.execute('sudo %s-restore' % (cmd,),
+                             process_input='\n'.join(new_filter),
+                             attempts=5)
+
+    def modify_rules(self, current_lines, table, binary=None):
+
+        chains = table.chains
+        rules = table.rules
+
+        # Remove any trace of our rules
+        new_filter = filter(lambda l: '%s' % binary 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
+
+        new_filter[rules_index:rules_index] = [str(rule) for rule in rules]
+        new_filter[rules_index:rules_index] = [':%s-%s - [0:0]' % \
+                                               (binary_name, name,) \
+                                               for name in chains]
+
+        return new_filter
+
+
+iptables_manager = IptablesManager()
+
+
 def metadata_forward():
     """Create forwarding rule for metadata"""
-    _confirm_rule("PREROUTING", "-t nat -s 0.0.0.0/0 "
-             "-d 169.254.169.254/32 -p tcp -m tcp --dport 80 -j DNAT "
-             "--to-destination %s:%s" % (FLAGS.ec2_dmz_host, FLAGS.ec2_port))
+    iptables_manager.ipv4['nat'].add_rule("PREROUTING",
+                                          "-s 0.0.0.0/0 -d 169.254.169.254/32 "
+                                          "-p tcp -m tcp --dport 80 -j DNAT "
+                                          "--to-destination %s:%s" % \
+                                          (FLAGS.ec2_dmz_host, FLAGS.ec2_port))
+    iptables_manager.apply()
 
 
 def init_host():
     """Basic networking setup goes here"""
 
-    if FLAGS.use_nova_chains:
-        _execute("sudo iptables -N nova_input", check_exit_code=False)
-        _execute("sudo iptables -D %s -j nova_input" % FLAGS.input_chain,
-                 check_exit_code=False)
-        _execute("sudo iptables -A %s -j nova_input" % FLAGS.input_chain)
-
-        _execute("sudo iptables -N nova_forward", check_exit_code=False)
-        _execute("sudo iptables -D FORWARD -j nova_forward",
-                 check_exit_code=False)
-        _execute("sudo iptables -A FORWARD -j nova_forward")
-
-        _execute("sudo iptables -N nova_output", check_exit_code=False)
-        _execute("sudo iptables -D OUTPUT -j nova_output",
-                 check_exit_code=False)
-        _execute("sudo iptables -A OUTPUT -j nova_output")
-
-        _execute("sudo iptables -t nat -N nova_prerouting",
-                 check_exit_code=False)
-        _execute("sudo iptables -t nat -D PREROUTING -j nova_prerouting",
-                 check_exit_code=False)
-        _execute("sudo iptables -t nat -A PREROUTING -j nova_prerouting")
-
-        _execute("sudo iptables -t nat -N nova_postrouting",
-                 check_exit_code=False)
-        _execute("sudo iptables -t nat -D POSTROUTING -j nova_postrouting",
-                 check_exit_code=False)
-        _execute("sudo iptables -t nat -A POSTROUTING -j nova_postrouting")
-
-        _execute("sudo iptables -t nat -N nova_snatting",
-                 check_exit_code=False)
-        _execute("sudo iptables -t nat -D POSTROUTING -j nova_snatting",
-                 check_exit_code=False)
-        _execute("sudo iptables -t nat -A POSTROUTING -j nova_snatting")
-
-        _execute("sudo iptables -t nat -N nova_output", check_exit_code=False)
-        _execute("sudo iptables -t nat -D OUTPUT -j nova_output",
-                 check_exit_code=False)
-        _execute("sudo iptables -t nat -A OUTPUT -j nova_output")
-    else:
-        # NOTE(vish): This makes it easy to ensure snatting rules always
-        #             come after the accept rules in the postrouting chain
-        _execute("sudo iptables -t nat -N SNATTING",
-                 check_exit_code=False)
-        _execute("sudo iptables -t nat -D POSTROUTING -j SNATTING",
-                 check_exit_code=False)
-        _execute("sudo iptables -t nat -A POSTROUTING -j SNATTING")
-
     # NOTE(devcamcar): Cloud public SNAT entries and the default
     # SNAT rule for outbound traffic.
-    _confirm_rule("SNATTING", "-t nat -s %s "
-             "-j SNAT --to-source %s"
-             % (FLAGS.fixed_range, FLAGS.routing_source_ip), append=True)
+    iptables_manager.ipv4['nat'].add_rule("SNATTING",
+                                          "-s %s -j SNAT --to-source %s" % \
+                                           (FLAGS.fixed_range,
+                                            FLAGS.routing_source_ip))
+
+    iptables_manager.ipv4['nat'].add_rule("POSTROUTING",
+                                          "-s %s -j SNAT --to-source %s" % \
+                                           (FLAGS.fixed_range,
+                                            FLAGS.routing_source_ip))
 
-    _confirm_rule("POSTROUTING", "-t nat -s %s -d %s -j ACCEPT" %
-                  (FLAGS.fixed_range, FLAGS.dmz_cidr))
-    _confirm_rule("POSTROUTING", "-t nat -s %(range)s -d %(range)s -j ACCEPT" %
-                  {'range': FLAGS.fixed_range})
+    iptables_manager.ipv4['nat'].add_rule("POSTROUTING",
+                                          "-s %s -d %s -j ACCEPT" % \
+                                          (FLAGS.fixed_range, FLAGS.dmz_cidr))
+
+    iptables_manager.ipv4['nat'].add_rule("POSTROUTING",
+                                          "-s %(range)s -d %(range)s "
+                                          "-j ACCEPT" % \
+                                          {'range': FLAGS.fixed_range})
+    iptables_manager.apply()
 
 
 def bind_floating_ip(floating_ip, check_exit_code=True):
@@ -147,32 +242,33 @@ def unbind_floating_ip(floating_ip):
 
 def ensure_vlan_forward(public_ip, port, private_ip):
     """Sets up forwarding rules for vlan"""
-    _confirm_rule("FORWARD", "-d %s -p udp --dport 1194 -j ACCEPT" %
-                  private_ip)
-    _confirm_rule("PREROUTING",
-                  "-t nat -d %s -p udp --dport %s -j DNAT --to %s:1194"
-            % (public_ip, port, private_ip))
+    iptables_manager.ipv4['filter'].add_rule("FORWARD",
+                                             "-d %s -p udp "
+                                             "--dport 1194 "
+                                             "-j ACCEPT" % private_ip)
+    iptables_manager.ipv4['nat'].add_rule("PREROUTING",
+                                          "-d %s -p udp "
+                                          "--dport %s -j DNAT --to %s:1194" %
+                                          (public_ip, port, private_ip))
+    iptables_manager.apply()
 
 
 def ensure_floating_forward(floating_ip, fixed_ip):
     """Ensure floating ip forwarding rule"""
-    _confirm_rule("PREROUTING", "-t nat -d %s -j DNAT --to %s"
-                           % (floating_ip, fixed_ip))
-    _confirm_rule("OUTPUT", "-t nat -d %s -j DNAT --to %s"
-                           % (floating_ip, fixed_ip))
-    _confirm_rule("SNATTING", "-t nat -s %s -j SNAT --to %s"
-                           % (fixed_ip, floating_ip))
-
+    for chain, rule in floating_forward_rules(floating_ip, fixed_ip):
+        iptables_manager.ipv4['nat'].add_rule(chain, rule)
+    iptables_manager.apply()
 
 def remove_floating_forward(floating_ip, fixed_ip):
     """Remove forwarding for floating ip"""
-    _remove_rule("PREROUTING", "-t nat -d %s -j DNAT --to %s"
-                          % (floating_ip, fixed_ip))
-    _remove_rule("OUTPUT", "-t nat -d %s -j DNAT --to %s"
-                          % (floating_ip, fixed_ip))
-    _remove_rule("SNATTING", "-t nat -s %s -j SNAT --to %s"
-                          % (fixed_ip, floating_ip))
+    for chain, rule in floating_forward_rules(floating_ip, fixed_ip):
+        iptables_manager.ipv4['nat'].remove_rule(chain, rule)
+    iptables_manager.apply()
 
+def floating_forward_rules(floating_ip, fixed_ip):
+    return [("PREROUTING", "-d %s -j DNAT --to %s" % (floating_ip, fixed_ip)),
+            ("OUTPUT", "-d %s -j DNAT --to %s" % (floating_ip, fixed_ip)),
+            ("SNATTING", "-d %s -j DNAT --to %s" % (fixed_ip, floating_ip))]
 
 def ensure_vlan_bridge(vlan_num, bridge, net_attrs=None):
     """Create a vlan and bridge unless they already exist"""
@@ -258,19 +354,12 @@ def ensure_bridge(bridge, interface, net_attrs=None):
                            "enslave it to bridge %s.\n" % (interface, bridge)):
             raise exception.Error("Failed to add interface: %s" % err)
 
-    if FLAGS.use_nova_chains:
-        (out, err) = _execute("sudo iptables -N nova_forward",
-                              check_exit_code=False)
-        if err != 'iptables: Chain already exists.\n':
-            # NOTE(vish): chain didn't exist link chain
-            _execute("sudo iptables -D FORWARD -j nova_forward",
-                     check_exit_code=False)
-            _execute("sudo iptables -A FORWARD -j nova_forward")
-
-    _confirm_rule("FORWARD", "--in-interface %s -j ACCEPT" % bridge)
-    _confirm_rule("FORWARD", "--out-interface %s -j ACCEPT" % bridge)
-    _execute("sudo iptables -N nova-local", check_exit_code=False)
-    _confirm_rule("FORWARD", "-j nova-local")
+    iptables_manager.ipv4['filter'].add_rule("FORWARD",
+                                             "--in-interface %s -j ACCEPT" % \
+                                             bridge)
+    iptables_manager.ipv4['filter'].add_rule("FORWARD",
+                                             "--out-interface %s -j ACCEPT" % \
+                                             bridge)
 
 
 def get_dhcp_hosts(context, network_id):
@@ -390,26 +479,6 @@ def _device_exists(device):
     return not err
 
 
-def _confirm_rule(chain, cmd, append=False):
-    """Delete and re-add iptables rule"""
-    if FLAGS.use_nova_chains:
-        chain = "nova_%s" % chain.lower()
-    if append:
-        loc = "-A"
-    else:
-        loc = "-I"
-    _execute("sudo iptables --delete %s %s" % (chain, cmd),
-             check_exit_code=False)
-    _execute("sudo iptables %s %s %s" % (loc, chain, cmd))
-
-
-def _remove_rule(chain, cmd):
-    """Remove iptables rule"""
-    if FLAGS.use_nova_chains:
-        chain = "%s" % chain.lower()
-    _execute("sudo iptables --delete %s %s" % (chain, cmd))
-
-
 def _dnsmasq_cmd(net):
     """Builds dnsmasq command"""
     cmd = ['sudo -E dnsmasq',
diff --git a/nova/tests/test_network.py b/nova/tests/test_network.py
index 00f9323f3..b28d64245 100644
--- a/nova/tests/test_network.py
+++ b/nova/tests/test_network.py
@@ -29,11 +29,70 @@ from nova import log as logging
 from nova import test
 from nova import utils
 from nova.auth import manager
+from nova.network import linux_net
 
 FLAGS = flags.FLAGS
 LOG = logging.getLogger('nova.tests.network')
 
 
+class IptablesManagerTestCase(test.TestCase):
+    sample_filter = """# Completed on Fri Feb 18 15:17:05 2011
+# Generated by iptables-save v1.4.10 on Fri Feb 18 15:17:05 2011
+*filter
+:INPUT ACCEPT [2223527:305688874]
+:FORWARD ACCEPT [0:0]
+:OUTPUT ACCEPT [2172501:140856656]
+-A INPUT -i virbr0 -p udp -m udp --dport 53 -j ACCEPT 
+-A INPUT -i virbr0 -p tcp -m tcp --dport 53 -j ACCEPT 
+-A INPUT -i virbr0 -p udp -m udp --dport 67 -j ACCEPT 
+-A INPUT -i virbr0 -p tcp -m tcp --dport 67 -j ACCEPT 
+-A FORWARD -d 192.168.122.0/24 -o virbr0 -m state --state RELATED,ESTABLISHED -j ACCEPT 
+-A FORWARD -s 192.168.122.0/24 -i virbr0 -j ACCEPT 
+-A FORWARD -i virbr0 -o virbr0 -j ACCEPT 
+-A FORWARD -o virbr0 -j REJECT --reject-with icmp-port-unreachable 
+-A FORWARD -i virbr0 -j REJECT --reject-with icmp-port-unreachable 
+COMMIT
+# Completed on Fri Feb 18 15:17:05 2011"""
+
+    def setUp(self):
+        super(IptablesManagerTestCase, self).setUp()
+        self.manager = linux_net.IptablesManager()
+
+    def test_rules_are_wrapped(self):
+        current_lines = self.sample_filter.split('\n')
+
+        table = self.manager.ipv4['filter']
+        table.add_rule('FORWARD', '-s 1.2.3.4/5 -j DROP')
+        new_lines = self.manager.modify_rules(current_lines, table)
+        self.assertTrue('-A run_tests.py-FORWARD '
+                        '-s 1.2.3.4/5 -j DROP' in new_lines)
+
+        table.remove_rule('FORWARD', '-s 1.2.3.4/5 -j DROP')
+        new_lines = self.manager.modify_rules(current_lines, table)
+        self.assertTrue('-A run_tests.py-FORWARD '
+                        '-s 1.2.3.4/5 -j DROP' not in new_lines)
+
+    def test_wrapper_rules_in_place(self):
+        current_lines = self.sample_filter.split('\n')
+
+        # TODO(soren): Add stuff for ipv6
+        check_matrix = {4: {'filter': ['INPUT', 'OUTPUT', 'FORWARD'],
+                            'nat': ['PREROUTING', 'INPUT',
+                                    'OUTPUT', 'POSTROUTING']} }
+
+        for ip_version in check_matrix:
+            ip = getattr(self.manager, 'ipv%d' % ip_version)
+            for table_name in ip:
+                table = ip[table_name]
+                new_lines = self.manager.modify_rules(current_lines, table)
+                for chain in check_matrix[ip_version][table_name]:
+                    self.assertTrue(':run_tests.py-%s - [0:0]' % \
+                                    (chain,) in new_lines)
+                    self.assertTrue('-A %s -j run_tests.py-%s' % \
+                                    (chain, chain) in new_lines)
+                print '\n'.join(new_lines)
+
+
 class NetworkTestCase(test.TestCase):
     """Test cases for network code"""
     def setUp(self):
diff --git a/nova/utils.py b/nova/utils.py
index ba71ebf39..bf3a4b098 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -124,32 +124,41 @@ def fetchfile(url, target):
     execute("curl --fail %s -o %s" % (url, target))
 
 
-def execute(cmd, process_input=None, addl_env=None, check_exit_code=True):
-    LOG.debug(_("Running cmd (subprocess): %s"), cmd)
-    env = os.environ.copy()
-    if addl_env:
-        env.update(addl_env)
-    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:
-        LOG.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)
-    # NOTE(termie): this appears to be necessary to let the subprocess call
-    #               clean something up in between calls, without it two
-    #               execute calls in a row hangs the second one
-    greenthread.sleep(0)
-    return result
+def execute(cmd, process_input=None, addl_env=None, check_exit_code=True, attempts=1):
+    while attempts > 0:
+        attempts -= 1
+        try:
+            LOG.debug(_("Running cmd (subprocess): %s"), cmd)
+            env = os.environ.copy()
+            if addl_env:
+                env.update(addl_env)
+            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:
+                LOG.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)
+            # NOTE(termie): this appears to be necessary to let the subprocess call
+            #               clean something up in between calls, without it two
+            #               execute calls in a row hangs the second one
+            greenthread.sleep(0)
+            return result
+        except ProcessExecutionError:
+            if not attempts:
+                raise
+            else:
+                greenthread.sleep(random.randint(50,300)/100)
+                pass
 
 
 def ssh_execute(ssh, cmd, process_input=None,
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/tests/test_xenapi.py  | 12 +++++++-----
 nova/tests/xenapi/stubs.py | 38 +++++++++++++++++++++++++++++---------
 nova/virt/xenapi/fake.py   |  3 +++
 3 files changed, 39 insertions(+), 14 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index ee4c68e6c..3cbc01e5c 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -362,11 +362,13 @@ class XenAPIMigrateInstance(test.TestCase):
         stubs.stub_out_migration_methods(self.stubs)
 
     def test_migrate_disk_and_power_off(self):
-        FLAGS.target_host = '127.0.0.1'
-        FLAGS.xenapi_connection_url = 'test_url'
-        FLAGS.xenapi_connection_password = 'test_pass'   
-        destination = '127.0.0.1'
         instance = db.instance_create(self.values)
         stubs.stubout_session(self.stubs, stubs.FakeSessionForMigrationTests)
         conn = xenapi_conn.get_connection(False)
-        conn.migrate_disk_and_power_off(instance, destination)
+        conn.migrate_disk_and_power_off(instance, '127.0.0.1')
+
+    def test_attach_disk(self):
+        instance = db.instance_create(self.values)
+        stubs.stubout_session(self.stubs, stubs.FakeSessionForMigrationTests)
+        conn = xenapi_conn.get_connection(False)
+        conn.attach_disk(instance, {'base_copy': 'hurr', 'cow': 'durr'})
diff --git a/nova/tests/xenapi/stubs.py b/nova/tests/xenapi/stubs.py
index d1c367475..054fc434b 100644
--- a/nova/tests/xenapi/stubs.py
+++ b/nova/tests/xenapi/stubs.py
@@ -213,16 +213,36 @@ class FakeSessionForMigrationTests(fake.SessionBase):
         super(FakeSessionForMigrationTests, self).__init__(uri)
 
 
-class FakeSnapshot(vmops.VMOps):
-    def __getattr__(self, key):
-        return 'fake'
+def stub_out_migration_methods(stubs):
+    class FakeSnapshot(object):
+        def __getattr__(self, key):
+            return str(key)
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, type, value, traceback):
+            pass
+
+    def fake_get_snapshot(self, instance):
+        return FakeSnapshot()
 
-    def __exit__(self, type, value, traceback)
+    @classmethod
+    def fake_get_vdi(cls, session, vm_ref):
+        vdi_ref = fake.create_vdi(name_label='derp', read_only=False,
+                             sr_ref='herp', sharable=False)
+        vdi_rec = session.get_xenapi().VDI.get_record(vdi_ref)
+        return vdi_ref, {'uuid': vdi_rec['uuid']}
+    
+    def fake_shutdown(self, inst, vm, method='clean'):
         pass
 
-def fake_get_snapshot(self, instance):
-     return FakeSnapshot()
+    @classmethod
+    def fake_scan_sr(cls, session):
+        pass
 
-def stub_out_migration_methods(stubs):
-    stubs.Set(vmops.VMOps, '_get_snapshot', 
-            fake_get_snapshot)
+    stubs.Set(vm_utils.VMHelper, 'scan_sr', fake_scan_sr)
+    stubs.Set(vmops.VMOps, '_get_snapshot', fake_get_snapshot)
+    stubs.Set(vm_utils.VMHelper, 'get_vdi_for_vm_safely', fake_get_vdi)
+    stubs.Set(xenapi_conn.XenAPISession, 'wait_for_task', lambda x,y,z: None)
+    stubs.Set(vmops.VMOps, '_shutdown', fake_shutdown)
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 <rick.harris@rackspace.com>
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')

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 18e573a14414838f11e772edca3eb5510f852c94 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Fri, 18 Feb 2011 17:45:57 -0400
Subject: sandy y u no read hacking guide and import classes?

---
 nova/api/openstack/zones.py            | 5 ++---
 nova/scheduler/manager.py              | 4 ++--
 nova/scheduler/zone_manager.py         | 4 ++--
 nova/tests/api/openstack/test_zones.py | 7 ++++---
 4 files changed, 10 insertions(+), 10 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/zones.py b/nova/api/openstack/zones.py
index 24a4444f7..99be0ba02 100644
--- a/nova/api/openstack/zones.py
+++ b/nova/api/openstack/zones.py
@@ -19,8 +19,7 @@ import logging
 from nova import flags
 from nova import wsgi
 from nova import db
-from nova import rpc
-from nova.scheduler.api import API
+from nova.scheduler import api
 
 
 FLAGS = flags.FLAGS
@@ -54,7 +53,7 @@ class Controller(wsgi.Controller):
         """Return all zones in brief"""
         # Ask the ZoneManager in the Scheduler for most recent data,
         # or fall-back to the database ...
-        items = API().get_zone_list(req.environ['nova.context'])
+        items = api.API().get_zone_list(req.environ['nova.context'])
         if not items:
             items = db.zone_get_all(req.environ['nova.context'])
 
diff --git a/nova/scheduler/manager.py b/nova/scheduler/manager.py
index 7ced33b9c..c94397210 100644
--- a/nova/scheduler/manager.py
+++ b/nova/scheduler/manager.py
@@ -29,7 +29,7 @@ from nova import log as logging
 from nova import manager
 from nova import rpc
 from nova import utils
-from nova.scheduler.zone_manager import ZoneManager
+from nova.scheduler import zone_manager
 
 LOG = logging.getLogger('nova.scheduler.manager')
 FLAGS = flags.FLAGS
@@ -44,7 +44,7 @@ class SchedulerManager(manager.Manager):
         if not scheduler_driver:
             scheduler_driver = FLAGS.scheduler_driver
         self.driver = utils.import_object(scheduler_driver)
-        self.zone_manager = ZoneManager()
+        self.zone_manager = zone_manager.ZoneManager()
         super(SchedulerManager, self).__init__(*args, **kwargs)
 
     def __getattr__(self, key):
diff --git a/nova/scheduler/zone_manager.py b/nova/scheduler/zone_manager.py
index 783783d06..758c5e3db 100644
--- a/nova/scheduler/zone_manager.py
+++ b/nova/scheduler/zone_manager.py
@@ -22,7 +22,7 @@ import thread
 import traceback
 
 from datetime import datetime
-from eventlet.greenpool import GreenPool
+from eventlet import greenpool
 
 from nova import db
 from nova import flags
@@ -105,7 +105,7 @@ class ZoneManager(object):
     def __init__(self):
         self.last_zone_db_check = datetime.min
         self.zone_states = {}
-        self.green_pool = GreenPool()
+        self.green_pool = greenpool.GreenPool()
 
     def get_zone_list(self):
         """Return the list of zones we know about."""
diff --git a/nova/tests/api/openstack/test_zones.py b/nova/tests/api/openstack/test_zones.py
index 4df7c7feb..4374cd457 100644
--- a/nova/tests/api/openstack/test_zones.py
+++ b/nova/tests/api/openstack/test_zones.py
@@ -24,7 +24,7 @@ from nova import context
 from nova import flags
 from nova.api.openstack import zones
 from nova.tests.api.openstack import fakes
-from nova.scheduler.api import API
+from nova.scheduler import api
 
 
 FLAGS = flags.FLAGS
@@ -97,7 +97,7 @@ class ZonesTest(unittest.TestCase):
         FLAGS.allow_admin_api = self.allow_admin
 
     def test_get_zone_list_scheduler(self):
-        self.stubs.Set(API, '_call_scheduler', zone_get_all_scheduler)
+        self.stubs.Set(api.API, '_call_scheduler', zone_get_all_scheduler)
         req = webob.Request.blank('/v1.0/zones')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
@@ -106,7 +106,8 @@ class ZonesTest(unittest.TestCase):
         self.assertEqual(len(res_dict['zones']), 2)
 
     def test_get_zone_list_db(self):
-        self.stubs.Set(API, '_call_scheduler', zone_get_all_scheduler_empty)
+        self.stubs.Set(api.API, '_call_scheduler',
+                                zone_get_all_scheduler_empty)
         self.stubs.Set(nova.db, 'zone_get_all', zone_get_all_db)
         req = webob.Request.blank('/v1.0/zones')
         res = req.get_response(fakes.wsgi_app())
-- 
cgit 


From a43c5929de7ebf58eb9ecb8416ce3cf4194c176a Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Fri, 18 Feb 2011 16:13:34 -0600
Subject: Pep8 cleanup

---
 nova/api/openstack/servers.py                      | 13 ++--
 nova/compute/api.py                                | 12 ++-
 nova/compute/manager.py                            | 85 +++++++++++-----------
 nova/db/api.py                                     |  5 +-
 nova/db/sqlalchemy/api.py                          |  6 +-
 .../versions/004_add_instance_migrations.py        |  3 +-
 nova/db/sqlalchemy/models.py                       |  5 +-
 nova/tests/api/openstack/common.py                 |  7 +-
 nova/tests/api/openstack/test_servers.py           | 24 +++---
 nova/tests/test_compute.py                         |  6 +-
 nova/tests/test_xenapi.py                          |  1 +
 nova/tests/xenapi/stubs.py                         | 11 +--
 nova/virt/xenapi/vm_utils.py                       | 13 ++--
 nova/virt/xenapi/vmops.py                          |  5 +-
 nova/virt/xenapi_conn.py                           |  6 +-
 15 files changed, 104 insertions(+), 98 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index a719f5e15..f68c97323 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -209,12 +209,12 @@ class Controller(wsgi.Controller):
         resize a server """
 
         actions = {
-            'reboot':self._action_reboot,
-            'resize':self._action_resize,
-            'confirmResize':self._action_confirm_resize,
-            'revertResize':self._action_revert_resize,
-            'rebuild':self._action_rebuild
-        }
+            'reboot':        self._action_reboot,
+            'resize':        self._action_resize,
+            'confirmResize': self._action_confirm_resize,
+            'revertResize':  self._action_revert_resize,
+            'rebuild':       self._action_rebuild,
+            }
 
         input_dict = self._deserialize(req.body, req)
         for key in actions.keys():
@@ -256,7 +256,6 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPBadRequest())
         return faults.Fault(exc.HTTPAccepted())
 
-
     def _action_reboot(self, input_dict, req, id):
         try:
             reboot_type = input_dict['reboot']['type']
diff --git a/nova/compute/api.py b/nova/compute/api.py
index 371cbae5f..2eb0e0743 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -408,7 +408,7 @@ class API(base.Base):
             raise exception.Error(_("No finished migrations found for \
                     instance"))
 
-        params = { 'migration_id': migration_ref['id'] }
+        params = {'migration_id': migration_ref['id']}
         self._cast_compute_message('revert_resize', context, instance_id,
                 migration_ref['dest_compute'], params=params)
 
@@ -422,14 +422,12 @@ class API(base.Base):
             raise exception.Error(_("No finished migrations found for \
                     instance"))
         instance_ref = self.db.instance_get(context, instance_id)
-        
-        params = { 'migration_id': migration_ref['id'] }
+        params = {'migration_id': migration_ref['id']}
         self._cast_compute_message('confirm_resize', context, instance_id,
                 migration_ref['source_compute'], params=params)
 
-        self.db.migration_update(context, migration_id, 
-                { 'status': 'confirmed' })
-
+        self.db.migration_update(context, migration_id,
+                {'status': 'confirmed'})
         self.db.instance_update(context, instance_id,
                 {'host': migration_ref['dest_compute'], })
 
@@ -439,7 +437,7 @@ class API(base.Base):
                     {"method": "prep_resize",
                      "args": {"topic": FLAGS.compute_topic,
                               "instance_id": instance_id, }},)
-        
+
     def pause(self, context, instance_id):
         """Pause the given instance."""
         self._cast_compute_message('pause_instance', context, instance_id)
diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 1e1c44663..3f6c359ba 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -379,7 +379,7 @@ class ComputeManager(manager.Manager):
     def _update_state_callback(self, context, instance_id, result):
         """Update instance state when async task completes."""
         self._update_state(context, instance_id)
-     
+
     @exception.wrap_exception
     @checks_instance_lock
     def confirm_resize(self, context, instance_id, migration_id):
@@ -392,8 +392,8 @@ class ComputeManager(manager.Manager):
     @exception.wrap_exception
     @checks_instance_lock
     def revert_resize(self, context, instance_id, migration_id):
-        """Destroys the new instance on the destination machine, 
-        reverts the model changes, and powers on the old 
+        """Destroys the new instance on the destination machine,
+        reverts the model changes, and powers on the old
         instance on the source machine"""
         instance_ref = self.db.instance_get(context, instance_id)
         migration_ref = self.db.migration_get(context, migration_id)
@@ -401,24 +401,23 @@ class ComputeManager(manager.Manager):
         #TODO(mdietz): we may want to split these into separate methods.
         if migration_ref['source_compute'] == FLAGS.host:
             self.driver.power_on(instance_ref)
-            self.db.migration_update(context, migration_id, 
-                    { 'status': 'reverted' })
+            self.db.migration_update(context, migration_id,
+                    {'status': 'reverted'})
         else:
             self.driver.destroy(instance_ref)
-            topic = self.db.queue_get_for(context, FLAGS.compute_topic, 
+            topic = self.db.queue_get_for(context, FLAGS.compute_topic,
                     instance_ref['host'])
-            rpc.cast(context, topic, 
-                    { 'method': 'revert_resize',
-                      'args': {
-                            'migration_id': migration_ref['id'], 
-                            'instance_id': instance_id,
-                      }, 
+            rpc.cast(context, topic,
+                    {'method': 'revert_resize',
+                     'args': {
+                           'migration_id': migration_ref['id'],
+                           'instance_id': instance_id, },
                     })
 
     @exception.wrap_exception
     @checks_instance_lock
     def prep_resize(self, context, instance_id):
-        """Initiates the process of moving a running instance to another 
+        """Initiates the process of moving a running instance to another
         host, possibly changing the RAM and disk size in the process"""
         context = context.elevated()
         instance_ref = self.db.instance_get(context, instance_id)
@@ -426,21 +425,21 @@ class ComputeManager(manager.Manager):
             raise exception.Error(_(
                     'Migration error: destination same as source!'))
 
-        migration_ref = self.db.migration_create(context, 
-                { 'instance_id': instance_id,
-                  'source_compute': instance_ref['host'],
-                  'dest_compute': FLAGS.host,
-                  'dest_host':   self.driver.get_host_ip_addr(),
-                  'status':      'pre-migrating' })
-        LOG.audit(_('instance %s: migrating to '), instance_id, context=context)
-        topic = self.db.queue_get_for(context, FLAGS.compute_topic, 
+        migration_ref = self.db.migration_create(context,
+                {'instance_id': instance_id,
+                 'source_compute': instance_ref['host'],
+                 'dest_compute': FLAGS.host,
+                 'dest_host':   self.driver.get_host_ip_addr(),
+                 'status':      'pre-migrating'})
+        LOG.audit(_('instance %s: migrating to '), instance_id,
+                context=context)
+        topic = self.db.queue_get_for(context, FLAGS.compute_topic,
                 instance_ref['host'])
-        rpc.cast(context, topic, 
-                { 'method': 'resize_instance',
-                  'args': {
-                        'migration_id': migration_ref['id'], 
-                        'instance_id': instance_id,
-                  }, 
+        rpc.cast(context, topic,
+                {'method': 'resize_instance',
+                 'args': {
+                       'migration_id': migration_ref['id'],
+                       'instance_id': instance_id, },
                 })
 
     @exception.wrap_exception
@@ -449,28 +448,26 @@ class ComputeManager(manager.Manager):
         """Starts the migration of a running instance to another host"""
         migration_ref = self.db.migration_get(context, migration_id)
         instance_ref = self.db.instance_get(context, instance_id)
-        self.db.migration_update(context, migration_id, 
-                { 'status': 'migrating', })
+        self.db.migration_update(context, migration_id,
+                {'status': 'migrating', })
 
-        disk_info = self.driver.migrate_disk_and_power_off(instance_ref, 
+        disk_info = self.driver.migrate_disk_and_power_off(instance_ref,
                                   migration_ref['dest_host'])
-    
-        self.db.migration_update(context, migration_id, 
-                { 'status': 'post-migrating', })
+        self.db.migration_update(context, migration_id,
+                {'status': 'post-migrating', })
 
-        #TODO(mdietz): This is where we would update the VM record 
+        #TODO(mdietz): This is where we would update the VM record
         #after resizing
         service = self.db.service_get_by_host_and_topic(context,
                 migration_ref['dest_compute'], FLAGS.compute_topic)
-        topic = self.db.queue_get_for(context, FLAGS.compute_topic, 
+        topic = self.db.queue_get_for(context, FLAGS.compute_topic,
                 migration_ref['dest_compute'])
-        rpc.cast(context, topic, 
-                { 'method': 'finish_resize',
-                  'args': {
-                        'migration_id': migration_id, 
-                        'instance_id': instance_id,
-                        'disk_info': disk_info,
-                  }, 
+        rpc.cast(context, topic,
+                {'method': 'finish_resize',
+                 'args': {
+                       'migration_id': migration_id,
+                       'instance_id': instance_id,
+                       'disk_info': disk_info, },
                 })
 
     @exception.wrap_exception
@@ -486,8 +483,8 @@ class ComputeManager(manager.Manager):
         new_disk_info = self.driver.attach_disk(instance_ref, disk_info)
         self.driver.spawn(instance_ref, disk=new_disk_info)
 
-        self.db.migration_update(context, migration_id, 
-                {'status': 'finished', }) 
+        self.db.migration_update(context, migration_id,
+                {'status': 'finished', })
 
     @exception.wrap_exception
     @checks_instance_lock
diff --git a/nova/db/api.py b/nova/db/api.py
index 5a9d49374..8706ef3d6 100644
--- a/nova/db/api.py
+++ b/nova/db/api.py
@@ -260,17 +260,20 @@ def floating_ip_get_by_address(context, address):
 ####################
 
 def migration_update(context, id, values):
-    """Update a migration instance""" 
+    """Update a migration instance"""
     return IMPL.migration_update(context, id, values)
 
+
 def migration_create(context, values):
     """Create a migration record"""
     return IMPL.migration_create(context, values)
 
+
 def migration_get(context, migration_id):
     """Finds a migration by the id"""
     return IMPL.migration_get(context, migration_id)
 
+
 def migration_get_by_instance_and_status(context, instance_id, status):
     """Finds a migration by the instance id its migrating"""
     return IMPL.migration_get_by_instance_and_status(context, instance_id,
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 210b53296..facb46b8b 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -156,6 +156,7 @@ def service_get_all_by_topic(context, topic):
                    filter_by(topic=topic).\
                    all()
 
+
 @require_admin_context
 def service_get_by_host_and_topic(context, host, topic):
     session = get_session()
@@ -166,6 +167,7 @@ def service_get_by_host_and_topic(context, host, topic):
                    filter_by(topic=topic).\
                    first()
 
+
 @require_admin_context
 def service_get_all_by_host(context, host):
     session = get_session()
@@ -1996,7 +1998,7 @@ def migration_get(context, id, session=None):
     result = session.query(models.Migration).\
                      filter_by(id=id).first()
     if not result:
-        raise exception.NotFound(_("No migration found with id %s") 
+        raise exception.NotFound(_("No migration found with id %s")
                 % migration_id)
     return result
 
@@ -2008,7 +2010,7 @@ def migration_get_by_instance_and_status(context, instance_id, status):
                      filter_by(instance_id=instance_id).\
                      filter_by(status=status).first()
     if not result:
-        raise exception.NotFound(_("No migration found with instance id %s") 
+        raise exception.NotFound(_("No migration found with instance id %s")
                 % migration_id)
     return result
 
diff --git a/nova/db/sqlalchemy/migrate_repo/versions/004_add_instance_migrations.py b/nova/db/sqlalchemy/migrate_repo/versions/004_add_instance_migrations.py
index 4aab5bdc6..4fda525f1 100644
--- a/nova/db/sqlalchemy/migrate_repo/versions/004_add_instance_migrations.py
+++ b/nova/db/sqlalchemy/migrate_repo/versions/004_add_instance_migrations.py
@@ -44,9 +44,10 @@ migrations = Table('migrations', meta,
             Column('dest_host', String(255)),
             Column('instance_id', Integer, ForeignKey('instances.id'),
                 nullable=True),
-            Column('status', String(255))
+            Column('status', String(255)),
       )
 
+
 def upgrade(migrate_engine):
     # Upgrade operations go here. Don't create your own engine;
     # bind migrate_engine to your metadata
diff --git a/nova/db/sqlalchemy/models.py b/nova/db/sqlalchemy/models.py
index 0140fbeab..b05f134b7 100644
--- a/nova/db/sqlalchemy/models.py
+++ b/nova/db/sqlalchemy/models.py
@@ -374,7 +374,8 @@ class Migration(BASE, NovaBase):
     dest_compute = Column(String(255))
     dest_host = Column(String(255))
     instance_id = Column(Integer, ForeignKey('instances.id'), nullable=True)
-    status = Column(String(255)) #TODO(_cerberus_): enum
+    #TODO(_cerberus_): enum
+    status = Column(String(255))
 
 
 class Network(BASE, NovaBase):
@@ -559,7 +560,7 @@ def register_models():
               Volume, ExportDevice, IscsiTarget, FixedIp, FloatingIp,
               Network, SecurityGroup, SecurityGroupIngressRule,
               SecurityGroupInstanceAssociation, AuthToken, User,
-              Project, Certificate, ConsolePool, Console, 
+              Project, Certificate, ConsolePool, Console,
               Migration)  # , Image, Host
     engine = create_engine(FLAGS.sql_connection, echo=False)
     for model in models:
diff --git a/nova/tests/api/openstack/common.py b/nova/tests/api/openstack/common.py
index 66207cddc..3f9c7d3cf 100644
--- a/nova/tests/api/openstack/common.py
+++ b/nova/tests/api/openstack/common.py
@@ -19,14 +19,17 @@ import json
 
 import webob
 
+
 def webob_factory(url):
+    """Factory for removing duplicate webob code from tests"""
+
     base_url = url
+
     def web_request(url, method=None, body=None):
-        req = webob.Request.blank("%s%s" % (base_url, url)) 
+        req = webob.Request.blank("%s%s" % (base_url, url))
         if method:
             req.method = method
         if body:
             req.body = json.dumps(body)
         return req
     return web_request
-    
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 665551c55..4eb4a3c62 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -419,8 +419,9 @@ class ServersTest(unittest.TestCase):
         req = self.webreq('/1/action', 'POST', dict(resize=dict(flavorId=3)))
 
         self.resize_called = False
+
         def resize_mock(*args):
-            self.resize_called = True 
+            self.resize_called = True
 
         self.stubs.Set(nova.compute.api.API, 'resize', resize_mock)
 
@@ -432,8 +433,9 @@ class ServersTest(unittest.TestCase):
         req = self.webreq('/1/action', 'POST', dict(resize=dict(derp=3)))
 
         self.resize_called = False
+
         def resize_mock(*args):
-            self.resize_called = True 
+            self.resize_called = True
 
         self.stubs.Set(nova.compute.api.API, 'resize', resize_mock)
 
@@ -445,7 +447,7 @@ class ServersTest(unittest.TestCase):
         req = self.webreq('/1/action', 'POST', dict(resize=dict(flavorId=3)))
 
         def resize_mock(*args):
-            raise Exception, 'hurr durr'
+            raise Exception('hurr durr')
 
         self.stubs.Set(nova.compute.api.API, 'resize', resize_mock)
 
@@ -456,10 +458,11 @@ class ServersTest(unittest.TestCase):
         req = self.webreq('/1/action', 'POST', dict(confirmResize=None))
 
         self.resize_called = False
+
         def confirm_resize_mock(*args):
-            self.resize_called = True 
+            self.resize_called = True
 
-        self.stubs.Set(nova.compute.api.API, 'confirm_resize', 
+        self.stubs.Set(nova.compute.api.API, 'confirm_resize',
                 confirm_resize_mock)
 
         res = req.get_response(fakes.wsgi_app())
@@ -470,9 +473,9 @@ class ServersTest(unittest.TestCase):
         req = self.webreq('/1/action', 'POST', dict(confirmResize=None))
 
         def confirm_resize_mock(*args):
-            raise Exception, 'hurr durr'
+            raise Exception('hurr durr')
 
-        self.stubs.Set(nova.compute.api.API, 'confirm_resize', 
+        self.stubs.Set(nova.compute.api.API, 'confirm_resize',
                 confirm_resize_mock)
 
         res = req.get_response(fakes.wsgi_app())
@@ -482,10 +485,11 @@ class ServersTest(unittest.TestCase):
         req = self.webreq('/1/action', 'POST', dict(revertResize=None))
 
         self.resize_called = False
+
         def revert_resize_mock(*args):
             self.resize_called = True
 
-        self.stubs.Set(nova.compute.api.API, 'revert_resize', 
+        self.stubs.Set(nova.compute.api.API, 'revert_resize',
                 revert_resize_mock)
 
         res = req.get_response(fakes.wsgi_app())
@@ -496,9 +500,9 @@ class ServersTest(unittest.TestCase):
         req = self.webreq('/1/action', 'POST', dict(revertResize=None))
 
         def revert_resize_mock(*args):
-            raise Exception, 'hurr durr'
+            raise Exception('hurr durr')
 
-        self.stubs.Set(nova.compute.api.API, 'revert_resize', 
+        self.stubs.Set(nova.compute.api.API, 'revert_resize',
                 revert_resize_mock)
 
         res = req.get_response(fakes.wsgi_app())
diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index 3f2e64c87..5fd1ddaec 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -265,8 +265,7 @@ class ComputeTestCase(test.TestCase):
         instance_id = self._create_instance()
         context = self.context.elevated()
         self.compute.run_instance(self.context, instance_id)
-        db.instance_update(self.context, instance_id, {'host':'foo'})
-
+        db.instance_update(self.context, instance_id, {'host': 'foo'})
         self.compute.prep_resize(context, instance_id)
         migration_ref = db.migration_get_by_instance_and_status(context,
                 instance_id, 'pre-migrating')
@@ -279,7 +278,6 @@ class ComputeTestCase(test.TestCase):
         the same host"""
         instance_id = self._create_instance()
         self.compute.run_instance(self.context, instance_id)
-        self.assertRaises(exception.Error, self.compute.prep_resize, 
+        self.assertRaises(exception.Error, self.compute.prep_resize,
                 self.context, instance_id)
-
         self.compute.terminate_instance(self.context, instance_id)
diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index 3cbc01e5c..cb9b6620a 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -337,6 +337,7 @@ class XenAPIDiffieHellmanTestCase(test.TestCase):
     def tearDown(self):
         super(XenAPIDiffieHellmanTestCase, self).tearDown()
 
+
 class XenAPIMigrateInstance(test.TestCase):
     """
     Unit test for verifying migration-related actions
diff --git a/nova/tests/xenapi/stubs.py b/nova/tests/xenapi/stubs.py
index 054fc434b..303c37eb9 100644
--- a/nova/tests/xenapi/stubs.py
+++ b/nova/tests/xenapi/stubs.py
@@ -171,8 +171,8 @@ class FakeSessionForVMTests(fake.SessionBase):
 
     def VM_destroy(self, session_ref, vm_ref):
         fake.destroy_vm(vm_ref)
-    
-    
+
+
 class FakeSessionForVolumeTests(fake.SessionBase):
     """ Stubs out a XenAPISession for Volume tests """
     def __init__(self, uri):
@@ -207,6 +207,7 @@ class FakeSessionForVolumeFailedTests(FakeSessionForVolumeTests):
     def SR_forget(self, _1, ref):
         pass
 
+
 class FakeSessionForMigrationTests(fake.SessionBase):
     """ Stubs out a XenAPISession for Migration tests """
     def __init__(self, uri):
@@ -232,8 +233,8 @@ def stub_out_migration_methods(stubs):
         vdi_ref = fake.create_vdi(name_label='derp', read_only=False,
                              sr_ref='herp', sharable=False)
         vdi_rec = session.get_xenapi().VDI.get_record(vdi_ref)
-        return vdi_ref, {'uuid': vdi_rec['uuid']}
-    
+        return vdi_ref, {'uuid': vdi_rec['uuid'], }
+
     def fake_shutdown(self, inst, vm, method='clean'):
         pass
 
@@ -244,5 +245,5 @@ def stub_out_migration_methods(stubs):
     stubs.Set(vm_utils.VMHelper, 'scan_sr', fake_scan_sr)
     stubs.Set(vmops.VMOps, '_get_snapshot', fake_get_snapshot)
     stubs.Set(vm_utils.VMHelper, 'get_vdi_for_vm_safely', fake_get_vdi)
-    stubs.Set(xenapi_conn.XenAPISession, 'wait_for_task', lambda x,y,z: None)
+    stubs.Set(xenapi_conn.XenAPISession, 'wait_for_task', lambda x, y, z: None)
     stubs.Set(vmops.VMOps, '_shutdown', fake_shutdown)
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 <rick.harris@rackspace.com>
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')

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 cfd6d4e403dcb2405cd7ff48bad3083a02159d2c Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Sat, 19 Feb 2011 00:14:08 +0100
Subject: Port libvirt_conn.IptablesDriver over to use
 linux_net.IptablesManager

---
 nova/network/linux_net.py |  17 +++-
 nova/tests/test_virt.py   |  55 ++++++++----
 nova/virt/libvirt_conn.py | 215 ++++++++++++++++++++--------------------------
 3 files changed, 145 insertions(+), 142 deletions(-)

(limited to 'nova')

diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index 3d267d941..c11d34922 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -100,13 +100,23 @@ class IptablesTable(object):
 
     def remove_chain(self, name):
         self.chains.remove(name)
+        self.rules = filter(lambda r: r.chain != name, self.rules)
 
     def add_rule(self, chain, rule, wrap=True):
         if wrap and chain not in self.chains:
             raise ValueError(_("Unknown chain: %r") % chain)
 
+        if '$' in rule:
+            rule = ' '.join(map(self._wrap_target_chain, rule.split(' ')))
+
+        print 'Adding rule: %r' % rule
         self.rules.append(IptablesRule(chain, rule, wrap))
 
+    def _wrap_target_chain(self, s):
+        if s.startswith('$'):
+            return '%s-%s' % (binary_name, s[1:])
+        return s
+
     def remove_rule(self, chain, rule):
         self.rules.remove(IptablesRule(chain, rule))
 
@@ -122,8 +132,7 @@ class IptablesManager(object):
 
         self.ipv4 = { 'filter': IptablesTable(),
                       'nat': IptablesTable() }
-        self.ipv6 = { 'filter': IptablesTable(),
-                      'nat': IptablesTable() }
+        self.ipv6 = { 'filter': IptablesTable() }
 
         self.ipv4['nat'].add_chain('SNATTING')
         self.ipv4['nat'].add_rule('POSTROUTING',
@@ -135,6 +144,10 @@ class IptablesManager(object):
                                     '-j %s-local' % (binary_name,),
                                     wrap=False)
 
+        self.ipv4['filter'].add_rule('OUTPUT',
+                                    '-j %s-local' % (binary_name,),
+                                    wrap=False)
+
         # Wrap the builtin chains
         builtin_chains = {'filter': ['INPUT', 'OUTPUT', 'FORWARD'],
                           'nat': ['PREROUTING', 'INPUT',
diff --git a/nova/tests/test_virt.py b/nova/tests/test_virt.py
index 6e5a0114b..a88e01818 100644
--- a/nova/tests/test_virt.py
+++ b/nova/tests/test_virt.py
@@ -14,6 +14,7 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+import re
 from xml.etree.ElementTree import fromstring as xml_to_tree
 from xml.dom.minidom import parseString as xml_to_dom
 
@@ -233,16 +234,22 @@ class IptablesFirewallTestCase(test.TestCase):
         self.manager.delete_user(self.user)
         super(IptablesFirewallTestCase, self).tearDown()
 
-    in_rules = [
+    in_nat_rules = [
+      '# Generated by iptables-save v1.4.10 on Sat Feb 19 00:03:19 2011',
+      '*nat',
+      ':PREROUTING ACCEPT [1170:189210]',
+      ':INPUT ACCEPT [844:71028]',
+      ':OUTPUT ACCEPT [5149:405186]',
+      ':POSTROUTING ACCEPT [5063:386098]'
+    ]
+
+    in_filter_rules = [
       '# Generated by iptables-save v1.4.4 on Mon Dec  6 11:54:13 2010',
       '*filter',
       ':INPUT ACCEPT [969615:281627771]',
       ':FORWARD ACCEPT [0:0]',
       ':OUTPUT ACCEPT [915599:63811649]',
       ':nova-block-ipv4 - [0:0]',
-      '-A INPUT -i virbr0 -p udp -m udp --dport 53 -j ACCEPT ',
-      '-A INPUT -i virbr0 -p tcp -m tcp --dport 53 -j ACCEPT ',
-      '-A INPUT -i virbr0 -p udp -m udp --dport 67 -j ACCEPT ',
       '-A INPUT -i virbr0 -p tcp -m tcp --dport 67 -j ACCEPT ',
       '-A FORWARD -d 192.168.122.0/24 -o virbr0 -m state --state RELATED'
       ',ESTABLISHED -j ACCEPT ',
@@ -254,7 +261,7 @@ class IptablesFirewallTestCase(test.TestCase):
       '# Completed on Mon Dec  6 11:54:13 2010',
     ]
 
-    in6_rules = [
+    in6_filter_rules = [
       '# Generated by ip6tables-save v1.4.4 on Tue Jan 18 23:47:56 2011',
       '*filter',
       ':INPUT ACCEPT [349155:75810423]',
@@ -314,23 +321,31 @@ class IptablesFirewallTestCase(test.TestCase):
         instance_ref = db.instance_get(admin_ctxt, instance_ref['id'])
 
 #        self.fw.add_instance(instance_ref)
-        def fake_iptables_execute(cmd, process_input=None):
+        def fake_iptables_execute(cmd, process_input=None, attempts=5):
             if cmd == 'sudo ip6tables-save -t filter':
-                return '\n'.join(self.in6_rules), None
+                return '\n'.join(self.in6_filter_rules), None
             if cmd == 'sudo iptables-save -t filter':
-                return '\n'.join(self.in_rules), None
+                return '\n'.join(self.in_filter_rules), None
+            if cmd == 'sudo iptables-save -t nat':
+                return '\n'.join(self.in_nat_rules), None
             if cmd == 'sudo iptables-restore':
-                self.out_rules = process_input.split('\n')
+                lines = process_input.split('\n')
+                if '*filter' in lines:
+                    self.out_rules = lines
                 return '', ''
             if cmd == 'sudo ip6tables-restore':
-                self.out6_rules = process_input.split('\n')
+                lines = process_input.split('\n')
+                if '*filter' in lines:
+                    self.out6_rules = lines
                 return '', ''
-        self.fw.execute = fake_iptables_execute
+
+        from nova.network import linux_net
+        linux_net.iptables_manager.execute = fake_iptables_execute
 
         self.fw.prepare_instance_filter(instance_ref)
         self.fw.apply_instance_filter(instance_ref)
 
-        in_rules = filter(lambda l: not l.startswith('#'), self.in_rules)
+        in_rules = filter(lambda l: not l.startswith('#'), self.in_filter_rules)
         for rule in in_rules:
             if not 'nova' in rule:
                 self.assertTrue(rule in self.out_rules,
@@ -338,6 +353,7 @@ class IptablesFirewallTestCase(test.TestCase):
 
         instance_chain = None
         for rule in self.out_rules:
+            print rule
             # This is pretty crude, but it'll do for now
             if '-d 10.11.12.13 -j' in rule:
                 instance_chain = rule.split(' ')[-1]
@@ -353,17 +369,18 @@ class IptablesFirewallTestCase(test.TestCase):
         self.assertTrue(security_group_chain,
                         "The security group chain wasn't added")
 
-        self.assertTrue('-A %s -p icmp -s 192.168.11.0/24 -j ACCEPT' % \
-                               security_group_chain in self.out_rules,
+        regex = re.compile('-A .* -p icmp -s 192.168.11.0/24 -j ACCEPT')
+        self.assertTrue(len(filter(regex.match, self.out_rules)) > 0,
                         "ICMP acceptance rule wasn't added")
 
-        self.assertTrue('-A %s -p icmp -s 192.168.11.0/24 -m icmp --icmp-type '
-                        '8 -j ACCEPT' % security_group_chain in self.out_rules,
+        regex = re.compile('-A .* -p icmp -s 192.168.11.0/24 -m icmp '
+                           '--icmp-type 8 -j ACCEPT')
+        self.assertTrue(len(filter(regex.match, self.out_rules)) > 0,
                         "ICMP Echo Request acceptance rule wasn't added")
 
-        self.assertTrue('-A %s -p tcp -s 192.168.10.0/24 -m multiport '
-                        '--dports 80:81 -j ACCEPT' % security_group_chain \
-                            in self.out_rules,
+        regex = re.compile('-A .* -p tcp -s 192.168.10.0/24 -m multiport '
+                           '--dports 80:81 -j ACCEPT')
+        self.assertTrue(len(filter(regex.match, self.out_rules)) > 0,
                         "TCP port 80/81 acceptance rule wasn't added")
 
 
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 99760bd7a51371b29cf0f76134187dc81e7545d0 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Sat, 19 Feb 2011 00:30:44 +0100
Subject: Rename a few things for more clarity.

---
 nova/network/linux_net.py | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

(limited to 'nova')

diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index c11d34922..b657ab4bc 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -109,7 +109,6 @@ class IptablesTable(object):
         if '$' in rule:
             rule = ' '.join(map(self._wrap_target_chain, rule.split(' ')))
 
-        print 'Adding rule: %r' % rule
         self.rules.append(IptablesRule(chain, rule, wrap))
 
     def _wrap_target_chain(self, s):
@@ -168,9 +167,9 @@ class IptablesManager(object):
 
         for cmd, tables in s:
             for table in tables:
-                current_filter, _ = self.execute('sudo %s-save -t %s' %
-                                                 (cmd, table), attempts=5)
-                current_lines = current_filter.split('\n')
+                current_table, _ = self.execute('sudo %s-save -t %s' %
+                                                (cmd, table), attempts=5)
+                current_lines = current_table.split('\n')
                 new_filter = self.modify_rules(current_lines, tables[table])
                 self.execute('sudo %s-restore' % (cmd,),
                              process_input='\n'.join(new_filter),
@@ -182,7 +181,7 @@ class IptablesManager(object):
         rules = table.rules
 
         # Remove any trace of our rules
-        new_filter = filter(lambda l: '%s' % binary not in l, current_lines)
+        new_filter = filter(lambda l: binary_name not in l, current_lines)
 
         seen_chains = False
         for rules_index in range(len(new_filter)):
-- 
cgit 


From 23729c543350ce4ce563077522f18d0bedd1e61b Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
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')

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 fcd31c4d7c3855cb95ac75d6966b377eca8bbe7d Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Fri, 18 Feb 2011 15:59:42 -0800
Subject: added instance types purge test

---
 nova/tests/test_instance_types.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/tests/test_instance_types.py b/nova/tests/test_instance_types.py
index 0d54cc283..fe052110f 100644
--- a/nova/tests/test_instance_types.py
+++ b/nova/tests/test_instance_types.py
@@ -49,12 +49,16 @@ class InstanceTypeTestCase(test.TestCase):
         new = instance_types.get_all_types()
         self.assertNotEqual(len(starting_inst_list),
                             len(new),
-                            'instance was not created')
+                            'instance type was not created')
         instance_types.destroy(self.name)
         self.assertEqual(1,
                     instance_types.get_instance_type(self.name)["deleted"])
         self.assertEqual(starting_inst_list, instance_types.get_all_types())
         db.instance_type_purge(context.get_admin_context(), self.name)
+        self.assertEqual(len(starting_inst_list),
+                         len(instance_types.get_all_types()),
+                         'instance type not purged')
+
 
     def test_get_all_instance_types(self):
         """Ensures that all instance types can be retrieved"""
-- 
cgit 


From 3609f1da7e1383b76295c6e8bd1d1dc0d798aa63 Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Fri, 18 Feb 2011 16:00:22 -0800
Subject: pep8

---
 nova/tests/test_instance_types.py | 1 -
 1 file changed, 1 deletion(-)

(limited to 'nova')

diff --git a/nova/tests/test_instance_types.py b/nova/tests/test_instance_types.py
index fe052110f..705144cb0 100644
--- a/nova/tests/test_instance_types.py
+++ b/nova/tests/test_instance_types.py
@@ -59,7 +59,6 @@ class InstanceTypeTestCase(test.TestCase):
                          len(instance_types.get_all_types()),
                          'instance type not purged')
 
-
     def test_get_all_instance_types(self):
         """Ensures that all instance types can be retrieved"""
         session = get_session()
-- 
cgit 


From d0733621758985bdd621a05c7c8a53fe27aa62f2 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Sat, 19 Feb 2011 01:28:26 +0100
Subject: Wrap iptables calls in a semaphore.

---
 nova/network/linux_net.py | 33 ++++++++++++++++++---------------
 1 file changed, 18 insertions(+), 15 deletions(-)

(limited to 'nova')

diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index b81a704bf..ecda450bf 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -20,6 +20,8 @@ Implements vlans, bridges, and iptables rules using linux utilities.
 import inspect
 import os
 
+from eventlet import semaphore
+
 from nova import db
 from nova import exception
 from nova import flags
@@ -149,8 +151,7 @@ class IptablesManager(object):
 
         # Wrap the builtin chains
         builtin_chains = {'filter': ['INPUT', 'OUTPUT', 'FORWARD'],
-                          'nat': ['PREROUTING', 'INPUT',
-                                  'OUTPUT', 'POSTROUTING']}
+                          'nat': ['PREROUTING', 'OUTPUT', 'POSTROUTING']}
 
         for table, chains in builtin_chains.iteritems():
             for chain in chains:
@@ -158,22 +159,24 @@ class IptablesManager(object):
                 self.ipv4[table].add_rule(chain,
                                           '-j %s-%s' % (binary_name, chain),
                                           wrap=False)
+        self.semaphore = semaphore.Semaphore()
 
 
     def apply(self):
-        s = [('iptables', self.ipv4)]
-        if FLAGS.use_ipv6:
-            s += [('ip6tables', self.ipv6)]
-
-        for cmd, tables in s:
-            for table in tables:
-                current_table, _ = self.execute('sudo %s-save -t %s' %
-                                                (cmd, table), attempts=5)
-                current_lines = current_table.split('\n')
-                new_filter = self.modify_rules(current_lines, tables[table])
-                self.execute('sudo %s-restore' % (cmd,),
-                             process_input='\n'.join(new_filter),
-                             attempts=5)
+        with self.semaphore:
+            s = [('iptables', self.ipv4)]
+            if FLAGS.use_ipv6:
+                s += [('ip6tables', self.ipv6)]
+
+            for cmd, tables in s:
+                for table in tables:
+                    current_table, _ = self.execute('sudo %s-save -t %s' %
+                                                    (cmd, table), attempts=5)
+                    current_lines = current_table.split('\n')
+                    new_filter = self.modify_rules(current_lines, tables[table])
+                    self.execute('sudo %s-restore' % (cmd,),
+                                 process_input='\n'.join(new_filter),
+                                 attempts=5)
 
     def modify_rules(self, current_lines, table, binary=None):
 
-- 
cgit 


From 53784c1afaa12d0a8b22248093ec1e623a1a913d Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Fri, 18 Feb 2011 17:17:47 -0800
Subject: added purge option and tightened up testing

---
 nova/compute/instance_types.py    | 13 ++++++++
 nova/tests/test_instance_types.py |  2 +-
 nova/tests/test_nova_manage.py    | 62 ++++++++++++++++++++-------------------
 3 files changed, 46 insertions(+), 31 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/instance_types.py b/nova/compute/instance_types.py
index a5e0a7baf..ce4b25964 100644
--- a/nova/compute/instance_types.py
+++ b/nova/compute/instance_types.py
@@ -81,6 +81,19 @@ def destroy(name):
                                      name)
 
 
+def purge(name):
+    """Removes instance types / flavors from database
+    arguments: name"""
+    if name == None:
+        raise exception.InvalidInputException(_("No instance type specified"))
+    else:
+        try:
+            db.instance_type_purge(context.get_admin_context(), name)
+        except exception.NotFound:
+            raise exception.ApiError(_("Unknown instance type: %s"),
+                                      name)
+
+
 def get_all_types(inactive=0):
     """Retrieves non-deleted instance_types.
     Pass true as argument if you want deleted instance types returned also."""
diff --git a/nova/tests/test_instance_types.py b/nova/tests/test_instance_types.py
index 705144cb0..1b192ca28 100644
--- a/nova/tests/test_instance_types.py
+++ b/nova/tests/test_instance_types.py
@@ -54,7 +54,7 @@ class InstanceTypeTestCase(test.TestCase):
         self.assertEqual(1,
                     instance_types.get_instance_type(self.name)["deleted"])
         self.assertEqual(starting_inst_list, instance_types.get_all_types())
-        db.instance_type_purge(context.get_admin_context(), self.name)
+        instance_types.purge(self.name)
         self.assertEqual(len(starting_inst_list),
                          len(instance_types.get_all_types()),
                          'instance type not purged')
diff --git a/nova/tests/test_nova_manage.py b/nova/tests/test_nova_manage.py
index 03b4e3fb8..03aea53c9 100644
--- a/nova/tests/test_nova_manage.py
+++ b/nova/tests/test_nova_manage.py
@@ -33,12 +33,13 @@ class NovaManageTestCase(test.TestCase):
                                      order_by("flavorid desc").first()
         self.flavorid = str(max_flavorid["flavorid"] + 1)
         self.name = str(int(time.time()))
+        self.fnull = open(os.devnull, 'w')
 
     def teardown(self):
-        fnull.close()
+        self.fnull.close()
 
     def test_create_and_delete_instance_types(self):
-        fnull = open(os.devnull, 'w')
+        myname = self.name + "create_and_delete"
         retcode = subprocess.call([
             "bin/nova-manage",
             "instance_type",
@@ -51,45 +52,44 @@ class NovaManageTestCase(test.TestCase):
             "2",
             "10",
             "10"],
-            stdout=fnull)
+            stdout=self.fnull)
         self.assertEqual(0, retcode)
-        retcode = subprocess.call(["bin/nova-manage", "instance_type",\
-                                    "delete", self.name], stdout=fnull)
+        retcode = subprocess.call(["bin/nova-manage", "instance_type",
+                                    "delete", self.name], stdout=self.fnull)
+        self.assertEqual(0, retcode)
+        retcode = subprocess.call(["bin/nova-manage", "instance_type",
+                                    "delete", self.name, "--purge"],
+                                    stdout=self.fnull)
         self.assertEqual(0, retcode)
 
     def test_list_instance_types_or_flavors(self):
-        fnull = open(os.devnull, 'w')
         for c in ["instance_type", "flavor"]:
             retcode = subprocess.call(["bin/nova-manage", c, \
-                                        "list"], stdout=fnull)
+                                        "list"], stdout=self.fnull)
             self.assertEqual(0, retcode)
 
     def test_list_specific_instance_type(self):
-        fnull = open(os.devnull, 'w')
         retcode = subprocess.call(["bin/nova-manage", "instance_type", "list",
-                                    "m1.medium"], stdout=fnull)
+                                    "m1.medium"], stdout=self.fnull)
         self.assertEqual(0, retcode)
 
     def test_should_error_on_bad_create_args(self):
-        fnull = open(os.devnull, 'w')
         # shouldn't be able to create instance type with 0 vcpus
-        retcode = subprocess.call(["bin/nova-manage", "instance_type",\
-                                    "create", self.name, "256", "0",\
-                                    "120", self.flavorid], stdout=fnull)
+        retcode = subprocess.call(["bin/nova-manage", "instance_type",
+                                    "create", self.name + "bad_args",
+                                    "256", "0", "120", self.flavorid],
+                                    stdout=self.fnull)
         self.assertEqual(1, retcode)
 
     def test_should_fail_on_duplicate_flavorid(self):
-        fnull = open(os.devnull, 'w')
         # flavorid 1 is set in migration seed data
         retcode = subprocess.call(["bin/nova-manage", "instance_type",\
-                                    "create", self.name, "256", "1",\
-                                    "120", "1"], stdout=fnull)
-        self.assertEqual(1, retcode)
+                                    "create", self.name + "dupflavor", "256",
+                                    "1", "120", "1"], stdout=self.fnull)
+        self.assertEqual(3, retcode)
 
     def test_should_fail_on_duplicate_name(self):
-        # FIXME(ken-pepple) duplicate_name really needs to be unique
-        duplicate_name = "sdfsdfsafsdfsd"
-        fnull = open(os.devnull, 'w')
+        duplicate_name = self.name + "dup_name"
         retcode = subprocess.call([
             "bin/nova-manage",
             "instance_type",
@@ -102,27 +102,29 @@ class NovaManageTestCase(test.TestCase):
             "2",
             "10",
             "10"],
-            stdout=fnull)
+            stdout=self.fnull)
+        self.assertEqual(0, retcode)
         duplicate_retcode = subprocess.call([
             "bin/nova-manage",
             "instance_type",
             "create",
             duplicate_name,
-            "256",
+            "512",
             "1",
-            "120",
-            self.flavorid,
+            "240",
+            str(int(self.flavorid) + 1),
             "2",
             "10",
             "10"],
-            stdout=fnull)
+            stdout=self.fnull)
         self.assertEqual(3, duplicate_retcode)
-        delete_retcode = subprocess.call(["bin/nova-manage", "instance_type",\
-                                    "delete", duplicate_name], stdout=fnull)
+        delete_retcode = subprocess.call(["bin/nova-manage", "instance_type",
+                                    "delete", duplicate_name, "--purge"],
+                                    stdout=self.fnull)
         self.assertEqual(0, delete_retcode)
 
     def test_instance_type_delete_should_fail_without_valid_name(self):
-        fnull = open(os.devnull, 'w')
-        retcode = subprocess.call(["bin/nova-manage", "instance_type",\
-                                    "delete", "doesntexist"], stdout=fnull)
+        retcode = subprocess.call(["bin/nova-manage", "instance_type",
+                                    "delete", "doesntexist"],
+                                    stdout=self.fnull)
         self.assertEqual(1, retcode)
-- 
cgit 


From 2a6ce075e19af5700960e3fb22c213e43a2e24b4 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Thu, 3 Mar 2011 16:28:04 -0400
Subject: start of fanout

---
 nova/rpc.py                    | 20 ++++++++++++++++++++
 nova/scheduler/manager.py      |  4 ++++
 nova/scheduler/zone_manager.py |  4 ++++
 nova/service.py                |  6 ++++++
 4 files changed, 34 insertions(+)

(limited to 'nova')

diff --git a/nova/rpc.py b/nova/rpc.py
index 8fe4565dd..a02cdc90c 100644
--- a/nova/rpc.py
+++ b/nova/rpc.py
@@ -218,6 +218,16 @@ class TopicPublisher(Publisher):
         super(TopicPublisher, self).__init__(connection=connection)
 
 
+class FanoutPublisher(Publisher):
+    """Publishes messages to a fanout exchange."""
+    exchange_type = "fanout"
+
+    def __init__(self, topic, connection=None):
+        self.exchange = "%s_fanout" % topic
+        self.durable = False
+        super(FanoutPublisher, self).__init__(connection=connection)
+
+
 class DirectConsumer(Consumer):
     """Consumes messages directly on a channel specified by msg_id"""
     exchange_type = "direct"
@@ -360,6 +370,16 @@ def cast(context, topic, msg):
     publisher.close()
 
 
+def fanout_cast(context, topic, msg):
+    """Sends a message on a fanout exchange without waiting for a response"""
+    LOG.debug(_("Making asynchronous fanout cast..."))
+    _pack_context(msg, context)
+    conn = Connection.instance()
+    publisher = FanoutPublisher(topic, connection=conn)
+    publisher.send(msg)
+    publisher.close()
+
+
 def generic_response(message_data, message):
     """Logs a result and exits"""
     LOG.debug(_('response %s'), message_data)
diff --git a/nova/scheduler/manager.py b/nova/scheduler/manager.py
index c94397210..7541523b0 100644
--- a/nova/scheduler/manager.py
+++ b/nova/scheduler/manager.py
@@ -59,6 +59,10 @@ class SchedulerManager(manager.Manager):
         """Get a list of zones from the ZoneManager."""
         return self.zone_manager.get_zone_list()
 
+    def update_compute_capabilities(self, context=None):
+        """Process a compute node update."""
+        return self.zone_manager.update_compute_capabilities()
+
     def _schedule(self, method, context, topic, *args, **kwargs):
         """Tries to call schedule_* method on the driver to retrieve host.
 
diff --git a/nova/scheduler/zone_manager.py b/nova/scheduler/zone_manager.py
index edf9000cc..eedc5c235 100644
--- a/nova/scheduler/zone_manager.py
+++ b/nova/scheduler/zone_manager.py
@@ -105,6 +105,7 @@ class ZoneManager(object):
     def __init__(self):
         self.last_zone_db_check = datetime.min
         self.zone_states = {}
+        self.compute_states = {}
         self.green_pool = greenpool.GreenPool()
 
     def get_zone_list(self):
@@ -141,3 +142,6 @@ class ZoneManager(object):
             self.last_zone_db_check = datetime.now()
             self._refresh_from_db(context)
         self._poll_zones(context)
+
+    def update_compute_capabilities(self):
+        logging.debug(_("****** UPDATE COMPUTE CAPABILITIES *******"))
diff --git a/nova/service.py b/nova/service.py
index f47358089..3ecf46525 100644
--- a/nova/service.py
+++ b/nova/service.py
@@ -84,6 +84,7 @@ class Service(object):
 
         conn1 = rpc.Connection.instance(new=True)
         conn2 = rpc.Connection.instance(new=True)
+        conn3 = rpc.Connection.instance(new=True)
         if self.report_interval:
             consumer_all = rpc.AdapterConsumer(
                     connection=conn1,
@@ -93,9 +94,14 @@ class Service(object):
                     connection=conn2,
                     topic='%s.%s' % (self.topic, self.host),
                     proxy=self)
+            fanout = rpc.AdapterConsumer(
+                    connection=conn2,
+                    topic='%s_fanout' % self.topic,
+                    proxy=self)
 
             self.timers.append(consumer_all.attach_to_eventlet())
             self.timers.append(consumer_node.attach_to_eventlet())
+            self.timers.append(fanout.attach_to_eventlet())
 
             pulse = utils.LoopingCall(self.report_state)
             pulse.start(interval=self.report_interval, now=False)
-- 
cgit 


From 3d9d99a53d372abf9f69f1d6e66fa6c6491ec752 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Thu, 3 Mar 2011 19:27:15 -0400
Subject: tests passing

---
 nova/tests/test_service.py | 6 ++++++
 1 file changed, 6 insertions(+)

(limited to 'nova')

diff --git a/nova/tests/test_service.py b/nova/tests/test_service.py
index 45d9afa6c..cb31a3c43 100644
--- a/nova/tests/test_service.py
+++ b/nova/tests/test_service.py
@@ -120,6 +120,12 @@ class ServiceTestCase(test.TestCase):
                             proxy=mox.IsA(service.Service)).AndReturn(
                                     rpc.AdapterConsumer)
 
+        rpc.AdapterConsumer(connection=mox.IgnoreArg(),
+                            topic='%s_fanout' % topic,
+                            proxy=mox.IsA(service.Service)).AndReturn(
+                                    rpc.AdapterConsumer)
+
+        rpc.AdapterConsumer.attach_to_eventlet()
         rpc.AdapterConsumer.attach_to_eventlet()
         rpc.AdapterConsumer.attach_to_eventlet()
 
-- 
cgit 


From a10d863e5e6127b8e987719ddfb60142b9f08db9 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Sun, 20 Feb 2011 13:36:45 -0800
Subject: scheduler manager

---
 nova/scheduler_manager.py | 39 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 nova/scheduler_manager.py

(limited to 'nova')

diff --git a/nova/scheduler_manager.py b/nova/scheduler_manager.py
new file mode 100644
index 000000000..c78b6fea5
--- /dev/null
+++ b/nova/scheduler_manager.py
@@ -0,0 +1,39 @@
+# Copyright 2011 OpenStack, LLC.
+# 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.
+
+"""
+This module provides SchedulerDependentManager, a base class for
+any Manager that has Capabilities that should be related to the
+Scheduler.
+
+These Capabilities are hints that can help the scheduler route
+requests to the appropriate service instance.
+"""
+
+from nova import manager
+from nova.scheduler import api
+
+
+FLAGS = flags.FLAGS
+
+
+def SchedulerDependentManage(manager.Manager):
+    def __init__(self, host=None, db_driver=None):
+        self.last_capabilities = {}
+        super(SchedulerDependentManager, self).__init__(host, db_driver)
+
+    def periodic_tasks(self, context=None):
+        """Pass data back to the scheduler at a periodic interval"""
+        logging.debug(_("Notifying Schedulers of capabilities ..."))
-- 
cgit 


From 5d821114fc20c88e36f079089cfe655d8188914a Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Sun, 20 Feb 2011 16:40:08 -0800
Subject: service ping working

---
 nova/compute/manager.py   | 4 ++--
 nova/scheduler_manager.py | 9 +++++++--
 nova/service.py           | 2 +-
 3 files changed, 10 insertions(+), 5 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 3af97683f..fd88158f7 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -44,7 +44,7 @@ import functools
 from nova import exception
 from nova import flags
 from nova import log as logging
-from nova import manager
+from nova import scheduler_manager
 from nova import rpc
 from nova import utils
 from nova.compute import power_state
@@ -99,7 +99,7 @@ def checks_instance_lock(function):
     return decorated_function
 
 
-class ComputeManager(manager.Manager):
+class ComputeManager(scheduler_manager.SchedulerDependentManager):
 
     """Manages the running instances from creation to destruction."""
 
diff --git a/nova/scheduler_manager.py b/nova/scheduler_manager.py
index c78b6fea5..987ca8e90 100644
--- a/nova/scheduler_manager.py
+++ b/nova/scheduler_manager.py
@@ -22,18 +22,23 @@ These Capabilities are hints that can help the scheduler route
 requests to the appropriate service instance.
 """
 
+import sys
+
+from nova import flags
 from nova import manager
 from nova.scheduler import api
+from nova import log as logging
 
 
 FLAGS = flags.FLAGS
 
 
-def SchedulerDependentManage(manager.Manager):
+class SchedulerDependentManager(manager.Manager):
     def __init__(self, host=None, db_driver=None):
         self.last_capabilities = {}
         super(SchedulerDependentManager, self).__init__(host, db_driver)
 
     def periodic_tasks(self, context=None):
         """Pass data back to the scheduler at a periodic interval"""
-        logging.debug(_("Notifying Schedulers of capabilities ..."))
+        logging.debug(_("*** Notifying Schedulers of capabilities ..."))
+        super(SchedulerDependentManager, self).periodic_tasks(context)
diff --git a/nova/service.py b/nova/service.py
index 3ecf46525..66287b505 100644
--- a/nova/service.py
+++ b/nova/service.py
@@ -95,7 +95,7 @@ class Service(object):
                     topic='%s.%s' % (self.topic, self.host),
                     proxy=self)
             fanout = rpc.AdapterConsumer(
-                    connection=conn2,
+                    connection=conn3,
                     topic='%s_fanout' % self.topic,
                     proxy=self)
 
-- 
cgit 


From 7297e6bf1536f20540200f28154c15d63372d943 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Sun, 20 Feb 2011 20:58:59 -0800
Subject: fanout kinda working

---
 nova/rpc.py               | 51 ++++++++++++++++++++++++++++++-----------------
 nova/scheduler/api.py     |  7 +++++++
 nova/scheduler/manager.py |  2 +-
 nova/scheduler_manager.py |  2 ++
 nova/service.py           |  8 ++++----
 5 files changed, 47 insertions(+), 23 deletions(-)

(limited to 'nova')

diff --git a/nova/rpc.py b/nova/rpc.py
index a02cdc90c..e0cf6d301 100644
--- a/nova/rpc.py
+++ b/nova/rpc.py
@@ -137,24 +137,7 @@ class Consumer(messaging.Consumer):
         return timer
 
 
-class Publisher(messaging.Publisher):
-    """Publisher base class"""
-    pass
-
-
-class TopicConsumer(Consumer):
-    """Consumes messages on a specific topic"""
-    exchange_type = "topic"
-
-    def __init__(self, connection=None, topic="broadcast"):
-        self.queue = topic
-        self.routing_key = topic
-        self.exchange = FLAGS.control_exchange
-        self.durable = False
-        super(TopicConsumer, self).__init__(connection=connection)
-
-
-class AdapterConsumer(TopicConsumer):
+class AdapterConsumer(Consumer):
     """Calls methods on a proxy object based on method and args"""
     def __init__(self, connection=None, topic="broadcast", proxy=None):
         LOG.debug(_('Initing the Adapter Consumer for %s') % topic)
@@ -207,6 +190,37 @@ class AdapterConsumer(TopicConsumer):
         return
 
 
+class Publisher(messaging.Publisher):
+    """Publisher base class"""
+    pass
+
+
+class TopicAdapterConsumer(AdapterConsumer):
+    """Consumes messages on a specific topic"""
+    exchange_type = "topic"
+
+    def __init__(self, connection=None, topic="broadcast", proxy=None):
+        self.queue = topic
+        self.routing_key = topic
+        self.exchange = FLAGS.control_exchange
+        self.durable = False
+        super(TopicAdapterConsumer, self).__init__(connection=connection,
+                                    topic=topic, proxy=proxy)
+
+
+class FanoutAdapterConsumer(AdapterConsumer):
+    """Consumes messages from a fanout exchange"""
+    exchange_type = "fanout"
+
+    def __init__(self, connection=None, topic="broadcast", proxy=None):
+        self.exchange = "%s_fanout" % topic
+        self.routing_key = topic
+        self.queue = "ignored"
+        self.durable = False
+        super(FanoutAdapterConsumer, self).__init__(connection=connection,
+                                    topic=topic, proxy=proxy)
+
+
 class TopicPublisher(Publisher):
     """Publishes messages on a specific topic"""
     exchange_type = "topic"
@@ -214,6 +228,7 @@ class TopicPublisher(Publisher):
     def __init__(self, connection=None, topic="broadcast"):
         self.routing_key = topic
         self.exchange = FLAGS.control_exchange
+        self.queue = "ignored"
         self.durable = False
         super(TopicPublisher, self).__init__(connection=connection)
 
diff --git a/nova/scheduler/api.py b/nova/scheduler/api.py
index 8491bf3a9..53d72507f 100644
--- a/nova/scheduler/api.py
+++ b/nova/scheduler/api.py
@@ -47,3 +47,10 @@ class API:
         for item in items:
             item['api_url'] = item['api_url'].replace('\\/', '/')
         return items
+
+    @classmethod
+    def update_service_capabilities(cls, context, service_name, capabilities):
+        kwargs = dict(method='update_service_capabilities',
+                        service_name=service_name, capabilities=capabilities)
+        return rpc.fanout_cast(context, 'scheduler', kwargs)
+
diff --git a/nova/scheduler/manager.py b/nova/scheduler/manager.py
index 7541523b0..3ff43a9d9 100644
--- a/nova/scheduler/manager.py
+++ b/nova/scheduler/manager.py
@@ -59,7 +59,7 @@ class SchedulerManager(manager.Manager):
         """Get a list of zones from the ZoneManager."""
         return self.zone_manager.get_zone_list()
 
-    def update_compute_capabilities(self, context=None):
+    def update_service_capabilities(self, context=None, service_name=None, capabilities={}):
         """Process a compute node update."""
         return self.zone_manager.update_compute_capabilities()
 
diff --git a/nova/scheduler_manager.py b/nova/scheduler_manager.py
index 987ca8e90..a45301617 100644
--- a/nova/scheduler_manager.py
+++ b/nova/scheduler_manager.py
@@ -41,4 +41,6 @@ class SchedulerDependentManager(manager.Manager):
     def periodic_tasks(self, context=None):
         """Pass data back to the scheduler at a periodic interval"""
         logging.debug(_("*** Notifying Schedulers of capabilities ..."))
+        api.API.update_service_capabilities(context, 'compute', self.last_capabilities)
+
         super(SchedulerDependentManager, self).periodic_tasks(context)
diff --git a/nova/service.py b/nova/service.py
index 66287b505..a98d6aac1 100644
--- a/nova/service.py
+++ b/nova/service.py
@@ -86,17 +86,17 @@ class Service(object):
         conn2 = rpc.Connection.instance(new=True)
         conn3 = rpc.Connection.instance(new=True)
         if self.report_interval:
-            consumer_all = rpc.AdapterConsumer(
+            consumer_all = rpc.TopicAdapterConsumer(
                     connection=conn1,
                     topic=self.topic,
                     proxy=self)
-            consumer_node = rpc.AdapterConsumer(
+            consumer_node = rpc.TopicAdapterConsumer(
                     connection=conn2,
                     topic='%s.%s' % (self.topic, self.host),
                     proxy=self)
-            fanout = rpc.AdapterConsumer(
+            fanout = rpc.FanoutAdapterConsumer(
                     connection=conn3,
-                    topic='%s_fanout' % self.topic,
+                    topic=self.topic,
                     proxy=self)
 
             self.timers.append(consumer_all.attach_to_eventlet())
-- 
cgit 


From 32f062c389a530b6af3f864eb4030a68d0a26eb1 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Sun, 20 Feb 2011 22:33:39 -0800
Subject: fanout works

---
 nova/rpc.py | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/rpc.py b/nova/rpc.py
index e0cf6d301..601e45b47 100644
--- a/nova/rpc.py
+++ b/nova/rpc.py
@@ -215,8 +215,12 @@ class FanoutAdapterConsumer(AdapterConsumer):
     def __init__(self, connection=None, topic="broadcast", proxy=None):
         self.exchange = "%s_fanout" % topic
         self.routing_key = topic
-        self.queue = "ignored"
+        unique = uuid.uuid4().hex
+        self.queue = "%s_fanout_%s" % (topic, unique)
         self.durable = False
+        LOG.info(_("Created '%(exchange)s' fanout exchange "
+                                        "with '%(key)s' routing key"),
+                            dict(exchange=self.exchange, key=self.routing_key))
         super(FanoutAdapterConsumer, self).__init__(connection=connection,
                                     topic=topic, proxy=proxy)
 
@@ -228,7 +232,6 @@ class TopicPublisher(Publisher):
     def __init__(self, connection=None, topic="broadcast"):
         self.routing_key = topic
         self.exchange = FLAGS.control_exchange
-        self.queue = "ignored"
         self.durable = False
         super(TopicPublisher, self).__init__(connection=connection)
 
@@ -239,7 +242,10 @@ class FanoutPublisher(Publisher):
 
     def __init__(self, topic, connection=None):
         self.exchange = "%s_fanout" % topic
+        self.queue = "%s_fanout" % topic
         self.durable = False
+        LOG.info(_("Writing to '%(exchange)s' fanout exchange"),
+                            dict(exchange=self.exchange))
         super(FanoutPublisher, self).__init__(connection=connection)
 
 
-- 
cgit 


From e729c49543c5acf354b154a3e2d9fd76a2f7da35 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
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')

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 <soren@linux2go.dk>
Date: Mon, 21 Feb 2011 10:18:43 +0100
Subject: Also remove rules that jump to deleted chains.

---
 nova/network/linux_net.py | 5 ++++-
 nova/virt/libvirt_conn.py | 7 ++-----
 2 files changed, 6 insertions(+), 6 deletions(-)

(limited to 'nova')

diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index ecda450bf..1f96a4d55 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -104,6 +104,9 @@ class IptablesTable(object):
         self.chains.remove(name)
         self.rules = filter(lambda r: r.chain != name, self.rules)
 
+        jump_snippet = '-j %s-%s' % (binary_name, name)
+        self.rules = filter(lambda r: jump_snippet not in r.rule, self.rules)
+
     def add_rule(self, chain, rule, wrap=True):
         if wrap and chain not in self.chains:
             raise ValueError(_("Unknown chain: %r") % chain)
@@ -283,7 +286,7 @@ def remove_floating_forward(floating_ip, fixed_ip):
 def floating_forward_rules(floating_ip, fixed_ip):
     return [("PREROUTING", "-d %s -j DNAT --to %s" % (floating_ip, fixed_ip)),
             ("OUTPUT", "-d %s -j DNAT --to %s" % (floating_ip, fixed_ip)),
-            ("SNATTING", "-d %s -j DNAT --to %s" % (fixed_ip, floating_ip))]
+            ("SNATTING", "-d %s -j SNAT --to %s" % (fixed_ip, floating_ip))]
 
 def ensure_vlan_bridge(vlan_num, bridge, net_attrs=None):
     """Create a vlan and bridge unless they already exist"""
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 <soren@linux2go.dk>
Date: Mon, 21 Feb 2011 10:42:59 +0100
Subject: Unfilter instance correctly on termination.

---
 nova/network/linux_net.py | 4 ++++
 nova/virt/libvirt_conn.py | 8 +++-----
 2 files changed, 7 insertions(+), 5 deletions(-)

(limited to 'nova')

diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index 1f96a4d55..1145bfa7a 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -101,6 +101,10 @@ class IptablesTable(object):
         self.chains.add(name)
 
     def remove_chain(self, name):
+        if name not in self.chain:
+            LOG.debug(_("Attempted to remove chain %s which doesn't exist"),
+                      name)
+            return
         self.chains.remove(name)
         self.rules = filter(lambda r: r.chain != name, self.rules)
 
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 384a4525e9d6de54158cd170487fce95df814b52 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Mon, 21 Feb 2011 11:01:27 +0100
Subject: Fix typo

---
 nova/network/linux_net.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index 1145bfa7a..c5779f85f 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -101,7 +101,7 @@ class IptablesTable(object):
         self.chains.add(name)
 
     def remove_chain(self, name):
-        if name not in self.chain:
+        if name not in self.chains:
             LOG.debug(_("Attempted to remove chain %s which doesn't exist"),
                       name)
             return
-- 
cgit 


From 15203c9ceaa94f0cd5bad96622ee93af7662bcce Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Mon, 21 Feb 2011 12:22:29 +0100
Subject: Allow non-existing rules to be removed.

---
 nova/network/linux_net.py | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index c5779f85f..d4cfbbde9 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -125,8 +125,12 @@ class IptablesTable(object):
             return '%s-%s' % (binary_name, s[1:])
         return s
 
-    def remove_rule(self, chain, rule):
-        self.rules.remove(IptablesRule(chain, rule))
+    def remove_rule(self, *args, **kwargs):
+        try:
+            self.rules.remove(IptablesRule(*args, **kwargs))
+        except ValueError:
+            LOG.debug(_("Tried to remove rule that wasn't there: %r %r"),
+                      args, kwargs)
 
 class IptablesManager(object):
     def __init__(self, execute=None):
-- 
cgit 


From a57dffb5fdfbfac59b9ddbe7b33d6f03b7b748ba Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Mon, 21 Feb 2011 14:16:42 +0100
Subject: PEP-8 fixes

---
 nova/network/linux_net.py  | 28 ++++++++++++++++++++--------
 nova/tests/test_network.py | 21 +++++++++------------
 nova/tests/test_virt.py    |  3 ++-
 nova/utils.py              | 12 ++++++------
 nova/virt/libvirt_conn.py  |  2 --
 5 files changed, 37 insertions(+), 29 deletions(-)

(limited to 'nova')

diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index d4cfbbde9..b5d1323a1 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -129,8 +129,10 @@ class IptablesTable(object):
         try:
             self.rules.remove(IptablesRule(*args, **kwargs))
         except ValueError:
-            LOG.debug(_("Tried to remove rule that wasn't there: %r %r"),
-                      args, kwargs)
+            LOG.debug(_("Tried to remove rule that wasn't there:"
+                        " %(args)r %(kwargs)r"), {'args': args,
+                                                  'kwargs': kwargs})
+
 
 class IptablesManager(object):
     def __init__(self, execute=None):
@@ -142,9 +144,9 @@ class IptablesManager(object):
         else:
             self.execute = execute
 
-        self.ipv4 = { 'filter': IptablesTable(),
-                      'nat': IptablesTable() }
-        self.ipv6 = { 'filter': IptablesTable() }
+        self.ipv4 = {'filter': IptablesTable(),
+                     'nat': IptablesTable()}
+        self.ipv6 = {'filter': IptablesTable()}
 
         self.ipv4['nat'].add_chain('SNATTING')
         self.ipv4['nat'].add_rule('POSTROUTING',
@@ -155,11 +157,18 @@ class IptablesManager(object):
         self.ipv4['filter'].add_rule('FORWARD',
                                     '-j %s-local' % (binary_name,),
                                     wrap=False)
-
         self.ipv4['filter'].add_rule('OUTPUT',
                                     '-j %s-local' % (binary_name,),
                                     wrap=False)
 
+        self.ipv6['filter'].add_chain('local')
+        self.ipv6['filter'].add_rule('FORWARD',
+                                    '-j %s-local' % (binary_name,),
+                                    wrap=False)
+        self.ipv6['filter'].add_rule('OUTPUT',
+                                    '-j %s-local' % (binary_name,),
+                                    wrap=False)
+
         # Wrap the builtin chains
         builtin_chains = {'filter': ['INPUT', 'OUTPUT', 'FORWARD'],
                           'nat': ['PREROUTING', 'OUTPUT', 'POSTROUTING']}
@@ -172,7 +181,6 @@ class IptablesManager(object):
                                           wrap=False)
         self.semaphore = semaphore.Semaphore()
 
-
     def apply(self):
         with self.semaphore:
             s = [('iptables', self.ipv4)]
@@ -184,7 +192,8 @@ class IptablesManager(object):
                     current_table, _ = self.execute('sudo %s-save -t %s' %
                                                     (cmd, table), attempts=5)
                     current_lines = current_table.split('\n')
-                    new_filter = self.modify_rules(current_lines, tables[table])
+                    new_filter = self.modify_rules(current_lines,
+                                                   tables[table])
                     self.execute('sudo %s-restore' % (cmd,),
                                  process_input='\n'.join(new_filter),
                                  attempts=5)
@@ -285,17 +294,20 @@ def ensure_floating_forward(floating_ip, fixed_ip):
         iptables_manager.ipv4['nat'].add_rule(chain, rule)
     iptables_manager.apply()
 
+
 def remove_floating_forward(floating_ip, fixed_ip):
     """Remove forwarding for floating ip"""
     for chain, rule in floating_forward_rules(floating_ip, fixed_ip):
         iptables_manager.ipv4['nat'].remove_rule(chain, rule)
     iptables_manager.apply()
 
+
 def floating_forward_rules(floating_ip, fixed_ip):
     return [("PREROUTING", "-d %s -j DNAT --to %s" % (floating_ip, fixed_ip)),
             ("OUTPUT", "-d %s -j DNAT --to %s" % (floating_ip, fixed_ip)),
             ("SNATTING", "-d %s -j SNAT --to %s" % (fixed_ip, floating_ip))]
 
+
 def ensure_vlan_bridge(vlan_num, bridge, net_attrs=None):
     """Create a vlan and bridge unless they already exist"""
     interface = ensure_vlan(vlan_num)
diff --git a/nova/tests/test_network.py b/nova/tests/test_network.py
index b28d64245..c9a62a391 100644
--- a/nova/tests/test_network.py
+++ b/nova/tests/test_network.py
@@ -42,15 +42,14 @@ class IptablesManagerTestCase(test.TestCase):
 :INPUT ACCEPT [2223527:305688874]
 :FORWARD ACCEPT [0:0]
 :OUTPUT ACCEPT [2172501:140856656]
--A INPUT -i virbr0 -p udp -m udp --dport 53 -j ACCEPT 
--A INPUT -i virbr0 -p tcp -m tcp --dport 53 -j ACCEPT 
--A INPUT -i virbr0 -p udp -m udp --dport 67 -j ACCEPT 
--A INPUT -i virbr0 -p tcp -m tcp --dport 67 -j ACCEPT 
--A FORWARD -d 192.168.122.0/24 -o virbr0 -m state --state RELATED,ESTABLISHED -j ACCEPT 
--A FORWARD -s 192.168.122.0/24 -i virbr0 -j ACCEPT 
--A FORWARD -i virbr0 -o virbr0 -j ACCEPT 
--A FORWARD -o virbr0 -j REJECT --reject-with icmp-port-unreachable 
--A FORWARD -i virbr0 -j REJECT --reject-with icmp-port-unreachable 
+-A INPUT -i virbr0 -p udp -m udp --dport 53 -j ACCEPT
+-A INPUT -i virbr0 -p tcp -m tcp --dport 53 -j ACCEPT
+-A INPUT -i virbr0 -p udp -m udp --dport 67 -j ACCEPT
+-A INPUT -i virbr0 -p tcp -m tcp --dport 67 -j ACCEPT
+-A FORWARD -s 192.168.122.0/24 -i virbr0 -j ACCEPT
+-A FORWARD -i virbr0 -o virbr0 -j ACCEPT
+-A FORWARD -o virbr0 -j REJECT --reject-with icmp-port-unreachable
+-A FORWARD -i virbr0 -j REJECT --reject-with icmp-port-unreachable
 COMMIT
 # Completed on Fri Feb 18 15:17:05 2011"""
 
@@ -77,8 +76,7 @@ COMMIT
 
         # TODO(soren): Add stuff for ipv6
         check_matrix = {4: {'filter': ['INPUT', 'OUTPUT', 'FORWARD'],
-                            'nat': ['PREROUTING', 'INPUT',
-                                    'OUTPUT', 'POSTROUTING']} }
+                            'nat': ['PREROUTING', 'OUTPUT', 'POSTROUTING']}}
 
         for ip_version in check_matrix:
             ip = getattr(self.manager, 'ipv%d' % ip_version)
@@ -90,7 +88,6 @@ COMMIT
                                     (chain,) in new_lines)
                     self.assertTrue('-A %s -j run_tests.py-%s' % \
                                     (chain, chain) in new_lines)
-                print '\n'.join(new_lines)
 
 
 class NetworkTestCase(test.TestCase):
diff --git a/nova/tests/test_virt.py b/nova/tests/test_virt.py
index a88e01818..11201788c 100644
--- a/nova/tests/test_virt.py
+++ b/nova/tests/test_virt.py
@@ -345,7 +345,8 @@ class IptablesFirewallTestCase(test.TestCase):
         self.fw.prepare_instance_filter(instance_ref)
         self.fw.apply_instance_filter(instance_ref)
 
-        in_rules = filter(lambda l: not l.startswith('#'), self.in_filter_rules)
+        in_rules = filter(lambda l: not l.startswith('#'),
+                          self.in_filter_rules)
         for rule in in_rules:
             if not 'nova' in rule:
                 self.assertTrue(rule in self.out_rules,
diff --git a/nova/utils.py b/nova/utils.py
index 644bf18fd..5b44bccb5 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -126,7 +126,8 @@ def fetchfile(url, target):
     execute("curl --fail %s -o %s" % (url, target))
 
 
-def execute(cmd, process_input=None, addl_env=None, check_exit_code=True, attempts=1):
+def execute(cmd, process_input=None, addl_env=None, check_exit_code=True,
+            attempts=1):
     while attempts > 0:
         attempts -= 1
         try:
@@ -150,17 +151,16 @@ def execute(cmd, process_input=None, addl_env=None, check_exit_code=True, attemp
                                                 stdout=stdout,
                                                 stderr=stderr,
                                                 cmd=cmd)
-            # NOTE(termie): this appears to be necessary to let the subprocess call
-            #               clean something up in between calls, without it two
-            #               execute calls in a row hangs the second one
+            # NOTE(termie): this appears to be necessary to let the subprocess
+            #               call clean something up in between calls, without
+            #               it two execute calls in a row hangs the second one
             greenthread.sleep(0)
             return result
         except ProcessExecutionError:
             if not attempts:
                 raise
             else:
-                greenthread.sleep(random.randint(50,300)/100)
-                pass
+                greenthread.sleep(random.randint(20, 200) / 100.0)
 
 
 def ssh_execute(ssh, cmd, process_input=None,
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 3d2ec0f594e02018a32c8d0d7a8cc46f7ab4c849 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Mon, 21 Feb 2011 14:39:02 +0100
Subject: Wrap ipv6 rules, too

---
 nova/network/linux_net.py  | 26 +++++++++++++++++---------
 nova/tests/test_network.py |  3 ++-
 2 files changed, 19 insertions(+), 10 deletions(-)

(limited to 'nova')

diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index b5d1323a1..f47219b2e 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -170,15 +170,23 @@ class IptablesManager(object):
                                     wrap=False)
 
         # Wrap the builtin chains
-        builtin_chains = {'filter': ['INPUT', 'OUTPUT', 'FORWARD'],
-                          'nat': ['PREROUTING', 'OUTPUT', 'POSTROUTING']}
-
-        for table, chains in builtin_chains.iteritems():
-            for chain in chains:
-                self.ipv4[table].add_chain(chain)
-                self.ipv4[table].add_rule(chain,
-                                          '-j %s-%s' % (binary_name, chain),
-                                          wrap=False)
+        builtin_chains = { 4: {'filter': ['INPUT', 'OUTPUT', 'FORWARD'],
+                               'nat': ['PREROUTING', 'OUTPUT', 'POSTROUTING']},
+                           6: {'filter': ['INPUT', 'OUTPUT', 'FORWARD']}}
+
+        for ip_version in builtin_chains:
+            if ip_version == 4:
+                tables = self.ipv4
+            elif ip_version == 6:
+                tables = self.ipv6
+
+            for table, chains in builtin_chains[ip_version].iteritems():
+                for chain in chains:
+                    tables[table].add_chain(chain)
+                    tables[table].add_rule(chain,
+                                           '-j %s-%s' % (binary_name, chain),
+                                           wrap=False)
+
         self.semaphore = semaphore.Semaphore()
 
     def apply(self):
diff --git a/nova/tests/test_network.py b/nova/tests/test_network.py
index c9a62a391..f1d4fe133 100644
--- a/nova/tests/test_network.py
+++ b/nova/tests/test_network.py
@@ -76,7 +76,8 @@ COMMIT
 
         # TODO(soren): Add stuff for ipv6
         check_matrix = {4: {'filter': ['INPUT', 'OUTPUT', 'FORWARD'],
-                            'nat': ['PREROUTING', 'OUTPUT', 'POSTROUTING']}}
+                            'nat': ['PREROUTING', 'OUTPUT', 'POSTROUTING']},
+                        6: {'filter': ['INPUT', 'OUTPUT', 'FORWARD']}}
 
         for ip_version in check_matrix:
             ip = getattr(self.manager, 'ipv%d' % ip_version)
-- 
cgit 


From 1ed4df93a246a06518f2c216cd0fc60ca67eb5c4 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Mon, 21 Feb 2011 14:39:38 +0100
Subject: More PEP-8

---
 nova/network/linux_net.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index f47219b2e..d7a3075cb 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -170,9 +170,9 @@ class IptablesManager(object):
                                     wrap=False)
 
         # Wrap the builtin chains
-        builtin_chains = { 4: {'filter': ['INPUT', 'OUTPUT', 'FORWARD'],
-                               'nat': ['PREROUTING', 'OUTPUT', 'POSTROUTING']},
-                           6: {'filter': ['INPUT', 'OUTPUT', 'FORWARD']}}
+        builtin_chains = {4: {'filter': ['INPUT', 'OUTPUT', 'FORWARD'],
+                              'nat': ['PREROUTING', 'OUTPUT', 'POSTROUTING']},
+                          6: {'filter': ['INPUT', 'OUTPUT', 'FORWARD']}}
 
         for ip_version in builtin_chains:
             if ip_version == 4:
-- 
cgit 


From 45f4b75491ef9f77b454792770609e0aa003a6e5 Mon Sep 17 00:00:00 2001
From: sateesh <sateesh.chodapuneedi@citrix.com>
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')

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 d5b81fa45fb43e1f90c572b7291280735aef2af8 Mon Sep 17 00:00:00 2001
From: sateesh <sateesh.chodapuneedi@citrix.com>
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')

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=<VMware ESX Host IP> 
-  --vmwareapi_host_username=<VMware ESX Username>
-  --vmwareapi_host_password=<VMware ESX Password>
-   
-Other flags
------------
-::
-  --network_manager=nova.network.manager.FlatManager
-  --flat_network_bridge=<ESX Virtual Machine Port Group>
-  --image_service=nova.image.glance.GlanceImageService
-  --glance_host=<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 <josh.kearney@rackspace.com>
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')

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 <josh.kearney@rackspace.com>
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')

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 fc0ea52d9379649d28de88d4fa1628e455533842 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Mon, 21 Feb 2011 23:08:26 +0100
Subject: Add a bunch of docs for the new iptables hotness.

---
 nova/network/linux_net.py | 72 ++++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 68 insertions(+), 4 deletions(-)

(limited to 'nova')

diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index d7a3075cb..3b6ec9338 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -69,6 +69,11 @@ binary_name = os.path.basename(inspect.stack()[-1][1])
 
 
 class IptablesRule(object):
+    """An iptables rule
+
+    You shouldn't need to use this class directly, it's only used by
+    IptablesManager
+    """
     def __init__(self, chain, rule, wrap=True):
         self.chain = chain
         self.rule = rule
@@ -93,14 +98,33 @@ class IptablesRule(object):
 
 
 class IptablesTable(object):
+    """An iptables table"""
+
     def __init__(self):
         self.rules = []
         self.chains = set()
 
     def add_chain(self, name):
+        """Adds a named chain to the table
+
+        The chain name is wrapped to be unique for the component creating
+        it, so different components of Nova can safely create identically
+        named chains without interfering with one another.
+
+        At the moment, its wrapped name is <binary name>-<chain name>,
+        so if nova-compute creates a chain named "OUTPUT", it'll actually
+        end up named "nova-compute-OUTPUT".
+        """
         self.chains.add(name)
 
     def remove_chain(self, name):
+        """Remove named chain
+
+        This removal "cascades". All rule in the chain are removed, as are
+        all rules in other chains that jump to it.
+
+        If the chain is not found, this is merely logged.
+        """
         if name not in self.chains:
             LOG.debug(_("Attempted to remove chain %s which doesn't exist"),
                       name)
@@ -112,6 +136,15 @@ class IptablesTable(object):
         self.rules = filter(lambda r: jump_snippet not in r.rule, self.rules)
 
     def add_rule(self, chain, rule, wrap=True):
+        """Add a rule to the table
+
+        This is just like what you'd feed to iptables, just without
+        the "-A <chain name>" bit at the start.
+
+        However, if you need to jump to one of your wrapped chains,
+        prepend its name with a '$' which will ensure the wrapping
+        is applied correctly.
+        """
         if wrap and chain not in self.chains:
             raise ValueError(_("Unknown chain: %r") % chain)
 
@@ -125,7 +158,13 @@ class IptablesTable(object):
             return '%s-%s' % (binary_name, s[1:])
         return s
 
-    def remove_rule(self, *args, **kwargs):
+    def remove_rule(self, chain, rule, wrap=True):
+        """Remove a rule from a chain
+
+        Note: The rule must be exactly identical to the one that was added.
+        You cannot switch arguments around like you can with the iptables
+        CLI tool.
+        """
         try:
             self.rules.remove(IptablesRule(*args, **kwargs))
         except ValueError:
@@ -135,6 +174,22 @@ class IptablesTable(object):
 
 
 class IptablesManager(object):
+    """Wrapper for iptables
+
+    See IptablesTable for some usage docs
+
+    A number of chains are set up to begin with.
+
+    For ipv4, the filter table has a INPUT, OUTPUT, FORWARD, and local chains
+    already set up, while the NAT chain has PREROUTING, OUTPUT, POSTROUTING,
+    and SNATTING. Except for "local" and "SNATTING" these are all set up so
+    that they are applied at the beginning of their non-wrapped counterparts.
+    "SNATTING" is jumped to from nat/POSTROUTING and "local" is jumped to from
+    filter/OUTPUT and filter/FORWARD.
+
+    For ipv6, the filter table has INPUT, OUTPUT, FORWARD, and local. "local"
+    has the same semantics as for ipv4.
+    """
     def __init__(self, execute=None):
         if not execute:
             if FLAGS.fake_network:
@@ -190,6 +245,16 @@ class IptablesManager(object):
         self.semaphore = semaphore.Semaphore()
 
     def apply(self):
+        """Apply the current in-memory set of iptables rules
+
+        This will blow away any rules left over from previous runs of the
+        same component of Nova, and replace them with our current set of
+        rules. This happens atomically, thanks to iptables-restore.
+        
+        We wrap the call in a semaphore lock, so that we don't race with
+        ourselves. In the event of a race with another component running
+        an iptables-* command at the same time, we retry up to 5 times.
+        """
         with self.semaphore:
             s = [('iptables', self.ipv4)]
             if FLAGS.use_ipv6:
@@ -200,14 +265,13 @@ class IptablesManager(object):
                     current_table, _ = self.execute('sudo %s-save -t %s' %
                                                     (cmd, table), attempts=5)
                     current_lines = current_table.split('\n')
-                    new_filter = self.modify_rules(current_lines,
+                    new_filter = self._modify_rules(current_lines,
                                                    tables[table])
                     self.execute('sudo %s-restore' % (cmd,),
                                  process_input='\n'.join(new_filter),
                                  attempts=5)
 
-    def modify_rules(self, current_lines, table, binary=None):
-
+    def _modify_rules(self, current_lines, table, binary=None):
         chains = table.chains
         rules = table.rules
 
-- 
cgit 


From 764f0a457e74c4498cbc9ea30a184e61f7932072 Mon Sep 17 00:00:00 2001
From: Kei Masumoto <masumotok@nttdata.co.jp>
Date: Tue, 22 Feb 2011 13:18:21 +0900
Subject: just add 005_add_live_migration.py.

---
 .../versions/005_add_live_migration.py             | 84 ++++++++++++++++++++++
 1 file changed, 84 insertions(+)
 create mode 100644 nova/db/sqlalchemy/migrate_repo/versions/005_add_live_migration.py

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/migrate_repo/versions/005_add_live_migration.py b/nova/db/sqlalchemy/migrate_repo/versions/005_add_live_migration.py
new file mode 100644
index 000000000..903f7a646
--- /dev/null
+++ b/nova/db/sqlalchemy/migrate_repo/versions/005_add_live_migration.py
@@ -0,0 +1,84 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# 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.
+
+from sqlalchemy import *
+from migrate import *
+
+from nova import log as logging
+
+
+meta = MetaData()
+
+instances = Table('instances', meta,
+        Column('id', Integer(),  primary_key=True, nullable=False),
+        )
+
+#
+# New Tables
+#
+
+compute_services = Table('compute_services', meta,
+        Column('created_at', DateTime(timezone=False)),
+        Column('updated_at', DateTime(timezone=False)),
+        Column('deleted_at', DateTime(timezone=False)),
+        Column('deleted', Boolean(create_constraint=True, name=None)),
+        Column('id', Integer(),  primary_key=True, nullable=False),
+        Column('service_id', Integer(), nullable=False),
+
+        Column('vcpus', Integer(), nullable=False),
+        Column('memory_mb', Integer(), nullable=False),
+        Column('local_gb', Integer(), nullable=False),
+        Column('vcpus_used', Integer(), nullable=False),
+        Column('memory_mb_used', Integer(), nullable=False),
+        Column('local_gb_used', Integer(), nullable=False),
+        Column('hypervisor_type',
+               Text(convert_unicode=False, assert_unicode=None,
+               unicode_error=None, _warn_on_bytestring=False),
+               nullable=False),
+        Column('hypervisor_version', Integer(), nullable=False),
+        Column('cpu_info',
+               Text(convert_unicode=False, assert_unicode=None,
+                    unicode_error=None, _warn_on_bytestring=False),
+               nullable=False),
+        )
+
+
+#
+# Tables to alter
+#
+instances_launched_on = Column(
+         'launched_on',
+         Text(convert_unicode=False, assert_unicode=None,
+              unicode_error=None, _warn_on_bytestring=False),
+              nullable=True)
+
+
+def upgrade(migrate_engine):
+    # Upgrade operations go here. Don't create your own engine;
+    # bind migrate_engine to your metadata
+    meta.bind = migrate_engine
+
+    try:
+        compute_services.create()
+    except Exception:
+        logging.info(repr(compute_services))
+        logging.exception('Exception while creating table')
+        meta.drop_all(tables=[compute_services])
+        raise
+
+    instances.create_column(instances_launched_on)
-- 
cgit 


From c53bb1718a9b5900d09637d0ee966dadbf073900 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Tue, 22 Feb 2011 09:00:29 +0100
Subject: Address some review comments.

---
 nova/network/linux_net.py | 16 ++++++++--------
 nova/tests/test_virt.py   |  1 -
 2 files changed, 8 insertions(+), 9 deletions(-)

(limited to 'nova')

diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index 3b6ec9338..42af73e74 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -54,8 +54,6 @@ flags.DEFINE_string('dhcpbridge', _bin_file('nova-dhcpbridge'),
                         'location of nova-dhcpbridge')
 flags.DEFINE_string('routing_source_ip', '$my_ip',
                     'Public IP of network host')
-flags.DEFINE_bool('use_nova_chains', False,
-                  'use the nova_ routing chains instead of default')
 flags.DEFINE_string('input_chain', 'INPUT',
                     'chain to add nova_input to')
 
@@ -266,7 +264,7 @@ class IptablesManager(object):
                                                     (cmd, table), attempts=5)
                     current_lines = current_table.split('\n')
                     new_filter = self._modify_rules(current_lines,
-                                                   tables[table])
+                                                    tables[table])
                     self.execute('sudo %s-restore' % (cmd,),
                                  process_input='\n'.join(new_filter),
                                  attempts=5)
@@ -276,15 +274,17 @@ class IptablesManager(object):
         rules = table.rules
 
         # Remove any trace of our rules
-        new_filter = filter(lambda l: binary_name not in l, current_lines)
+        new_filter = filter(lambda line: binary_name not in line,
+                            current_lines)
 
         seen_chains = False
-        for rules_index in range(len(new_filter)):
+        rules_index = 0
+        for rules_index, rule in enumerate(new_filter):
             if not seen_chains:
-                if new_filter[rules_index].startswith(':'):
+                if rule.startswith(':'):
                     seen_chains = True
-            elif seen_chains == 1:
-                if not new_filter[rules_index].startswith(':'):
+            else:
+                if not rule.startswith(':'):
                     break
 
         new_filter[rules_index:rules_index] = [str(rule) for rule in rules]
diff --git a/nova/tests/test_virt.py b/nova/tests/test_virt.py
index 11201788c..c2c7c8337 100644
--- a/nova/tests/test_virt.py
+++ b/nova/tests/test_virt.py
@@ -354,7 +354,6 @@ class IptablesFirewallTestCase(test.TestCase):
 
         instance_chain = None
         for rule in self.out_rules:
-            print rule
             # This is pretty crude, but it'll do for now
             if '-d 10.11.12.13 -j' in rule:
                 instance_chain = rule.split(' ')[-1]
-- 
cgit 


From 70d526dc44299b6bd54a5757d013ca3109887747 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Tue, 22 Feb 2011 09:28:02 +0100
Subject: Add a new chain, floating-ip-snat, at the top of SNATTING, so that
 SNATting for floating ips gets applied before the default SNAT rule.

---
 nova/network/linux_net.py | 43 ++++++++++++++++++-------------------------
 1 file changed, 18 insertions(+), 25 deletions(-)

(limited to 'nova')

diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index 42af73e74..6b0735b5c 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -201,26 +201,13 @@ class IptablesManager(object):
                      'nat': IptablesTable()}
         self.ipv6 = {'filter': IptablesTable()}
 
-        self.ipv4['nat'].add_chain('SNATTING')
-        self.ipv4['nat'].add_rule('POSTROUTING',
-                                  '-j %s-SNATTING' % (binary_name,),
-                                  wrap=False)
-
         self.ipv4['filter'].add_chain('local')
-        self.ipv4['filter'].add_rule('FORWARD',
-                                    '-j %s-local' % (binary_name,),
-                                    wrap=False)
-        self.ipv4['filter'].add_rule('OUTPUT',
-                                    '-j %s-local' % (binary_name,),
-                                    wrap=False)
+        self.ipv4['filter'].add_rule('FORWARD', '-j $local', wrap=False)
+        self.ipv4['filter'].add_rule('OUTPUT', '-j $local', wrap=False)
 
         self.ipv6['filter'].add_chain('local')
-        self.ipv6['filter'].add_rule('FORWARD',
-                                    '-j %s-local' % (binary_name,),
-                                    wrap=False)
-        self.ipv6['filter'].add_rule('OUTPUT',
-                                    '-j %s-local' % (binary_name,),
-                                    wrap=False)
+        self.ipv6['filter'].add_rule('FORWARD', '-j $local', wrap=False)
+        self.ipv6['filter'].add_rule('OUTPUT', '-j $local', wrap=False)
 
         # Wrap the builtin chains
         builtin_chains = {4: {'filter': ['INPUT', 'OUTPUT', 'FORWARD'],
@@ -236,12 +223,22 @@ class IptablesManager(object):
             for table, chains in builtin_chains[ip_version].iteritems():
                 for chain in chains:
                     tables[table].add_chain(chain)
-                    tables[table].add_rule(chain,
-                                           '-j %s-%s' % (binary_name, chain),
+                    tables[table].add_rule(chain, '-j $%s' % (chain,),
                                            wrap=False)
 
+        # We add a SNATTING chain after our (wrapped) POSTROUTING chain
+        # so that rules added there will be applied after whatever we have in
+        # (the wrapped) POSTROUTING.
+        self.ipv4['nat'].add_chain('SNATTING')
+        self.ipv4['nat'].add_rule('POSTROUTING', '-j $SNATTING', wrap=False)
+
+        self.ipv4['nat'].add_chain('floating-ip-snat')
+        self.ipv4['nat'].add_rule('SNATTING', '-j $floating-ip-snat')
+
         self.semaphore = semaphore.Semaphore()
 
+        iptables_manager.apply()
+
     def apply(self):
         """Apply the current in-memory set of iptables rules
 
@@ -318,11 +315,6 @@ def init_host():
                                            (FLAGS.fixed_range,
                                             FLAGS.routing_source_ip))
 
-    iptables_manager.ipv4['nat'].add_rule("POSTROUTING",
-                                          "-s %s -j SNAT --to-source %s" % \
-                                           (FLAGS.fixed_range,
-                                            FLAGS.routing_source_ip))
-
     iptables_manager.ipv4['nat'].add_rule("POSTROUTING",
                                           "-s %s -d %s -j ACCEPT" % \
                                           (FLAGS.fixed_range, FLAGS.dmz_cidr))
@@ -377,7 +369,8 @@ def remove_floating_forward(floating_ip, fixed_ip):
 def floating_forward_rules(floating_ip, fixed_ip):
     return [("PREROUTING", "-d %s -j DNAT --to %s" % (floating_ip, fixed_ip)),
             ("OUTPUT", "-d %s -j DNAT --to %s" % (floating_ip, fixed_ip)),
-            ("SNATTING", "-d %s -j SNAT --to %s" % (fixed_ip, floating_ip))]
+            ("floating-ip-snat",
+             "-s %s -j SNAT --to %s" % (fixed_ip, floating_ip))]
 
 
 def ensure_vlan_bridge(vlan_num, bridge, net_attrs=None):
-- 
cgit 


From bf37fb0ab5503a077a3d9e4109990d252e27cb15 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Tue, 22 Feb 2011 11:29:58 +0100
Subject: Add a bunch of tests for everything.

Add a 'head' kwarg to add_rule that lets the rule bubble to the top. This is needed for nova-filter-top to end up at the top.
---
 nova/network/linux_net.py  | 120 ++++++++++++++++++++++++++++++------------
 nova/tests/test_network.py | 128 +++++++++++++++++++++++++++++++++++++--------
 2 files changed, 192 insertions(+), 56 deletions(-)

(limited to 'nova')

diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index 6b0735b5c..2ccb5969e 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -72,19 +72,22 @@ class IptablesRule(object):
     You shouldn't need to use this class directly, it's only used by
     IptablesManager
     """
-    def __init__(self, chain, rule, wrap=True):
+    def __init__(self, chain, rule, wrap=True, head=False):
         self.chain = chain
         self.rule = rule
         self.wrap = wrap
+        self.head = head
 
     def __eq__(self, other):
         return ((self.chain == other.chain) and
                 (self.rule == other.rule) and
+                (self.head == other.head) and
                 (self.wrap == other.wrap))
 
     def __ne__(self, other):
         return ((self.chain != other.chain) or
                 (self.rule != other.rule) or
+                (self.head != other.head) or
                 (self.wrap != other.wrap))
 
     def __str__(self):
@@ -101,8 +104,9 @@ class IptablesTable(object):
     def __init__(self):
         self.rules = []
         self.chains = set()
+        self.unwrapped_chains = set()
 
-    def add_chain(self, name):
+    def add_chain(self, name, wrap=True):
         """Adds a named chain to the table
 
         The chain name is wrapped to be unique for the component creating
@@ -113,9 +117,12 @@ class IptablesTable(object):
         so if nova-compute creates a chain named "OUTPUT", it'll actually
         end up named "nova-compute-OUTPUT".
         """
-        self.chains.add(name)
+        if wrap:
+            self.chains.add(name)
+        else:
+            self.unwrapped_chains.add(name)
 
-    def remove_chain(self, name):
+    def remove_chain(self, name, wrap=True):
         """Remove named chain
 
         This removal "cascades". All rule in the chain are removed, as are
@@ -123,17 +130,27 @@ class IptablesTable(object):
 
         If the chain is not found, this is merely logged.
         """
-        if name not in self.chains:
+        if wrap:
+            chain_set = self.chains
+        else:
+            chain_set = self.unwrapped_chains
+
+        if name not in chain_set:
             LOG.debug(_("Attempted to remove chain %s which doesn't exist"),
                       name)
             return
-        self.chains.remove(name)
+
+        chain_set.remove(name)
         self.rules = filter(lambda r: r.chain != name, self.rules)
 
-        jump_snippet = '-j %s-%s' % (binary_name, name)
+        if wrap:
+            jump_snippet = '-j %s-%s' % (binary_name, name)
+        else:
+            jump_snippet = '-j %s' % (name,)
+
         self.rules = filter(lambda r: jump_snippet not in r.rule, self.rules)
 
-    def add_rule(self, chain, rule, wrap=True):
+    def add_rule(self, chain, rule, wrap=True, head=False):
         """Add a rule to the table
 
         This is just like what you'd feed to iptables, just without
@@ -149,14 +166,14 @@ class IptablesTable(object):
         if '$' in rule:
             rule = ' '.join(map(self._wrap_target_chain, rule.split(' ')))
 
-        self.rules.append(IptablesRule(chain, rule, wrap))
+        self.rules.append(IptablesRule(chain, rule, wrap, head))
 
     def _wrap_target_chain(self, s):
         if s.startswith('$'):
             return '%s-%s' % (binary_name, s[1:])
         return s
 
-    def remove_rule(self, chain, rule, wrap=True):
+    def remove_rule(self, chain, rule, wrap=True, head=False):
         """Remove a rule from a chain
 
         Note: The rule must be exactly identical to the one that was added.
@@ -164,11 +181,12 @@ class IptablesTable(object):
         CLI tool.
         """
         try:
-            self.rules.remove(IptablesRule(*args, **kwargs))
+            self.rules.remove(IptablesRule(chain, rule, wrap, head))
         except ValueError:
             LOG.debug(_("Tried to remove rule that wasn't there:"
-                        " %(args)r %(kwargs)r"), {'args': args,
-                                                  'kwargs': kwargs})
+                        " %(chain)r %(rule)r %(wrap)r %(head)r"),
+                      {'chain': chain, 'rule': rule,
+                       'head': head, 'wrap': wrap})
 
 
 class IptablesManager(object):
@@ -178,15 +196,19 @@ class IptablesManager(object):
 
     A number of chains are set up to begin with.
 
-    For ipv4, the filter table has a INPUT, OUTPUT, FORWARD, and local chains
-    already set up, while the NAT chain has PREROUTING, OUTPUT, POSTROUTING,
-    and SNATTING. Except for "local" and "SNATTING" these are all set up so
-    that they are applied at the beginning of their non-wrapped counterparts.
-    "SNATTING" is jumped to from nat/POSTROUTING and "local" is jumped to from
-    filter/OUTPUT and filter/FORWARD.
+    First, nova-filter-top. It's added at the top of FORWARD and OUTPUT. Its
+    name is not wrapped, so it's shared between the various nova workers. It's
+    intended for rules that need to live at the top of the FORWARD and OUTPUT
+    chains. It's in both the ipv4 and ipv6 set of tables.
 
-    For ipv6, the filter table has INPUT, OUTPUT, FORWARD, and local. "local"
-    has the same semantics as for ipv4.
+    For ipv4 and ipv6, the builtin INPUT, OUTPUT, and FORWARD filter chains are
+    wrapped, meaning that the "real" INPUT chain has a rule that jumps to the
+    wrapped INPUT chain, etc. Additionally, there's a wrapped chain named
+    "local" which is jumped to from nova-filter-top.
+
+    For ipv4, the builtin PREROUTING, OUTPUT, and POSTROUTING nat chains are
+    wrapped in the same was as the builtin filter chains. Additionally, there's
+    a SNATTING chain that is applied after the POSTROUTING chain.
     """
     def __init__(self, execute=None):
         if not execute:
@@ -201,13 +223,19 @@ class IptablesManager(object):
                      'nat': IptablesTable()}
         self.ipv6 = {'filter': IptablesTable()}
 
-        self.ipv4['filter'].add_chain('local')
-        self.ipv4['filter'].add_rule('FORWARD', '-j $local', wrap=False)
-        self.ipv4['filter'].add_rule('OUTPUT', '-j $local', wrap=False)
+        # Add a nova-filter-top chain. It's intended to be shared
+        # among the various nova components. It sits at the very top
+        # of FORWARD and OUTPUT.
+        for tables in [self.ipv4, self.ipv6]:
+            tables['filter'].add_chain('nova-filter-top', wrap=False)
+            tables['filter'].add_rule('FORWARD', '-j nova-filter-top',
+                                      wrap=False, head=True)
+            tables['filter'].add_rule('OUTPUT', '-j nova-filter-top',
+                                      wrap=False, head=True)
 
-        self.ipv6['filter'].add_chain('local')
-        self.ipv6['filter'].add_rule('FORWARD', '-j $local', wrap=False)
-        self.ipv6['filter'].add_rule('OUTPUT', '-j $local', wrap=False)
+            tables['filter'].add_chain('local')
+            tables['filter'].add_rule('nova-filter-top', '-j $local',
+                                      wrap=False)
 
         # Wrap the builtin chains
         builtin_chains = {4: {'filter': ['INPUT', 'OUTPUT', 'FORWARD'],
@@ -226,18 +254,27 @@ class IptablesManager(object):
                     tables[table].add_rule(chain, '-j $%s' % (chain,),
                                            wrap=False)
 
-        # We add a SNATTING chain after our (wrapped) POSTROUTING chain
-        # so that rules added there will be applied after whatever we have in
-        # (the wrapped) POSTROUTING.
+        # Add a nova-postrouting-bottom chain. It's intended to be shared
+        # among the various nova components. We set it as the last chain
+        # of POSTROUTING chain.
+        self.ipv4['nat'].add_chain('nova-postrouting-bottom', wrap=False)
+        self.ipv4['nat'].add_rule('POSTROUTING', '-j nova-postrouting-bottom',
+                                  wrap=False)
+
+
+        # We add a SNATTING chain to the shared nova-postrouting-bottom chain
+        # so that it's applied last.
         self.ipv4['nat'].add_chain('SNATTING')
-        self.ipv4['nat'].add_rule('POSTROUTING', '-j $SNATTING', wrap=False)
+        self.ipv4['nat'].add_rule('nova-postrouting-bottom', '-j $SNATTING', wrap=False)
 
+        # And then we add a floating-ip-snat chain and jump to first thing in the SNATTING
+        # chain.
         self.ipv4['nat'].add_chain('floating-ip-snat')
         self.ipv4['nat'].add_rule('SNATTING', '-j $floating-ip-snat')
 
         self.semaphore = semaphore.Semaphore()
 
-        iptables_manager.apply()
+        self.apply()
 
     def apply(self):
         """Apply the current in-memory set of iptables rules
@@ -245,7 +282,7 @@ class IptablesManager(object):
         This will blow away any rules left over from previous runs of the
         same component of Nova, and replace them with our current set of
         rules. This happens atomically, thanks to iptables-restore.
-        
+
         We wrap the call in a semaphore lock, so that we don't race with
         ourselves. In the event of a race with another component running
         an iptables-* command at the same time, we retry up to 5 times.
@@ -267,6 +304,7 @@ class IptablesManager(object):
                                  attempts=5)
 
     def _modify_rules(self, current_lines, table, binary=None):
+        unwrapped_chains = table.unwrapped_chains
         chains = table.chains
         rules = table.rules
 
@@ -284,11 +322,25 @@ class IptablesManager(object):
                 if not rule.startswith(':'):
                     break
 
-        new_filter[rules_index:rules_index] = [str(rule) for rule in rules]
+        new_filter[rules_index:rules_index] = [str(rule) for rule in rules
+                                               if rule.head or
+                                                  str(rule) not in new_filter]
+        new_filter[rules_index:rules_index] = [':%s - [0:0]' % \
+                                               (name,) \
+                                               for name in unwrapped_chains]
         new_filter[rules_index:rules_index] = [':%s-%s - [0:0]' % \
                                                (binary_name, name,) \
                                                for name in chains]
 
+        seen_lines = set()
+        def _weed_out_duplicates(line):
+            if line in seen_lines:
+                return False
+            else:
+                seen_lines.add(line)
+                return True
+
+        new_filter = filter(_weed_out_duplicates, new_filter)
         return new_filter
 
 
diff --git a/nova/tests/test_network.py b/nova/tests/test_network.py
index f1d4fe133..afd38272d 100644
--- a/nova/tests/test_network.py
+++ b/nova/tests/test_network.py
@@ -36,12 +36,22 @@ LOG = logging.getLogger('nova.tests.network')
 
 
 class IptablesManagerTestCase(test.TestCase):
-    sample_filter = """# Completed on Fri Feb 18 15:17:05 2011
-# Generated by iptables-save v1.4.10 on Fri Feb 18 15:17:05 2011
+    sample_filter = """# Generated by iptables-save on Fri Feb 18 15:17:05 2011
 *filter
 :INPUT ACCEPT [2223527:305688874]
 :FORWARD ACCEPT [0:0]
 :OUTPUT ACCEPT [2172501:140856656]
+:nova-compute-FORWARD - [0:0]
+:nova-compute-INPUT - [0:0]
+:nova-compute-local - [0:0]
+:nova-compute-OUTPUT - [0:0]
+:nova-filter-top - [0:0]
+-A FORWARD -j nova-filter-top
+-A OUTPUT -j nova-filter-top
+-A nova-filter-top -j nova-compute-local
+-A INPUT -j nova-compute-INPUT
+-A OUTPUT -j nova-compute-OUTPUT
+-A FORWARD -j nova-compute-FORWARD
 -A INPUT -i virbr0 -p udp -m udp --dport 53 -j ACCEPT
 -A INPUT -i virbr0 -p tcp -m tcp --dport 53 -j ACCEPT
 -A INPUT -i virbr0 -p udp -m udp --dport 67 -j ACCEPT
@@ -53,42 +63,116 @@ class IptablesManagerTestCase(test.TestCase):
 COMMIT
 # Completed on Fri Feb 18 15:17:05 2011"""
 
+    sample_nat = """# Generated by iptables-save on Fri Feb 18 15:17:05 2011
+*nat
+:PREROUTING ACCEPT [3936:762355]
+:INPUT ACCEPT [2447:225266]
+:OUTPUT ACCEPT [63491:4191863]
+:POSTROUTING ACCEPT [63112:4108641]
+:nova-compute-OUTPUT - [0:0]
+:nova-compute-floating-ip-snat - [0:0]
+:nova-compute-SNATTING - [0:0]
+:nova-compute-PREROUTING - [0:0]
+:nova-compute-POSTROUTING - [0:0]
+:nova-postrouting-bottom - [0:0]
+-A PREROUTING -j nova-compute-PREROUTING
+-A OUTPUT -j nova-compute-OUTPUT
+-A POSTROUTING -j nova-compute-POSTROUTING
+-A POSTROUTING -j nova-postrouting-bottom
+-A nova-postrouting-bottom -j nova-compute-SNATTING
+-A nova-compute-SNATTING -j nova-compute-floating-ip-snat
+COMMIT
+# Completed on Fri Feb 18 15:17:05 2011
+"""
+
     def setUp(self):
         super(IptablesManagerTestCase, self).setUp()
         self.manager = linux_net.IptablesManager()
 
-    def test_rules_are_wrapped(self):
+        
+    def test_filter_rules_are_wrapped(self):
         current_lines = self.sample_filter.split('\n')
 
         table = self.manager.ipv4['filter']
         table.add_rule('FORWARD', '-s 1.2.3.4/5 -j DROP')
-        new_lines = self.manager.modify_rules(current_lines, table)
+        new_lines = self.manager._modify_rules(current_lines, table)
         self.assertTrue('-A run_tests.py-FORWARD '
                         '-s 1.2.3.4/5 -j DROP' in new_lines)
 
         table.remove_rule('FORWARD', '-s 1.2.3.4/5 -j DROP')
-        new_lines = self.manager.modify_rules(current_lines, table)
+        new_lines = self.manager._modify_rules(current_lines, table)
         self.assertTrue('-A run_tests.py-FORWARD '
                         '-s 1.2.3.4/5 -j DROP' not in new_lines)
 
-    def test_wrapper_rules_in_place(self):
-        current_lines = self.sample_filter.split('\n')
+    def test_nat_rules(self):
+        current_lines = self.sample_nat.split('\n')
+        new_lines = self.manager._modify_rules(current_lines,
+                                               self.manager.ipv4['nat'])
+
+        for line in [':nova-compute-OUTPUT - [0:0]',
+                     ':nova-compute-floating-ip-snat - [0:0]',
+                     ':nova-compute-SNATTING - [0:0]',
+                     ':nova-compute-PREROUTING - [0:0]',
+                     ':nova-compute-POSTROUTING - [0:0]']:
+             self.assertTrue(line in new_lines, "One of nova-compute's chains "
+                                                "went missing.")
+
+        seen_lines = set()
+        for line in new_lines:
+            self.assertTrue(line not in seen_lines,
+                            "Duplicate line: %s" % line)
+            seen_lines.add(line)
 
-        # TODO(soren): Add stuff for ipv6
-        check_matrix = {4: {'filter': ['INPUT', 'OUTPUT', 'FORWARD'],
-                            'nat': ['PREROUTING', 'OUTPUT', 'POSTROUTING']},
-                        6: {'filter': ['INPUT', 'OUTPUT', 'FORWARD']}}
-
-        for ip_version in check_matrix:
-            ip = getattr(self.manager, 'ipv%d' % ip_version)
-            for table_name in ip:
-                table = ip[table_name]
-                new_lines = self.manager.modify_rules(current_lines, table)
-                for chain in check_matrix[ip_version][table_name]:
-                    self.assertTrue(':run_tests.py-%s - [0:0]' % \
-                                    (chain,) in new_lines)
-                    self.assertTrue('-A %s -j run_tests.py-%s' % \
-                                    (chain, chain) in new_lines)
+        last_postrouting_line = ''
+
+        for line in new_lines:
+            if line.startswith('-A POSTROUTING'):
+                last_postrouting_line = line
+
+        self.assertTrue('-j nova-postrouting-bottom' in last_postrouting_line,
+                        "Last POSTROUTING rule does not jump to "
+                        "nova-postouting-bottom: %s" % last_postrouting_line)
+
+        for chain in ['POSTROUTING', 'PREROUTING', 'OUTPUT']:
+            self.assertTrue('-A %s -j run_tests.py-%s' \
+                            % (chain, chain) in new_lines,
+                            "Built-in chain %s not wrapped" % (chain,))
+
+
+    def test_filter_rules(self):
+        current_lines = self.sample_filter.split('\n')
+        new_lines = self.manager._modify_rules(current_lines,
+                                               self.manager.ipv4['filter'])
+
+        for line in [':nova-compute-FORWARD - [0:0]',
+                     ':nova-compute-INPUT - [0:0]',
+                     ':nova-compute-local - [0:0]',
+                     ':nova-compute-OUTPUT - [0:0]']:
+             self.assertTrue(line in new_lines, "One of nova-compute's chains"
+                                                " went missing.")
+
+        seen_lines = set()
+        for line in new_lines:
+            self.assertTrue(line not in seen_lines,
+                            "Duplicate line: %s" % line)
+            seen_lines.add(line)
+
+        for chain in ['FORWARD', 'OUTPUT']:
+            for line in new_lines:
+                if line.startswith('-A %s' % chain):
+                    self.assertTrue('-j nova-filter-top' in line,
+                                    "First %s rule does not "
+                                    "jump to nova-filter-top" % chain)
+                    break
+
+        self.assertTrue('-A nova-filter-top '
+                        '-j run_tests.py-local' in new_lines,
+                        "nova-filter-top does not jump to wrapped local chain")
+
+        for chain in ['INPUT', 'OUTPUT', 'FORWARD']:
+            self.assertTrue('-A %s -j run_tests.py-%s' \
+                            % (chain, chain) in new_lines,
+                            "Built-in chain %s not wrapped" % (chain,))
 
 
 class NetworkTestCase(test.TestCase):
-- 
cgit 


From 54f2362d09393ad6ccdfee5689d4f547c69b3f42 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Tue, 22 Feb 2011 11:47:46 +0100
Subject: Remove leftover from debugging.

---
 nova/network/linux_net.py | 2 --
 1 file changed, 2 deletions(-)

(limited to 'nova')

diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index 2ccb5969e..5f480f633 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -274,8 +274,6 @@ class IptablesManager(object):
 
         self.semaphore = semaphore.Semaphore()
 
-        self.apply()
-
     def apply(self):
         """Apply the current in-memory set of iptables rules
 
-- 
cgit 


From b5e6601f76d64a96d6c7de5e9acdf5a8cf0fe8e9 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Tue, 22 Feb 2011 12:21:29 +0100
Subject: PEP8 adjustments.

---
 nova/network/linux_net.py  |  9 +++++----
 nova/tests/test_network.py | 10 ++++------
 2 files changed, 9 insertions(+), 10 deletions(-)

(limited to 'nova')

diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index 5f480f633..7c4c16810 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -261,14 +261,14 @@ class IptablesManager(object):
         self.ipv4['nat'].add_rule('POSTROUTING', '-j nova-postrouting-bottom',
                                   wrap=False)
 
-
         # We add a SNATTING chain to the shared nova-postrouting-bottom chain
         # so that it's applied last.
         self.ipv4['nat'].add_chain('SNATTING')
-        self.ipv4['nat'].add_rule('nova-postrouting-bottom', '-j $SNATTING', wrap=False)
+        self.ipv4['nat'].add_rule('nova-postrouting-bottom', '-j $SNATTING',
+                                  wrap=False)
 
-        # And then we add a floating-ip-snat chain and jump to first thing in the SNATTING
-        # chain.
+        # And then we add a floating-ip-snat chain and jump to first thing in
+        # the SNATTING chain.
         self.ipv4['nat'].add_chain('floating-ip-snat')
         self.ipv4['nat'].add_rule('SNATTING', '-j $floating-ip-snat')
 
@@ -331,6 +331,7 @@ class IptablesManager(object):
                                                for name in chains]
 
         seen_lines = set()
+
         def _weed_out_duplicates(line):
             if line in seen_lines:
                 return False
diff --git a/nova/tests/test_network.py b/nova/tests/test_network.py
index afd38272d..2bdf3709e 100644
--- a/nova/tests/test_network.py
+++ b/nova/tests/test_network.py
@@ -89,7 +89,6 @@ COMMIT
         super(IptablesManagerTestCase, self).setUp()
         self.manager = linux_net.IptablesManager()
 
-        
     def test_filter_rules_are_wrapped(self):
         current_lines = self.sample_filter.split('\n')
 
@@ -114,8 +113,8 @@ COMMIT
                      ':nova-compute-SNATTING - [0:0]',
                      ':nova-compute-PREROUTING - [0:0]',
                      ':nova-compute-POSTROUTING - [0:0]']:
-             self.assertTrue(line in new_lines, "One of nova-compute's chains "
-                                                "went missing.")
+            self.assertTrue(line in new_lines, "One of nova-compute's chains "
+                                               "went missing.")
 
         seen_lines = set()
         for line in new_lines:
@@ -138,7 +137,6 @@ COMMIT
                             % (chain, chain) in new_lines,
                             "Built-in chain %s not wrapped" % (chain,))
 
-
     def test_filter_rules(self):
         current_lines = self.sample_filter.split('\n')
         new_lines = self.manager._modify_rules(current_lines,
@@ -148,8 +146,8 @@ COMMIT
                      ':nova-compute-INPUT - [0:0]',
                      ':nova-compute-local - [0:0]',
                      ':nova-compute-OUTPUT - [0:0]']:
-             self.assertTrue(line in new_lines, "One of nova-compute's chains"
-                                                " went missing.")
+            self.assertTrue(line in new_lines, "One of nova-compute's chains"
+                                               " went missing.")
 
         seen_lines = set()
         for line in new_lines:
-- 
cgit 


From 92a693b04feddad2420a835a12f53520c5529d8f Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Tue, 22 Feb 2011 12:42:38 +0100
Subject: floating-ip-snat was too long. Use floating-snat instead.

---
 nova/network/linux_net.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'nova')

diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index 7c4c16810..5e89a1df6 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -267,10 +267,10 @@ class IptablesManager(object):
         self.ipv4['nat'].add_rule('nova-postrouting-bottom', '-j $SNATTING',
                                   wrap=False)
 
-        # And then we add a floating-ip-snat chain and jump to first thing in
+        # And then we add a floating-snat chain and jump to first thing in
         # the SNATTING chain.
-        self.ipv4['nat'].add_chain('floating-ip-snat')
-        self.ipv4['nat'].add_rule('SNATTING', '-j $floating-ip-snat')
+        self.ipv4['nat'].add_chain('floating-snat')
+        self.ipv4['nat'].add_rule('SNATTING', '-j $floating-snat')
 
         self.semaphore = semaphore.Semaphore()
 
@@ -420,7 +420,7 @@ def remove_floating_forward(floating_ip, fixed_ip):
 def floating_forward_rules(floating_ip, fixed_ip):
     return [("PREROUTING", "-d %s -j DNAT --to %s" % (floating_ip, fixed_ip)),
             ("OUTPUT", "-d %s -j DNAT --to %s" % (floating_ip, fixed_ip)),
-            ("floating-ip-snat",
+            ("floating-snat",
              "-s %s -j SNAT --to %s" % (fixed_ip, floating_ip))]
 
 
-- 
cgit 


From 443f01ef7d977ba6ff86508b908f66733bdd989e Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Tue, 22 Feb 2011 14:32:20 +0100
Subject: Account for the fact that iptables-save outputs rules with a space at
 the end. Reverse the rule deduplication so that the last one takes
 precedence.

---
 nova/network/linux_net.py  | 45 ++++++++++++++++++++++++++++++---------------
 nova/tests/test_network.py | 42 ++++++++++++++++++++++--------------------
 2 files changed, 52 insertions(+), 35 deletions(-)

(limited to 'nova')

diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index 5e89a1df6..849181641 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -72,22 +72,22 @@ class IptablesRule(object):
     You shouldn't need to use this class directly, it's only used by
     IptablesManager
     """
-    def __init__(self, chain, rule, wrap=True, head=False):
+    def __init__(self, chain, rule, wrap=True, top=False):
         self.chain = chain
         self.rule = rule
         self.wrap = wrap
-        self.head = head
+        self.top = top
 
     def __eq__(self, other):
         return ((self.chain == other.chain) and
                 (self.rule == other.rule) and
-                (self.head == other.head) and
+                (self.top == other.top) and
                 (self.wrap == other.wrap))
 
     def __ne__(self, other):
         return ((self.chain != other.chain) or
                 (self.rule != other.rule) or
-                (self.head != other.head) or
+                (self.top != other.top) or
                 (self.wrap != other.wrap))
 
     def __str__(self):
@@ -150,7 +150,7 @@ class IptablesTable(object):
 
         self.rules = filter(lambda r: jump_snippet not in r.rule, self.rules)
 
-    def add_rule(self, chain, rule, wrap=True, head=False):
+    def add_rule(self, chain, rule, wrap=True, top=False):
         """Add a rule to the table
 
         This is just like what you'd feed to iptables, just without
@@ -166,14 +166,14 @@ class IptablesTable(object):
         if '$' in rule:
             rule = ' '.join(map(self._wrap_target_chain, rule.split(' ')))
 
-        self.rules.append(IptablesRule(chain, rule, wrap, head))
+        self.rules.append(IptablesRule(chain, rule, wrap, top))
 
     def _wrap_target_chain(self, s):
         if s.startswith('$'):
             return '%s-%s' % (binary_name, s[1:])
         return s
 
-    def remove_rule(self, chain, rule, wrap=True, head=False):
+    def remove_rule(self, chain, rule, wrap=True, top=False):
         """Remove a rule from a chain
 
         Note: The rule must be exactly identical to the one that was added.
@@ -181,12 +181,12 @@ class IptablesTable(object):
         CLI tool.
         """
         try:
-            self.rules.remove(IptablesRule(chain, rule, wrap, head))
+            self.rules.remove(IptablesRule(chain, rule, wrap, top))
         except ValueError:
             LOG.debug(_("Tried to remove rule that wasn't there:"
-                        " %(chain)r %(rule)r %(wrap)r %(head)r"),
+                        " %(chain)r %(rule)r %(wrap)r %(top)r"),
                       {'chain': chain, 'rule': rule,
-                       'head': head, 'wrap': wrap})
+                       'top': top, 'wrap': wrap})
 
 
 class IptablesManager(object):
@@ -229,9 +229,9 @@ class IptablesManager(object):
         for tables in [self.ipv4, self.ipv6]:
             tables['filter'].add_chain('nova-filter-top', wrap=False)
             tables['filter'].add_rule('FORWARD', '-j nova-filter-top',
-                                      wrap=False, head=True)
+                                      wrap=False, top=True)
             tables['filter'].add_rule('OUTPUT', '-j nova-filter-top',
-                                      wrap=False, head=True)
+                                      wrap=False, top=True)
 
             tables['filter'].add_chain('local')
             tables['filter'].add_rule('nova-filter-top', '-j $local',
@@ -320,9 +320,19 @@ class IptablesManager(object):
                 if not rule.startswith(':'):
                     break
 
-        new_filter[rules_index:rules_index] = [str(rule) for rule in rules
-                                               if rule.head or
-                                                  str(rule) not in new_filter]
+        our_rules = []
+        for rule in rules:
+            rule_str = str(rule)
+            if rule.top:
+                # rule.top == True means we want this rule to be at the top.
+                # Further down, we weed out duplicates from the bottom of the
+                # list, so here we remove the dupes ahead of time.
+                new_filter = filter(lambda s: s.strip() != rule_str.strip(),
+                                    new_filter)
+            our_rules += [rule_str]
+
+        new_filter[rules_index:rules_index] = our_rules
+
         new_filter[rules_index:rules_index] = [':%s - [0:0]' % \
                                                (name,) \
                                                for name in unwrapped_chains]
@@ -333,13 +343,18 @@ class IptablesManager(object):
         seen_lines = set()
 
         def _weed_out_duplicates(line):
+            line = line.strip()
             if line in seen_lines:
                 return False
             else:
                 seen_lines.add(line)
                 return True
 
+        # We filter duplicates, letting the *last* occurrence take
+        # precendence.
+        new_filter.reverse()
         new_filter = filter(_weed_out_duplicates, new_filter)
+        new_filter.reverse()
         return new_filter
 
 
diff --git a/nova/tests/test_network.py b/nova/tests/test_network.py
index 2bdf3709e..b1d70e323 100644
--- a/nova/tests/test_network.py
+++ b/nova/tests/test_network.py
@@ -46,20 +46,20 @@ class IptablesManagerTestCase(test.TestCase):
 :nova-compute-local - [0:0]
 :nova-compute-OUTPUT - [0:0]
 :nova-filter-top - [0:0]
--A FORWARD -j nova-filter-top
--A OUTPUT -j nova-filter-top
--A nova-filter-top -j nova-compute-local
--A INPUT -j nova-compute-INPUT
--A OUTPUT -j nova-compute-OUTPUT
--A FORWARD -j nova-compute-FORWARD
--A INPUT -i virbr0 -p udp -m udp --dport 53 -j ACCEPT
--A INPUT -i virbr0 -p tcp -m tcp --dport 53 -j ACCEPT
--A INPUT -i virbr0 -p udp -m udp --dport 67 -j ACCEPT
--A INPUT -i virbr0 -p tcp -m tcp --dport 67 -j ACCEPT
--A FORWARD -s 192.168.122.0/24 -i virbr0 -j ACCEPT
--A FORWARD -i virbr0 -o virbr0 -j ACCEPT
--A FORWARD -o virbr0 -j REJECT --reject-with icmp-port-unreachable
--A FORWARD -i virbr0 -j REJECT --reject-with icmp-port-unreachable
+-A FORWARD -j nova-filter-top 
+-A OUTPUT -j nova-filter-top 
+-A nova-filter-top -j nova-compute-local 
+-A INPUT -j nova-compute-INPUT 
+-A OUTPUT -j nova-compute-OUTPUT 
+-A FORWARD -j nova-compute-FORWARD 
+-A INPUT -i virbr0 -p udp -m udp --dport 53 -j ACCEPT 
+-A INPUT -i virbr0 -p tcp -m tcp --dport 53 -j ACCEPT 
+-A INPUT -i virbr0 -p udp -m udp --dport 67 -j ACCEPT 
+-A INPUT -i virbr0 -p tcp -m tcp --dport 67 -j ACCEPT 
+-A FORWARD -s 192.168.122.0/24 -i virbr0 -j ACCEPT 
+-A FORWARD -i virbr0 -o virbr0 -j ACCEPT 
+-A FORWARD -o virbr0 -j REJECT --reject-with icmp-port-unreachable 
+-A FORWARD -i virbr0 -j REJECT --reject-with icmp-port-unreachable 
 COMMIT
 # Completed on Fri Feb 18 15:17:05 2011"""
 
@@ -75,12 +75,12 @@ COMMIT
 :nova-compute-PREROUTING - [0:0]
 :nova-compute-POSTROUTING - [0:0]
 :nova-postrouting-bottom - [0:0]
--A PREROUTING -j nova-compute-PREROUTING
--A OUTPUT -j nova-compute-OUTPUT
--A POSTROUTING -j nova-compute-POSTROUTING
--A POSTROUTING -j nova-postrouting-bottom
--A nova-postrouting-bottom -j nova-compute-SNATTING
--A nova-compute-SNATTING -j nova-compute-floating-ip-snat
+-A PREROUTING -j nova-compute-PREROUTING 
+-A OUTPUT -j nova-compute-OUTPUT 
+-A POSTROUTING -j nova-compute-POSTROUTING 
+-A POSTROUTING -j nova-postrouting-bottom 
+-A nova-postrouting-bottom -j nova-compute-SNATTING 
+-A nova-compute-SNATTING -j nova-compute-floating-ip-snat 
 COMMIT
 # Completed on Fri Feb 18 15:17:05 2011
 """
@@ -118,6 +118,7 @@ COMMIT
 
         seen_lines = set()
         for line in new_lines:
+            line = line.strip()
             self.assertTrue(line not in seen_lines,
                             "Duplicate line: %s" % line)
             seen_lines.add(line)
@@ -151,6 +152,7 @@ COMMIT
 
         seen_lines = set()
         for line in new_lines:
+            line = line.strip()
             self.assertTrue(line not in seen_lines,
                             "Duplicate line: %s" % line)
             seen_lines.add(line)
-- 
cgit 


From 7eee81ee6480a36b179ae26be88ebad9415c4b62 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Tue, 22 Feb 2011 14:40:00 +0100
Subject: PEP8 again

---
 nova/tests/test_network.py | 103 +++++++++++++++++++++++----------------------
 1 file changed, 52 insertions(+), 51 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/test_network.py b/nova/tests/test_network.py
index b1d70e323..d3a23abf4 100644
--- a/nova/tests/test_network.py
+++ b/nova/tests/test_network.py
@@ -36,61 +36,62 @@ LOG = logging.getLogger('nova.tests.network')
 
 
 class IptablesManagerTestCase(test.TestCase):
-    sample_filter = """# Generated by iptables-save on Fri Feb 18 15:17:05 2011
-*filter
-:INPUT ACCEPT [2223527:305688874]
-:FORWARD ACCEPT [0:0]
-:OUTPUT ACCEPT [2172501:140856656]
-:nova-compute-FORWARD - [0:0]
-:nova-compute-INPUT - [0:0]
-:nova-compute-local - [0:0]
-:nova-compute-OUTPUT - [0:0]
-:nova-filter-top - [0:0]
--A FORWARD -j nova-filter-top 
--A OUTPUT -j nova-filter-top 
--A nova-filter-top -j nova-compute-local 
--A INPUT -j nova-compute-INPUT 
--A OUTPUT -j nova-compute-OUTPUT 
--A FORWARD -j nova-compute-FORWARD 
--A INPUT -i virbr0 -p udp -m udp --dport 53 -j ACCEPT 
--A INPUT -i virbr0 -p tcp -m tcp --dport 53 -j ACCEPT 
--A INPUT -i virbr0 -p udp -m udp --dport 67 -j ACCEPT 
--A INPUT -i virbr0 -p tcp -m tcp --dport 67 -j ACCEPT 
--A FORWARD -s 192.168.122.0/24 -i virbr0 -j ACCEPT 
--A FORWARD -i virbr0 -o virbr0 -j ACCEPT 
--A FORWARD -o virbr0 -j REJECT --reject-with icmp-port-unreachable 
--A FORWARD -i virbr0 -j REJECT --reject-with icmp-port-unreachable 
-COMMIT
-# Completed on Fri Feb 18 15:17:05 2011"""
-
-    sample_nat = """# Generated by iptables-save on Fri Feb 18 15:17:05 2011
-*nat
-:PREROUTING ACCEPT [3936:762355]
-:INPUT ACCEPT [2447:225266]
-:OUTPUT ACCEPT [63491:4191863]
-:POSTROUTING ACCEPT [63112:4108641]
-:nova-compute-OUTPUT - [0:0]
-:nova-compute-floating-ip-snat - [0:0]
-:nova-compute-SNATTING - [0:0]
-:nova-compute-PREROUTING - [0:0]
-:nova-compute-POSTROUTING - [0:0]
-:nova-postrouting-bottom - [0:0]
--A PREROUTING -j nova-compute-PREROUTING 
--A OUTPUT -j nova-compute-OUTPUT 
--A POSTROUTING -j nova-compute-POSTROUTING 
--A POSTROUTING -j nova-postrouting-bottom 
--A nova-postrouting-bottom -j nova-compute-SNATTING 
--A nova-compute-SNATTING -j nova-compute-floating-ip-snat 
-COMMIT
-# Completed on Fri Feb 18 15:17:05 2011
-"""
+    sample_filter = ['#Generated by iptables-save on Fri Feb 18 15:17:05 2011',
+                     '*filter',
+                     ':INPUT ACCEPT [2223527:305688874]',
+                     ':FORWARD ACCEPT [0:0]',
+                     ':OUTPUT ACCEPT [2172501:140856656]',
+                     ':nova-compute-FORWARD - [0:0]',
+                     ':nova-compute-INPUT - [0:0]',
+                     ':nova-compute-local - [0:0]',
+                     ':nova-compute-OUTPUT - [0:0]',
+                     ':nova-filter-top - [0:0]',
+                     '-A FORWARD -j nova-filter-top ',
+                     '-A OUTPUT -j nova-filter-top ',
+                     '-A nova-filter-top -j nova-compute-local ',
+                     '-A INPUT -j nova-compute-INPUT ',
+                     '-A OUTPUT -j nova-compute-OUTPUT ',
+                     '-A FORWARD -j nova-compute-FORWARD ',
+                     '-A INPUT -i virbr0 -p udp -m udp --dport 53 -j ACCEPT ',
+                     '-A INPUT -i virbr0 -p tcp -m tcp --dport 53 -j ACCEPT ',
+                     '-A INPUT -i virbr0 -p udp -m udp --dport 67 -j ACCEPT ',
+                     '-A INPUT -i virbr0 -p tcp -m tcp --dport 67 -j ACCEPT ',
+                     '-A FORWARD -s 192.168.122.0/24 -i virbr0 -j ACCEPT ',
+                     '-A FORWARD -i virbr0 -o virbr0 -j ACCEPT ',
+                     '-A FORWARD -o virbr0 -j REJECT --reject-with '
+                     'icmp-port-unreachable ',
+                     '-A FORWARD -i virbr0 -j REJECT --reject-with '
+                     'icmp-port-unreachable ',
+                     'COMMIT',
+                     '# Completed on Fri Feb 18 15:17:05 2011']
+
+    sample_nat = ['# Generated by iptables-save on Fri Feb 18 15:17:05 2011',
+                  '*nat',
+                  ':PREROUTING ACCEPT [3936:762355]',
+                  ':INPUT ACCEPT [2447:225266]',
+                  ':OUTPUT ACCEPT [63491:4191863]',
+                  ':POSTROUTING ACCEPT [63112:4108641]',
+                  ':nova-compute-OUTPUT - [0:0]',
+                  ':nova-compute-floating-ip-snat - [0:0]',
+                  ':nova-compute-SNATTING - [0:0]',
+                  ':nova-compute-PREROUTING - [0:0]',
+                  ':nova-compute-POSTROUTING - [0:0]',
+                  ':nova-postrouting-bottom - [0:0]',
+                  '-A PREROUTING -j nova-compute-PREROUTING ',
+                  '-A OUTPUT -j nova-compute-OUTPUT ',
+                  '-A POSTROUTING -j nova-compute-POSTROUTING ',
+                  '-A POSTROUTING -j nova-postrouting-bottom ',
+                  '-A nova-postrouting-bottom -j nova-compute-SNATTING ',
+                  '-A nova-compute-SNATTING -j nova-compute-floating-ip-snat ',
+                  'COMMIT',
+                  '# Completed on Fri Feb 18 15:17:05 2011']
 
     def setUp(self):
         super(IptablesManagerTestCase, self).setUp()
         self.manager = linux_net.IptablesManager()
 
     def test_filter_rules_are_wrapped(self):
-        current_lines = self.sample_filter.split('\n')
+        current_lines = self.sample_filter
 
         table = self.manager.ipv4['filter']
         table.add_rule('FORWARD', '-s 1.2.3.4/5 -j DROP')
@@ -104,7 +105,7 @@ COMMIT
                         '-s 1.2.3.4/5 -j DROP' not in new_lines)
 
     def test_nat_rules(self):
-        current_lines = self.sample_nat.split('\n')
+        current_lines = self.sample_nat
         new_lines = self.manager._modify_rules(current_lines,
                                                self.manager.ipv4['nat'])
 
@@ -139,7 +140,7 @@ COMMIT
                             "Built-in chain %s not wrapped" % (chain,))
 
     def test_filter_rules(self):
-        current_lines = self.sample_filter.split('\n')
+        current_lines = self.sample_filter
         new_lines = self.manager._modify_rules(current_lines,
                                                self.manager.ipv4['filter'])
 
-- 
cgit 


From c32e57999be09368b18f5a89315465e629ed4819 Mon Sep 17 00:00:00 2001
From: Kei Masumoto <masumotok@nttdata.co.jp>
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/compute/manager.py                            | 123 +++++---
 nova/db/api.py                                     |  12 +-
 nova/db/sqlalchemy/api.py                          |  27 +-
 .../versions/005_add_live_migration.py             |   3 +-
 nova/db/sqlalchemy/models.py                       |  12 +-
 nova/scheduler/driver.py                           | 121 +++++---
 nova/scheduler/manager.py                          |  15 +-
 nova/tests/test_compute.py                         |  77 ++---
 nova/tests/test_scheduler.py                       | 141 ++++------
 nova/tests/test_service.py                         |   6 +-
 nova/tests/test_virt.py                            | 309 +++++++++------------
 nova/virt/fake.py                                  |  74 +----
 nova/virt/libvirt_conn.py                          | 182 ++++++++----
 nova/virt/xenapi_conn.py                           |  14 +-
 nova/volume/driver.py                              |  14 +-
 15 files changed, 557 insertions(+), 573 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index d548cef6f..5b6e9082e 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -36,10 +36,10 @@ terminating it.
 
 import base64
 import datetime
+import os
 import random
 import string
 import socket
-import os
 import tempfile
 import time
 import functools
@@ -65,8 +65,8 @@ flags.DEFINE_string('console_host', socket.gethostname(),
                     'Console proxy host to use to connect to instances on'
                     'this host.')
 flags.DEFINE_string('live_migration_retry_count', 30,
-                    ("""Retry count needed in live_migration."""
-                     """ sleep 1 sec for each count"""))
+                    ("Retry count needed in live_migration."
+                     " sleep 1 sec for each count"))
 
 LOG = logging.getLogger('nova.compute.manager')
 
@@ -602,31 +602,66 @@ class ComputeManager(manager.Manager):
 
     @exception.wrap_exception
     def compare_cpu(self, context, 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.
+
+        :param context: security context
+        :param cpu_info: json string obtained from virConnect.getCapabilities
+        :returns: See driver.compare_cpu
+
+        """
         return self.driver.compare_cpu(cpu_info)
 
     @exception.wrap_exception
     def mktmpfile(self, context):
-        """make tmpfile under FLAGS.instance_path."""
-        fd, name = tempfile.mkstemp(dir=FLAGS.instances_path)
-        # No essential reason to write dateinfo. just for debugging reason.
-        os.fdopen(fd, 'w').write(str(datetime.datetime.utcnow()))
+        """Makes tmpfile under FLAGS.instance_path.
+
+        This method enables compute nodes to recognize that they mounts
+        same shared storage. mktmpfile()/confirm_tmpfile is a pair.
+
+        :param context: security context
+        :returns: tmpfile name
+
+        """
+
+        dirpath = FLAGS.instances_path
+        fd, name = tempfile.mkstemp(dir=dirpath)
+        LOG.debug(_("Creating tmpfile %s to notify to other "
+                    "compute node that they mounts same storage.") % name)
+        os.fdopen(fd, 'w+').close()
         return name
 
     @exception.wrap_exception
     def confirm_tmpfile(self, context, path):
-        """Confirm existence of the tmpfile given by path."""
+        """Confirms existence of the tmpfile given by path.
+
+        :param context: security context
+        :param path: confirm existence of this path
+        :returns: depends on os.remove()
+
+        """
+
         if not os.path.exists(path):
             raise exception.NotFound(_('%s not found') % path)
         return os.remove(path)
 
     @exception.wrap_exception
     def update_available_resource(self, context):
-        """See comments update_resource_info"""
+        """See comments update_resource_info.
+
+        :param context: security context
+        :returns: See driver.update_available_resource()
+
+        """
+
         return self.driver.update_available_resource(context, self.host)
 
     def pre_live_migration(self, context, instance_id):
-        """Any preparation for live migration at dst host."""
+        """Preparations for live migration at dest host.
+
+        :param context: security context
+        :param instance_id: nova.db.sqlalchemy.models.Instance.Id
+
+        """
 
         # Getting instance info
         instance_ref = self.db.instance_get(context, instance_id)
@@ -635,7 +670,7 @@ class ComputeManager(manager.Manager):
         # Getting fixed ips
         fixed_ip = self.db.instance_get_fixed_address(context, instance_id)
         if not fixed_ip:
-            msg = _("%(instance_id)s(%(ec2_id)s) doesnt have fixed_ip")
+            msg = _("%(instance_id)s(%(ec2_id)s) does'nt have fixed_ip")
             raise exception.NotFound(msg % locals())
 
         # If any volume is mounted, prepare here.
@@ -645,8 +680,8 @@ class ComputeManager(manager.Manager):
             for v in instance_ref['volumes']:
                 self.volume_manager.setup_compute_volume(context, v['id'])
 
-        # Bridge settings
-        # call this method prior to ensure_filtering_rules_for_instance,
+        # Bridge settings.
+        # Call this method prior to ensure_filtering_rules_for_instance,
         # since bridge is not set up, ensure_filtering_rules_for instance
         # fails.
         #
@@ -660,24 +695,29 @@ class ComputeManager(manager.Manager):
                 break
             except exception.ProcessExecutionError, e:
                 if i == max_retry - 1:
-                    raise e
+                    raise
                 else:
-                    LOG.warn(_("setup_compute_network() fail %(i)d th. "
-                               "Retry up to %(max_retry)d for %(ec2_id)s")
+                    LOG.warn(_("setup_compute_network() failed %(i)d."
+                               "Retry up to %(max_retry)d for %(ec2_id)s.")
                                % locals())
                     time.sleep(1)
 
         # Creating filters to hypervisors and firewalls.
         # An example is that nova-instance-instance-xxx,
-        # which is written to libvirt.xml( check "virsh nwfilter-list )
-        # On destination host, this nwfilter is necessary.
+        # which is written to libvirt.xml(Check "virsh nwfilter-list")
+        # This nwfilter is necessary on the destination host.
         # In addition, this method is creating filtering rule
         # onto destination host.
         self.driver.ensure_filtering_rules_for_instance(instance_ref)
 
-    #@exception.wrap_exception
     def live_migration(self, context, instance_id, dest):
-        """Executing live migration."""
+        """Executing live migration.
+
+        :param context: security context
+        :param instance_id: nova.db.sqlalchemy.models.Instance.Id
+        :param dest: destination host
+
+        """
 
         # Get instance for error handling.
         instance_ref = self.db.instance_get(context, instance_id)
@@ -702,7 +742,7 @@ class ComputeManager(manager.Manager):
             msg = _("Pre live migration for %(i_name)s failed at %(dest)s")
             LOG.error(msg % locals())
             self.recover_live_migration(context, instance_ref)
-            raise e
+            raise
 
         # Executing live migration
         # live_migration might raises exceptions, but
@@ -712,10 +752,17 @@ class ComputeManager(manager.Manager):
                                    self.recover_live_migration)
 
     def post_live_migration(self, ctxt, instance_ref, dest):
+        """Post operations for live migration.
+
+        This method is called from live_migration
+        and mainly updating database record.
+
+        :param ctxt: security context
+        :param instance_id: nova.db.sqlalchemy.models.Instance.Id
+        :param dest: destination host
+
         """
-        Post operations for live migration.
-        Mainly, database updating.
-        """
+
         LOG.info(_('post_live_migration() is started..'))
         instance_id = instance_ref['id']
 
@@ -734,19 +781,12 @@ class ComputeManager(manager.Manager):
 
         # Database updating.
         i_name = instance_ref.name
-        #fixed_ip = self.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:
-        #    LOG.warn(_('fixed_ip is not found for %s.') % i_name)
-        #self.db.fixed_ip_update(ctxt, fixed_ip, {'host': dest})
-
         try:
             # Not return if floating_ip is not found, otherwise,
             # instance never be accessible..
             floating_ip = self.db.instance_get_floating_address(ctxt,
                                                          instance_id)
-            if None == floating_ip:
+            if not floating_ip:
                 LOG.info(_('floating_ip is not found for %s'), i_name)
             else:
                 floating_ip_ref = self.db.floating_ip_get_by_address(ctxt,
@@ -763,15 +803,23 @@ class ComputeManager(manager.Manager):
         # Restore instance/volume state
         self.recover_live_migration(ctxt, instance_ref, dest)
 
-        msg = _('Migrating %(i_name)s to %(dest)s finishes successfully.')
-        LOG.info(msg % locals())
+        LOG.info(_('Migrating %(i_name)s to %(dest)s finishes successfully.')
+                 % locals())
         LOG.info(_("The below error is normally occurs."
                 "Just check if instance is successfully migrated.\n"
                 "libvir: QEMU error : Domain not found: no domain "
                 "with matching name.."))
 
     def recover_live_migration(self, ctxt, instance_ref, host=None):
-        """Instance/volume state is recovered from migrating -> running."""
+        """Recovers Instance/volume state from migrating -> running.
+
+        :param ctxt: security context
+        :param instance_id: nova.db.sqlalchemy.models.Instance.Id
+        :param host:
+            DB column value is updated by this hostname.
+            if none, the host instance currently running is selected.
+
+        """
 
         if not host:
             host = instance_ref['host']
@@ -783,5 +831,4 @@ class ComputeManager(manager.Manager):
                                  'host': host})
 
         for v in instance_ref['volumes']:
-            self.db.volume_update(ctxt, v['id'], {'status': 'in-use',
-                                                  'host': host})
+            self.db.volume_update(ctxt, v['id'], {'status': 'in-use'})
diff --git a/nova/db/api.py b/nova/db/api.py
index 609f62495..e10a06178 100644
--- a/nova/db/api.py
+++ b/nova/db/api.py
@@ -169,6 +169,7 @@ def compute_service_update(context, compute_id, values):
     Raises NotFound if computeService does not exist.
 
     """
+
     return IMPL.compute_service_update(context, compute_id, values)
 
 
@@ -446,27 +447,22 @@ def instance_add_security_group(context, instance_id, security_group_id):
                                             security_group_id)
 
 
-def instance_get_all_by_host(context, hostname):
-    """Get instances by host"""
-    return IMPL.instance_get_all_by_host(context, hostname)
-
-
 def instance_get_vcpu_sum_by_host_and_project(context, hostname, proj_id):
-    """Get instances.vcpus by host and project"""
+    """Get instances.vcpus by host and project."""
     return IMPL.instance_get_vcpu_sum_by_host_and_project(context,
                                                           hostname,
                                                           proj_id)
 
 
 def instance_get_memory_sum_by_host_and_project(context, hostname, proj_id):
-    """Get amount of memory by host and project """
+    """Get amount of memory by host and project."""
     return IMPL.instance_get_memory_sum_by_host_and_project(context,
                                                             hostname,
                                                             proj_id)
 
 
 def instance_get_disk_sum_by_host_and_project(context, hostname, proj_id):
-    """Get total amount of disk by host and project """
+    """Get total amount of disk by host and project."""
     return IMPL.instance_get_disk_sum_by_host_and_project(context,
                                                           hostname,
                                                           proj_id)
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 43d56cd8a..b4f45a089 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -184,8 +184,8 @@ def service_get_all_compute_by_host(context, host):
                   all()
 
     if not result:
-        msg = _('%s does not exist or not compute node')
-        raise exception.NotFound(msg % host)
+        raise exception.NotFound(_("%s does not exist or not "
+                                   "compute node.") % host)
 
     return result
 
@@ -328,7 +328,7 @@ def compute_service_create(context, values):
 def compute_service_update(context, compute_id, values):
     session = get_session()
     with session.begin():
-        compute_ref = service_get(context, compute_id, session=session)
+        compute_ref = compute_service_get(context, compute_id, session=session)
         compute_ref.update(values)
         compute_ref.save(session=session)
 
@@ -964,21 +964,6 @@ def instance_add_security_group(context, instance_id, security_group_id):
         instance_ref.save(session=session)
 
 
-@require_context
-def instance_get_all_by_host(context, hostname):
-    session = get_session()
-    if not session:
-        session = get_session()
-
-    result = session.query(models.Instance).\
-                     filter_by(host=hostname).\
-                     filter_by(deleted=can_read_deleted(context)).\
-                     all()
-    if not result:
-        return []
-    return result
-
-
 @require_context
 def instance_get_vcpu_sum_by_host_and_project(context, hostname, proj_id):
     session = get_session()
@@ -987,7 +972,7 @@ def instance_get_vcpu_sum_by_host_and_project(context, hostname, proj_id):
                       filter_by(project_id=proj_id).\
                       filter_by(deleted=False).\
                       value(func.sum(models.Instance.vcpus))
-    if None == result:
+    if not result:
         return 0
     return result
 
@@ -1000,7 +985,7 @@ def instance_get_memory_sum_by_host_and_project(context, hostname, proj_id):
                       filter_by(project_id=proj_id).\
                       filter_by(deleted=False).\
                       value(func.sum(models.Instance.memory_mb))
-    if None == result:
+    if not result:
         return 0
     return result
 
@@ -1013,7 +998,7 @@ def instance_get_disk_sum_by_host_and_project(context, hostname, proj_id):
                       filter_by(project_id=proj_id).\
                       filter_by(deleted=False).\
                       value(func.sum(models.Instance.local_gb))
-    if None == result:
+    if not result:
         return 0
     return result
 
diff --git a/nova/db/sqlalchemy/migrate_repo/versions/005_add_live_migration.py b/nova/db/sqlalchemy/migrate_repo/versions/005_add_live_migration.py
index 903f7a646..2689b5b74 100644
--- a/nova/db/sqlalchemy/migrate_repo/versions/005_add_live_migration.py
+++ b/nova/db/sqlalchemy/migrate_repo/versions/005_add_live_migration.py
@@ -16,10 +16,9 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-from sqlalchemy import *
 from migrate import *
-
 from nova import log as logging
+from sqlalchemy import *
 
 
 meta = MetaData()
diff --git a/nova/db/sqlalchemy/models.py b/nova/db/sqlalchemy/models.py
index 02d4e2f9b..f2a029c20 100644
--- a/nova/db/sqlalchemy/models.py
+++ b/nova/db/sqlalchemy/models.py
@@ -137,12 +137,14 @@ class ComputeService(BASE, NovaBase):
 
     # Note(masumotok): Expected Strings example:
     #
-    # '{"arch":"x86_64", "model":"Nehalem",
-    #  "topology":{"sockets":1, "threads":2, "cores":3},
-    #  features:[ "tdtscp", "xtpr"]}'
+    # '{"arch":"x86_64",
+    #   "model":"Nehalem",
+    #   "topology":{"sockets":1, "threads":2, "cores":3},
+    #   "features":["tdtscp", "xtpr"]}'
     #
     # Points are "json translatable" and it must have all dictionary keys
-    # above, and <cpu> tag of getCapabilities()(See libvirt.virtConnection).
+    # above, since it is copied from <cpu> tag of getCapabilities()
+    # (See libvirt.virtConnection).
     cpu_info = Column(Text, nullable=True)
 
 
@@ -220,7 +222,7 @@ class Instance(BASE, NovaBase):
     display_description = Column(String(255))
 
     # To remember on which host a instance booted.
-    # An instance may moved to other host by live migraiton.
+    # An instance may have moved to another host by live migraiton.
     launched_on = Column(Text)
     locked = Column(Boolean)
 
diff --git a/nova/scheduler/driver.py b/nova/scheduler/driver.py
index 41b87bbca..8c30702ba 100644
--- a/nova/scheduler/driver.py
+++ b/nova/scheduler/driver.py
@@ -70,9 +70,18 @@ class Scheduler(object):
         raise NotImplementedError(_("Must implement a fallback schedule"))
 
     def schedule_live_migration(self, context, instance_id, dest):
-        """live migration method"""
+        """Live migration scheduling method.
 
-        # Whether instance exists and running
+        :param context:
+        :param instance_id:
+        :param dest: destination host
+        :return:
+            The host where instance is running currently.
+            Then scheduler send request that host.
+
+        """
+
+        # Whether instance exists and is running.
         instance_ref = db.instance_get(context, instance_id)
 
         # Checking instance.
@@ -102,11 +111,16 @@ class Scheduler(object):
         return src
 
     def _live_migration_src_check(self, context, instance_ref):
-        """Live migration check routine (for src host)"""
+        """Live migration check routine (for src host).
+
+        :param context: security context
+        :param instance_ref: nova.db.sqlalchemy.models.Instance object
+
+        """
 
         # Checking instance is running.
-        if power_state.RUNNING != instance_ref['state'] or \
-           'running' != instance_ref['state_description']:
+        if (power_state.RUNNING != instance_ref['state'] or \
+           'running' != instance_ref['state_description']):
             msg = _('Instance(%s) is not running')
             ec2_id = instance_ref['hostname']
             raise exception.Invalid(msg % ec2_id)
@@ -129,7 +143,13 @@ class Scheduler(object):
             raise exception.Invalid(msg % src)
 
     def _live_migration_dest_check(self, context, instance_ref, dest):
-        """Live migration check routine (for destination host)"""
+        """Live migration check routine (for destination host).
+
+        :param context: security context
+        :param instance_ref: nova.db.sqlalchemy.models.Instance object
+        :param dest: destination host
+
+        """
 
         # Checking dest exists and compute node.
         dservice_refs = db.service_get_all_compute_by_host(context, dest)
@@ -145,20 +165,25 @@ class Scheduler(object):
         src = instance_ref['host']
         if dest == src:
             ec2_id = instance_ref['hostname']
-            msg = _("""%(dest)s is where %(ec2_id)s is """
-                    """running now. choose other host.""") % locals()
-            raise exception.Invalid(msg)
+            raise exception.Invalid(_("%(dest)s is where %(ec2_id)s is "
+                                       "running now. choose other host.")
+                                       % locals())
 
         # Checking dst host still has enough capacities.
-        self.has_enough_resource(context, instance_ref, dest)
+        self.has_enough_resources(context, instance_ref, dest)
 
     def _live_migration_common_check(self, context, instance_ref, dest):
-        """
-        Live migration check routine.
-        Below pre-checkings are followed by
+        """Live migration common check routine.
+
+        Below checkings are followed by
         http://wiki.libvirt.org/page/TodoPreMigrationChecks
 
+        :param context: security context
+        :param instance_ref: nova.db.sqlalchemy.models.Instance object
+        :param dest: destination host
+
         """
+
         # Checking shared storage connectivity
         self.mounted_on_same_shared_storage(context, instance_ref, dest)
 
@@ -168,27 +193,27 @@ class Scheduler(object):
 
         # Checking original host( where instance was launched at) exists.
         try:
-            oservice_refs = \
-                db.service_get_all_compute_by_host(context,
-                                                   instance_ref['launched_on'])
+            oservice_refs = db.service_get_all_compute_by_host(context,
+                                           instance_ref['launched_on'])
         except exception.NotFound:
-            msg = _('%s(where instance was launched at) does not exists.')
-            raise exception.Invalid(msg % instance_ref['launched_on'])
+            raise exception.Invalid(_("host %s where instance was launched "
+                                      "does not exist.")
+                                       % instance_ref['launched_on'])
         oservice_ref = oservice_refs[0]['compute_service'][0]
 
         # Checking hypervisor is same.
         o = oservice_ref['hypervisor_type']
         d = dservice_ref['hypervisor_type']
         if o != d:
-            msg = _('Different hypervisor type(%(o)s->%(d)s)') % locals()
-            raise exception.Invalid(msg)
+            raise exception.Invalid(_("Different hypervisor type"
+                                      "(%(o)s->%(d)s)')" % locals()))
 
         # Checkng hypervisor version.
         o = oservice_ref['hypervisor_version']
         d = dservice_ref['hypervisor_version']
         if o > d:
-            msg = _('Older hypervisor version(%(o)s->%(d)s)') % locals()
-            raise exception.Invalid(msg)
+            raise exception.Invalid(_('Older hypervisor version(%(o)s->%(d)s)')
+                                    % locals())
 
         # Checking cpuinfo.
         try:
@@ -200,19 +225,24 @@ class Scheduler(object):
         except rpc.RemoteError, e:
             ec2_id = instance_ref['hostname']
             src = instance_ref['host']
-            msg = _("""%(dest)s doesnt have compatibility to %(src)s"""
-                    """(where %(ec2_id)s was launched at)""")
-            logging.exception(msg % locals())
-            raise e
+            logging.exception(_("host %(dest)s is not compatible with "
+                                "original host %(src)s.") % locals())
+            raise
+
+    def has_enough_resources(self, context, instance_ref, dest):
+        """Checks if destination host has enough resource for live migration.
 
-    def has_enough_resource(self, context, instance_ref, dest):
-        """
-        Check if destination host has enough resource for live migration.
         Currently, only memory checking has been done.
         If storage migration(block migration, meaning live-migration
         without any shared storage) will be available, local storage
         checking is also necessary.
+
+        :param context: security context
+        :param instance_ref: nova.db.sqlalchemy.models.Instance object
+        :param dest: destination host
+
         """
+
         # Getting instance information
         ec2_id = instance_ref['hostname']
 
@@ -225,15 +255,23 @@ class Scheduler(object):
         mem_avail = mem_total - mem_used
         mem_inst = instance_ref['memory_mb']
         if mem_avail <= mem_inst:
-            msg = _("""%(ec2_id)s is not capable to migrate %(dest)s"""
-                    """(host:%(mem_avail)s <= instance:%(mem_inst)s)""")
-            raise exception.NotEmpty(msg % locals())
+            raise exception.NotEmpty(_("%(ec2_id)s is not capable to "
+                                       "migrate %(dest)s (host:%(mem_avail)s "
+                                       " <= instance:%(mem_inst)s)")
+                                       % locals())
 
     def mounted_on_same_shared_storage(self, context, instance_ref, dest):
+        """Check if the src and dest host mount same shared storage.
+
+        At first, dest host creates temp file, and src host can see
+        it if they mounts same shared storage. Then src host erase it.
+
+        :param context: security context
+        :param instance_ref: nova.db.sqlalchemy.models.Instance object
+        :param dest: destination host
+
         """
-        Check if /nova-inst-dir/insntances is mounted same storage at
-        live-migration src and dest host.
-        """
+
         src = instance_ref['host']
         dst_t = db.queue_get_for(context, FLAGS.compute_topic, dest)
         src_t = db.queue_get_for(context, FLAGS.compute_topic, src)
@@ -243,8 +281,8 @@ class Scheduler(object):
             filename = rpc.call(context, dst_t, {"method": 'mktmpfile'})
         except rpc.RemoteError, e:
             msg = _("Cannot create tmpfile at %s to confirm shared storage.")
-            logging.error(msg % FLAGS.instance_path)
-            raise e
+            LOG.error(msg % FLAGS.instances_path)
+            raise
 
         # make sure existence at src host.
         try:
@@ -252,8 +290,7 @@ class Scheduler(object):
                      {"method": 'confirm_tmpfile', "args": {'path': filename}})
 
         except (rpc.RemoteError, exception.NotFound), e:
-            ipath = FLAGS.instance_path
-            msg = _("""Cannot comfirm %(ipath)s at %(dest)s is located at"""
-                    """ same shared storage.""") % locals()
-            logging.error(msg)
-            raise e
+            ipath = FLAGS.instances_path
+            logging.error(_("Cannot comfirm %(ipath)s at %(dest)s is "
+                            "located at same shared storage.") % locals())
+            raise
diff --git a/nova/scheduler/manager.py b/nova/scheduler/manager.py
index 584dc49d2..783594c6f 100644
--- a/nova/scheduler/manager.py
+++ b/nova/scheduler/manager.py
@@ -69,10 +69,19 @@ class SchedulerManager(manager.Manager):
         LOG.debug(_("Casting to %(topic)s %(host)s for %(method)s") % locals())
 
     # NOTE (masumotok) : This method should be moved to nova.api.ec2.admin.
-    #                    Based on bear design summit discussion,
+    #                    Based on bexar design summit discussion,
     #                    just put this here for bexar release.
-    def show_host_resource(self, context, host, *args):
-        """show the physical/usage resource given by hosts."""
+    def show_host_resources(self, context, host, *args):
+        """Shows the physical/usage resource given by hosts.
+
+        :param context: security context
+        :param host: hostname
+        :returns:
+            example format is below.
+            {'resource':D, 'usage':{proj_id1:D, proj_id2:D}}
+            D: {'vcpus':3, 'memory_mb':2048, 'local_gb':2048}
+
+        """
 
         compute_ref = db.service_get_all_compute_by_host(context, host)
         compute_ref = compute_ref[0]
diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index 74cb82eeb..3c88d186d 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -314,10 +314,7 @@ class ComputeTestCase(test.TestCase):
         self.compute_driver = utils.import_object(FLAGS.compute_driver)
 
     def test_pre_live_migration_instance_has_no_fixed_ip(self):
-        """
-           if instances that are intended to be migrated doesnt have fixed_ip
-           (not happens usually), pre_live_migration has to raise Exception.
-        """
+        """Confirm raising exception if instance doesn't have fixed_ip."""
         instance_ref = self._get_dummy_instance()
         c = context.get_admin_context()
         i_id = instance_ref['id']
@@ -331,14 +328,9 @@ class ComputeTestCase(test.TestCase):
         self.assertRaises(exception.NotFound,
                           self.compute.pre_live_migration,
                           c, instance_ref['id'])
-        self.mox.ResetAll()
 
     def test_pre_live_migration_instance_has_volume(self):
-        """if any volumes are attached to the instances that are
-           intended to be migrated, setup_compute_volume must be
-           called because aoe module should be inserted at destination
-           host. This testcase checks on it.
-        """
+        """Confirm setup_compute_volume is called when volume is mounted."""
         i_ref = self._get_dummy_instance()
         c = context.get_admin_context()
 
@@ -364,14 +356,9 @@ class ComputeTestCase(test.TestCase):
         self.mox.ReplayAll()
         ret = self.compute.pre_live_migration(c, i_ref['id'])
         self.assertEqual(ret, None)
-        self.mox.ResetAll()
 
     def test_pre_live_migration_instance_has_no_volume(self):
-        """if any volumes are not attached to the instances that are
-           intended to be migrated, log message should be appears
-           because administrator can proove instance conditions before
-           live_migration if any trouble occurs.
-        """
+        """Confirm log meg when instance doesn't mount any volumes."""
         i_ref = self._get_dummy_instance()
         i_ref.__setitem__('volumes', [])
         c = context.get_admin_context()
@@ -395,14 +382,14 @@ class ComputeTestCase(test.TestCase):
         self.mox.ReplayAll()
         ret = self.compute.pre_live_migration(c, i_ref['id'])
         self.assertEqual(ret, None)
-        self.mox.ResetAll()
 
     def test_pre_live_migration_setup_compute_node_fail(self):
-        """setup_compute_node sometimes fail since concurrent request
-           comes to iptables and iptables complains. Then this method
-           tries to retry, but raise exception in case of over
-            max_retry_count. this method confirms raising exception.
+        """Confirm operation setup_compute_network() fails.
+
+        It retries and raise exception when timeout exceeded.
+
         """
+
         i_ref = self._get_dummy_instance()
         c = context.get_admin_context()
 
@@ -427,14 +414,9 @@ class ComputeTestCase(test.TestCase):
         self.assertRaises(exception.ProcessExecutionError,
                           self.compute.pre_live_migration,
                           c, i_ref['id'])
-        self.mox.ResetAll()
 
-    def test_live_migration_instance_has_volume(self):
-        """Any volumes are mounted by instances to be migrated are found,
-           vblade health must be checked before starting live-migration.
-           And that is checked by check_for_export().
-           This testcase confirms check_for_export() is called.
-        """
+    def test_live_migration_works_correctly_with_volume(self):
+        """Confirm check_for_export to confirm volume health check."""
         i_ref = self._get_dummy_instance()
         c = context.get_admin_context()
         topic = db.queue_get_for(c, FLAGS.compute_topic, i_ref['host'])
@@ -457,15 +439,9 @@ class ComputeTestCase(test.TestCase):
         self.mox.ReplayAll()
         ret = self.compute.live_migration(c, i_ref['id'], i_ref['host'])
         self.assertEqual(ret, None)
-        self.mox.ResetAll()
-
-    def test_live_migration_instance_has_volume_and_exception(self):
-        """In addition to test_live_migration_instance_has_volume testcase,
-           this testcase confirms if any exception raises from
-           check_for_export(). Then, valid seaquence of this method should
-           recovering instance/volumes status(ex. instance['state_description']
-           is changed from 'migrating' -> 'running', was changed by scheduler)
-        """
+
+    def test_live_migration_dest_raises_exception(self):
+        """Confirm exception when pre_live_migration fails."""
         i_ref = self._get_dummy_instance()
         c = context.get_admin_context()
         topic = db.queue_get_for(c, FLAGS.compute_topic, i_ref['host'])
@@ -484,20 +460,16 @@ class ComputeTestCase(test.TestCase):
                                                 'state': power_state.RUNNING,
                                                 'host': i_ref['host']})
         for v in i_ref['volumes']:
-            dbmock.volume_update(c, v['id'], {'status': 'in-use',
-                                              'host': i_ref['host']})
+            dbmock.volume_update(c, v['id'], {'status': 'in-use'})
 
         self.compute.db = dbmock
         self.mox.ReplayAll()
         self.assertRaises(rpc.RemoteError,
                           self.compute.live_migration,
                           c, i_ref['id'], i_ref['host'])
-        self.mox.ResetAll()
 
-    def test_live_migration_instance_has_no_volume_and_exception(self):
-        """Simpler than
-           test_live_migration_instance_has_volume_and_exception
-        """
+    def test_live_migration_dest_raises_exception_no_volume(self):
+        """Same as above test(input pattern is different) """
         i_ref = self._get_dummy_instance()
         i_ref.__setitem__('volumes', [])
         c = context.get_admin_context()
@@ -520,10 +492,9 @@ class ComputeTestCase(test.TestCase):
         self.assertRaises(rpc.RemoteError,
                           self.compute.live_migration,
                           c, i_ref['id'], i_ref['host'])
-        self.mox.ResetAll()
 
-    def test_live_migration_instance_has_no_volume(self):
-        """Simpler than test_live_migration_instance_has_volume."""
+    def test_live_migration_works_correctly_no_volume(self):
+        """Confirm live_migration() works as expected correctly."""
         i_ref = self._get_dummy_instance()
         i_ref.__setitem__('volumes', [])
         c = context.get_admin_context()
@@ -545,11 +516,9 @@ class ComputeTestCase(test.TestCase):
         self.mox.ReplayAll()
         ret = self.compute.live_migration(c, i_ref['id'], i_ref['host'])
         self.assertEqual(ret, None)
-        self.mox.ResetAll()
 
     def test_post_live_migration_working_correctly(self):
-        """post_live_migration works as expected correctly """
-
+        """Confirm post_live_migration() works as expected correctly."""
         dest = 'desthost'
         flo_addr = '1.2.1.2'
 
@@ -579,19 +548,15 @@ class ComputeTestCase(test.TestCase):
         # executing
         self.mox.ReplayAll()
         ret = self.compute.post_live_migration(c, i_ref, dest)
-        self.mox.UnsetStubs()
 
         # make sure every data is rewritten to dest
         i_ref = db.instance_get(c, i_ref['id'])
         c1 = (i_ref['host'] == dest)
-        v_ref = db.volume_get(c, v_ref['id'])
-        c2 = (v_ref['host'] == dest)
-        c3 = False
         flo_refs = db.floating_ip_get_all_by_host(c, dest)
-        c3 = (len(flo_refs) != 0 and flo_refs[0]['address'] == flo_addr)
+        c2 = (len(flo_refs) != 0 and flo_refs[0]['address'] == flo_addr)
 
         # post operaton
-        self.assertTrue(c1 and c2 and c3)
+        self.assertTrue(c1 and c2)
         db.instance_destroy(c, instance_id)
         db.volume_destroy(c, v_ref['id'])
         db.floating_ip_destroy(c, flo_addr)
diff --git a/nova/tests/test_scheduler.py b/nova/tests/test_scheduler.py
index 729bcb580..301106848 100644
--- a/nova/tests/test_scheduler.py
+++ b/nova/tests/test_scheduler.py
@@ -108,22 +108,21 @@ class SchedulerTestCase(test.TestCase):
         self.mox.ReplayAll()
         scheduler.named_method(ctxt, 'topic', num=7)
 
-    def test_show_host_resource_host_not_exit(self):
-        """
-        A testcase of driver.has_enough_resource
-        given host does not exists.
-        """
+    def test_show_host_resources_host_not_exit(self):
+        """A host given as an argument does not exists."""
+
         scheduler = manager.SchedulerManager()
         dest = 'dummydest'
         ctxt = context.get_admin_context()
 
         try:
-            scheduler.show_host_resource(ctxt, dest)
+            scheduler.show_host_resources(ctxt, dest)
         except exception.NotFound, e:
             c1 = (0 <= e.message.find('does not exist or not compute node'))
         self.assertTrue(c1)
 
     def _dic_is_equal(self, dic1, dic2, keys=None):
+        """Compares 2 dictionary contents(Helper method)"""
         if not keys:
             keys = ['vcpus', 'memory_mb', 'local_gb',
                     'vcpus_used', 'memory_mb_used', 'local_gb_used']
@@ -133,16 +132,14 @@ class SchedulerTestCase(test.TestCase):
                 return False
         return True
 
-    def test_show_host_resource_no_project(self):
-        """
-        A testcase of driver.show_host_resource
-        no instance stays on the given host
-        """
+    def test_show_host_resources_no_project(self):
+        """No instance are running on the given host."""
+
         scheduler = manager.SchedulerManager()
         ctxt = context.get_admin_context()
         s_ref = self._create_compute_service()
 
-        result = scheduler.show_host_resource(ctxt, s_ref['host'])
+        result = scheduler.show_host_resources(ctxt, s_ref['host'])
 
         # result checking
         c1 = ('resource' in result and 'usage' in result)
@@ -152,11 +149,9 @@ class SchedulerTestCase(test.TestCase):
         self.assertTrue(c1 and c2 and c3)
         db.service_destroy(ctxt, s_ref['id'])
 
-    def test_show_host_resource_works_correctly(self):
-        """
-        A testcase of driver.show_host_resource
-        to make sure everything finished with no error.
-        """
+    def test_show_host_resources_works_correctly(self):
+        """show_host_resources() works correctly as expected."""
+
         scheduler = manager.SchedulerManager()
         ctxt = context.get_admin_context()
         s_ref = self._create_compute_service()
@@ -164,7 +159,7 @@ class SchedulerTestCase(test.TestCase):
         i_ref2 = self._create_instance(project_id='p-02', vcpus=3,
                                        host=s_ref['host'])
 
-        result = scheduler.show_host_resource(ctxt, s_ref['host'])
+        result = scheduler.show_host_resources(ctxt, s_ref['host'])
 
         c1 = ('resource' in result and 'usage' in result)
         compute_service = s_ref['compute_service'][0]
@@ -284,6 +279,7 @@ class SimpleDriverTestCase(test.TestCase):
         return db.volume_create(self.context, vol)['id']
 
     def _create_compute_service(self, **kwargs):
+        """Create a compute service."""
 
         dic = {'binary': 'nova-compute', 'topic': 'compute',
                'report_count': 0, 'availability_zone': 'dummyzone'}
@@ -698,13 +694,13 @@ class SimpleDriverTestCase(test.TestCase):
         volume1.kill()
         volume2.kill()
 
-    def test_scheduler_live_migraiton_with_volume(self):
-        """
-        driver.scheduler_live_migration finishes successfully
-        (volumes are attached to instances)
-        This testcase make sure schedule_live_migration
-        changes instance state from 'running' -> 'migrating'
+    def test_scheduler_live_migration_with_volume(self):
+        """scheduler_live_migration() works correctly as expected.
+
+        Also, checks instance state is changed from 'running' -> 'migrating'.
+
         """
+
         instance_id = self._create_instance()
         i_ref = db.instance_get(self.context, instance_id)
         dic = {'instance_id': instance_id, 'size': 1}
@@ -737,11 +733,9 @@ class SimpleDriverTestCase(test.TestCase):
         db.instance_destroy(self.context, instance_id)
         db.volume_destroy(self.context, v_ref['id'])
 
-    def test_live_migraiton_src_check_instance_not_running(self):
-        """
-        A testcase of driver._live_migration_src_check.
-        The instance given by instance_id is not running.
-        """
+    def test_live_migration_src_check_instance_not_running(self):
+        """The instance given by instance_id is not running."""
+
         instance_id = self._create_instance(state_description='migrating')
         i_ref = db.instance_get(self.context, instance_id)
 
@@ -754,12 +748,9 @@ class SimpleDriverTestCase(test.TestCase):
         self.assertTrue(c)
         db.instance_destroy(self.context, instance_id)
 
-    def test_live_migraiton_src_check_volume_node_not_alive(self):
-        """
-        A testcase of driver._live_migration_src_check.
-        Volume node is not alive if any volumes are attached to
-        the given instance.
-        """
+    def test_live_migration_src_check_volume_node_not_alive(self):
+        """Raise exception when volume node is not alive."""
+
         instance_id = self._create_instance()
         i_ref = db.instance_get(self.context, instance_id)
         dic = {'instance_id': instance_id, 'size': 1}
@@ -782,11 +773,8 @@ class SimpleDriverTestCase(test.TestCase):
         db.service_destroy(self.context, s_ref['id'])
         db.volume_destroy(self.context, v_ref['id'])
 
-    def test_live_migraiton_src_check_compute_node_not_alive(self):
-        """
-        A testcase of driver._live_migration_src_check.
-        The testcase make sure src-compute node is alive.
-        """
+    def test_live_migration_src_check_compute_node_not_alive(self):
+        """Confirms src-compute node is alive."""
         instance_id = self._create_instance()
         i_ref = db.instance_get(self.context, instance_id)
         t = datetime.datetime.utcnow() - datetime.timedelta(10)
@@ -803,11 +791,8 @@ class SimpleDriverTestCase(test.TestCase):
         db.instance_destroy(self.context, instance_id)
         db.service_destroy(self.context, s_ref['id'])
 
-    def test_live_migraiton_src_check_works_correctly(self):
-        """
-        A testcase of driver._live_migration_src_check.
-        The testcase make sure everything finished with no error.
-        """
+    def test_live_migration_src_check_works_correctly(self):
+        """Confirms this method finishes with no error."""
         instance_id = self._create_instance()
         i_ref = db.instance_get(self.context, instance_id)
         s_ref = self._create_compute_service(host=i_ref['host'])
@@ -819,11 +804,8 @@ class SimpleDriverTestCase(test.TestCase):
         db.instance_destroy(self.context, instance_id)
         db.service_destroy(self.context, s_ref['id'])
 
-    def test_live_migraiton_dest_check_not_alive(self):
-        """
-        A testcase of driver._live_migration_dst_check.
-        Destination host does not exist.
-        """
+    def test_live_migration_dest_check_not_alive(self):
+        """Confirms exception raises in case dest host does not exist."""
         instance_id = self._create_instance()
         i_ref = db.instance_get(self.context, instance_id)
         t = datetime.datetime.utcnow() - datetime.timedelta(10)
@@ -841,11 +823,8 @@ class SimpleDriverTestCase(test.TestCase):
         db.instance_destroy(self.context, instance_id)
         db.service_destroy(self.context, s_ref['id'])
 
-    def test_live_migraiton_dest_check_service_same_host(self):
-        """
-        A testcase of driver._live_migration_dst_check.
-        Destination host is same as src host.
-        """
+    def test_live_migration_dest_check_service_same_host(self):
+        """Confirms exceptioin raises in case dest and src is same host."""
         instance_id = self._create_instance()
         i_ref = db.instance_get(self.context, instance_id)
         s_ref = self._create_compute_service(host=i_ref['host'])
@@ -861,11 +840,8 @@ class SimpleDriverTestCase(test.TestCase):
         db.instance_destroy(self.context, instance_id)
         db.service_destroy(self.context, s_ref['id'])
 
-    def test_live_migraiton_dest_check_service_lack_memory(self):
-        """
-        A testcase of driver._live_migration_dst_check.
-        destination host doesnt have enough memory.
-        """
+    def test_live_migration_dest_check_service_lack_memory(self):
+        """Confirms exception raises when dest doesn't have enough memory."""
         instance_id = self._create_instance()
         i_ref = db.instance_get(self.context, instance_id)
         s_ref = self._create_compute_service(host='somewhere',
@@ -882,11 +858,8 @@ class SimpleDriverTestCase(test.TestCase):
         db.instance_destroy(self.context, instance_id)
         db.service_destroy(self.context, s_ref['id'])
 
-    def test_live_migraiton_dest_check_service_works_correctly(self):
-        """
-        A testcase of driver._live_migration_dst_check.
-        The testcase make sure everything finished with no error.
-        """
+    def test_live_migration_dest_check_service_works_correctly(self):
+        """Confirms method finishes with no error."""
         instance_id = self._create_instance()
         i_ref = db.instance_get(self.context, instance_id)
         s_ref = self._create_compute_service(host='somewhere',
@@ -899,13 +872,11 @@ class SimpleDriverTestCase(test.TestCase):
         db.instance_destroy(self.context, instance_id)
         db.service_destroy(self.context, s_ref['id'])
 
-    def test_live_migraiton_common_check_service_orig_not_exists(self):
-        """
-        A testcase of driver._live_migration_common_check.
-        Destination host does not exist.
-        """
+    def test_live_migration_common_check_service_orig_not_exists(self):
+        """Destination host does not exist."""
+
         dest = 'dummydest'
-        # mocks for live_migraiton_common_check()
+        # mocks for live_migration_common_check()
         instance_id = self._create_instance()
         i_ref = db.instance_get(self.context, instance_id)
         t1 = datetime.datetime.utcnow() - datetime.timedelta(10)
@@ -929,18 +900,15 @@ class SimpleDriverTestCase(test.TestCase):
                                                                i_ref,
                                                                dest)
         except exception.Invalid, e:
-            c = (e.message.find('does not exists') >= 0)
+            c = (e.message.find('does not exist') >= 0)
 
         self.assertTrue(c)
         self.mox.UnsetStubs()
         db.instance_destroy(self.context, instance_id)
         db.service_destroy(self.context, s_ref['id'])
 
-    def test_live_migraiton_common_check_service_different_hypervisor(self):
-        """
-        A testcase of driver._live_migration_common_check.
-        Original host and dest host has different hypervisor type.
-        """
+    def test_live_migration_common_check_service_different_hypervisor(self):
+        """Original host and dest host has different hypervisor type."""
         dest = 'dummydest'
         instance_id = self._create_instance()
         i_ref = db.instance_get(self.context, instance_id)
@@ -969,11 +937,8 @@ class SimpleDriverTestCase(test.TestCase):
         db.service_destroy(self.context, s_ref['id'])
         db.service_destroy(self.context, s_ref2['id'])
 
-    def test_live_migraiton_common_check_service_different_version(self):
-        """
-        A testcase of driver._live_migration_common_check.
-        Original host and dest host has different hypervisor version.
-        """
+    def test_live_migration_common_check_service_different_version(self):
+        """Original host and dest host has different hypervisor version."""
         dest = 'dummydest'
         instance_id = self._create_instance()
         i_ref = db.instance_get(self.context, instance_id)
@@ -1003,11 +968,9 @@ class SimpleDriverTestCase(test.TestCase):
         db.service_destroy(self.context, s_ref['id'])
         db.service_destroy(self.context, s_ref2['id'])
 
-    def test_live_migraiton_common_check_service_checking_cpuinfo_fail(self):
-        """
-        A testcase of driver._live_migration_common_check.
-        Original host and dest host has different hypervisor version.
-        """
+    def test_live_migration_common_check_checking_cpuinfo_fail(self):
+        """Raise excetion when original host doen't have compatible cpu."""
+
         dest = 'dummydest'
         instance_id = self._create_instance()
         i_ref = db.instance_get(self.context, instance_id)
@@ -1025,7 +988,7 @@ class SimpleDriverTestCase(test.TestCase):
         rpc.call(mox.IgnoreArg(), mox.IgnoreArg(),
             {"method": 'compare_cpu',
             "args": {'cpu_info': s_ref2['compute_service'][0]['cpu_info']}}).\
-             AndRaise(rpc.RemoteError('doesnt have compatibility to', '', ''))
+             AndRaise(rpc.RemoteError("doesn't have compatibility to", "", ""))
 
         self.mox.ReplayAll()
         try:
@@ -1033,7 +996,7 @@ class SimpleDriverTestCase(test.TestCase):
                                                                i_ref,
                                                                dest)
         except rpc.RemoteError, e:
-            c = (e.message.find(_('doesnt have compatibility to')) >= 0)
+            c = (e.message.find(_("doesn't have compatibility to")) >= 0)
 
         self.assertTrue(c)
         self.mox.UnsetStubs()
diff --git a/nova/tests/test_service.py b/nova/tests/test_service.py
index cb65584cf..bbd5c6d92 100644
--- a/nova/tests/test_service.py
+++ b/nova/tests/test_service.py
@@ -279,11 +279,7 @@ class ServiceTestCase(test.TestCase):
         self.assert_(not serv.model_disconnected)
 
     def test_compute_can_update_available_resource(self):
-        """
-        Test nova-compute successfully updated Service table on DB.
-        Doing so, self.manager.update_service must be called
-        if 'self.binary == nova-compute', and this testcase checks on it.
-        """
+        """Confirm compute updates their record of compute-service table."""
         host = 'foo'
         binary = 'nova-compute'
         topic = 'compute1'
diff --git a/nova/tests/test_virt.py b/nova/tests/test_virt.py
index 8ed726c21..91bdfcc5a 100644
--- a/nova/tests/test_virt.py
+++ b/nova/tests/test_virt.py
@@ -23,8 +23,8 @@ from nova import context
 from nova import db
 from nova import exception
 from nova import flags
-from nova import test
 from nova import logging
+from nova import test
 from nova import utils
 from nova.api.ec2 import cloud
 from nova.auth import manager
@@ -76,12 +76,12 @@ class LibvirtConnTestCase(test.TestCase):
                      'bridge':        'br101',
                      'instance_type': 'm1.small'}
 
-    def _driver_dependent_test_setup(self):
-        """
-        Setup method.
-        Call this method at the top of each testcase method,
-        if the testcase is necessary libvirt and cheetah.
-        """
+    def _driver_dependant_test_setup(self):
+        """Call this method at the top of each testcase method.
+
+        Checks if libvirt and cheetah, etc is installed.
+        Otherwise, skip testing."""
+
         try:
             global libvirt
             global libxml2
@@ -92,10 +92,9 @@ class LibvirtConnTestCase(test.TestCase):
         except ImportError, e:
             logging.warn("""This test has not been done since """
                  """using driver-dependent library Cheetah/libvirt/libxml2.""")
-            raise e
+            raise
 
         # inebitable mocks for calling
-        #nova.virt.libvirt_conn.LibvirtConnection.__init__
         obj = utils.import_object(FLAGS.firewall_driver)
         fwmock = self.mox.CreateMock(obj)
         self.mox.StubOutWithMock(libvirt_conn, 'utils',
@@ -258,51 +257,31 @@ class LibvirtConnTestCase(test.TestCase):
             self.assertEquals(uri, testuri)
 
     def test_get_vcpu_total(self):
-        """
-        Check if get_vcpu_total returns appropriate cpu value
-        Connection/OS/driver differenct does not matter for this method,
-        everyone can execute for checking.
-        """
+        """Check if get_vcpu_total returns appropriate cpu value."""
         try:
-            self._driver_dependent_test_setup()
+            self._driver_dependant_test_setup()
         except:
             return
 
         self.mox.ReplayAll()
         conn = libvirt_conn.LibvirtConnection(False)
         self.assertTrue(0 < conn.get_vcpu_total())
-        self.mox.UnsetStubs()
 
     def test_get_memory_mb_total(self):
-        """Check if get_memory_mb returns appropriate memory value"""
+        """Check if get_memory_mb returns appropriate memory value."""
         try:
-            self._driver_dependent_test_setup()
+            self._driver_dependant_test_setup()
         except:
             return
 
         self.mox.ReplayAll()
         conn = libvirt_conn.LibvirtConnection(False)
         self.assertTrue(0 < conn.get_memory_mb_total())
-        self.mox.UnsetStubs()
-
-    def test_get_local_gb_total(self):
-        """Check if get_local_gb_total returns appropriate disk value"""
-        # Note(masumotok): leave this b/c FLAGS.instances_path is inevitable..
-        #try:
-        #    self._driver_dependent_test_setup()
-        #except:
-        #    return
-        #
-        #self.mox.ReplayAll()
-        #conn = libvirt_conn.LibvirtConnection(False)
-        #self.assertTrue(0 < conn.get_local_gb_total())
-        #self.mox.UnsetStubs()
-        pass
 
     def test_get_vcpu_used(self):
-        """Check if get_local_gb_total returns appropriate disk value"""
+        """Check if get_local_gb_total returns appropriate disk value."""
         try:
-            self._driver_dependent_test_setup()
+            self._driver_dependant_test_setup()
         except:
             return
 
@@ -321,52 +300,45 @@ class LibvirtConnTestCase(test.TestCase):
         self.mox.ReplayAll()
         conn = libvirt_conn.LibvirtConnection(False)
         self.assertTrue(conn.get_vcpu_used() == 4)
-        self.mox.UnsetStubs()
 
     def test_get_memory_mb_used(self):
-        """Check if get_memory_mb returns appropriate memory value"""
+        """Check if get_memory_mb returns appropriate memory value."""
         try:
-            self._driver_dependent_test_setup()
+            self._driver_dependant_test_setup()
         except:
             return
 
         self.mox.ReplayAll()
         conn = libvirt_conn.LibvirtConnection(False)
         self.assertTrue(0 < conn.get_memory_mb_used())
-        self.mox.UnsetStubs()
-
-    def test_get_local_gb_used(self):
-        """Check if get_local_gb_total returns appropriate disk value"""
-        # Note(masumotok): leave this b/c FLAGS.instances_path is inevitable
-        #try:
-        #    self._driver_dependent_test_setup()
-        #except:
-        #    return
-
-        #self.mox.ReplayAll()
-        #conn = libvirt_conn.LibvirtConnection(False)
-        #self.assertTrue(0 < conn.get_local_gb_used())
-        #self.mox.UnsetStubs()
-        pass
 
     def test_get_cpu_info_works_correctly(self):
-        """
-        Check if get_cpu_info works correctly.
-        (in case libvirt.getCapabilities() works correctly)
-        """
-        xml = ("""<cpu><arch>x86_64</arch><model>Nehalem</model>"""
-               """<vendor>Intel</vendor><topology sockets='2' """
-               """cores='4' threads='2'/><feature name='rdtscp'/>"""
-               """<feature name='dca'/><feature name='xtpr'/>"""
-               """<feature name='tm2'/><feature name='est'/>"""
-               """<feature name='vmx'/><feature name='ds_cpl'/>"""
-               """<feature name='monitor'/><feature name='pbe'/>"""
-               """<feature name='tm'/><feature name='ht'/>"""
-               """<feature name='ss'/><feature name='acpi'/>"""
-               """<feature name='ds'/><feature name='vme'/></cpu>""")
+        """Check if get_cpu_info works correctly as expected."""
+        xml = """<cpu>
+                     <arch>x86_64</arch>
+                     <model>Nehalem</model>
+                     <vendor>Intel</vendor>
+                     <topology sockets='2' cores='4' threads='2'/>
+                     <feature name='rdtscp'/>
+                     <feature name='dca'/>
+                     <feature name='xtpr'/>
+                     <feature name='tm2'/>
+                     <feature name='est'/>
+                     <feature name='vmx'/>
+                     <feature name='ds_cpl'/>
+                     <feature name='monitor'/>
+                     <feature name='pbe'/>
+                     <feature name='tm'/>
+                     <feature name='ht'/>
+                     <feature name='ss'/>
+                     <feature name='acpi'/>
+                     <feature name='ds'/>
+                     <feature name='vme'/>
+                </cpu>
+             """
 
         try:
-            self._driver_dependent_test_setup()
+            self._driver_dependant_test_setup()
         except:
             return
         self.mox.StubOutWithMock(libvirt_conn.LibvirtConnection,
@@ -376,27 +348,34 @@ class LibvirtConnTestCase(test.TestCase):
         self.mox.ReplayAll()
         conn = libvirt_conn.LibvirtConnection(False)
         self.assertTrue(0 < len(conn.get_cpu_info()))
-        self.mox.UnsetStubs()
 
     def test_get_cpu_info_inappropreate_xml(self):
-        """
-        Check if get_cpu_info raises exception
-        in case libvirt.getCapabilities() returns wrong xml
-        (in case of xml doesnt have <cpu> tag)
-        """
-        xml = ("""<cccccpu><arch>x86_64</arch><model>Nehalem</model>"""
-              """<vendor>Intel</vendor><topology sockets='2' """
-              """cores='4' threads='2'/><feature name='rdtscp'/>"""
-              """<feature name='dca'/><feature name='xtpr'/>"""
-              """<feature name='tm2'/><feature name='est'/>"""
-              """<feature name='vmx'/><feature name='ds_cpl'/>"""
-              """<feature name='monitor'/><feature name='pbe'/>"""
-              """<feature name='tm'/><feature name='ht'/>"""
-              """<feature name='ss'/><feature name='acpi'/>"""
-              """<feature name='ds'/><feature name='vme'/></cccccpu>""")
+        """Raise exception if given xml is inappropriate."""
+        xml = """<cccccpu>
+                     <arch>x86_64</arch>
+                     <model>Nehalem</model>
+                     <vendor>Intel</vendor>
+                     <topology sockets='2' cores='4' threads='2'/>
+                     <feature name='rdtscp'/>
+                     <feature name='dca'/>
+                     <feature name='xtpr'/>
+                     <feature name='tm2'/>
+                     <feature name='est'/>
+                     <feature name='vmx'/>
+                     <feature name='ds_cpl'/>
+                     <feature name='monitor'/>
+                     <feature name='pbe'/>
+                     <feature name='tm'/>
+                     <feature name='ht'/>
+                     <feature name='ss'/>
+                     <feature name='acpi'/>
+                     <feature name='ds'/>
+                     <feature name='vme'/>
+                 </cccccpu>
+              """
 
         try:
-            self._driver_dependent_test_setup()
+            self._driver_dependant_test_setup()
         except:
             return
         self.mox.StubOutWithMock(libvirt_conn.LibvirtConnection,
@@ -409,29 +388,34 @@ class LibvirtConnTestCase(test.TestCase):
             conn.get_cpu_info()
         except exception.Invalid, e:
             c1 = (0 <= e.message.find('Invalid xml'))
-            self.assertTrue(c1)
-        self.mox.UnsetStubs()
+        self.assertTrue(c1)
 
     def test_get_cpu_info_inappropreate_xml2(self):
-        """
-        Check if get_cpu_info raises exception
-        in case libvirt.getCapabilities() returns wrong xml
-        (in case of xml doesnt have inproper <topology> tag
-        meaning missing "socket" attribute)
-        """
-        xml = ("""<cpu><arch>x86_64</arch><model>Nehalem</model>"""
-               """<vendor>Intel</vendor><topology """
-               """cores='4' threads='2'/><feature name='rdtscp'/>"""
-               """<feature name='dca'/><feature name='xtpr'/>"""
-               """<feature name='tm2'/><feature name='est'/>"""
-               """<feature name='vmx'/><feature name='ds_cpl'/>"""
-               """<feature name='monitor'/><feature name='pbe'/>"""
-               """<feature name='tm'/><feature name='ht'/>"""
-               """<feature name='ss'/><feature name='acpi'/>"""
-               """<feature name='ds'/><feature name='vme'/></cpu>""")
-
+        """Raise exception if given xml is inappropriate(topology tag)."""
+
+        xml = """<cpu>
+                      <arch>x86_64</arch>
+                      <model>Nehalem</model>
+                      <vendor>Intel</vendor><topology cores='4' threads='2'/>
+                      <feature name='rdtscp'/>
+                      <feature name='dca'/>
+                      <feature name='xtpr'/>
+                      <feature name='tm2'/>
+                      <feature name='est'/>
+                      <feature name='vmx'/>
+                      <feature name='ds_cpl'/>
+                      <feature name='monitor'/>
+                      <feature name='pbe'/>
+                      <feature name='tm'/>
+                      <feature name='ht'/>
+                      <feature name='ss'/>
+                      <feature name='acpi'/>
+                      <feature name='ds'/>
+                      <feature name='vme'/>
+                  </cpu>
+              """
         try:
-            self._driver_dependent_test_setup()
+            self._driver_dependant_test_setup()
         except:
             return
         self.mox.StubOutWithMock(libvirt_conn.LibvirtConnection,
@@ -444,29 +428,12 @@ class LibvirtConnTestCase(test.TestCase):
             conn.get_cpu_info()
         except exception.Invalid, e:
             c1 = (0 <= e.message.find('Invalid xml: topology'))
-            self.assertTrue(c1)
-        self.mox.UnsetStubs()
+        self.assertTrue(c1)
 
     def test_update_available_resource_works_correctly(self):
-        """
-        In this method, vcpus/memory_mb/local_gb/vcpu_used/
-        memory_mb_used/local_gb_used/hypervisor_type/
-        hypervisor_version/cpu_info should be changed.
-        Based on this specification, this testcase confirms
-        if this method finishes successfully,
-        meaning self.db.service_update must be called with dictinary
-
-        {'vcpu':aaa, 'memory_mb':bbb, 'local_gb':ccc,
-        'vcpu_used':aaa, 'memory_mb_used':bbb, 'local_gb_sed':ccc,
-        'hypervisor_type':ddd, 'hypervisor_version':eee,
-        'cpu_info':fff}
-
-        Since each value of above dict can be obtained through
-        driver(different depends on environment),
-        only dictionary keys are checked.
-        """
+        """Confirm compute_service table is updated successfully."""
         try:
-            self._driver_dependent_test_setup()
+            self._driver_dependant_test_setup()
         except:
             return
 
@@ -478,7 +445,9 @@ class LibvirtConnTestCase(test.TestCase):
 
         host = 'foo'
         binary = 'nova-compute'
-        service_ref = {'id': 1, 'host': host, 'binary': binary,
+        service_ref = {'id': 1,
+                       'host': host,
+                       'binary': binary,
                        'topic': 'compute'}
 
         self.mox.StubOutWithMock(db, 'service_get_all_by_topic')
@@ -491,15 +460,11 @@ class LibvirtConnTestCase(test.TestCase):
         self.mox.ReplayAll()
         conn = libvirt_conn.LibvirtConnection(False)
         conn.update_available_resource(host)
-        self.mox.UnsetStubs()
 
     def test_update_resource_info_raise_exception(self):
-        """
-        This testcase confirms if no record found on Service
-        table, exception can be raised.
-        """
+        """Raise exception if no recorde found on services table."""
         try:
-            self._driver_dependent_test_setup()
+            self._driver_dependant_test_setup()
         except:
             return
 
@@ -518,18 +483,19 @@ class LibvirtConnTestCase(test.TestCase):
             msg = 'Cannot insert compute manager specific info'
             c1 = (0 <= e.message.find(msg))
             self.assertTrue(c1)
-        self.mox.ResetAll()
 
     def test_compare_cpu_works_correctly(self):
-        """Calling libvirt.compute_cpu() and works correctly """
-
-        t = ("""{"arch":"%s", "model":"%s", "vendor":"%s", """
-                    """"topology":{"cores":"%s", "threads":"%s", """
-                    """"sockets":"%s"}, "features":[%s]}""")
-        cpu_info = t % ('x86', 'model', 'vendor', '2', '1', '4', '"tm"')
+        """Calling libvirt.compute_cpu() and works correctly."""
+        t = {}
+        t['arch'] = 'x86'
+        t['model'] = 'model'
+        t['vendor'] = 'Intel'
+        t['topology'] = {'cores': "2", "threads": "1", "sockets": "4"}
+        t['features'] = ["tm"]
+        cpu_info = utils.dumps(t)
 
         try:
-            self._driver_dependent_test_setup()
+            self._driver_dependant_test_setup()
         except:
             return
 
@@ -542,20 +508,19 @@ class LibvirtConnTestCase(test.TestCase):
         self.mox.ReplayAll()
         conn = libvirt_conn.LibvirtConnection(False)
         self.assertTrue(None == conn.compare_cpu(cpu_info))
-        self.mox.UnsetStubs()
 
     def test_compare_cpu_raises_exception(self):
-        """
-        Libvirt-related exception occurs when calling
-        libvirt.compare_cpu().
-        """
-        t = ("""{"arch":"%s", "model":"%s", "vendor":"%s", """
-                    """"topology":{"cores":"%s", "threads":"%s", """
-                    """"sockets":"%s"}, "features":[%s]}""")
-        cpu_info = t % ('x86', 'model', 'vendor', '2', '1', '4', '"tm"')
+        """Libvirt-related exception occurs when calling compare_cpu()."""
+        t = {}
+        t['arch'] = 'x86'
+        t['model'] = 'model'
+        t['vendor'] = 'Intel'
+        t['topology'] = {'cores': "2", "threads": "1", "sockets": "4"}
+        t['features'] = ["tm"]
+        cpu_info = utils.dumps(t)
 
         try:
-            self._driver_dependent_test_setup()
+            self._driver_dependant_test_setup()
         except:
             return
 
@@ -567,18 +532,19 @@ class LibvirtConnTestCase(test.TestCase):
         self.mox.ReplayAll()
         conn = libvirt_conn.LibvirtConnection(False)
         self.assertRaises(libvirt.libvirtError, conn.compare_cpu, cpu_info)
-        self.mox.UnsetStubs()
 
     def test_compare_cpu_no_compatibility(self):
-        """libvirt.compare_cpu() return less than 0.(no compatibility)"""
-
-        t = ("""{"arch":"%s", "model":"%s", "vendor":"%s", """
-                    """"topology":{"cores":"%s", "threads":"%s", """
-                    """"sockets":"%s"}, "features":[%s]}""")
-        cpu_info = t % ('x86', 'model', 'vendor', '2', '1', '4', '"tm"')
+        """Libvirt.compare_cpu() return less than 0.(no compatibility)."""
+        t = {}
+        t['arch'] = 'x86'
+        t['model'] = 'model'
+        t['vendor'] = 'Intel'
+        t['topology'] = {'cores': "2", "threads": "1", "sockets": "4"}
+        t['features'] = ["tm"]
+        cpu_info = utils.dumps(t)
 
         try:
-            self._driver_dependent_test_setup()
+            self._driver_dependant_test_setup()
         except:
             return
 
@@ -590,16 +556,14 @@ class LibvirtConnTestCase(test.TestCase):
         self.mox.ReplayAll()
         conn = libvirt_conn.LibvirtConnection(False)
         self.assertRaises(exception.Invalid, conn.compare_cpu, cpu_info)
-        self.mox.UnsetStubs()
 
     def test_ensure_filtering_rules_for_instance_works_correctly(self):
-        """ensure_filtering_rules_for_instance works as expected correctly"""
-
+        """ensure_filtering_rules_for_instance() works successfully."""
         instance_ref = models.Instance()
         instance_ref.__setitem__('id', 1)
 
         try:
-            nwmock, fwmock = self._driver_dependent_test_setup()
+            nwmock, fwmock = self._driver_dependant_test_setup()
         except:
             return
 
@@ -613,16 +577,14 @@ class LibvirtConnTestCase(test.TestCase):
         self.mox.ReplayAll()
         conn = libvirt_conn.LibvirtConnection(False)
         conn.ensure_filtering_rules_for_instance(instance_ref)
-        self.mox.UnsetStubs()
 
     def test_ensure_filtering_rules_for_instance_timeout(self):
-        """ensure_filtering_fules_for_instance finishes with timeout"""
-
+        """ensure_filtering_fules_for_instance() finishes with timeout."""
         instance_ref = models.Instance()
         instance_ref.__setitem__('id', 1)
 
         try:
-            nwmock, fwmock = self._driver_dependent_test_setup()
+            nwmock, fwmock = self._driver_dependant_test_setup()
         except:
             return
 
@@ -642,11 +604,9 @@ class LibvirtConnTestCase(test.TestCase):
         except exception.Error, e:
             c1 = (0 <= e.message.find('Timeout migrating for'))
             self.assertTrue(c1)
-        self.mox.UnsetStubs()
 
     def test_live_migration_works_correctly(self):
-        """_live_migration works as expected correctly """
-
+        """_live_migration() works as expected correctly."""
         class dummyCall(object):
             f = None
 
@@ -659,7 +619,7 @@ class LibvirtConnTestCase(test.TestCase):
         ctxt = context.get_admin_context()
 
         try:
-            self._driver_dependent_test_setup()
+            self._driver_dependant_test_setup()
         except:
             return
 
@@ -681,13 +641,9 @@ class LibvirtConnTestCase(test.TestCase):
         # Not setting post_method/recover_method in this testcase.
         ret = conn._live_migration(ctxt, i_ref, i_ref['host'], '', '')
         self.assertTrue(ret == None)
-        self.mox.UnsetStubs()
 
     def test_live_migration_raises_exception(self):
-        """
-        _live_migration raises exception, then this testcase confirms
-        recovered method is called.
-        """
+        """Confirms recover method is called when exceptions are raised."""
         i_ref = models.Instance()
         i_ref.__setitem__('id', 1)
         i_ref.__setitem__('host', 'dummy')
@@ -697,7 +653,7 @@ class LibvirtConnTestCase(test.TestCase):
             pass
 
         try:
-            nwmock, fwmock = self._driver_dependent_test_setup()
+            nwmock, fwmock = self._driver_dependant_test_setup()
         except:
             return
 
@@ -724,7 +680,6 @@ class LibvirtConnTestCase(test.TestCase):
                           conn._mlive_migration,
                           ctxt, instance_ref, dest,
                           '', dummy_recover_method)
-        self.mox.UnsetStubs()
 
     def tearDown(self):
         super(LibvirtConnTestCase, self).tearDown()
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):
diff --git a/nova/volume/driver.py b/nova/volume/driver.py
index b74c74197..fbc52a598 100644
--- a/nova/volume/driver.py
+++ b/nova/volume/driver.py
@@ -140,7 +140,7 @@ class VolumeDriver(object):
 
     def check_for_export(self, context, volume_id):
         """Make sure volume is exported."""
-        return True
+        raise NotImplementedError()
 
 
 class AOEDriver(VolumeDriver):
@@ -229,9 +229,9 @@ class AOEDriver(VolumeDriver):
                 break
         if not exported:
             # Instance will be terminated in this case.
-            desc = _("""Cannot confirm exported volume id:%(volume_id)s."""
-                     """vblade process for e%(shelf_id)s.%(blade_id)s """
-                     """isn't running.""") % locals()
+            desc = _("Cannot confirm exported volume id:%(volume_id)s."
+                     "vblade process for e%(shelf_id)s.%(blade_id)s "
+                     "isn't running.") % locals()
             raise exception.ProcessExecutionError(out, _err, cmd=cmd,
                                                   description=desc)
 
@@ -373,9 +373,9 @@ class ISCSIDriver(VolumeDriver):
             # Instances remount read-only in this case.
             # /etc/init.d/iscsitarget restart and rebooting nova-volume
             # is better since ensure_export() works at boot time.
-            logging.error(_("""Cannot confirm exported volume """
-                            """id:%(volume_id)s.""") % locals())
-            raise e
+            logging.error(_("Cannot confirm exported volume "
+                            "id:%(volume_id)s.") % locals())
+            raise
 
 
 class FakeISCSIDriver(ISCSIDriver):
-- 
cgit 


From c6b2d07f47004576fa386a6d270203b1d7937664 Mon Sep 17 00:00:00 2001
From: Kei Masumoto <masumotok@nttdata.co.jp>
Date: Wed, 23 Feb 2011 00:15:39 +0900
Subject: Fix tiny mitakes! (remove unnecessary comment, etc)

---
 nova/tests/test_scheduler.py | 2 +-
 nova/tests/test_volume.py    | 3 ---
 nova/virt/libvirt_conn.py    | 2 +-
 3 files changed, 2 insertions(+), 5 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/test_scheduler.py b/nova/tests/test_scheduler.py
index 301106848..47a6d0e82 100644
--- a/nova/tests/test_scheduler.py
+++ b/nova/tests/test_scheduler.py
@@ -258,10 +258,10 @@ class SimpleDriverTestCase(test.TestCase):
         inst['project_id'] = self.project.id
         inst['instance_type'] = 'm1.tiny'
         inst['mac_address'] = utils.generate_mac()
+        inst['vcpus'] = kwargs.get('vcpus', 1)
         inst['ami_launch_index'] = 0
         inst['availability_zone'] = kwargs.get('availability_zone', None)
         inst['host'] = kwargs.get('host', 'dummy')
-        inst['vcpus'] = kwargs.get('vcpus', 4)
         inst['memory_mb'] = kwargs.get('memory_mb', 20)
         inst['local_gb'] = kwargs.get('local_gb', 30)
         inst['launched_on'] = kwargs.get('launghed_on', 'dummy')
diff --git a/nova/tests/test_volume.py b/nova/tests/test_volume.py
index 6ae075caa..e8b4ceee8 100644
--- a/nova/tests/test_volume.py
+++ b/nova/tests/test_volume.py
@@ -318,9 +318,6 @@ class ISCSITestCase(DriverTestCase):
             mountpoint = "/dev/sd" + chr((ord('b') + index))
             db.volume_attached(self.context, vol_ref['id'], self.instance_id,
                                mountpoint)
-            #iscsi_target = db.volume_allocate_iscsi_target(self.context,
-            #                                               vol_ref['id'],
-            #                                               vol_ref['host'])
             volume_id_list.append(vol_ref['id'])
 
         return volume_id_list
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 <sateesh.chodapuneedi@citrix.com>
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')

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 485a6c5a9502679bc5ecf02f8e758170ac0335dc Mon Sep 17 00:00:00 2001
From: Kei Masumoto <masumotok@nttdata.co.jp>
Date: Wed, 23 Feb 2011 01:20:39 +0900
Subject: Fixed some docstring

---
 nova/scheduler/manager.py    | 2 +-
 nova/tests/test_scheduler.py | 3 ++-
 2 files changed, 3 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/scheduler/manager.py b/nova/scheduler/manager.py
index 783594c6f..cd5012fd5 100644
--- a/nova/scheduler/manager.py
+++ b/nova/scheduler/manager.py
@@ -59,7 +59,7 @@ class SchedulerManager(manager.Manager):
         try:
             host = getattr(self.driver, driver_method)(elevated, *args,
                                                        **kwargs)
-        except AttributeError, e:
+        except AttributeError:
             host = self.driver.schedule(elevated, topic, *args, **kwargs)
 
         rpc.cast(context,
diff --git a/nova/tests/test_scheduler.py b/nova/tests/test_scheduler.py
index 47a6d0e82..71e524bca 100644
--- a/nova/tests/test_scheduler.py
+++ b/nova/tests/test_scheduler.py
@@ -60,6 +60,7 @@ class SchedulerTestCase(test.TestCase):
         self.flags(scheduler_driver='nova.tests.test_scheduler.TestDriver')
 
     def _create_compute_service(self):
+        """Create compute-manager(ComputeService and Service record)."""
         ctxt = context.get_admin_context()
         dic = {'host': 'dummy', 'binary': 'nova-compute', 'topic': 'compute',
                'report_count': 0, 'availability_zone': 'dummyzone'}
@@ -150,7 +151,7 @@ class SchedulerTestCase(test.TestCase):
         db.service_destroy(ctxt, s_ref['id'])
 
     def test_show_host_resources_works_correctly(self):
-        """show_host_resources() works correctly as expected."""
+        """Show_host_resources() works correctly as expected."""
 
         scheduler = manager.SchedulerManager()
         ctxt = context.get_admin_context()
-- 
cgit 


From 8b0e8b155eab313e0caece48eee609d12df5e5d4 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Tue, 22 Feb 2011 20:45:36 +0100
Subject: Rename "SNATTING" chain to "snat".

---
 nova/network/linux_net.py | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

(limited to 'nova')

diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index 849181641..34337901a 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -208,7 +208,7 @@ class IptablesManager(object):
 
     For ipv4, the builtin PREROUTING, OUTPUT, and POSTROUTING nat chains are
     wrapped in the same was as the builtin filter chains. Additionally, there's
-    a SNATTING chain that is applied after the POSTROUTING chain.
+    a snat chain that is applied after the POSTROUTING chain.
     """
     def __init__(self, execute=None):
         if not execute:
@@ -261,16 +261,16 @@ class IptablesManager(object):
         self.ipv4['nat'].add_rule('POSTROUTING', '-j nova-postrouting-bottom',
                                   wrap=False)
 
-        # We add a SNATTING chain to the shared nova-postrouting-bottom chain
+        # We add a snat chain to the shared nova-postrouting-bottom chain
         # so that it's applied last.
-        self.ipv4['nat'].add_chain('SNATTING')
-        self.ipv4['nat'].add_rule('nova-postrouting-bottom', '-j $SNATTING',
+        self.ipv4['nat'].add_chain('snat')
+        self.ipv4['nat'].add_rule('nova-postrouting-bottom', '-j $snat',
                                   wrap=False)
 
         # And then we add a floating-snat chain and jump to first thing in
-        # the SNATTING chain.
+        # the snat chain.
         self.ipv4['nat'].add_chain('floating-snat')
-        self.ipv4['nat'].add_rule('SNATTING', '-j $floating-snat')
+        self.ipv4['nat'].add_rule('snat', '-j $floating-snat')
 
         self.semaphore = semaphore.Semaphore()
 
@@ -376,7 +376,7 @@ def init_host():
 
     # NOTE(devcamcar): Cloud public SNAT entries and the default
     # SNAT rule for outbound traffic.
-    iptables_manager.ipv4['nat'].add_rule("SNATTING",
+    iptables_manager.ipv4['nat'].add_rule("snat",
                                           "-s %s -j SNAT --to-source %s" % \
                                            (FLAGS.fixed_range,
                                             FLAGS.routing_source_ip))
-- 
cgit 


From d1a6cb96c1c72894cbba24e6806da5c81fb915df Mon Sep 17 00:00:00 2001
From: Ewan Mellor <ewan.mellor@citrix.com>
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')

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 f4289df0e58080d6d9fa381915bbd0d29f3b9751 Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Tue, 22 Feb 2011 15:05:48 -0800
Subject: We're not using prefix matching on AMQP, so fakerabbit shouldn't be
 doing it!

---
 nova/fakerabbit.py | 1 -
 1 file changed, 1 deletion(-)

(limited to 'nova')

diff --git a/nova/fakerabbit.py b/nova/fakerabbit.py
index dd82a9366..a7dee8caf 100644
--- a/nova/fakerabbit.py
+++ b/nova/fakerabbit.py
@@ -48,7 +48,6 @@ class Exchange(object):
         nm = self.name
         LOG.debug(_('(%(nm)s) publish (key: %(routing_key)s)'
                 ' %(message)s') % locals())
-        routing_key = routing_key.split('.')[0]
         if routing_key in self._routes:
             for f in self._routes[routing_key]:
                 LOG.debug(_('Publishing to route %s'), f)
-- 
cgit 


From e8a3f461319c1ee20a18f3a375af5e1e958af05e Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Tue, 22 Feb 2011 15:50:42 -0800
Subject: Missing import for nova.exceptions (!)

---
 nova/network/api.py | 1 +
 1 file changed, 1 insertion(+)

(limited to 'nova')

diff --git a/nova/network/api.py b/nova/network/api.py
index bf43acb51..4ee1148cb 100644
--- a/nova/network/api.py
+++ b/nova/network/api.py
@@ -21,6 +21,7 @@ Handles all requests relating to instances (guest vms).
 """
 
 from nova import db
+from nova import exception
 from nova import flags
 from nova import log as logging
 from nova import quota
-- 
cgit 


From ab6b11b0399655ccdd9619be00470eda464cf2a7 Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Tue, 22 Feb 2011 16:09:41 -0800
Subject: Don't blindly concatenate queue name if second portiion is None

---
 nova/db/sqlalchemy/api.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 2697fac73..009ed1f06 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -1209,7 +1209,9 @@ def project_get_network_v6(context, project_id):
 
 def queue_get_for(_context, topic, physical_node_id):
     # FIXME(ja): this should be servername?
-    return "%s.%s" % (topic, physical_node_id)
+    if physical_node_id:
+        return "%s.%s" % (topic, physical_node_id)
+    return topic
 
 
 ###################
-- 
cgit 


From b6254db80ca9841361775a92b85f88db7251f857 Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Tue, 22 Feb 2011 17:45:38 -0800
Subject: Refactoring nova-api to be a service, so that we can reuse it in
 tests

---
 nova/apiservice.py | 85 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 85 insertions(+)
 create mode 100644 nova/apiservice.py

(limited to 'nova')

diff --git a/nova/apiservice.py b/nova/apiservice.py
new file mode 100644
index 000000000..7b453e19f
--- /dev/null
+++ b/nova/apiservice.py
@@ -0,0 +1,85 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# 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.
+
+"""
+Wrapper for API service, makes it look more like the non-WSGI services
+"""
+
+from nova import flags
+from nova import log as logging
+from nova import version
+from nova import wsgi
+
+
+LOG = logging.getLogger('nova.api')
+
+FLAGS = flags.FLAGS
+flags.DEFINE_string('ec2_listen', "0.0.0.0",
+                    'IP address for EC2 API to listen')
+flags.DEFINE_integer('ec2_listen_port', 8773, 'port for ec2 api to listen')
+flags.DEFINE_string('osapi_listen', "0.0.0.0",
+                    'IP address for OpenStack API to listen')
+flags.DEFINE_integer('osapi_listen_port', 8774, 'port for os api to listen')
+
+API_ENDPOINTS = ['ec2', 'osapi']
+
+
+def _run_app(paste_config_file):
+    LOG.debug(_("Using paste.deploy config at: %s"), paste_config_file)
+    apps = []
+    for api in API_ENDPOINTS:
+        config = wsgi.load_paste_configuration(paste_config_file, api)
+        if config is None:
+            LOG.debug(_("No paste configuration for app: %s"), api)
+            continue
+        LOG.debug(_("App Config: %(api)s\n%(config)r") % locals())
+        LOG.info(_("Running %s API"), api)
+        app = wsgi.load_paste_app(paste_config_file, api)
+        apps.append((app, getattr(FLAGS, "%s_listen_port" % api),
+                     getattr(FLAGS, "%s_listen" % api)))
+    if len(apps) == 0:
+        LOG.error(_("No known API applications configured in %s."),
+                  paste_config_file)
+        return
+
+    server = wsgi.Server()
+    for app in apps:
+        server.start(*app)
+    server.wait()
+
+
+class ApiService(object):
+    """Base class for workers that run on hosts."""
+
+    def __init__(self, conf):
+        self.conf = conf
+
+    def start(self):
+        _run_app(self.conf)
+
+
+def serve(conf):
+    LOG.audit(_("Starting nova-api node (version %s)"),
+              version.version_string_with_vcs())
+    LOG.debug(_("Full set of FLAGS:"))
+    for flag in FLAGS:
+        flag_get = FLAGS.get(flag, None)
+        LOG.debug("%(flag)s : %(flag_get)s" % locals())
+
+    service = ApiService(conf)
+    service.start()
-- 
cgit 


From 79f6c437b486262bab3faacb59197a5cae30b2bd Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Tue, 22 Feb 2011 17:50:26 -0800
Subject: Added create static method to ApiService

---
 nova/apiservice.py | 7 +++++++
 1 file changed, 7 insertions(+)

(limited to 'nova')

diff --git a/nova/apiservice.py b/nova/apiservice.py
index 7b453e19f..1914b9e59 100644
--- a/nova/apiservice.py
+++ b/nova/apiservice.py
@@ -72,6 +72,11 @@ class ApiService(object):
     def start(self):
         _run_app(self.conf)
 
+    @staticmethod
+    def create():
+        conf = wsgi.paste_config_file('nova-api.conf')
+        return serve(conf)
+
 
 def serve(conf):
     LOG.audit(_("Starting nova-api node (version %s)"),
@@ -83,3 +88,5 @@ def serve(conf):
 
     service = ApiService(conf)
     service.start()
+
+    return service
-- 
cgit 


From e37e7b91a9fb5664ad50c1ff38e95f1a2d655c06 Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Tue, 22 Feb 2011 17:58:01 -0800
Subject: Support service-like wait behaviour for API service

---
 nova/apiservice.py | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/apiservice.py b/nova/apiservice.py
index 1914b9e59..14239f196 100644
--- a/nova/apiservice.py
+++ b/nova/apiservice.py
@@ -60,7 +60,7 @@ def _run_app(paste_config_file):
     server = wsgi.Server()
     for app in apps:
         server.start(*app)
-    server.wait()
+    return server
 
 
 class ApiService(object):
@@ -68,9 +68,13 @@ class ApiService(object):
 
     def __init__(self, conf):
         self.conf = conf
+        self.wsgi_app = None
 
     def start(self):
-        _run_app(self.conf)
+        self.wsgi_app = _run_app(self.conf)
+
+    def wait(self):
+        self.wsgi_app.wait()
 
     @staticmethod
     def create():
-- 
cgit 


From 7c8c325f475926724f3243344803841e24d5cb84 Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Tue, 22 Feb 2011 18:15:29 -0800
Subject: Make static create method behave more like other services

---
 nova/apiservice.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/apiservice.py b/nova/apiservice.py
index 14239f196..693bc9a63 100644
--- a/nova/apiservice.py
+++ b/nova/apiservice.py
@@ -79,7 +79,10 @@ class ApiService(object):
     @staticmethod
     def create():
         conf = wsgi.paste_config_file('nova-api.conf')
-        return serve(conf)
+        LOG.audit(_("Starting nova-api node (version %s)"),
+              version.version_string_with_vcs())
+        service = ApiService(conf)
+        return service
 
 
 def serve(conf):
-- 
cgit 


From 50e71cef14c3bd079fbc2d2c203b0e0f76ee869e Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Tue, 22 Feb 2011 18:59:23 -0800
Subject: Removed unused import & formatting cleanups

---
 nova/apiservice.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/apiservice.py b/nova/apiservice.py
index 693bc9a63..6340e9b9b 100644
--- a/nova/apiservice.py
+++ b/nova/apiservice.py
@@ -16,9 +16,7 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-"""
-Wrapper for API service, makes it look more like the non-WSGI services
-"""
+"""Wrapper for API service, makes it look more like the non-WSGI services"""
 
 from nova import flags
 from nova import log as logging
@@ -28,6 +26,7 @@ from nova import wsgi
 
 LOG = logging.getLogger('nova.api')
 
+
 FLAGS = flags.FLAGS
 flags.DEFINE_string('ec2_listen', "0.0.0.0",
                     'IP address for EC2 API to listen')
@@ -36,6 +35,7 @@ flags.DEFINE_string('osapi_listen', "0.0.0.0",
                     'IP address for OpenStack API to listen')
 flags.DEFINE_integer('osapi_listen_port', 8774, 'port for os api to listen')
 
+
 API_ENDPOINTS = ['ec2', 'osapi']
 
 
-- 
cgit 


From c0d3b8415ed34c6b259e183a047ca37c9598ffd4 Mon Sep 17 00:00:00 2001
From: sateesh <sateesh.chodapuneedi@citrix.com>
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')

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("<ZSI.FaultException> in"
-                           " %s:" % (attr_name), excep)
+                    raise SessionFaultyException(_("<ZSI.FaultException> in"
+                           " %s:") % (attr_name), excep)
                 except ZSI.EvaluateException, excep:
-                    raise SessionFaultyException("<ZSI.EvaluateException> in"
-                           " %s:" % (attr_name), excep)
+                    raise SessionFaultyException(_("<ZSI.EvaluateException> 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 <josh.kearney@rackspace.com>
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')

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 3c6a44327f0015cb531b06fbce38eb4e3a04ce6a Mon Sep 17 00:00:00 2001
From: Ricardo Carrillo Cruz <emaildericky@gmail.com>
Date: Wed, 23 Feb 2011 20:13:50 +0100
Subject: Fixes lp715424, code now checks network range can fit num_networks *
 network_size

---
 nova/network/manager.py | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'nova')

diff --git a/nova/network/manager.py b/nova/network/manager.py
index c6eba225e..1b8627562 100644
--- a/nova/network/manager.py
+++ b/nova/network/manager.py
@@ -521,6 +521,11 @@ class VlanManager(NetworkManager):
                                ' than 4094'))
 
         fixed_net = IPy.IP(cidr)
+        if fixed_net.len() < num_networks * network_size:
+            raise ValueError(_('The network range is not big enough to fit %s'
+                               ' networks of size %s' % 
+                               (num_networks, network_size)))
+
         fixed_net_v6 = IPy.IP(cidr_v6)
         network_size_v6 = 1 << 64
         significant_bits_v6 = 64
-- 
cgit 


From 7c19fe87693b89d56ef9d9402d2667eacf297b97 Mon Sep 17 00:00:00 2001
From: Ricardo Carrillo Cruz <emaildericky@gmail.com>
Date: Wed, 23 Feb 2011 20:51:27 +0100
Subject: Deleted trailing whitespace

---
 nova/network/manager.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/network/manager.py b/nova/network/manager.py
index 1b8627562..7bdd56d7b 100644
--- a/nova/network/manager.py
+++ b/nova/network/manager.py
@@ -523,7 +523,7 @@ class VlanManager(NetworkManager):
         fixed_net = IPy.IP(cidr)
         if fixed_net.len() < num_networks * network_size:
             raise ValueError(_('The network range is not big enough to fit %s'
-                               ' networks of size %s' % 
+                               ' networks of size %s' %
                                (num_networks, network_size)))
 
         fixed_net_v6 = IPy.IP(cidr_v6)
-- 
cgit 


From 05065a72ab06879d8ddd48ab45bc870386a0562d Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Wed, 23 Feb 2011 14:41:11 -0800
Subject: tests working again

---
 nova/tests/test_rpc.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/test_rpc.py b/nova/tests/test_rpc.py
index 4820e04fb..44d7c91eb 100644
--- a/nova/tests/test_rpc.py
+++ b/nova/tests/test_rpc.py
@@ -36,7 +36,7 @@ class RpcTestCase(test.TestCase):
         super(RpcTestCase, self).setUp()
         self.conn = rpc.Connection.instance(True)
         self.receiver = TestReceiver()
-        self.consumer = rpc.AdapterConsumer(connection=self.conn,
+        self.consumer = rpc.TopicAdapterConsumer(connection=self.conn,
                                             topic='test',
                                             proxy=self.receiver)
         self.consumer.attach_to_eventlet()
@@ -97,7 +97,7 @@ class RpcTestCase(test.TestCase):
 
         nested = Nested()
         conn = rpc.Connection.instance(True)
-        consumer = rpc.AdapterConsumer(connection=conn,
+        consumer = rpc.TopicAdapterConsumer(connection=conn,
                                        topic='nested',
                                        proxy=nested)
         consumer.attach_to_eventlet()
-- 
cgit 


From 861a7f2b53f02af2ef196411171182394edd7e17 Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Wed, 23 Feb 2011 15:31:40 -0800
Subject: Changed create from a @staticmethod to a @classmethod

---
 nova/apiservice.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/apiservice.py b/nova/apiservice.py
index 6340e9b9b..03aa781fb 100644
--- a/nova/apiservice.py
+++ b/nova/apiservice.py
@@ -76,12 +76,12 @@ class ApiService(object):
     def wait(self):
         self.wsgi_app.wait()
 
-    @staticmethod
-    def create():
+    @classmethod
+    def create(cls):
         conf = wsgi.paste_config_file('nova-api.conf')
         LOG.audit(_("Starting nova-api node (version %s)"),
               version.version_string_with_vcs())
-        service = ApiService(conf)
+        service = cls(conf)
         return service
 
 
-- 
cgit 


From 503fe37427247b2728051426d3c40266de69bd71 Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Wed, 23 Feb 2011 15:59:54 -0800
Subject: Reverted bad-fix to sqlalchemy code

---
 nova/db/sqlalchemy/api.py | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 53498fbc5..d8751bef4 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -1209,9 +1209,7 @@ def project_get_network_v6(context, project_id):
 
 def queue_get_for(_context, topic, physical_node_id):
     # FIXME(ja): this should be servername?
-    if physical_node_id:
-        return "%s.%s" % (topic, physical_node_id)
-    return topic
+    return "%s.%s" % (topic, physical_node_id)
 
 
 ###################
-- 
cgit 


From 05fc3ea219f36bc1c246179b25b1feb017888b01 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Wed, 23 Feb 2011 17:58:32 -0800
Subject: Tests all working again

---
 nova/compute/manager.py    |  3 ++-
 nova/flags.py              |  2 +-
 nova/network/manager.py    |  7 ++++---
 nova/scheduler/api.py      |  1 -
 nova/scheduler/manager.py  |  3 ++-
 nova/scheduler_manager.py  | 22 ++++++++++++++++++----
 nova/tests/test_service.py | 25 ++++++++++++++-----------
 nova/tests/test_test.py    |  2 +-
 nova/volume/manager.py     |  7 ++++---
 9 files changed, 46 insertions(+), 26 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index fd88158f7..b307ffa59 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -112,7 +112,8 @@ class ComputeManager(scheduler_manager.SchedulerDependentManager):
         self.driver = utils.import_object(compute_driver)
         self.network_manager = utils.import_object(FLAGS.network_manager)
         self.volume_manager = utils.import_object(FLAGS.volume_manager)
-        super(ComputeManager, self).__init__(*args, **kwargs)
+        super(ComputeManager, self).__init__(service_name="compute",
+                                                        *args, **kwargs)
 
     def init_host(self):
         """Do any initialization that needs to be run if this is a
diff --git a/nova/flags.py b/nova/flags.py
index 6f37c82f0..7036180fc 100644
--- a/nova/flags.py
+++ b/nova/flags.py
@@ -356,5 +356,5 @@ DEFINE_string('node_availability_zone', 'nova',
               'availability zone of this node')
 
 DEFINE_string('zone_name', 'nova', 'name of this zone')
-DEFINE_string('zone_capabilities', 'kypervisor:xenserver;os:linux',
+DEFINE_string('zone_capabilities', 'hypervisor:xenserver;os:linux',
               'Key/Value tags which represent capabilities of this zone')
diff --git a/nova/network/manager.py b/nova/network/manager.py
index b36dd59cf..f5f5b17aa 100644
--- a/nova/network/manager.py
+++ b/nova/network/manager.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 manager
+from nova import scheduler_manager
 from nova import utils
 from nova import rpc
 
@@ -105,7 +105,7 @@ class AddressAlreadyAllocated(exception.Error):
     pass
 
 
-class NetworkManager(manager.Manager):
+class NetworkManager(scheduler_manager.SchedulerDependentManager):
     """Implements common network manager functionality.
 
     This class must be subclassed to support specific topologies.
@@ -116,7 +116,8 @@ class NetworkManager(manager.Manager):
         if not network_driver:
             network_driver = FLAGS.network_driver
         self.driver = utils.import_object(network_driver)
-        super(NetworkManager, self).__init__(*args, **kwargs)
+        super(NetworkManager, self).__init__(service_name='network',
+                                                *args, **kwargs)
 
     def init_host(self):
         """Do any initialization that needs to be run if this is a
diff --git a/nova/scheduler/api.py b/nova/scheduler/api.py
index 53d72507f..6a6bfc032 100644
--- a/nova/scheduler/api.py
+++ b/nova/scheduler/api.py
@@ -53,4 +53,3 @@ class API:
         kwargs = dict(method='update_service_capabilities',
                         service_name=service_name, capabilities=capabilities)
         return rpc.fanout_cast(context, 'scheduler', kwargs)
-
diff --git a/nova/scheduler/manager.py b/nova/scheduler/manager.py
index 3ff43a9d9..6b5c6e246 100644
--- a/nova/scheduler/manager.py
+++ b/nova/scheduler/manager.py
@@ -59,7 +59,8 @@ class SchedulerManager(manager.Manager):
         """Get a list of zones from the ZoneManager."""
         return self.zone_manager.get_zone_list()
 
-    def update_service_capabilities(self, context=None, service_name=None, capabilities={}):
+    def update_service_capabilities(self, context=None, service_name=None,
+                                                capabilities={}):
         """Process a compute node update."""
         return self.zone_manager.update_compute_capabilities()
 
diff --git a/nova/scheduler_manager.py b/nova/scheduler_manager.py
index a45301617..65bd71c05 100644
--- a/nova/scheduler_manager.py
+++ b/nova/scheduler_manager.py
@@ -34,13 +34,27 @@ FLAGS = flags.FLAGS
 
 
 class SchedulerDependentManager(manager.Manager):
-    def __init__(self, host=None, db_driver=None):
-        self.last_capabilities = {}
+
+    """Periodically send capability updates to the Scheduler services.
+       Services that need to update the Scheduler of their capabilities
+       should derive from this class. Otherwise they can derive from
+       manager.Manager directly. Updates are only sent after
+       update_service_capabilities is called with non-None values."""
+
+    def __init__(self, host=None, db_driver=None, service_name="undefined"):
+        self.last_capabilities = None
+        self.service_name = service_name
         super(SchedulerDependentManager, self).__init__(host, db_driver)
 
+    def update_service_capabilities(self, capabilities):
+        """Remember these capabilities to send on next periodic update."""
+        self.last_capabilities = capabilities
+
     def periodic_tasks(self, context=None):
         """Pass data back to the scheduler at a periodic interval"""
-        logging.debug(_("*** Notifying Schedulers of capabilities ..."))
-        api.API.update_service_capabilities(context, 'compute', self.last_capabilities)
+        if self.last_capabilities:
+            logging.debug(_("*** Notifying Schedulers of capabilities ..."))
+            api.API.update_service_capabilities(context, self.service_name,
+                                self.last_capabilities)
 
         super(SchedulerDependentManager, self).periodic_tasks(context)
diff --git a/nova/tests/test_service.py b/nova/tests/test_service.py
index cb31a3c43..b006caadd 100644
--- a/nova/tests/test_service.py
+++ b/nova/tests/test_service.py
@@ -108,26 +108,29 @@ class ServiceTestCase(test.TestCase):
         app = service.Service.create(host=host, binary=binary)
 
         self.mox.StubOutWithMock(rpc,
-                                 'AdapterConsumer',
+                                 'TopicAdapterConsumer',
                                  use_mock_anything=True)
-        rpc.AdapterConsumer(connection=mox.IgnoreArg(),
+        self.mox.StubOutWithMock(rpc,
+                                 'FanoutAdapterConsumer',
+                                 use_mock_anything=True)
+        rpc.TopicAdapterConsumer(connection=mox.IgnoreArg(),
                             topic=topic,
                             proxy=mox.IsA(service.Service)).AndReturn(
-                                    rpc.AdapterConsumer)
+                                    rpc.TopicAdapterConsumer)
 
-        rpc.AdapterConsumer(connection=mox.IgnoreArg(),
+        rpc.TopicAdapterConsumer(connection=mox.IgnoreArg(),
                             topic='%s.%s' % (topic, host),
                             proxy=mox.IsA(service.Service)).AndReturn(
-                                    rpc.AdapterConsumer)
+                                    rpc.TopicAdapterConsumer)
 
-        rpc.AdapterConsumer(connection=mox.IgnoreArg(),
-                            topic='%s_fanout' % topic,
+        rpc.FanoutAdapterConsumer(connection=mox.IgnoreArg(),
+                            topic=topic,
                             proxy=mox.IsA(service.Service)).AndReturn(
-                                    rpc.AdapterConsumer)
+                                    rpc.FanoutAdapterConsumer)
 
-        rpc.AdapterConsumer.attach_to_eventlet()
-        rpc.AdapterConsumer.attach_to_eventlet()
-        rpc.AdapterConsumer.attach_to_eventlet()
+        rpc.TopicAdapterConsumer.attach_to_eventlet()
+        rpc.TopicAdapterConsumer.attach_to_eventlet()
+        rpc.FanoutAdapterConsumer.attach_to_eventlet()
 
         service_create = {'host': host,
                           'binary': binary,
diff --git a/nova/tests/test_test.py b/nova/tests/test_test.py
index e237674e6..35c838065 100644
--- a/nova/tests/test_test.py
+++ b/nova/tests/test_test.py
@@ -34,7 +34,7 @@ class IsolationTestCase(test.TestCase):
 
     def test_rpc_consumer_isolation(self):
         connection = rpc.Connection.instance(new=True)
-        consumer = rpc.TopicConsumer(connection, topic='compute')
+        consumer = rpc.TopicAdapterConsumer(connection, topic='compute')
         consumer.register_callback(
                 lambda x, y: self.fail('I should never be called'))
         consumer.attach_to_eventlet()
diff --git a/nova/volume/manager.py b/nova/volume/manager.py
index 3e8bc16b3..c53acf1e3 100644
--- a/nova/volume/manager.py
+++ b/nova/volume/manager.py
@@ -49,7 +49,7 @@ from nova import context
 from nova import exception
 from nova import flags
 from nova import log as logging
-from nova import manager
+from nova import scheduler_manager
 from nova import utils
 
 
@@ -64,14 +64,15 @@ flags.DEFINE_boolean('use_local_volumes', True,
                      'if True, will not discover local volumes')
 
 
-class VolumeManager(manager.Manager):
+class VolumeManager(scheduler_manager.SchedulerDependentManager):
     """Manages attachable block storage devices."""
     def __init__(self, volume_driver=None, *args, **kwargs):
         """Load the driver from the one specified in args, or from flags."""
         if not volume_driver:
             volume_driver = FLAGS.volume_driver
         self.driver = utils.import_object(volume_driver)
-        super(VolumeManager, self).__init__(*args, **kwargs)
+        super(VolumeManager, self).__init__(service_name='volume',
+                                                    *args, **kwargs)
         # NOTE(vish): Implementation specific db handling is done
         #             by the driver.
         self.driver.db = self.db
-- 
cgit 


From 4a002ffdc1937856de7dbf35b83ae0dd78dfe4c6 Mon Sep 17 00:00:00 2001
From: sateesh <sateesh.chodapuneedi@citrix.com>
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')

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 cc8276655cd2424b71689776f24e2a5cc767e844 Mon Sep 17 00:00:00 2001
From: Vishvananda Ishaya <vishvananda@gmail.com>
Date: Wed, 23 Feb 2011 23:37:52 -0800
Subject: move relevant code to baseclass and make flatdhcp not inherit from
 flat

---
 nova/network/manager.py | 141 +++++++++++++++++++++---------------------------
 1 file changed, 62 insertions(+), 79 deletions(-)

(limited to 'nova')

diff --git a/nova/network/manager.py b/nova/network/manager.py
index 1df193be0..e999adae5 100644
--- a/nova/network/manager.py
+++ b/nova/network/manager.py
@@ -163,11 +163,22 @@ class NetworkManager(manager.Manager):
 
     def allocate_fixed_ip(self, context, instance_id, *args, **kwargs):
         """Gets a fixed ip from the pool."""
-        raise NotImplementedError()
+        # TODO(vish): when this is called by compute, we can associate compute
+        #             with a network, or a cluster of computes with a network
+        #             and use that network here with a method like
+        #             network_get_by_compute_host
+        network_ref = self.db.network_get_by_bridge(context,
+                                                    FLAGS.flat_network_bridge)
+        address = self.db.fixed_ip_associate_pool(context.elevated(),
+                                                  network_ref['id'],
+                                                  instance_id)
+        self.db.fixed_ip_update(context, address, {'allocated': True})
+        return address
 
     def deallocate_fixed_ip(self, context, address, *args, **kwargs):
         """Returns a fixed ip to the pool."""
-        raise NotImplementedError()
+        self.db.fixed_ip_update(context, address, {'allocated': False})
+        self.db.fixed_ip_disassociate(context.elevated(), address)
 
     def setup_fixed_ip(self, context, address):
         """Sets up rules for fixed ip."""
@@ -257,12 +268,57 @@ class NetworkManager(manager.Manager):
 
     def get_network_host(self, context):
         """Get the network host for the current context."""
-        raise NotImplementedError()
+        network_ref = self.db.network_get_by_bridge(context,
+                                                    FLAGS.flat_network_bridge)
+        # NOTE(vish): If the network has no host, use the network_host flag.
+        #             This could eventually be a a db lookup of some sort, but
+        #             a flag is easy to handle for now.
+        host = network_ref['host']
+        if not host:
+            topic = self.db.queue_get_for(context,
+                                          FLAGS.network_topic,
+                                          FLAGS.network_host)
+            if FLAGS.fake_call:
+                return self.set_network_host(context, network_ref['id'])
+            host = rpc.call(context,
+                            FLAGS.network_topic,
+                            {"method": "set_network_host",
+                             "args": {"network_id": network_ref['id']}})
+        return host
 
     def create_networks(self, context, cidr, num_networks, network_size,
-                        cidr_v6, *args, **kwargs):
+                        cidr_v6, label, *args, **kwargs):
         """Create networks based on parameters."""
-        raise NotImplementedError()
+        fixed_net = IPy.IP(cidr)
+        fixed_net_v6 = IPy.IP(cidr_v6)
+        significant_bits_v6 = 64
+        count = 1
+        for index in range(num_networks):
+            start = index * network_size
+            significant_bits = 32 - int(math.log(network_size, 2))
+            cidr = "%s/%s" % (fixed_net[start], significant_bits)
+            project_net = IPy.IP(cidr)
+            net = {}
+            net['bridge'] = FLAGS.flat_network_bridge
+            net['cidr'] = cidr
+            net['netmask'] = str(project_net.netmask())
+            net['gateway'] = str(project_net[1])
+            net['broadcast'] = str(project_net.broadcast())
+            net['dhcp_start'] = str(project_net[2])
+            if num_networks > 1:
+                net['label'] = "%s_%d" % (label, count)
+            else:
+                net['label'] = label
+            count += 1
+
+            if(FLAGS.use_ipv6):
+                cidr_v6 = "%s/%s" % (fixed_net_v6[0], significant_bits_v6)
+                net['cidr_v6'] = cidr_v6
+
+            network_ref = self.db.network_create_safe(context, net)
+
+            if network_ref:
+                self._create_fixed_ips(context, network_ref['id'])
 
     @property
     def _bottom_reserved_ips(self):  # pylint: disable-msg=R0201
@@ -332,83 +388,10 @@ class FlatManager(NetworkManager):
         for network in self.db.host_get_networks(ctxt, self.host):
             self._on_set_network_host(ctxt, network['id'])
 
-    def allocate_fixed_ip(self, context, instance_id, *args, **kwargs):
-        """Gets a fixed ip from the pool."""
-        # TODO(vish): when this is called by compute, we can associate compute
-        #             with a network, or a cluster of computes with a network
-        #             and use that network here with a method like
-        #             network_get_by_compute_host
-        network_ref = self.db.network_get_by_bridge(context,
-                                                    FLAGS.flat_network_bridge)
-        address = self.db.fixed_ip_associate_pool(context.elevated(),
-                                                  network_ref['id'],
-                                                  instance_id)
-        self.db.fixed_ip_update(context, address, {'allocated': True})
-        return address
-
-    def deallocate_fixed_ip(self, context, address, *args, **kwargs):
-        """Returns a fixed ip to the pool."""
-        self.db.fixed_ip_update(context, address, {'allocated': False})
-        self.db.fixed_ip_disassociate(context.elevated(), address)
-
     def setup_compute_network(self, context, instance_id):
         """Network is created manually."""
         pass
 
-    def create_networks(self, context, cidr, num_networks, network_size,
-                        cidr_v6, label, *args, **kwargs):
-        """Create networks based on parameters."""
-        fixed_net = IPy.IP(cidr)
-        fixed_net_v6 = IPy.IP(cidr_v6)
-        significant_bits_v6 = 64
-        count = 1
-        for index in range(num_networks):
-            start = index * network_size
-            significant_bits = 32 - int(math.log(network_size, 2))
-            cidr = "%s/%s" % (fixed_net[start], significant_bits)
-            project_net = IPy.IP(cidr)
-            net = {}
-            net['bridge'] = FLAGS.flat_network_bridge
-            net['cidr'] = cidr
-            net['netmask'] = str(project_net.netmask())
-            net['gateway'] = str(project_net[1])
-            net['broadcast'] = str(project_net.broadcast())
-            net['dhcp_start'] = str(project_net[2])
-            if num_networks > 1:
-                net['label'] = "%s_%d" % (label, count)
-            else:
-                net['label'] = label
-            count += 1
-
-            if(FLAGS.use_ipv6):
-                cidr_v6 = "%s/%s" % (fixed_net_v6[0], significant_bits_v6)
-                net['cidr_v6'] = cidr_v6
-
-            network_ref = self.db.network_create_safe(context, net)
-
-            if network_ref:
-                self._create_fixed_ips(context, network_ref['id'])
-
-    def get_network_host(self, context):
-        """Get the network host for the current context."""
-        network_ref = self.db.network_get_by_bridge(context,
-                                                    FLAGS.flat_network_bridge)
-        # NOTE(vish): If the network has no host, use the network_host flag.
-        #             This could eventually be a a db lookup of some sort, but
-        #             a flag is easy to handle for now.
-        host = network_ref['host']
-        if not host:
-            topic = self.db.queue_get_for(context,
-                                          FLAGS.network_topic,
-                                          FLAGS.network_host)
-            if FLAGS.fake_call:
-                return self.set_network_host(context, network_ref['id'])
-            host = rpc.call(context,
-                            FLAGS.network_topic,
-                            {"method": "set_network_host",
-                             "args": {"network_id": network_ref['id']}})
-        return host
-
     def _on_set_network_host(self, context, network_id):
         """Called when this host becomes the host for a network."""
         net = {}
@@ -433,7 +416,7 @@ class FlatManager(NetworkManager):
         raise NotImplementedError()
 
 
-class FlatDHCPManager(FlatManager):
+class FlatDHCPManager(NetworkManager):
     """Flat networking with dhcp.
 
     FlatDHCPManager will start up one dhcp server to give out addresses.
-- 
cgit 


From 65b9dfbea28f1607ef471e78b73ba77183d943f6 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Thu, 24 Feb 2011 01:53:01 -0800
Subject: capability aggregation working

---
 nova/api/openstack/zones.py    | 15 ++++++++++++---
 nova/scheduler/api.py          | 15 +++++++++++++--
 nova/scheduler/manager.py      | 12 +++++++++---
 nova/scheduler/zone_manager.py | 35 ++++++++++++++++++++++++++++++++---
 nova/scheduler_manager.py      |  6 ++----
 5 files changed, 68 insertions(+), 15 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/zones.py b/nova/api/openstack/zones.py
index 989b3a235..c6c27dd4b 100644
--- a/nova/api/openstack/zones.py
+++ b/nova/api/openstack/zones.py
@@ -15,9 +15,10 @@
 
 import common
 
+from nova import db
 from nova import flags
+from nova import log as logging
 from nova import wsgi
-from nova import db
 from nova.scheduler import api
 
 
@@ -67,8 +68,16 @@ class Controller(wsgi.Controller):
 
     def info(self, req):
         """Return name and capabilities for this zone."""
-        return dict(zone=dict(name=FLAGS.zone_name,
-                    capabilities=FLAGS.zone_capabilities))
+        items = api.API().get_zone_capabilities(req.environ['nova.context'])
+
+        zone = dict(name=FLAGS.zone_name)
+        caps = FLAGS.zone_capabilities.split(';')
+        for cap in caps:
+            key_values = cap.split(':')
+            zone[key_values[0]] = key_values[1]
+        for item, (min_value, max_value) in items.iteritems():
+            zone[item] = "%s,%s" % (min_value, max_value)
+        return dict(zone=zone)
 
     def show(self, req, id):
         """Return data about the given zone id"""
diff --git a/nova/scheduler/api.py b/nova/scheduler/api.py
index 6a6bfc032..ac38350ed 100644
--- a/nova/scheduler/api.py
+++ b/nova/scheduler/api.py
@@ -43,13 +43,24 @@ class API:
         return rpc.call(context, queue, kwargs)
 
     def get_zone_list(self, context):
+        """Return a list of zones assoicated with this zone."""
         items = self._call_scheduler('get_zone_list', context)
         for item in items:
             item['api_url'] = item['api_url'].replace('\\/', '/')
         return items
 
+    def get_zone_capabilities(self, context, service=None):
+        """Returns a dict of key, value capabilities for this zone,
+           or for a particular class of services running in this zone."""
+        return self._call_scheduler('get_zone_capabilities', context=context,
+                            params=dict(service=service))
+
     @classmethod
-    def update_service_capabilities(cls, context, service_name, capabilities):
+    def update_service_capabilities(cls, context, service_name, host,
+                                                capabilities):
+        """Send an update to all the scheduler services informing them
+           of the capabilities of this service."""
         kwargs = dict(method='update_service_capabilities',
-                        service_name=service_name, capabilities=capabilities)
+                      args=dict(service_name=service_name, host=host,
+                                capabilities=capabilities))
         return rpc.fanout_cast(context, 'scheduler', kwargs)
diff --git a/nova/scheduler/manager.py b/nova/scheduler/manager.py
index 6b5c6e246..1bda77d89 100644
--- a/nova/scheduler/manager.py
+++ b/nova/scheduler/manager.py
@@ -59,10 +59,16 @@ class SchedulerManager(manager.Manager):
         """Get a list of zones from the ZoneManager."""
         return self.zone_manager.get_zone_list()
 
+    def get_zone_capabilities(self, context=None, service=None):
+        """Get the normalized set of capabilites for this zone,
+           or for a particular service."""
+        return self.zone_manager.get_zone_capabilities(context, service)
+
     def update_service_capabilities(self, context=None, service_name=None,
-                                                capabilities={}):
-        """Process a compute node update."""
-        return self.zone_manager.update_compute_capabilities()
+                                                host=None, capabilities={}):
+        """Process a capability update from a service node."""
+        self.zone_manager.update_service_capabilities(service_name,
+                            host, capabilities)
 
     def _schedule(self, method, context, topic, *args, **kwargs):
         """Tries to call schedule_* method on the driver to retrieve host.
diff --git a/nova/scheduler/zone_manager.py b/nova/scheduler/zone_manager.py
index eedc5c235..09c9811f3 100644
--- a/nova/scheduler/zone_manager.py
+++ b/nova/scheduler/zone_manager.py
@@ -105,13 +105,37 @@ class ZoneManager(object):
     def __init__(self):
         self.last_zone_db_check = datetime.min
         self.zone_states = {}
-        self.compute_states = {}
+        self.service_states = {}  # { <service> : { <host> : { cap k : v }}}
         self.green_pool = greenpool.GreenPool()
 
     def get_zone_list(self):
         """Return the list of zones we know about."""
         return [zone.to_dict() for zone in self.zone_states.values()]
 
+    def get_zone_capabilities(self, context, service=None):
+        """Roll up all the individual host info to generic 'service'
+           capabilities. Each capability is aggregated into
+           <cap>_min and <cap>_max values."""
+        service_dict = self.service_states
+        if service:
+            service_dict = dict(service_name=service,
+                                hosts=self.service_states.get(service, {}))
+
+        # TODO(sandy) - be smarter about fabricating this structure.
+        # But it's likely to change once we understand what the Best-Match
+        # code will need better.
+        combined = {}  # { <service>_<cap> : (min, max), ... }
+        for service_name, host_dict in service_dict.iteritems():
+            for host, caps_dict in host_dict.iteritems():
+                for cap, value in caps_dict.iteritems():
+                    key = "%s_%s" % (service_name, cap)
+                    min_value, max_value = combined.get(key, (value, value))
+                    min_value = min(min_value, value)
+                    max_value = max(max_value, value)
+                    combined[key] = (min_value, max_value)
+
+        return combined
+
     def _refresh_from_db(self, context):
         """Make our zone state map match the db."""
         # Add/update existing zones ...
@@ -143,5 +167,10 @@ class ZoneManager(object):
             self._refresh_from_db(context)
         self._poll_zones(context)
 
-    def update_compute_capabilities(self):
-        logging.debug(_("****** UPDATE COMPUTE CAPABILITIES *******"))
+    def update_service_capabilities(self, service_name, host, capabilities):
+        """Update the per-service capabilities based on this notification."""
+        logging.debug(_("Received %(service_name)s service update from "
+                            "%(host)s: %(capabilities)s") % locals())
+        service_caps = self.service_states.get(service_name, {})
+        service_caps[host] = capabilities
+        self.service_states[service_name] = service_caps
diff --git a/nova/scheduler_manager.py b/nova/scheduler_manager.py
index 65bd71c05..ca39b85dd 100644
--- a/nova/scheduler_manager.py
+++ b/nova/scheduler_manager.py
@@ -34,13 +34,11 @@ FLAGS = flags.FLAGS
 
 
 class SchedulerDependentManager(manager.Manager):
-
     """Periodically send capability updates to the Scheduler services.
        Services that need to update the Scheduler of their capabilities
        should derive from this class. Otherwise they can derive from
        manager.Manager directly. Updates are only sent after
        update_service_capabilities is called with non-None values."""
-
     def __init__(self, host=None, db_driver=None, service_name="undefined"):
         self.last_capabilities = None
         self.service_name = service_name
@@ -53,8 +51,8 @@ class SchedulerDependentManager(manager.Manager):
     def periodic_tasks(self, context=None):
         """Pass data back to the scheduler at a periodic interval"""
         if self.last_capabilities:
-            logging.debug(_("*** Notifying Schedulers of capabilities ..."))
+            logging.debug(_("Notifying Schedulers of capabilities ..."))
             api.API.update_service_capabilities(context, self.service_name,
-                                self.last_capabilities)
+                                self.host, self.last_capabilities)
 
         super(SchedulerDependentManager, self).periodic_tasks(context)
-- 
cgit 


From 9e018bbee1d4a308fdf1700bd25aa733cedc26e6 Mon Sep 17 00:00:00 2001
From: Josh Kearney <josh@jk0.org>
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')

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 bf222b9173e0a5a0bfbcf4705caab390ee33334b Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Thu, 24 Feb 2011 11:17:42 -0800
Subject: moved migrate script to 007 (again..sigh)

---
 .../versions/006_add_instance_types.py             | 86 ----------------------
 .../versions/007_add_instance_types.py             | 86 ++++++++++++++++++++++
 2 files changed, 86 insertions(+), 86 deletions(-)
 delete mode 100644 nova/db/sqlalchemy/migrate_repo/versions/006_add_instance_types.py
 create mode 100644 nova/db/sqlalchemy/migrate_repo/versions/007_add_instance_types.py

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/migrate_repo/versions/006_add_instance_types.py b/nova/db/sqlalchemy/migrate_repo/versions/006_add_instance_types.py
deleted file mode 100644
index fec191214..000000000
--- a/nova/db/sqlalchemy/migrate_repo/versions/006_add_instance_types.py
+++ /dev/null
@@ -1,86 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-#    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 sqlalchemy import *
-from migrate import *
-
-from nova import api
-from nova import db
-from nova import log as logging
-
-import datetime
-
-meta = MetaData()
-
-
-#
-# New Tables
-#
-instance_types = Table('instance_types', meta,
-        Column('created_at', DateTime(timezone=False)),
-        Column('updated_at', DateTime(timezone=False)),
-        Column('deleted_at', DateTime(timezone=False)),
-        Column('deleted', Boolean(create_constraint=True, name=None)),
-        Column('name',
-               String(length=255, convert_unicode=False, assert_unicode=None,
-                      unicode_error=None, _warn_on_bytestring=False),
-                      unique=True),
-        Column('id', Integer(),  primary_key=True, nullable=False),
-        Column('memory_mb', Integer(),  nullable=False),
-        Column('vcpus', Integer(),  nullable=False),
-        Column('local_gb', Integer(),  nullable=False),
-        Column('flavorid', Integer(),  nullable=False, unique=True),
-        Column('swap', Integer(),  nullable=False, default=0),
-        Column('rxtx_quota', Integer(),  nullable=False, default=0),
-        Column('rxtx_cap', Integer(),  nullable=False, default=0))
-
-
-def upgrade(migrate_engine):
-    # Upgrade operations go here
-    # Don't create your own engine; bind migrate_engine
-    # to your metadata
-    meta.bind = migrate_engine
-    try:
-        instance_types.create()
-    except Exception:
-        logging.info(repr(table))
-        logging.exception('Exception while creating instance_types table')
-        raise
-
-    # Here are the old static instance types
-    INSTANCE_TYPES = {
-    'm1.tiny': dict(memory_mb=512, vcpus=1, local_gb=0, flavorid=1),
-    'm1.small': dict(memory_mb=2048, vcpus=1, local_gb=20, flavorid=2),
-    'm1.medium': dict(memory_mb=4096, vcpus=2, local_gb=40, flavorid=3),
-    'm1.large': dict(memory_mb=8192, vcpus=4, local_gb=80, flavorid=4),
-    'm1.xlarge': dict(memory_mb=16384, vcpus=8, local_gb=160, flavorid=5)}
-    try:
-        i = instance_types.insert()
-        for name, values in INSTANCE_TYPES.iteritems():
-            # FIXME(kpepple) should we be seeding created_at / updated_at ?
-            # now = datetime.datatime.utcnow()
-            i.execute({'name': name, 'memory_mb': values["memory_mb"],
-                        'vcpus': values["vcpus"], 'deleted': 0,
-                        'local_gb': values["local_gb"],
-                        'flavorid': values["flavorid"]})
-    except Exception:
-        logging.info(repr(table))
-        logging.exception('Exception while seeding instance_types table')
-        raise
-
-
-def downgrade(migrate_engine):
-    # Operations to reverse the above upgrade go here.
-    for table in (instance_types):
-        table.drop()
diff --git a/nova/db/sqlalchemy/migrate_repo/versions/007_add_instance_types.py b/nova/db/sqlalchemy/migrate_repo/versions/007_add_instance_types.py
new file mode 100644
index 000000000..fec191214
--- /dev/null
+++ b/nova/db/sqlalchemy/migrate_repo/versions/007_add_instance_types.py
@@ -0,0 +1,86 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+#    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 sqlalchemy import *
+from migrate import *
+
+from nova import api
+from nova import db
+from nova import log as logging
+
+import datetime
+
+meta = MetaData()
+
+
+#
+# New Tables
+#
+instance_types = Table('instance_types', meta,
+        Column('created_at', DateTime(timezone=False)),
+        Column('updated_at', DateTime(timezone=False)),
+        Column('deleted_at', DateTime(timezone=False)),
+        Column('deleted', Boolean(create_constraint=True, name=None)),
+        Column('name',
+               String(length=255, convert_unicode=False, assert_unicode=None,
+                      unicode_error=None, _warn_on_bytestring=False),
+                      unique=True),
+        Column('id', Integer(),  primary_key=True, nullable=False),
+        Column('memory_mb', Integer(),  nullable=False),
+        Column('vcpus', Integer(),  nullable=False),
+        Column('local_gb', Integer(),  nullable=False),
+        Column('flavorid', Integer(),  nullable=False, unique=True),
+        Column('swap', Integer(),  nullable=False, default=0),
+        Column('rxtx_quota', Integer(),  nullable=False, default=0),
+        Column('rxtx_cap', Integer(),  nullable=False, default=0))
+
+
+def upgrade(migrate_engine):
+    # Upgrade operations go here
+    # Don't create your own engine; bind migrate_engine
+    # to your metadata
+    meta.bind = migrate_engine
+    try:
+        instance_types.create()
+    except Exception:
+        logging.info(repr(table))
+        logging.exception('Exception while creating instance_types table')
+        raise
+
+    # Here are the old static instance types
+    INSTANCE_TYPES = {
+    'm1.tiny': dict(memory_mb=512, vcpus=1, local_gb=0, flavorid=1),
+    'm1.small': dict(memory_mb=2048, vcpus=1, local_gb=20, flavorid=2),
+    'm1.medium': dict(memory_mb=4096, vcpus=2, local_gb=40, flavorid=3),
+    'm1.large': dict(memory_mb=8192, vcpus=4, local_gb=80, flavorid=4),
+    'm1.xlarge': dict(memory_mb=16384, vcpus=8, local_gb=160, flavorid=5)}
+    try:
+        i = instance_types.insert()
+        for name, values in INSTANCE_TYPES.iteritems():
+            # FIXME(kpepple) should we be seeding created_at / updated_at ?
+            # now = datetime.datatime.utcnow()
+            i.execute({'name': name, 'memory_mb': values["memory_mb"],
+                        'vcpus': values["vcpus"], 'deleted': 0,
+                        'local_gb': values["local_gb"],
+                        'flavorid': values["flavorid"]})
+    except Exception:
+        logging.info(repr(table))
+        logging.exception('Exception while seeding instance_types table')
+        raise
+
+
+def downgrade(migrate_engine):
+    # Operations to reverse the above upgrade go here.
+    for table in (instance_types):
+        table.drop()
-- 
cgit 


From 907df1b90e5c22eb82ce85bc12f48d8abf09b665 Mon Sep 17 00:00:00 2001
From: Josh Kearney <josh@jk0.org>
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')

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 c8df2602fd8f4f2cb7716e6283f3779c6895a479 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Thu, 24 Feb 2011 14:32:25 -0800
Subject: service capabilities test

---
 nova/scheduler/driver.py  |  7 +++++++
 nova/scheduler/manager.py |  3 ++-
 nova/tests/test_zones.py  | 28 ++++++++++++++++++++++++++++
 3 files changed, 37 insertions(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/scheduler/driver.py b/nova/scheduler/driver.py
index 66e46c1b9..317a039cc 100644
--- a/nova/scheduler/driver.py
+++ b/nova/scheduler/driver.py
@@ -45,6 +45,13 @@ class WillNotSchedule(exception.Error):
 class Scheduler(object):
     """The base class that all Scheduler clases should inherit from."""
 
+    def __init__(self):
+        self.zone_manager = None
+
+    def set_zone_manager(self, zone_manager):
+        """Called by the Scheduler Service to supply a ZoneManager."""
+        self.zone_manager = zone_manager
+
     @staticmethod
     def service_is_up(service):
         """Check whether a service is up based on last heartbeat."""
diff --git a/nova/scheduler/manager.py b/nova/scheduler/manager.py
index 1bda77d89..d3d338943 100644
--- a/nova/scheduler/manager.py
+++ b/nova/scheduler/manager.py
@@ -41,10 +41,11 @@ flags.DEFINE_string('scheduler_driver',
 class SchedulerManager(manager.Manager):
     """Chooses a host to run instances on."""
     def __init__(self, scheduler_driver=None, *args, **kwargs):
+        self.zone_manager = zone_manager.ZoneManager()
         if not scheduler_driver:
             scheduler_driver = FLAGS.scheduler_driver
         self.driver = utils.import_object(scheduler_driver)
-        self.zone_manager = zone_manager.ZoneManager()
+        self.driver.set_zone_manager(self.zone_manager)
         super(SchedulerManager, self).__init__(*args, **kwargs)
 
     def __getattr__(self, key):
diff --git a/nova/tests/test_zones.py b/nova/tests/test_zones.py
index 5a52a0506..3ca71d5f1 100644
--- a/nova/tests/test_zones.py
+++ b/nova/tests/test_zones.py
@@ -76,6 +76,34 @@ class ZoneManagerTestCase(test.TestCase):
         self.assertEquals(len(zm.zone_states), 1)
         self.assertEquals(zm.zone_states[1].username, 'user1')
 
+    def test_service_capabilities(self):
+        zm = zone_manager.ZoneManager()
+        caps = zm.get_zone_capabilities(self, None)
+        self.assertEquals(caps, {})
+
+        zm.update_service_capabilities("svc1", "host1", dict(a=1, b=2))
+        caps = zm.get_zone_capabilities(self, None)
+        self.assertEquals(caps, dict(svc1_a=(1, 1), svc1_b=(2, 2)))
+
+        zm.update_service_capabilities("svc1", "host1", dict(a=2, b=3))
+        caps = zm.get_zone_capabilities(self, None)
+        self.assertEquals(caps, dict(svc1_a=(2, 2), svc1_b=(3, 3)))
+ 
+        zm.update_service_capabilities("svc1", "host2", dict(a=20, b=30))
+        caps = zm.get_zone_capabilities(self, None)
+        self.assertEquals(caps, dict(svc1_a=(2, 20), svc1_b=(3, 30)))
+  
+        zm.update_service_capabilities("svc10", "host1", dict(a=99, b=99))
+        caps = zm.get_zone_capabilities(self, None)
+        self.assertEquals(caps, dict(svc1_a=(2, 20), svc1_b=(3, 30),
+                                        svc10_a=(99, 99), svc10_b=(99, 99)))
+   
+        zm.update_service_capabilities("svc1", "host3", dict(c=5))
+        caps = zm.get_zone_capabilities(self, None)
+        self.assertEquals(caps, dict(svc1_a=(2, 20), svc1_b=(3, 30),
+                                     svc1_c=(5, 5), svc10_a=(99, 99),
+                                     svc10_b=(99, 99)))
+ 
     def test_refresh_from_db_replace_existing(self):
         zm = zone_manager.ZoneManager()
         zone_state = zone_manager.ZoneState()
-- 
cgit 


From 47bbfaab52642f3ff79bcdefb8d705fb02b549f9 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Thu, 24 Feb 2011 15:23:15 -0800
Subject: new tests

---
 nova/api/openstack/zones.py            |  4 ++--
 nova/scheduler/api.py                  | 37 ++++++++++++++++++----------------
 nova/scheduler/zone_manager.py         |  3 +--
 nova/tests/api/openstack/test_zones.py | 30 ++++++++++++++++++++++++---
 nova/tests/test_zones.py               |  6 ++++++
 5 files changed, 56 insertions(+), 24 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/zones.py b/nova/api/openstack/zones.py
index c6c27dd4b..fecbd6fa3 100644
--- a/nova/api/openstack/zones.py
+++ b/nova/api/openstack/zones.py
@@ -53,7 +53,7 @@ class Controller(wsgi.Controller):
         """Return all zones in brief"""
         # Ask the ZoneManager in the Scheduler for most recent data,
         # or fall-back to the database ...
-        items = api.API().get_zone_list(req.environ['nova.context'])
+        items = api.API.get_zone_list(req.environ['nova.context'])
         if not items:
             items = db.zone_get_all(req.environ['nova.context'])
 
@@ -68,7 +68,7 @@ class Controller(wsgi.Controller):
 
     def info(self, req):
         """Return name and capabilities for this zone."""
-        items = api.API().get_zone_capabilities(req.environ['nova.context'])
+        items = api.API.get_zone_capabilities(req.environ['nova.context'])
 
         zone = dict(name=FLAGS.zone_name)
         caps = FLAGS.zone_capabilities.split(';')
diff --git a/nova/scheduler/api.py b/nova/scheduler/api.py
index ac38350ed..fcff2f146 100644
--- a/nova/scheduler/api.py
+++ b/nova/scheduler/api.py
@@ -25,34 +25,37 @@ FLAGS = flags.FLAGS
 LOG = logging.getLogger('nova.scheduler.api')
 
 
-class API:
-    """API for interacting with the scheduler."""
+def _call_scheduler(method, context, params=None):
+    """Generic handler for RPC calls to the scheduler.
 
-    def _call_scheduler(self, method, context, params=None):
-        """Generic handler for RPC calls to the scheduler.
+    :param params: Optional dictionary of arguments to be passed to the
+                   scheduler worker
 
-        :param params: Optional dictionary of arguments to be passed to the
-                       scheduler worker
+    :retval: Result returned by scheduler worker
+    """
+    if not params:
+        params = {}
+    queue = FLAGS.scheduler_topic
+    kwargs = {'method': method, 'args': params}
+    return rpc.call(context, queue, kwargs)
 
-        :retval: Result returned by scheduler worker
-        """
-        if not params:
-            params = {}
-        queue = FLAGS.scheduler_topic
-        kwargs = {'method': method, 'args': params}
-        return rpc.call(context, queue, kwargs)
 
-    def get_zone_list(self, context):
+class API:
+    """API for interacting with the scheduler."""
+
+    @classmethod
+    def get_zone_list(cls, context):
         """Return a list of zones assoicated with this zone."""
-        items = self._call_scheduler('get_zone_list', context)
+        items = _call_scheduler('get_zone_list', context)
         for item in items:
             item['api_url'] = item['api_url'].replace('\\/', '/')
         return items
 
-    def get_zone_capabilities(self, context, service=None):
+    @classmethod
+    def get_zone_capabilities(cls, context, service=None):
         """Returns a dict of key, value capabilities for this zone,
            or for a particular class of services running in this zone."""
-        return self._call_scheduler('get_zone_capabilities', context=context,
+        return _call_scheduler('get_zone_capabilities', context=context,
                             params=dict(service=service))
 
     @classmethod
diff --git a/nova/scheduler/zone_manager.py b/nova/scheduler/zone_manager.py
index 09c9811f3..c1a50dbc3 100644
--- a/nova/scheduler/zone_manager.py
+++ b/nova/scheduler/zone_manager.py
@@ -118,8 +118,7 @@ class ZoneManager(object):
            <cap>_min and <cap>_max values."""
         service_dict = self.service_states
         if service:
-            service_dict = dict(service_name=service,
-                                hosts=self.service_states.get(service, {}))
+            service_dict = {service: self.service_states.get(service, {})}
 
         # TODO(sandy) - be smarter about fabricating this structure.
         # But it's likely to change once we understand what the Best-Match
diff --git a/nova/tests/api/openstack/test_zones.py b/nova/tests/api/openstack/test_zones.py
index 82b892b9e..33a66df0b 100644
--- a/nova/tests/api/openstack/test_zones.py
+++ b/nova/tests/api/openstack/test_zones.py
@@ -75,6 +75,10 @@ def zone_get_all_db(context):
     ]
 
 
+def zone_caps(method, context, params):
+   return dict()
+
+
 class ZonesTest(test.TestCase):
     def setUp(self):
         super(ZonesTest, self).setUp()
@@ -93,13 +97,18 @@ class ZonesTest(test.TestCase):
         self.stubs.Set(nova.db, 'zone_create', zone_create)
         self.stubs.Set(nova.db, 'zone_delete', zone_delete)
 
+        self.old_zone_name = FLAGS.zone_name
+        self.old_zone_caps = FLAGS.zone_capabilities
+
     def tearDown(self):
         self.stubs.UnsetAll()
         FLAGS.allow_admin_api = self.allow_admin
+        FLAGS.zone_name = self.old_zone_name
+        FLAGS.zone_capabilities = self.old_zone_caps
         super(ZonesTest, self).tearDown()
 
     def test_get_zone_list_scheduler(self):
-        self.stubs.Set(api.API, '_call_scheduler', zone_get_all_scheduler)
+        self.stubs.Set(api, '_call_scheduler', zone_get_all_scheduler)
         req = webob.Request.blank('/v1.0/zones')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
@@ -108,8 +117,7 @@ class ZonesTest(test.TestCase):
         self.assertEqual(len(res_dict['zones']), 2)
 
     def test_get_zone_list_db(self):
-        self.stubs.Set(api.API, '_call_scheduler',
-                                zone_get_all_scheduler_empty)
+        self.stubs.Set(api, '_call_scheduler', zone_get_all_scheduler_empty)
         self.stubs.Set(nova.db, 'zone_get_all', zone_get_all_db)
         req = webob.Request.blank('/v1.0/zones')
         res = req.get_response(fakes.wsgi_app())
@@ -162,3 +170,19 @@ class ZonesTest(test.TestCase):
         self.assertEqual(res_dict['zone']['id'], 1)
         self.assertEqual(res_dict['zone']['api_url'], 'http://example.com')
         self.assertFalse('username' in res_dict['zone'])
+
+    def test_zone_info(self):
+        FLAGS.zone_name = 'darksecret'
+        FLAGS.zone_capabilities = 'cap1:a,b;cap2:c,d'
+        self.stubs.Set(api, '_call_scheduler', zone_caps)
+ 
+        body = dict(zone=dict(username='zeb', password='sneaky'))
+        req = webob.Request.blank('/v1.0/zones/info')
+
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+        self.assertEqual(res.status_int, 200)
+        self.assertEqual(res_dict['zone']['name'], 'darksecret')
+        self.assertEqual(res_dict['zone']['cap1'], 'a,b')
+        self.assertEqual(res_dict['zone']['cap2'], 'c,d')
+ 
diff --git a/nova/tests/test_zones.py b/nova/tests/test_zones.py
index 3ca71d5f1..79d766f28 100644
--- a/nova/tests/test_zones.py
+++ b/nova/tests/test_zones.py
@@ -104,6 +104,12 @@ class ZoneManagerTestCase(test.TestCase):
                                      svc1_c=(5, 5), svc10_a=(99, 99),
                                      svc10_b=(99, 99)))
  
+        caps = zm.get_zone_capabilities(self, 'svc1')
+        self.assertEquals(caps, dict(svc1_a=(2, 20), svc1_b=(3, 30),
+                                     svc1_c=(5, 5)))
+        caps = zm.get_zone_capabilities(self, 'svc10')
+        self.assertEquals(caps, dict(svc10_a=(99, 99), svc10_b=(99, 99)))
+ 
     def test_refresh_from_db_replace_existing(self):
         zm = zone_manager.ZoneManager()
         zone_state = zone_manager.ZoneState()
-- 
cgit 


From 307dcb7906ff066e2883cdee8998dfa78ebc8221 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Thu, 24 Feb 2011 15:44:27 -0800
Subject: sorry, pep8

---
 nova/tests/api/openstack/test_zones.py |  5 ++---
 nova/tests/test_zones.py               | 10 +++++-----
 2 files changed, 7 insertions(+), 8 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/test_zones.py b/nova/tests/api/openstack/test_zones.py
index 33a66df0b..a40d46749 100644
--- a/nova/tests/api/openstack/test_zones.py
+++ b/nova/tests/api/openstack/test_zones.py
@@ -76,7 +76,7 @@ def zone_get_all_db(context):
 
 
 def zone_caps(method, context, params):
-   return dict()
+    return dict()
 
 
 class ZonesTest(test.TestCase):
@@ -175,7 +175,7 @@ class ZonesTest(test.TestCase):
         FLAGS.zone_name = 'darksecret'
         FLAGS.zone_capabilities = 'cap1:a,b;cap2:c,d'
         self.stubs.Set(api, '_call_scheduler', zone_caps)
- 
+
         body = dict(zone=dict(username='zeb', password='sneaky'))
         req = webob.Request.blank('/v1.0/zones/info')
 
@@ -185,4 +185,3 @@ class ZonesTest(test.TestCase):
         self.assertEqual(res_dict['zone']['name'], 'darksecret')
         self.assertEqual(res_dict['zone']['cap1'], 'a,b')
         self.assertEqual(res_dict['zone']['cap2'], 'c,d')
- 
diff --git a/nova/tests/test_zones.py b/nova/tests/test_zones.py
index 79d766f28..48e1442cf 100644
--- a/nova/tests/test_zones.py
+++ b/nova/tests/test_zones.py
@@ -88,28 +88,28 @@ class ZoneManagerTestCase(test.TestCase):
         zm.update_service_capabilities("svc1", "host1", dict(a=2, b=3))
         caps = zm.get_zone_capabilities(self, None)
         self.assertEquals(caps, dict(svc1_a=(2, 2), svc1_b=(3, 3)))
- 
+
         zm.update_service_capabilities("svc1", "host2", dict(a=20, b=30))
         caps = zm.get_zone_capabilities(self, None)
         self.assertEquals(caps, dict(svc1_a=(2, 20), svc1_b=(3, 30)))
-  
+
         zm.update_service_capabilities("svc10", "host1", dict(a=99, b=99))
         caps = zm.get_zone_capabilities(self, None)
         self.assertEquals(caps, dict(svc1_a=(2, 20), svc1_b=(3, 30),
                                         svc10_a=(99, 99), svc10_b=(99, 99)))
-   
+
         zm.update_service_capabilities("svc1", "host3", dict(c=5))
         caps = zm.get_zone_capabilities(self, None)
         self.assertEquals(caps, dict(svc1_a=(2, 20), svc1_b=(3, 30),
                                      svc1_c=(5, 5), svc10_a=(99, 99),
                                      svc10_b=(99, 99)))
- 
+
         caps = zm.get_zone_capabilities(self, 'svc1')
         self.assertEquals(caps, dict(svc1_a=(2, 20), svc1_b=(3, 30),
                                      svc1_c=(5, 5)))
         caps = zm.get_zone_capabilities(self, 'svc10')
         self.assertEquals(caps, dict(svc10_a=(99, 99), svc10_b=(99, 99)))
- 
+
     def test_refresh_from_db_replace_existing(self):
         zm = zone_manager.ZoneManager()
         zone_state = zone_manager.ZoneState()
-- 
cgit 


From f7beae47ca505443eb86ea1a4fba6b47c1658755 Mon Sep 17 00:00:00 2001
From: Tushar Patil <tushar.vitthal.patil@gmail.com>
Date: Thu, 24 Feb 2011 17:07:59 -0800
Subject: IPV6 FlatManager changes

---
 nova/db/sqlalchemy/api.py                          | 11 ++--
 .../versions/007_add_ipv6_flatmanager.py           | 75 ++++++++++++++++++++++
 nova/db/sqlalchemy/models.py                       |  3 +
 nova/network/manager.py                            | 35 +++++++++-
 nova/virt/interfaces.template                      | 16 +++--
 nova/virt/libvirt_conn.py                          | 27 +++++---
 6 files changed, 149 insertions(+), 18 deletions(-)
 create mode 100644 nova/db/sqlalchemy/migrate_repo/versions/007_add_ipv6_flatmanager.py

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index d8751bef4..9bc59de60 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -833,10 +833,13 @@ def instance_get_fixed_address_v6(context, instance_id):
     session = get_session()
     with session.begin():
         instance_ref = instance_get(context, instance_id, session=session)
-        network_ref = network_get_by_instance(context, instance_id)
-        prefix = network_ref.cidr_v6
-        mac = instance_ref.mac_address
-        return utils.to_global_ipv6(prefix, mac)
+        if 'nova.network.manager.FlatManager' == FLAGS.network_manager:
+            return instance_ref.fixed_ip['addressv6']
+        else:
+            network_ref = network_get_by_instance(context, instance_id)
+            prefix = network_ref.cidr_v6
+            mac = instance_ref.mac_address
+            return utils.to_global_ipv6(prefix, mac)
 
 
 @require_context
diff --git a/nova/db/sqlalchemy/migrate_repo/versions/007_add_ipv6_flatmanager.py b/nova/db/sqlalchemy/migrate_repo/versions/007_add_ipv6_flatmanager.py
new file mode 100644
index 000000000..2951cbc0a
--- /dev/null
+++ b/nova/db/sqlalchemy/migrate_repo/versions/007_add_ipv6_flatmanager.py
@@ -0,0 +1,75 @@
+# Copyright 2010 OpenStack LLC.
+# 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.
+
+from sqlalchemy import *
+from migrate import *
+
+from nova import log as logging
+
+
+meta = MetaData()
+
+
+# Table stub-definitions
+# Just for the ForeignKey and column creation to succeed, these are not the
+# actual definitions of instances or services.
+#
+networks = Table('networks', meta,
+        Column('id', Integer(),  primary_key=True, nullable=False),
+        )
+
+fixed_ips = Table('fixed_ips', meta,
+        Column('id', Integer(),  primary_key=True, nullable=False),
+        )
+
+#
+# New Tables
+#
+# None
+
+#
+# Tables to alter
+#
+# None
+
+#
+# Columns to add to existing tables
+#
+
+networks_gatewayv6 = Column(
+        'gatewayv6',
+        String(length=255, convert_unicode=False, assert_unicode=None,
+               unicode_error=None, _warn_on_bytestring=False))
+
+networks_netmaskv6 = Column(
+        'netmaskv6',
+        String(length=255, convert_unicode=False, assert_unicode=None,
+               unicode_error=None, _warn_on_bytestring=False))
+
+fixed_ips_addressv6 = Column(
+        'addressv6',
+        String(length=255, convert_unicode=False, assert_unicode=None,
+               unicode_error=None, _warn_on_bytestring=False))
+
+
+def upgrade(migrate_engine):
+    # Upgrade operations go here. Don't create your own engine;
+    # bind migrate_engine to your metadata
+    meta.bind = migrate_engine
+
+    # Add columns to existing tables
+    networks.create_column(networks_gatewayv6)
+    networks.create_column(networks_netmaskv6)
+    fixed_ips.create_column(fixed_ips_addressv6)
diff --git a/nova/db/sqlalchemy/models.py b/nova/db/sqlalchemy/models.py
index 1882efeba..4fa4d443c 100644
--- a/nova/db/sqlalchemy/models.py
+++ b/nova/db/sqlalchemy/models.py
@@ -385,6 +385,8 @@ class Network(BASE, NovaBase):
 
     ra_server = Column(String(255))
 
+    gatewayv6 = Column(String(255))
+    netmaskv6 = Column(String(255))
     netmask = Column(String(255))
     bridge = Column(String(255))
     gateway = Column(String(255))
@@ -425,6 +427,7 @@ class FixedIp(BASE, NovaBase):
     __tablename__ = 'fixed_ips'
     id = Column(Integer, primary_key=True)
     address = Column(String(255))
+    addressv6 = Column(String(255))
     network_id = Column(Integer, ForeignKey('networks.id'), nullable=True)
     network = relationship(Network, backref=backref('fixed_ips'))
     instance_id = Column(Integer, ForeignKey('instances.id'), nullable=True)
diff --git a/nova/network/manager.py b/nova/network/manager.py
index 12a0c5018..61b5dc07f 100644
--- a/nova/network/manager.py
+++ b/nova/network/manager.py
@@ -361,9 +361,11 @@ class FlatManager(NetworkManager):
         fixed_net = IPy.IP(cidr)
         fixed_net_v6 = IPy.IP(cidr_v6)
         significant_bits_v6 = 64
+        network_size_v6 = 1 << 64
         count = 1
         for index in range(num_networks):
             start = index * network_size
+            start_v6 = index * network_size_v6
             significant_bits = 32 - int(math.log(network_size, 2))
             cidr = "%s/%s" % (fixed_net[start], significant_bits)
             project_net = IPy.IP(cidr)
@@ -382,14 +384,45 @@ class FlatManager(NetworkManager):
             count += 1
 
             if(FLAGS.use_ipv6):
-                cidr_v6 = "%s/%s" % (fixed_net_v6[0], significant_bits_v6)
+                cidr_v6 = "%s/%s" % (fixed_net_v6[start_v6],
+                                     significant_bits_v6)
                 net['cidr_v6'] = cidr_v6
+                project_net_v6 = IPy.IP(cidr_v6)
+                net['gatewayv6'] = str(project_net_v6[1])
+                net['netmaskv6'] = str(project_net_v6.prefixlen())
 
             network_ref = self.db.network_create_safe(context, net)
 
             if network_ref:
                 self._create_fixed_ips(context, network_ref['id'])
 
+    def _create_fixed_ips(self, context, network_id):
+        """Create all fixed ips for network."""
+        network_ref = self.db.network_get(context, network_id)
+        # NOTE(vish): Should these be properties of the network as opposed
+        #             to properties of the manager class?
+        bottom_reserved = self._bottom_reserved_ips
+        top_reserved = self._top_reserved_ips
+        project_net = IPy.IP(network_ref['cidr'])
+
+        if(FLAGS.use_ipv6):
+            project_net_v6 = IPy.IP(network_ref['cidr_v6'])
+
+        num_ips = len(project_net)
+        addressv6 = None
+        for index in range(num_ips):
+            address = str(project_net[index])
+            if(FLAGS.use_ipv6):
+                addressv6 = str(project_net_v6[index])
+            if index < bottom_reserved or num_ips - index < top_reserved:
+                reserved = True
+            else:
+                reserved = False
+            self.db.fixed_ip_create(context, {'network_id': network_id,
+                                              'address': address,
+                                              'addressv6': addressv6,
+                                              'reserved': reserved})
+
     def get_network_host(self, context):
         """Get the network host for the current context."""
         network_ref = self.db.network_get_by_bridge(context,
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 e3d6dc70a6b77d80afcf87473bc79549540ac4ce Mon Sep 17 00:00:00 2001
From: Rick Harris <rick.harris@rackspace.com>
Date: Fri, 25 Feb 2011 02:51:14 +0000
Subject: Removing unecessary nokernel stuff

---
 nova/api/openstack/servers.py | 51 ++++++++++++++++++++++++-------------------
 1 file changed, 29 insertions(+), 22 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index c8c94f1fd..f51da0cdd 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -136,28 +136,6 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPNotFound())
         return exc.HTTPAccepted()
 
-    def _get_kernel_ramdisk_from_image(self, req, image_id):
-        """
-        Machine images are associated with Kernels and Ramdisk images via
-        metadata stored in Glance as 'image_properties'
-        """
-        # FIXME(sirp): Currently Nova requires us to specify the `null_kernel`
-        # identifier ('nokernel') to indicate a RAW (or VHD) image.  It would
-        # be better if we could omit the kernel_id and ramdisk_id properties
-        # on the image
-        def lookup(image, param):
-            _image_id = image['id']
-            try:
-                return image['properties'][param]
-            except KeyError:
-                LOG.debug(
-                    _("%(param)s property not found for image %(_image_id)s") %
-                      locals())
-            return None
-
-        image = self._image_service.show(req.environ['nova.context'], image_id)
-        return lookup(image, 'kernel_id'), lookup(image, 'ramdisk_id')
-
     def create(self, req):
         """ Creates a new server for a given user """
         env = self._deserialize(req.body, req)
@@ -367,3 +345,32 @@ class Controller(wsgi.Controller):
                 action=item.action,
                 error=item.error))
         return dict(actions=actions)
+
+    def _get_kernel_ramdisk_from_image(self, req, image_id):
+        """Retrevies kernel and ramdisk IDs from Glance
+
+        Only 'machine' (ami) type use kernel and ramdisk outside of the
+        image.
+        """
+        # FIXME(sirp): Since we're retrieving the kernel_id from an
+        # image_property, this means only Glance is supported.
+        # The BaseImageService needs to expose a consistent way of accessing
+        # kernel_id and ramdisk_id
+        image = self._image_service.show(req.environ['nova.context'], image_id)
+
+        if image['type'] != 'machine':
+            return None, None
+
+        try:
+            kernel_id = image['properties']['kernel_id']
+        except KeyError:
+            raise exception.NotFound(
+                _("Kernel not found for image %(image_id)s") % locals())
+
+        try:
+            ramdisk_id = image['properties']['ramdisk_id']
+        except KeyError:
+            raise exception.NotFound(
+                _("Ramdisk not found for image %(image_id)s") % locals())
+
+        return kernel_id, ramdisk_id
-- 
cgit 


From 079b532a1080da9fe5d99e90fa9c60d16506de06 Mon Sep 17 00:00:00 2001
From: Rick Harris <rick.harris@rackspace.com>
Date: Fri, 25 Feb 2011 16:24:51 +0000
Subject: Verify status of image is active

---
 nova/api/openstack/servers.py | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index f51da0cdd..bf5663f60 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -358,6 +358,11 @@ class Controller(wsgi.Controller):
         # kernel_id and ramdisk_id
         image = self._image_service.show(req.environ['nova.context'], image_id)
 
+        if image['status'] != 'active':
+            raise exception.Invalid(
+                _("Cannot build from image %(image_id)s, status not active") %
+                  locals())
+
         if image['type'] != 'machine':
             return None, None
 
-- 
cgit 


From 6033f657aad9bd5b244a21908caedfc92840c9cf Mon Sep 17 00:00:00 2001
From: Josh Kearney <josh@jk0.org>
Date: Fri, 25 Feb 2011 10:54:37 -0600
Subject: Create rescue instance

---
 nova/db/sqlalchemy/models.py |  7 ++++-
 nova/virt/xenapi/vmops.py    | 69 +++++++++++++++++++++++++-------------------
 2 files changed, 45 insertions(+), 31 deletions(-)

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/models.py b/nova/db/sqlalchemy/models.py
index 1882efeba..b1eb1a7b7 100644
--- a/nova/db/sqlalchemy/models.py
+++ b/nova/db/sqlalchemy/models.py
@@ -126,11 +126,16 @@ class Certificate(BASE, NovaBase):
 class Instance(BASE, NovaBase):
     """Represents a guest vm."""
     __tablename__ = 'instances'
+    onset_files = []
+
     id = Column(Integer, primary_key=True, autoincrement=True)
 
     @property
     def name(self):
-        return FLAGS.instance_name_template % self.id
+        base_name = FLAGS.instance_name_template % self.id
+        if getattr(self, '_rescue', False):
+            base_name += "-rescue"
+        return base_name
 
     admin_pass = Column(String(255))
     user_id = Column(String(255))
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 <josh@jk0.org>
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')

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 <josh@jk0.org>
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')

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 <josh@jk0.org>
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')

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 7c6638cc5effc7d727087ed4354c180d75476d1a Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Fri, 25 Feb 2011 13:40:15 -0800
Subject: API changed to new style class

---
 nova/scheduler/api.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/scheduler/api.py b/nova/scheduler/api.py
index 8491bf3a9..2405f1343 100644
--- a/nova/scheduler/api.py
+++ b/nova/scheduler/api.py
@@ -25,7 +25,7 @@ FLAGS = flags.FLAGS
 LOG = logging.getLogger('nova.scheduler.api')
 
 
-class API:
+class API(object):
     """API for interacting with the scheduler."""
 
     def _call_scheduler(self, method, context, params=None):
-- 
cgit 


From 97566c04b3a04626f1bc1b66e72c61b4621b6c7d Mon Sep 17 00:00:00 2001
From: Josh Kearney <josh@jk0.org>
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')

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 20e9df05acdb89382023af1ac98cf040c827e18d Mon Sep 17 00:00:00 2001
From: Tushar Patil <tushar.vitthal.patil@gmail.com>
Date: Fri, 25 Feb 2011 14:49:33 -0800
Subject: DescribeInstances modified to return ipv6 fixed ip address in case of
 flatmanager

---
 nova/api/ec2/cloud.py | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 7458d307a..15799670c 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -701,9 +701,13 @@ class CloudController(object):
                     fixed = instance['fixed_ip']
                     floating_addr = fixed['floating_ips'][0]['address']
                 if instance['fixed_ip']['network'] and 'use_v6' in kwargs:
-                    i['dnsNameV6'] = utils.to_global_ipv6(
-                        instance['fixed_ip']['network']['cidr_v6'],
-                        instance['mac_address'])
+                    if FLAGS.network_manager == \
+                                  'nova.network.manager.FlatManager':
+                        i['dnsNameV6'] = instance['fixed_ip']['addressv6']
+                    else:
+                        i['dnsNameV6'] = utils.to_global_ipv6(
+                            instance['fixed_ip']['network']['cidr_v6'],
+                            instance['mac_address'])
 
             i['privateDnsName'] = fixed_addr
             i['publicDnsName'] = floating_addr
-- 
cgit 


From c7c3fe85186862d9d8989ebe01ad69e6cdaa4ee3 Mon Sep 17 00:00:00 2001
From: "Kevin L. Mitchell" <kevin.mitchell@rackspace.com>
Date: Sun, 20 Mar 2011 22:58:49 +0000
Subject: No reason to dump a stack trace just because we can't reach the AMQP
 servire; it ends up being just noise

---
 nova/rpc.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'nova')

diff --git a/nova/rpc.py b/nova/rpc.py
index 205bb524a..089bf99c1 100644
--- a/nova/rpc.py
+++ b/nova/rpc.py
@@ -95,14 +95,14 @@ class Consumer(messaging.Consumer):
                 fl_host = FLAGS.rabbit_host
                 fl_port = FLAGS.rabbit_port
                 fl_intv = FLAGS.rabbit_retry_interval
-                LOG.exception(_("AMQP server on %(fl_host)s:%(fl_port)d is"
+                LOG.error(_("AMQP server on %(fl_host)s:%(fl_port)d is"
                         " unreachable. Trying again in %(fl_intv)d seconds.")
                         % locals())
                 self.failed_connection = True
         if self.failed_connection:
-            LOG.exception(_("Unable to connect to AMQP server "
-                          "after %d tries. Shutting down."),
-                          FLAGS.rabbit_max_retries)
+            LOG.error(_("Unable to connect to AMQP server "
+                        "after %d tries. Shutting down."),
+                      FLAGS.rabbit_max_retries)
             sys.exit(1)
 
     def fetch(self, no_ack=None, auto_ack=None, enable_callbacks=False):
-- 
cgit 


From 4a217b640c3e0f488c87572787c92b6808ab0a9a Mon Sep 17 00:00:00 2001
From: "Kevin L. Mitchell" <kevin.mitchell@rackspace.com>
Date: Fri, 25 Mar 2011 05:30:36 +0000
Subject: Add error message to the error report so we know why the AMQP server
 is unreachable

---
 nova/rpc.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/rpc.py b/nova/rpc.py
index 089bf99c1..8fe4565dd 100644
--- a/nova/rpc.py
+++ b/nova/rpc.py
@@ -91,12 +91,13 @@ class Consumer(messaging.Consumer):
                 super(Consumer, self).__init__(*args, **kwargs)
                 self.failed_connection = False
                 break
-            except:  # Catching all because carrot sucks
+            except Exception as e:  # Catching all because carrot sucks
                 fl_host = FLAGS.rabbit_host
                 fl_port = FLAGS.rabbit_port
                 fl_intv = FLAGS.rabbit_retry_interval
                 LOG.error(_("AMQP server on %(fl_host)s:%(fl_port)d is"
-                        " unreachable. Trying again in %(fl_intv)d seconds.")
+                        " unreachable: %(e)s. Trying again in %(fl_intv)d"
+                        " seconds.")
                         % locals())
                 self.failed_connection = True
         if self.failed_connection:
-- 
cgit 


From 4c83130464c88650df7dfc7974f2fd088a733fec Mon Sep 17 00:00:00 2001
From: Christian Berendt <berendt@b1-systems.de>
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')

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 <berendt@b1-systems.de>
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')

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 2714b2df0d21ecb08966c4d145d2d75fa1bb201d Mon Sep 17 00:00:00 2001
From: Christian Berendt <berendt@b1-systems.de>
Date: Sun, 27 Feb 2011 00:07:03 +0100
Subject: fixed FIXME

---
 nova/db/sqlalchemy/api.py | 16 +++++-----------
 1 file changed, 5 insertions(+), 11 deletions(-)

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index d07c53759..828d24c78 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -598,17 +598,11 @@ def fixed_ip_get_all(context, session=None):
 def fixed_ip_get_all_by_host(context, host=None):
     session = get_session()
 
-    # FIXME: I'm sure that SQLAlchemy can handle this in a nicer way
-    instances = session.query(models.Instance).\
-                     filter_by(state=1).\
-                     filter_by(host=host).\
-                     all()
-
-    result = []
-    for instance in instances:
-        result.append(session.query(models.FixedIp).\
-                       filter_by(instance_id=instance['id']).\
-                       first())
+    result = session.query(models.FixedIp).\
+                    join(models.FixedIp.instance).\
+                    filter_by(state=1).\
+                    filter_by(host=host).\
+                    all()
 
     if not result:
         raise exception.NotFound(_('No fixed ips for this host defined'))
-- 
cgit 


From 38c21546ecc079300c575e5950bcb990eecee3a3 Mon Sep 17 00:00:00 2001
From: Eric Windisch <eric@cloudscaling.com>
Date: Sun, 27 Feb 2011 20:28:04 -0500
Subject: execute: shell=True removed.

---
 nova/utils.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/utils.py b/nova/utils.py
index 0cf91e0cc..40a8d8d8c 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -125,7 +125,7 @@ def fetchfile(url, target):
 #    c.perform()
 #    c.close()
 #    fp.close()
-    execute("curl --fail %s -o %s" % (url, target))
+    execute("curl","--fail",url,"-o",target)
 
 
 def execute(cmd, process_input=None, addl_env=None, check_exit_code=True):
@@ -133,7 +133,7 @@ def execute(cmd, process_input=None, addl_env=None, check_exit_code=True):
     env = os.environ.copy()
     if addl_env:
         env.update(addl_env)
-    obj = subprocess.Popen(cmd, shell=True, stdin=subprocess.PIPE,
+    obj = subprocess.Popen(cmd, stdin=subprocess.PIPE,
         stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env)
     result = None
     if process_input != None:
@@ -254,7 +254,7 @@ def last_octet(address):
 
 def  get_my_linklocal(interface):
     try:
-        if_str = execute("ip -f inet6 -o addr show %s" % interface)
+        if_str = execute("ip","-f","inet6","-o","addr","show", interface)
         condition = "\s+inet6\s+([0-9a-f:]+)/\d+\s+scope\s+link"
         links = [re.search(condition, x) for x in if_str[0].split('\n')]
         address = [w.group(1) for w in links if w is not None]
-- 
cgit 


From 4f90783224025618661bf8814e016843ec237875 Mon Sep 17 00:00:00 2001
From: Eric Windisch <eric@cloudscaling.com>
Date: Sun, 27 Feb 2011 20:52:32 -0500
Subject: execvp

---
 nova/volume/driver.py | 69 ++++++++++++++++++++++++++-------------------------
 1 file changed, 35 insertions(+), 34 deletions(-)

(limited to 'nova')

diff --git a/nova/volume/driver.py b/nova/volume/driver.py
index e3744c790..e73202b73 100644
--- a/nova/volume/driver.py
+++ b/nova/volume/driver.py
@@ -97,22 +97,21 @@ class VolumeDriver(object):
             sizestr = '100M'
         else:
             sizestr = '%sG' % volume['size']
-        self._try_execute("sudo lvcreate -L %s -n %s %s" %
-                          (sizestr,
+        self._try_execute('sudo','lvcreate','-L',sizestr,'-n',
                            volume['name'],
-                           FLAGS.volume_group))
+                           FLAGS.volume_group)
 
     def delete_volume(self, volume):
         """Deletes a logical volume."""
         try:
-            self._try_execute("sudo lvdisplay %s/%s" %
+            self._try_execute('sudo','lvdisplay','%s/%s" %
                               (FLAGS.volume_group,
                                volume['name']))
         except Exception as e:
             # If the volume isn't present, then don't attempt to delete
             return True
 
-        self._try_execute("sudo lvremove -f %s/%s" %
+        self._try_execute('sudo','lvremove','-f',"%s/%s" %
                           (FLAGS.volume_group,
                            volume['name']))
 
@@ -168,12 +167,13 @@ class AOEDriver(VolumeDriver):
          blade_id) = self.db.volume_allocate_shelf_and_blade(context,
                                                              volume['id'])
         self._try_execute(
-                "sudo vblade-persist setup %s %s %s /dev/%s/%s" %
-                (shelf_id,
+                'sudo','vblade-persist','setup',
+                 shelf_id,
                  blade_id,
                  FLAGS.aoe_eth_dev,
-                 FLAGS.volume_group,
-                 volume['name']))
+                 "/dev/%s/%s" %
+                 (FLAGS.volume_group,
+                  volume['name']))
         # NOTE(vish): The standard _try_execute does not work here
         #             because these methods throw errors if other
         #             volumes on this host are in the process of
@@ -182,9 +182,9 @@ class AOEDriver(VolumeDriver):
         #             just wait a bit for the current volume to
         #             be ready and ignore any errors.
         time.sleep(2)
-        self._execute("sudo vblade-persist auto all",
+        self._execute('sudo','vblade-persist','auto','all',
                       check_exit_code=False)
-        self._execute("sudo vblade-persist start all",
+        self._execute('sudo','vblade-persist','start','all',
                       check_exit_code=False)
 
     def remove_export(self, context, volume):
@@ -192,15 +192,15 @@ class AOEDriver(VolumeDriver):
         (shelf_id,
          blade_id) = self.db.volume_get_shelf_and_blade(context,
                                                         volume['id'])
-        self._try_execute("sudo vblade-persist stop %s %s" %
-                          (shelf_id, blade_id))
-        self._try_execute("sudo vblade-persist destroy %s %s" %
-                          (shelf_id, blade_id))
+        self._try_execute('sudo','vblade-persist','stop',
+                          shelf_id, blade_id)
+        self._try_execute('sudo','vblade-persist','destroy',
+                          shelf_id, blade_id)
 
     def discover_volume(self, _volume):
         """Discover volume on a remote host."""
-        self._execute("sudo aoe-discover")
-        self._execute("sudo aoe-stat", check_exit_code=False)
+        self._execute('sudo','aoe-discover')
+        self._execute('sudo','aoe-stat', check_exit_code=False)
 
     def undiscover_volume(self, _volume):
         """Undiscover volume on a remote host."""
@@ -252,13 +252,16 @@ class ISCSIDriver(VolumeDriver):
 
         iscsi_name = "%s%s" % (FLAGS.iscsi_target_prefix, volume['name'])
         volume_path = "/dev/%s/%s" % (FLAGS.volume_group, volume['name'])
-        self._sync_exec("sudo ietadm --op new "
-                        "--tid=%s --params Name=%s" %
-                        (iscsi_target, iscsi_name),
+        self._sync_exec('sudo','ietadm','--op','new',
+                        "--tid=%s" % iscsi_target,
+                        '--params',
+                        "Name=%s" % iscsi-name,
                         check_exit_code=False)
-        self._sync_exec("sudo ietadm --op new --tid=%s "
-                        "--lun=0 --params Path=%s,Type=fileio" %
-                        (iscsi_target, volume_path),
+        self._sync_exec('sudo','ietadm','--op','new',
+                        "--tid=%s" % iscsi_target,
+                        '--lun=0',
+                        '--params',
+                        "Path=%s,Type=fileio" % volume_path,
                         check_exit_code=False)
 
     def _ensure_iscsi_targets(self, context, host):
@@ -490,16 +493,13 @@ class RBDDriver(VolumeDriver):
             size = 100
         else:
             size = int(volume['size']) * 1024
-        self._try_execute("rbd --pool %s --size %d create %s" %
-                          (FLAGS.rbd_pool,
-                           size,
-                           volume['name']))
+        self._try_execute('rbd','--pool',FLAGS.rbd_pool,
+                          '--size', size,'create', volume['name'])
 
     def delete_volume(self, volume):
         """Deletes a logical volume."""
-        self._try_execute("rbd --pool %s rm %s" %
-                          (FLAGS.rbd_pool,
-                           volume['name']))
+        self._try_execute('rbd','--pool',FLAGS.rbd_pool,
+                          'rm', voluname['name'])
 
     def local_path(self, volume):
         """Returns the path of the rbd volume."""
@@ -534,7 +534,7 @@ class SheepdogDriver(VolumeDriver):
     def check_for_setup_error(self):
         """Returns an error if prerequisites aren't met"""
         try:
-            (out, err) = self._execute("collie cluster info")
+            (out, err) = self._execute('collie','cluster','info')
             if not out.startswith('running'):
                 raise exception.Error(_("Sheepdog is not working: %s") % out)
         except exception.ProcessExecutionError:
@@ -546,12 +546,13 @@ class SheepdogDriver(VolumeDriver):
             sizestr = '100M'
         else:
             sizestr = '%sG' % volume['size']
-        self._try_execute("qemu-img create sheepdog:%s %s" %
-                          (volume['name'], sizestr))
+        self._try_execute('qemu-img','create',
+                          "sheepdog:%s" %s" % volume['name'],
+                          sizestr)
 
     def delete_volume(self, volume):
         """Deletes a logical volume"""
-        self._try_execute("collie vdi delete %s" % volume['name'])
+        self._try_execute('collie','vdi','delete',volume['name'])
 
     def local_path(self, volume):
         return "sheepdog:%s" % volume['name']
-- 
cgit 


From 953efce36b74c18a32ef9c42e6b1a57190e3ff6e Mon Sep 17 00:00:00 2001
From: Eric Windisch <eric@cloudscaling.com>
Date: Sun, 27 Feb 2011 20:53:53 -0500
Subject: execvp

---
 nova/crypto.py | 28 +++++++++++++---------------
 1 file changed, 13 insertions(+), 15 deletions(-)

(limited to 'nova')

diff --git a/nova/crypto.py b/nova/crypto.py
index a34b940f5..b240a3958 100644
--- a/nova/crypto.py
+++ b/nova/crypto.py
@@ -105,8 +105,8 @@ def generate_key_pair(bits=1024):
 
     tmpdir = tempfile.mkdtemp()
     keyfile = os.path.join(tmpdir, 'temp')
-    utils.execute('ssh-keygen -q -b %d -N "" -f %s' % (bits, keyfile))
-    (out, err) = utils.execute('ssh-keygen -q -l -f %s.pub' % (keyfile))
+    utils.execute('ssh-keygen','-q','-b',"%d" % bits,'-N','""','-f',keyfile)
+    (out, err) = utils.execute('ssh-keygen','-q','-l','-f',"%s.pub" % (keyfile))
     fingerprint = out.split(' ')[1]
     private_key = open(keyfile).read()
     public_key = open(keyfile + '.pub').read()
@@ -118,7 +118,7 @@ def generate_key_pair(bits=1024):
     # bio = M2Crypto.BIO.MemoryBuffer()
     # key.save_pub_key_bio(bio)
     # public_key = bio.read()
-    # public_key, err = execute('ssh-keygen -y -f /dev/stdin', private_key)
+    # public_key, err = execute('ssh-keygen','-y','-f','/dev/stdin', private_key)
 
     return (private_key, public_key, fingerprint)
 
@@ -143,8 +143,8 @@ def revoke_cert(project_id, file_name):
     start = os.getcwd()
     os.chdir(ca_folder(project_id))
     # NOTE(vish): potential race condition here
-    utils.execute("openssl ca -config ./openssl.cnf -revoke '%s'" % file_name)
-    utils.execute("openssl ca -gencrl -config ./openssl.cnf -out '%s'" %
+    utils.execute('openssl','ca','-config','./openssl.cnf','-revoke',"'%s'" % file_name)
+    utils.execute('openssl','ca','-gencrl','-config','./openssl.cnf','-out',"'%s'" %
                   FLAGS.crl_file)
     os.chdir(start)
 
@@ -193,9 +193,8 @@ def generate_x509_cert(user_id, project_id, bits=1024):
     tmpdir = tempfile.mkdtemp()
     keyfile = os.path.abspath(os.path.join(tmpdir, 'temp.key'))
     csrfile = os.path.join(tmpdir, 'temp.csr')
-    utils.execute("openssl genrsa -out %s %s" % (keyfile, bits))
-    utils.execute("openssl req -new -key %s -out %s -batch -subj %s" %
-                  (keyfile, csrfile, subject))
+    utils.execute('openssl','genrsa','-out',keyfile,bits)
+    utils.execute('openssl','req','-new','-key',keyfile,'-out',csrfile,'-batch','-subj',subject)
     private_key = open(keyfile).read()
     csr = open(csrfile).read()
     shutil.rmtree(tmpdir)
@@ -212,8 +211,7 @@ def _ensure_project_folder(project_id):
     if not os.path.exists(ca_path(project_id)):
         start = os.getcwd()
         os.chdir(ca_folder())
-        utils.execute("sh geninter.sh %s %s" %
-                      (project_id, _project_cert_subject(project_id)))
+        utils.execute('sh','geninter.sh',project_id, _project_cert_subject(project_id))
         os.chdir(start)
 
 
@@ -228,8 +226,8 @@ def generate_vpn_files(project_id):
     start = os.getcwd()
     os.chdir(ca_folder())
     # TODO(vish): the shell scripts could all be done in python
-    utils.execute("sh genvpn.sh %s %s" %
-                  (project_id, _vpn_cert_subject(project_id)))
+    utils.execute('sh','genvpn.sh',
+                  project_id, _vpn_cert_subject(project_id))
     with open(csr_fn, "r") as csrfile:
         csr_text = csrfile.read()
     (serial, signed_csr) = sign_csr(csr_text, project_id)
@@ -259,9 +257,9 @@ def _sign_csr(csr_text, ca_folder):
     start = os.getcwd()
     # Change working dir to CA
     os.chdir(ca_folder)
-    utils.execute("openssl ca -batch -out %s -config "
-                  "./openssl.cnf -infiles %s" % (outbound, inbound))
-    out, _err = utils.execute("openssl x509 -in %s -serial -noout" % outbound)
+    utils.execute('openssl','ca','-batch','-out',outbound,'-config'
+                  './openssl.cnf','-infiles',inbound)
+    out, _err = utils.execute('openssl','x509','-in',outbound','-serial','-noout')
     serial = out.rpartition("=")[2]
     os.chdir(start)
     with open(outbound, "r") as crtfile:
-- 
cgit 


From 90abcdc7ae9e3f855dadb1ccc88892a2cc7bab05 Mon Sep 17 00:00:00 2001
From: Eric Windisch <eric@cloudscaling.com>
Date: Sun, 27 Feb 2011 20:57:13 -0500
Subject: execvp

---
 nova/console/xvp.py | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'nova')

diff --git a/nova/console/xvp.py b/nova/console/xvp.py
index cd257e0a6..271dffa54 100644
--- a/nova/console/xvp.py
+++ b/nova/console/xvp.py
@@ -133,10 +133,10 @@ class XVPConsoleProxy(object):
             return
         logging.debug(_("Starting xvp"))
         try:
-            utils.execute('xvp -p %s -c %s -l %s' %
-                          (FLAGS.console_xvp_pid,
-                           FLAGS.console_xvp_conf,
-                           FLAGS.console_xvp_log))
+            utils.execute('xvp',
+                          '-p',FLAGS.console_xvp_pid,
+			  '-c',FLAGS.console_xvp_conf,
+			  '-l',FLAGS.console_xvp_log)
         except exception.ProcessExecutionError, err:
             logging.error(_("Error starting xvp: %s") % err)
 
@@ -190,5 +190,5 @@ class XVPConsoleProxy(object):
             flag = '-x'
         #xvp will blow up on passwords that are too long (mdragon)
         password = password[:maxlen]
-        out, err = utils.execute('xvp %s' % flag, process_input=password)
+        out, err = utils.execute('xvp', flag, process_input=password)
         return out.strip()
-- 
cgit 


From 8b3e9ad11c2f5c425701f1eb4abb7b3f577ae1cc Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Mon, 28 Feb 2011 12:37:02 +0100
Subject: Add utils.synchronized decorator to allow for synchronising method
 entrance across multiple workers on the same host.

---
 nova/tests/test_misc.py | 37 ++++++++++++++++++++++++++++++++++++-
 nova/utils.py           | 11 +++++++++++
 2 files changed, 47 insertions(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/tests/test_misc.py b/nova/tests/test_misc.py
index e6da6112a..154b6fae6 100644
--- a/nova/tests/test_misc.py
+++ b/nova/tests/test_misc.py
@@ -14,10 +14,14 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+from datetime import datetime
+import errno
 import os
+import select
+import time
 
 from nova import test
-from nova.utils import parse_mailmap, str_dict_replace
+from nova.utils import parse_mailmap, str_dict_replace, synchronized
 
 
 class ProjectTestCase(test.TestCase):
@@ -55,3 +59,34 @@ class ProjectTestCase(test.TestCase):
                                 '%r not listed in Authors' % missing)
             finally:
                 tree.unlock()
+
+
+class LockTestCase(test.TestCase):
+    def test_synchronized(self):
+        rpipe, wpipe = os.pipe()
+        pid = os.fork()
+        if pid > 0:
+            os.close(wpipe)
+
+            @synchronized('testlock')
+            def f():
+                rfds, _, __ = select.select([rpipe], [], [], 1)
+                self.assertEquals(len(rfds), 0, "The other process, which was"
+                                                " supposed to be locked, "
+                                                "wrote on its end of the "
+                                                "pipe")
+                os.close(rpipe)
+
+            f()
+        else:
+            os.close(rpipe)
+
+            @synchronized('testlock')
+            def g():
+                try:
+                    os.write(wpipe, "foo")
+                except OSError, e:
+                    self.assertEquals(e.errno, errno.EPIPE)
+                    return
+            g()
+            os._exit(0)
diff --git a/nova/utils.py b/nova/utils.py
index 0cf91e0cc..cb1ea5a7d 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -25,6 +25,7 @@ import base64
 import datetime
 import inspect
 import json
+import lockfile
 import os
 import random
 import socket
@@ -491,6 +492,16 @@ def loads(s):
     return json.loads(s)
 
 
+def synchronized(name):
+    def wrap(f):
+        def inner(*args, **kwargs):
+            lock = lockfile.FileLock('nova-%s.lock' % name)
+            with lock:
+                return f(*args, **kwargs)
+        return inner
+    return wrap
+
+
 def ensure_b64_encoding(val):
     """Safety method to ensure that values expected to be base64-encoded
     actually are. If they are, the value is returned unchanged. Otherwise,
-- 
cgit 


From 0d3a1f9c7478ae3c4f042e1876d47359804e1973 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Mon, 28 Feb 2011 15:29:42 +0100
Subject: Wrap IptablesManager.apply() calls in utils.synchronized to avoid
 having different workers step on each other's toes.

---
 nova/network/linux_net.py | 1 +
 1 file changed, 1 insertion(+)

(limited to 'nova')

diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index 34337901a..8832f7c68 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -274,6 +274,7 @@ class IptablesManager(object):
 
         self.semaphore = semaphore.Semaphore()
 
+    @utils.synchronized('iptables')
     def apply(self):
         """Apply the current in-memory set of iptables rules
 
-- 
cgit 


From 72940957611bcba7dc41bfe9232743369d9a151f Mon Sep 17 00:00:00 2001
From: Salvatore Orlando <salvatore.orlando@eu.citrix.com>
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')

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 <salvatore.orlando@eu.citrix.com>
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')

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 a457595224a5ca5cdb0191ba2f6fa542d16e18f5 Mon Sep 17 00:00:00 2001
From: Nirmal Ranganathan <nirmal.ranganathan@rackspace.com>
Date: Mon, 28 Feb 2011 11:25:14 -0600
Subject: Removed extraneous newline

---
 nova/tests/test_compute.py | 1 -
 1 file changed, 1 deletion(-)

(limited to 'nova')

diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index e338a7cfa..949b5e6eb 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -274,4 +274,3 @@ class ComputeTestCase(test.TestCase):
 
         type = instance_types.get_by_flavor_id("1")
         self.assertEqual(type, 'm1.tiny')
-
-- 
cgit 


From 7a6daa8d92f4f11fe2fce8fb2f4b11d96cb98c2d Mon Sep 17 00:00:00 2001
From: "Kevin L. Mitchell" <kevin.mitchell@rackspace.com>
Date: Mon, 28 Feb 2011 17:27:19 +0000
Subject: Suppress stack traces unless --verbose is specified

---
 nova/log.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/log.py b/nova/log.py
index 87a21ddb4..d194ab8f0 100644
--- a/nova/log.py
+++ b/nova/log.py
@@ -266,7 +266,10 @@ class NovaRootLogger(NovaLogger):
 
 
 def handle_exception(type, value, tb):
-    logging.root.critical(str(value), exc_info=(type, value, tb))
+    extra = {}
+    if FLAGS.verbose:
+        extra['exc_info'] = (type, value, tb)
+    logging.root.critical(str(value), **extra)
 
 
 def reset():
-- 
cgit 


From c1bcf1dead8734a02172b4ac20b24fbbb7dbb993 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Mon, 28 Feb 2011 11:40:22 -0600
Subject: Rename migration to coincide with latest trunk changes

---
 .../versions/004_add_instance_migrations.py        | 61 ----------------------
 .../versions/007_add_instance_migrations.py        | 61 ++++++++++++++++++++++
 2 files changed, 61 insertions(+), 61 deletions(-)
 delete mode 100644 nova/db/sqlalchemy/migrate_repo/versions/004_add_instance_migrations.py
 create mode 100644 nova/db/sqlalchemy/migrate_repo/versions/007_add_instance_migrations.py

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/migrate_repo/versions/004_add_instance_migrations.py b/nova/db/sqlalchemy/migrate_repo/versions/004_add_instance_migrations.py
deleted file mode 100644
index 4fda525f1..000000000
--- a/nova/db/sqlalchemy/migrate_repo/versions/004_add_instance_migrations.py
+++ /dev/null
@@ -1,61 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 OpenStack LLC.
-# 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.from sqlalchemy import *
-
-from sqlalchemy import *
-from migrate import *
-
-from nova import log as logging
-
-
-meta = MetaData()
-
-# Just for the ForeignKey and column creation to succeed, these are not the
-# actual definitions of instances or services.
-instances = Table('instances', meta,
-        Column('id', Integer(),  primary_key=True, nullable=False),
-        )
-
-#
-# New Tables
-#
-
-migrations = Table('migrations', meta,
-            Column('created_at', DateTime(timezone=False)),
-            Column('updated_at', DateTime(timezone=False)),
-            Column('deleted_at', DateTime(timezone=False)),
-            Column('deleted', Boolean(create_constraint=True, name=None)),
-            Column('id', Integer(), primary_key=True, nullable=False),
-            Column('source_compute', String(255)),
-            Column('dest_compute', String(255)),
-            Column('dest_host', String(255)),
-            Column('instance_id', Integer, ForeignKey('instances.id'),
-                nullable=True),
-            Column('status', String(255)),
-      )
-
-
-def upgrade(migrate_engine):
-    # Upgrade operations go here. Don't create your own engine;
-    # bind migrate_engine to your metadata
-    meta.bind = migrate_engine
-    for table in (migrations, ):
-        try:
-            table.create()
-        except Exception:
-            logging.info(repr(table))
-            logging.exception('Exception while creating table')
-            raise
diff --git a/nova/db/sqlalchemy/migrate_repo/versions/007_add_instance_migrations.py b/nova/db/sqlalchemy/migrate_repo/versions/007_add_instance_migrations.py
new file mode 100644
index 000000000..4fda525f1
--- /dev/null
+++ b/nova/db/sqlalchemy/migrate_repo/versions/007_add_instance_migrations.py
@@ -0,0 +1,61 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 OpenStack LLC.
+# 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.from sqlalchemy import *
+
+from sqlalchemy import *
+from migrate import *
+
+from nova import log as logging
+
+
+meta = MetaData()
+
+# Just for the ForeignKey and column creation to succeed, these are not the
+# actual definitions of instances or services.
+instances = Table('instances', meta,
+        Column('id', Integer(),  primary_key=True, nullable=False),
+        )
+
+#
+# New Tables
+#
+
+migrations = Table('migrations', meta,
+            Column('created_at', DateTime(timezone=False)),
+            Column('updated_at', DateTime(timezone=False)),
+            Column('deleted_at', DateTime(timezone=False)),
+            Column('deleted', Boolean(create_constraint=True, name=None)),
+            Column('id', Integer(), primary_key=True, nullable=False),
+            Column('source_compute', String(255)),
+            Column('dest_compute', String(255)),
+            Column('dest_host', String(255)),
+            Column('instance_id', Integer, ForeignKey('instances.id'),
+                nullable=True),
+            Column('status', String(255)),
+      )
+
+
+def upgrade(migrate_engine):
+    # Upgrade operations go here. Don't create your own engine;
+    # bind migrate_engine to your metadata
+    meta.bind = migrate_engine
+    for table in (migrations, ):
+        try:
+            table.create()
+        except Exception:
+            logging.info(repr(table))
+            logging.exception('Exception while creating table')
+            raise
-- 
cgit 


From 8da6796789767b1341cb5a650066b67ad3191c74 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
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')

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 7f3dbdab80a4b36a75c860fe1748dfbd03228f2a Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Mon, 28 Feb 2011 11:29:52 -0800
Subject: moving nova-manage integration tests to smoke tests

---
 nova/tests/test_nova_manage.py | 130 -----------------------------------------
 1 file changed, 130 deletions(-)
 delete mode 100644 nova/tests/test_nova_manage.py

(limited to 'nova')

diff --git a/nova/tests/test_nova_manage.py b/nova/tests/test_nova_manage.py
deleted file mode 100644
index 03aea53c9..000000000
--- a/nova/tests/test_nova_manage.py
+++ /dev/null
@@ -1,130 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-#    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.
-"""
-Tests For Nova-Manage
-"""
-
-import time
-import os
-import subprocess
-
-from nova import test
-from nova.db.sqlalchemy.session import get_session
-from nova.db.sqlalchemy import models
-
-
-class NovaManageTestCase(test.TestCase):
-    """Test case for nova-manage"""
-    def setUp(self):
-        super(NovaManageTestCase, self).setUp()
-        session = get_session()
-        max_flavorid = session.query(models.InstanceTypes).\
-                                     order_by("flavorid desc").first()
-        self.flavorid = str(max_flavorid["flavorid"] + 1)
-        self.name = str(int(time.time()))
-        self.fnull = open(os.devnull, 'w')
-
-    def teardown(self):
-        self.fnull.close()
-
-    def test_create_and_delete_instance_types(self):
-        myname = self.name + "create_and_delete"
-        retcode = subprocess.call([
-            "bin/nova-manage",
-            "instance_type",
-            "create",
-            self.name,
-            "256",
-            "1",
-            "120",
-            self.flavorid,
-            "2",
-            "10",
-            "10"],
-            stdout=self.fnull)
-        self.assertEqual(0, retcode)
-        retcode = subprocess.call(["bin/nova-manage", "instance_type",
-                                    "delete", self.name], stdout=self.fnull)
-        self.assertEqual(0, retcode)
-        retcode = subprocess.call(["bin/nova-manage", "instance_type",
-                                    "delete", self.name, "--purge"],
-                                    stdout=self.fnull)
-        self.assertEqual(0, retcode)
-
-    def test_list_instance_types_or_flavors(self):
-        for c in ["instance_type", "flavor"]:
-            retcode = subprocess.call(["bin/nova-manage", c, \
-                                        "list"], stdout=self.fnull)
-            self.assertEqual(0, retcode)
-
-    def test_list_specific_instance_type(self):
-        retcode = subprocess.call(["bin/nova-manage", "instance_type", "list",
-                                    "m1.medium"], stdout=self.fnull)
-        self.assertEqual(0, retcode)
-
-    def test_should_error_on_bad_create_args(self):
-        # shouldn't be able to create instance type with 0 vcpus
-        retcode = subprocess.call(["bin/nova-manage", "instance_type",
-                                    "create", self.name + "bad_args",
-                                    "256", "0", "120", self.flavorid],
-                                    stdout=self.fnull)
-        self.assertEqual(1, retcode)
-
-    def test_should_fail_on_duplicate_flavorid(self):
-        # flavorid 1 is set in migration seed data
-        retcode = subprocess.call(["bin/nova-manage", "instance_type",\
-                                    "create", self.name + "dupflavor", "256",
-                                    "1", "120", "1"], stdout=self.fnull)
-        self.assertEqual(3, retcode)
-
-    def test_should_fail_on_duplicate_name(self):
-        duplicate_name = self.name + "dup_name"
-        retcode = subprocess.call([
-            "bin/nova-manage",
-            "instance_type",
-            "create",
-            duplicate_name,
-            "256",
-            "1",
-            "120",
-            self.flavorid,
-            "2",
-            "10",
-            "10"],
-            stdout=self.fnull)
-        self.assertEqual(0, retcode)
-        duplicate_retcode = subprocess.call([
-            "bin/nova-manage",
-            "instance_type",
-            "create",
-            duplicate_name,
-            "512",
-            "1",
-            "240",
-            str(int(self.flavorid) + 1),
-            "2",
-            "10",
-            "10"],
-            stdout=self.fnull)
-        self.assertEqual(3, duplicate_retcode)
-        delete_retcode = subprocess.call(["bin/nova-manage", "instance_type",
-                                    "delete", duplicate_name, "--purge"],
-                                    stdout=self.fnull)
-        self.assertEqual(0, delete_retcode)
-
-    def test_instance_type_delete_should_fail_without_valid_name(self):
-        retcode = subprocess.call(["bin/nova-manage", "instance_type",
-                                    "delete", "doesntexist"],
-                                    stdout=self.fnull)
-        self.assertEqual(1, retcode)
-- 
cgit 


From 05a96b320cf1d6b911b0edb11df0ed408a894e77 Mon Sep 17 00:00:00 2001
From: Brian Lamar <brian.lamar@rackspace.com>
Date: Mon, 28 Feb 2011 14:49:03 -0500
Subject: Edited `nova.api.openstack.common:limited` method to raise an
 HTTPBadRequest exception if a negative limit or offset is given. I'm not
 confident that this is the correct approach, because I guess this method
 could be called out of an API/WSGI context, but the method *is* located in
 the OpenStack API module and is currently only used in WSGI-capable methods,
 so we should be safe.

---
 nova/api/openstack/common.py            |  8 +++++++-
 nova/tests/api/openstack/test_common.py | 21 +++++++++++++++++++++
 2 files changed, 28 insertions(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/api/openstack/common.py b/nova/api/openstack/common.py
index 1dc3767e2..9f85c5c8a 100644
--- a/nova/api/openstack/common.py
+++ b/nova/api/openstack/common.py
@@ -15,6 +15,8 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+import webob.exc
+
 from nova import exception
 
 
@@ -27,7 +29,8 @@ def limited(items, request, max_limit=1000):
                     GET variables. 'offset' is where to start in the list,
                     and 'limit' is the maximum number of items to return. If
                     'limit' is not specified, 0, or > max_limit, we default
-                    to max_limit.
+                    to max_limit. Negative values for either offset or limit
+                    will cause exc.HTTPBadRequest() exceptions to be raised.
     @kwarg max_limit: The maximum number of items to return from 'items'
     """
     try:
@@ -40,6 +43,9 @@ def limited(items, request, max_limit=1000):
     except ValueError:
         limit = max_limit
 
+    if offset < 0 or limit < 0:
+        raise webob.exc.HTTPBadRequest()
+
     limit = min(max_limit, limit or max_limit)
     range_end = offset + limit
     return items[offset:range_end]
diff --git a/nova/tests/api/openstack/test_common.py b/nova/tests/api/openstack/test_common.py
index 59d850157..92023362c 100644
--- a/nova/tests/api/openstack/test_common.py
+++ b/nova/tests/api/openstack/test_common.py
@@ -19,6 +19,7 @@
 Test suites for 'common' code used throughout the OpenStack HTTP API.
 """
 
+import webob.exc
 
 from webob import Request
 
@@ -160,3 +161,23 @@ class LimiterTest(test.TestCase):
         self.assertEqual(limited(items, req, max_limit=2000), items[3:])
         req = Request.blank('/?offset=3000&limit=10')
         self.assertEqual(limited(items, req, max_limit=2000), [])
+
+    def test_limiter_negative_limit(self):
+        """
+        Test a negative limit.
+        """
+        def _limit_large():
+            limited(self.large, req, max_limit=2000)
+
+        req = Request.blank('/?limit=-3000')
+        self.assertRaises(webob.exc.HTTPBadRequest, _limit_large)
+
+    def test_limiter_negative_offset(self):
+        """
+        Test a negative offset.
+        """
+        def _limit_large():
+            limited(self.large, req, max_limit=2000)
+
+        req = Request.blank('/?offset=-30')
+        self.assertRaises(webob.exc.HTTPBadRequest, _limit_large)
-- 
cgit 


From 7ad5fe27144e592df7e794a0748301d41603377e Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Mon, 28 Feb 2011 13:16:07 -0800
Subject: refactored nova-manage list (-all, <name>) and fixed docs

---
 nova/db/sqlalchemy/api.py | 18 ++++++++++--------
 1 file changed, 10 insertions(+), 8 deletions(-)

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index d47b11891..f4cd16d9a 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -2090,16 +2090,18 @@ def instance_type_create(context, values):
 @require_context
 def instance_type_get_all(context, inactive=0):
     """
-    Returns a dict describing all non-deleted instance_types with name as key:
-        {'m1.tiny': dict(memory_mb=512, vcpus=1, local_gb=0, flavorid=1),
-         'm1.small': dict(memory_mb=2048, vcpus=1, local_gb=20, flavorid=2),
-         'm1.medium': dict(memory_mb=4096, vcpus=2, local_gb=40, flavorid=3)}
+    Returns a dict describing all instance_types with name as key.
     """
     session = get_session()
-    inst_types = session.query(models.InstanceTypes).\
-                    filter_by(deleted=inactive).\
-                    order_by("name").\
-                    all()
+    if inactive:
+        inst_types = session.query(models.InstanceTypes).\
+                        order_by("name").\
+                        all()
+    else:
+        inst_types = session.query(models.InstanceTypes).\
+                        filter_by(deleted=inactive).\
+                        order_by("name").\
+                        all()
     if inst_types:
         inst_dict = {}
         for i in inst_types:
-- 
cgit 


From d5736e925f288462f6325130be0af49f0ace5884 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Mon, 28 Feb 2011 23:31:09 +0100
Subject: Add a lock_path flag for lock files.

---
 nova/flags.py | 2 ++
 nova/utils.py | 5 ++++-
 2 files changed, 6 insertions(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/flags.py b/nova/flags.py
index 8cf199b2f..213d4d4e1 100644
--- a/nova/flags.py
+++ b/nova/flags.py
@@ -321,6 +321,8 @@ DEFINE_integer('auth_token_ttl', 3600, 'Seconds for auth tokens to linger')
 
 DEFINE_string('state_path', os.path.join(os.path.dirname(__file__), '../'),
               "Top-level directory for maintaining nova's state")
+DEFINE_string('lock_path', os.path.join(os.path.dirname(__file__), '../'),
+              "Directory for lock files")
 DEFINE_string('logdir', None, 'output to a per-service log file in named '
                               'directory')
 
diff --git a/nova/utils.py b/nova/utils.py
index cb1ea5a7d..48f12350f 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -44,11 +44,13 @@ from eventlet.green import subprocess
 
 from nova import exception
 from nova.exception import ProcessExecutionError
+from nova import flags
 from nova import log as logging
 
 
 LOG = logging.getLogger("nova.utils")
 TIME_FORMAT = "%Y-%m-%dT%H:%M:%SZ"
+FLAGS = flags.FLAGS
 
 
 def import_class(import_str):
@@ -495,7 +497,8 @@ def loads(s):
 def synchronized(name):
     def wrap(f):
         def inner(*args, **kwargs):
-            lock = lockfile.FileLock('nova-%s.lock' % name)
+            lock = lockfile.FileLock(os.path.join(FLAGS.lock_path,
+                                                  'nova-%s.lock' % name))
             with lock:
                 return f(*args, **kwargs)
         return inner
-- 
cgit 


From 0550124fcd863be60dd0e6fefb5f30641331b198 Mon Sep 17 00:00:00 2001
From: Mark Washenberger <mark.washenberger@rackspace.com>
Date: Mon, 28 Feb 2011 18:06:11 -0500
Subject: add test for instance creation without personalities

---
 nova/tests/api/openstack/test_servers.py | 40 ++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 7a25abe9d..7e5bc0080 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -232,6 +232,46 @@ class ServersTest(test.TestCase):
 
         self.assertEqual(res.status_int, 200)
 
+    def _create_instance_with_personality(self, personality):
+
+        class FakeComputeAPI(object):
+
+            def __init__(self):
+                self.onset_files = None
+
+            def create(*args, **kwargs):
+                if 'onset_files' in kwargs:
+                    self.onset_files = kwargs['onset_files']
+                else:
+                    self.onset_files = None
+                return [{'id': '1234', 'display_name': 'fakeinstance'}]
+
+        def make_stub_method(canned_return):
+            def stub_method(*args, **kwargs):
+                return canned_return
+            return stub_method
+
+        compute_api = FakeComputeAPI()
+        self.stubs.Set(nova.compute, 'API', make_stub_method(compute_api))
+        self.stubs.Set(nova.api.openstack.servers.Controller,
+            '_get_kernel_ramdisk_from_image', make_stub_method((1, 1)))
+        self.stubs.Set(nova.api.openstack.common,
+            'get_image_id_from_image_hash', make_stub_method(2))
+        body = dict(server=dict(
+            name='server_test', imageId=2, flavorId=2,
+            metadata={},
+            personality=personality))
+
+        req = webob.Request.blank('/v1.0/servers')
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        return req.get_response(fakes.wsgi_app()), compute_api.onset_files
+
+    def test_create_instance_with_no_personality(self):
+        res, onset_files = self._create_instance_with_personality(personality={})
+        self.assertEquals(res.status_int, 200)
+        self.assertEquals(onset_files, None)
+
     def test_update_no_body(self):
         req = webob.Request.blank('/v1.0/servers/1')
         req.method = 'PUT'
-- 
cgit 


From aafd83233a675ccf5f3c4e737d966652e45a0ecb Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Mon, 28 Feb 2011 16:28:46 -0800
Subject: replaced ugly INSTANCE_TYPE constant with (slightly less ugly) stubs

---
 nova/test.py              |  8 --------
 nova/tests/db/fakes.py    | 20 ++++++++++++++++++--
 nova/tests/test_quota.py  | 17 ++++++++++++++---
 nova/tests/test_xenapi.py |  2 +-
 4 files changed, 33 insertions(+), 14 deletions(-)

(limited to 'nova')

diff --git a/nova/test.py b/nova/test.py
index 0329383b8..d8a47464f 100644
--- a/nova/test.py
+++ b/nova/test.py
@@ -48,14 +48,6 @@ flags.DEFINE_bool('fake_tests', True,
                   'should we use everything for testing')
 
 
-INSTANCE_TYPES = {
-    'm1.tiny': dict(memory_mb=512, vcpus=1, local_gb=0, flavorid=1),
-    'm1.small': dict(memory_mb=2048, vcpus=1, local_gb=20, flavorid=2),
-    'm1.medium': dict(memory_mb=4096, vcpus=2, local_gb=40, flavorid=3),
-    'm1.large': dict(memory_mb=8192, vcpus=4, local_gb=80, flavorid=4),
-    'm1.xlarge': dict(memory_mb=16384, vcpus=8, local_gb=160, flavorid=5)}
-
-
 def skip_if_fake(func):
     """Decorator that skips a test if running in fake mode"""
     def _skipper(*args, **kw):
diff --git a/nova/tests/db/fakes.py b/nova/tests/db/fakes.py
index d9a5032ee..d760dc456 100644
--- a/nova/tests/db/fakes.py
+++ b/nova/tests/db/fakes.py
@@ -22,12 +22,20 @@ import time
 from nova import db
 from nova import test
 from nova import utils
-from nova.compute import instance_types
 
 
 def stub_out_db_instance_api(stubs):
     """ Stubs out the db API for creating Instances """
 
+    INSTANCE_TYPES = {
+        'm1.tiny': dict(memory_mb=512, vcpus=1, local_gb=0, flavorid=1),
+        'm1.small': dict(memory_mb=2048, vcpus=1, local_gb=20, flavorid=2),
+        'm1.medium':
+            dict(memory_mb=4096, vcpus=2, local_gb=40, flavorid=3),
+        'm1.large': dict(memory_mb=8192, vcpus=4, local_gb=80, flavorid=4),
+        'm1.xlarge':
+            dict(memory_mb=16384, vcpus=8, local_gb=160, flavorid=5)}
+
     class FakeModel(object):
         """ Stubs out for model """
         def __init__(self, values):
@@ -42,10 +50,16 @@ def stub_out_db_instance_api(stubs):
             else:
                 raise NotImplementedError()
 
+    def fake_instance_type_get_all(context, inactive=0):
+        return INSTANCE_TYPES
+
+    def fake_instance_type_get_by_name(context, name):
+        return INSTANCE_TYPES[name]
+
     def fake_instance_create(values):
         """ Stubs out the db.instance_create method """
 
-        type_data = test.INSTANCE_TYPES[values['instance_type']]
+        type_data = INSTANCE_TYPES[values['instance_type']]
 
         base_options = {
             'name': values['name'],
@@ -74,3 +88,5 @@ def stub_out_db_instance_api(stubs):
 
     stubs.Set(db, 'instance_create', fake_instance_create)
     stubs.Set(db, 'network_get_by_instance', fake_network_get_by_instance)
+    stubs.Set(db, 'instance_type_get_all', fake_instance_type_get_all)
+    stubs.Set(db, 'instance_type_get_by_name', fake_instance_type_get_by_name)
diff --git a/nova/tests/test_quota.py b/nova/tests/test_quota.py
index faafe2d31..4ecb36b54 100644
--- a/nova/tests/test_quota.py
+++ b/nova/tests/test_quota.py
@@ -74,19 +74,30 @@ class QuotaTestCase(test.TestCase):
         vol['size'] = size
         return db.volume_create(self.context, vol)['id']
 
+    def _get_instance_type(self, name):
+        instance_types = {
+            'm1.tiny': dict(memory_mb=512, vcpus=1, local_gb=0, flavorid=1),
+            'm1.small': dict(memory_mb=2048, vcpus=1, local_gb=20, flavorid=2),
+            'm1.medium':
+                dict(memory_mb=4096, vcpus=2, local_gb=40, flavorid=3),
+            'm1.large': dict(memory_mb=8192, vcpus=4, local_gb=80, flavorid=4),
+            'm1.xlarge':
+                dict(memory_mb=16384, vcpus=8, local_gb=160, flavorid=5)}
+        return instance_types[name]
+
     def test_quota_overrides(self):
         """Make sure overriding a projects quotas works"""
         num_instances = quota.allowed_instances(self.context, 100,
-            test.INSTANCE_TYPES['m1.small'])
+            self._get_instance_type('m1.small'))
         self.assertEqual(num_instances, 2)
         db.quota_create(self.context, {'project_id': self.project.id,
                                        'instances': 10})
         num_instances = quota.allowed_instances(self.context, 100,
-            test.INSTANCE_TYPES['m1.small'])
+            self._get_instance_type('m1.small'))
         self.assertEqual(num_instances, 4)
         db.quota_update(self.context, self.project.id, {'cores': 100})
         num_instances = quota.allowed_instances(self.context, 100,
-            test.INSTANCE_TYPES['m1.small'])
+            self._get_instance_type('m1.small'))
         self.assertEqual(num_instances, 10)
 
         # metadata_items
diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index 27131c45e..106c0bd6f 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -233,7 +233,7 @@ class XenAPIVMTestCase(test.TestCase):
         vm = vms[0]
 
         # Check that m1.large above turned into the right thing.
-        instance_type = test.INSTANCE_TYPES['m1.large']
+        instance_type = db.instance_type_get_by_name(conn, 'm1.large')
         mem_kib = long(instance_type['memory_mb']) << 10
         mem_bytes = str(mem_kib << 10)
         vcpus = instance_type['vcpus']
-- 
cgit 


From 4e4711ccfc7ce3c3df704a8635dccd506d6e7f01 Mon Sep 17 00:00:00 2001
From: Salvatore Orlando <salvatore.orlando@eu.citrix.com>
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/tests/db/fakes.py       | 41 +++++++++++++++++++++++++++++++----------
 nova/tests/test_xenapi.py    | 42 ++++++++++++++++++------------------------
 nova/tests/xenapi/stubs.py   |  3 +++
 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 +-
 7 files changed, 71 insertions(+), 36 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/db/fakes.py b/nova/tests/db/fakes.py
index c47fba5f3..b939f99a0 100644
--- a/nova/tests/db/fakes.py
+++ b/nova/tests/db/fakes.py
@@ -36,6 +36,8 @@ class FakeModel(object):
         if key in self.values:
             return self.values[key]
         else:
+            print "Key:%s" %key
+            print "Values:%s" %self.values
             raise NotImplementedError()
 
 
@@ -70,26 +72,45 @@ def stub_out_db_instance_api(stubs):
     stubs.Set(db, 'instance_create', fake_instance_create)
 
 
-def stub_out_db_network_api(stubs, injected=False):
+def stub_out_db_network_api(stubs, injected=True):
     """Stubs out the db API for retrieving networks"""
+    
     network_fields = {
+        'id': 'test',
         'bridge': 'xenbr0',
+        'label': 'test_network',
+        'netmask': '255.255.255.0',
+        'gateway': '10.0.0.1',
+        'broadcast': '10.0.0.255',
+        'dns': '10.0.0.2',
+        'ra_server': None,        
         'injected': injected}
-
-    if injected:
-        network_fields.update({
-            'netmask': '255.255.255.0',
-            'gateway': '10.0.0.1',
-            'broadcast': '10.0.0.255',
-            'dns': '10.0.0.2',
-            'ra_server': None})
+    
+    fixed_ip_fields = {
+        'address':'10.0.0.3',
+        'network_id':'test'}
 
     def fake_network_get_by_instance(context, instance_id):
         return FakeModel(network_fields)
 
+    def fake_network_get_all_by_instance(context, instance_id):
+        l = []
+        l.append(FakeModel(network_fields))
+        return l
+
     def fake_instance_get_fixed_address(context, instance_id):
-        return '10.0.0.3'
+        return FakeModel(fixed_ip_fields).address
+
+    def fake_fixed_ip_get_all_by_instance(context, instance_id):
+        l = []
+        l.append(FakeModel(fixed_ip_fields))
+        return l
 
     stubs.Set(db, 'network_get_by_instance', fake_network_get_by_instance)
     stubs.Set(db, 'instance_get_fixed_address',
         fake_instance_get_fixed_address)
+    stubs.Set(db, 'network_get_all_by_instance',
+              fake_network_get_all_by_instance)
+    stubs.Set(db, 'fixed_ip_get_all_by_instance',
+        fake_fixed_ip_get_all_by_instance)
+    
\ No newline at end of file
diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index ce89a53c8..10a1b6c11 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -261,30 +261,21 @@ class XenAPIVMTestCase(test.TestCase):
 
         if check_injection:
             xenstore_data = xenapi_fake.VM_get_xenstore_data(vm_ref)
-            key_prefix = 'vm-data/vif/22_33_2A_B3_CC_DD/tcpip/'
-            tcpip_data = dict([(k.replace(key_prefix, ''), v)
-                for k, v in xenstore_data.iteritems()
-                if k.startswith(key_prefix)])
-
-            self.assertEquals(tcpip_data, {
-                'BroadcastAddress/data/0': '10.0.0.255',
-                'BroadcastAddress/name': 'BroadcastAddress',
-                'BroadcastAddress/type': 'multi_sz',
-                'DefaultGateway/data/0': '10.0.0.1',
-                'DefaultGateway/name': 'DefaultGateway',
-                'DefaultGateway/type': 'multi_sz',
-                'EnableDhcp/data': '0',
-                'EnableDhcp/name': 'EnableDhcp',
-                'EnableDhcp/type': 'dword',
-                'IPAddress/data/0': '10.0.0.3',
-                'IPAddress/name': 'IPAddress',
-                'IPAddress/type': 'multi_sz',
-                'NameServer/data': '10.0.0.2',
-                'NameServer/name': 'NameServer',
-                'NameServer/type': 'string',
-                'SubnetMask/data/0': '255.255.255.0',
-                'SubnetMask/name': 'SubnetMask',
-                'SubnetMask/type': 'multi_sz'})
+            key = 'vm-data/networking/aabbccddeeff'
+            LOG.debug("Xenstore data: %s",xenstore_data)
+            xenstore_value=xenstore_data[key]
+            #tcpip_data = dict([(k, v)
+            #    for k, v in xenstore_value.iteritems()
+            #    if k.startswith(key_prefix)])
+            #LOG.debug("tcpip data: %s",tcpip_data)
+            #self.assertEquals(tcpip_data['label'],'test_network')
+            #self.assertEquals(tcpip_data, {
+            #    'label': 'test_network',
+            #    'broadcast': '10.0.0.255',
+            #    'ips': [{'ip': '10.0.0.3', 'netmask':'255.255.255.0', 'enabled':'1'}],
+            #    'mac': 'aa:bb:cc:dd:ee:ff',
+            #    'dns': ['10.0.0.2'],
+            #    'gateway': '10.0.0.1'})
 
     def _test_spawn(self, image_id, kernel_id, ramdisk_id,
         instance_type="m1.large", check_injection=False):
@@ -340,6 +331,9 @@ class XenAPIVMTestCase(test.TestCase):
 
             # Find the start of eth0 configuration and check it
             index = config.index('auto eth0')
+            LOG.debug("CONFIG")
+            LOG.debug(config)
+            
             self.assertEquals(config[index + 1:index + 8], [
                 'iface eth0 inet static',
                 'address 10.0.0.3',
diff --git a/nova/tests/xenapi/stubs.py b/nova/tests/xenapi/stubs.py
index 6981b4f7a..551d326a4 100644
--- a/nova/tests/xenapi/stubs.py
+++ b/nova/tests/xenapi/stubs.py
@@ -191,6 +191,9 @@ class FakeSessionForVMTests(fake.SessionBase):
 
     def VM_add_to_xenstore_data(self, session_ref, vm_ref, key, value):
         fake.VM_add_to_xenstore_data(vm_ref, key, value)
+    
+    def VM_remove_from_xenstore_data(self, session_ref, vm_ref, key):
+        fake.VM_remove_from_xenstore_data(vm_ref, key)
 
 
 class FakeSessionForVolumeTests(fake.SessionBase):
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 4572ffcf734b734870b90497063fc27e7642f67c Mon Sep 17 00:00:00 2001
From: Naveed Massjouni <naveedm9@gmail.com>
Date: Mon, 28 Feb 2011 19:56:46 -0500
Subject: No reason to initialize metadata twice.

---
 nova/api/openstack/servers.py | 2 --
 1 file changed, 2 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 7d20f681b..69273ad7b 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -72,8 +72,6 @@ def _translate_detail_keys(inst):
     public_ips = utils.get_from_path(inst, 'fixed_ip/floating_ips/address')
     inst_dict['addresses']['public'] = public_ips
 
-    inst_dict['metadata'] = {}
-
     # Return the metadata as a dictionary
     metadata = {}
     for item in inst['metadata']:
-- 
cgit 


From 69779dcdc5584fafa95974f263cef14912a12ed7 Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Mon, 28 Feb 2011 17:06:35 -0800
Subject: refactored adminclient

---
 nova/api/ec2/admin.py | 12 ------------
 1 file changed, 12 deletions(-)

(limited to 'nova')

diff --git a/nova/api/ec2/admin.py b/nova/api/ec2/admin.py
index d867e5da9..51a06bb26 100644
--- a/nova/api/ec2/admin.py
+++ b/nova/api/ec2/admin.py
@@ -29,7 +29,6 @@ from nova import flags
 from nova import log as logging
 from nova import utils
 from nova.auth import manager
-from nova.compute import instance_types
 
 
 FLAGS = flags.FLAGS
@@ -115,21 +114,10 @@ class AdminController(object):
     def __str__(self):
         return 'AdminController'
 
-    # FIXME(kpepple) this is untested code path.
     def describe_instance_types(self, _context, **_kwargs):
         """Returns all active instance types data (vcpus, memory, etc.)"""
-        # return {'instanceTypeSet': [instance_dict(n, v) for n, v in
-        #                           instance_types.INSTANCE_TYPES.iteritems()]}
-        # return {'instanceTypeSet':
-        #         [for i in db.instance_type_get_all(): instance_dict(i)]}
         return {'instanceTypeSet': [db.instance_type_get_all(_context)]}
 
-    # FIXME(kpepple) this is untested code path.
-    def describe_instance_type(self, _context, name, **_kwargs):
-        """Returns a specific active instance types data"""
-        return {'instanceTypeSet':
-                [instance_dict(db.instance_type_get_by_name(name))]}
-
     def describe_user(self, _context, name, **_kwargs):
         """Returns user data, including access and secret keys."""
         return user_dict(manager.AuthManager().get_user(name))
-- 
cgit 


From 8806858918f396cfca41a28c191dc9e8d2809a0e Mon Sep 17 00:00:00 2001
From: Salvatore Orlando <salvatore.orlando@eu.citrix.com>
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/tests/db/fakes.py       | 13 +++++--------
 nova/tests/test_xenapi.py    | 46 ++++++++++++++++++++------------------------
 nova/tests/xenapi/stubs.py   |  2 +-
 nova/virt/xenapi/fake.py     |  6 ++----
 nova/virt/xenapi/vm_utils.py |  8 --------
 nova/virt/xenapi/vmops.py    | 15 +++------------
 6 files changed, 32 insertions(+), 58 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/db/fakes.py b/nova/tests/db/fakes.py
index b939f99a0..7aa72e4a3 100644
--- a/nova/tests/db/fakes.py
+++ b/nova/tests/db/fakes.py
@@ -36,8 +36,6 @@ class FakeModel(object):
         if key in self.values:
             return self.values[key]
         else:
-            print "Key:%s" %key
-            print "Values:%s" %self.values
             raise NotImplementedError()
 
 
@@ -74,7 +72,7 @@ def stub_out_db_instance_api(stubs):
 
 def stub_out_db_network_api(stubs, injected=True):
     """Stubs out the db API for retrieving networks"""
-    
+
     network_fields = {
         'id': 'test',
         'bridge': 'xenbr0',
@@ -83,12 +81,12 @@ def stub_out_db_network_api(stubs, injected=True):
         'gateway': '10.0.0.1',
         'broadcast': '10.0.0.255',
         'dns': '10.0.0.2',
-        'ra_server': None,        
+        'ra_server': None,
         'injected': injected}
-    
+
     fixed_ip_fields = {
-        'address':'10.0.0.3',
-        'network_id':'test'}
+        'address': '10.0.0.3',
+        'network_id': 'test'}
 
     def fake_network_get_by_instance(context, instance_id):
         return FakeModel(network_fields)
@@ -113,4 +111,3 @@ def stub_out_db_network_api(stubs, injected=True):
               fake_network_get_all_by_instance)
     stubs.Set(db, 'fixed_ip_get_all_by_instance',
         fake_fixed_ip_get_all_by_instance)
-    
\ No newline at end of file
diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index 10a1b6c11..a3d3371a1 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -21,6 +21,7 @@ Test suite for XenAPI
 import os
 import re
 import stubout
+import ast
 
 from nova import db
 from nova import context
@@ -204,7 +205,7 @@ class XenAPIVMTestCase(test.TestCase):
                 if not vm_rec["is_control_domain"]:
                     vm_labels.append(vm_rec["name_label"])
 
-            self.assertEquals(vm_labels, [1])
+            self.assertEquals(vm_labels, ['1'])
 
         def ensure_vbd_was_torn_down():
             vbd_labels = []
@@ -212,7 +213,7 @@ class XenAPIVMTestCase(test.TestCase):
                 vbd_rec = xenapi_fake.get_record('VBD', vbd_ref)
                 vbd_labels.append(vbd_rec["vm_name_label"])
 
-            self.assertEquals(vbd_labels, [1])
+            self.assertEquals(vbd_labels, ['1'])
 
         def ensure_vdi_was_torn_down():
             for vdi_ref in xenapi_fake.get_all('VDI'):
@@ -229,10 +230,10 @@ class XenAPIVMTestCase(test.TestCase):
 
     def check_vm_record(self, conn, check_injection=False):
         instances = conn.list_instances()
-        self.assertEquals(instances, [1])
+        self.assertEquals(instances, ['1'])
 
         # Get Nova record for VM
-        vm_info = conn.get_info(1)
+        vm_info = conn.get_info('1')
 
         # Get XenAPI record for VM
         vms = [(ref, rec) for ref, rec
@@ -262,27 +263,24 @@ class XenAPIVMTestCase(test.TestCase):
         if check_injection:
             xenstore_data = xenapi_fake.VM_get_xenstore_data(vm_ref)
             key = 'vm-data/networking/aabbccddeeff'
-            LOG.debug("Xenstore data: %s",xenstore_data)
-            xenstore_value=xenstore_data[key]
-            #tcpip_data = dict([(k, v)
-            #    for k, v in xenstore_value.iteritems()
-            #    if k.startswith(key_prefix)])
-            #LOG.debug("tcpip data: %s",tcpip_data)
-            #self.assertEquals(tcpip_data['label'],'test_network')
-            #self.assertEquals(tcpip_data, {
-            #    'label': 'test_network',
-            #    'broadcast': '10.0.0.255',
-            #    'ips': [{'ip': '10.0.0.3', 'netmask':'255.255.255.0', 'enabled':'1'}],
-            #    'mac': 'aa:bb:cc:dd:ee:ff',
-            #    'dns': ['10.0.0.2'],
-            #    'gateway': '10.0.0.1'})
+            xenstore_value = xenstore_data[key]
+            tcpip_data = ast.literal_eval(xenstore_value)
+            self.assertEquals(tcpip_data, {
+                'label': 'test_network',
+                'broadcast': '10.0.0.255',
+                'ips': [{'ip': '10.0.0.3',
+                         'netmask':'255.255.255.0',
+                         'enabled':'1'}],
+                'mac': 'aa:bb:cc:dd:ee:ff',
+                'dns': ['10.0.0.2'],
+                'gateway': '10.0.0.1'})
 
     def _test_spawn(self, image_id, kernel_id, ramdisk_id,
         instance_type="m1.large", check_injection=False):
 
         stubs.stubout_session(self.stubs, stubs.FakeSessionForVMTests)
-        values = {'name': 1,
-                  'id': 1,
+        values = {'name': "1",
+                  'id': "1",
                   'project_id': self.project.id,
                   'user_id': self.user.id,
                   'image_id': image_id,
@@ -331,9 +329,7 @@ class XenAPIVMTestCase(test.TestCase):
 
             # Find the start of eth0 configuration and check it
             index = config.index('auto eth0')
-            LOG.debug("CONFIG")
-            LOG.debug(config)
-            
+
             self.assertEquals(config[index + 1:index + 8], [
                 'iface eth0 inet static',
                 'address 10.0.0.3',
@@ -409,8 +405,8 @@ class XenAPIVMTestCase(test.TestCase):
     def _create_instance(self):
         """Creates and spawns a test instance"""
         values = {
-            'name': 1,
-            'id': 1,
+            'name': '1',
+            'id': '1',
             'project_id': self.project.id,
             'user_id': self.user.id,
             'image_id': 1,
diff --git a/nova/tests/xenapi/stubs.py b/nova/tests/xenapi/stubs.py
index 551d326a4..2392a97b3 100644
--- a/nova/tests/xenapi/stubs.py
+++ b/nova/tests/xenapi/stubs.py
@@ -191,7 +191,7 @@ class FakeSessionForVMTests(fake.SessionBase):
 
     def VM_add_to_xenstore_data(self, session_ref, vm_ref, key, value):
         fake.VM_add_to_xenstore_data(vm_ref, key, value)
-    
+
     def VM_remove_from_xenstore_data(self, session_ref, vm_ref, key):
         fake.VM_remove_from_xenstore_data(vm_ref, key)
 
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 1caa7f189827b4721c2e9d3ddf753acd749d7916 Mon Sep 17 00:00:00 2001
From: Kei Masumoto <masumotok@nttdata.co.jp>
Date: Tue, 1 Mar 2011 17:52:46 +0900
Subject: rename db migration script

---
 nova/compute/manager.py                            |  2 +-
 .../versions/007_add_live_migration.py             | 83 ++++++++++++++++++++++
 2 files changed, 84 insertions(+), 1 deletion(-)
 create mode 100644 nova/db/sqlalchemy/migrate_repo/versions/007_add_live_migration.py

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 8b90ffbca..d085a0b6a 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -818,7 +818,7 @@ class ComputeManager(manager.Manager):
 
         LOG.info(_('Migrating %(i_name)s to %(dest)s finishes successfully.')
                  % locals())
-        LOG.info(_("The below error is normally occurs."
+        LOG.info(_("The below error is normally occurs. "
                 "Just check if instance is successfully migrated.\n"
                 "libvir: QEMU error : Domain not found: no domain "
                 "with matching name.."))
diff --git a/nova/db/sqlalchemy/migrate_repo/versions/007_add_live_migration.py b/nova/db/sqlalchemy/migrate_repo/versions/007_add_live_migration.py
new file mode 100644
index 000000000..2689b5b74
--- /dev/null
+++ b/nova/db/sqlalchemy/migrate_repo/versions/007_add_live_migration.py
@@ -0,0 +1,83 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# 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.
+
+from migrate import *
+from nova import log as logging
+from sqlalchemy import *
+
+
+meta = MetaData()
+
+instances = Table('instances', meta,
+        Column('id', Integer(),  primary_key=True, nullable=False),
+        )
+
+#
+# New Tables
+#
+
+compute_services = Table('compute_services', meta,
+        Column('created_at', DateTime(timezone=False)),
+        Column('updated_at', DateTime(timezone=False)),
+        Column('deleted_at', DateTime(timezone=False)),
+        Column('deleted', Boolean(create_constraint=True, name=None)),
+        Column('id', Integer(),  primary_key=True, nullable=False),
+        Column('service_id', Integer(), nullable=False),
+
+        Column('vcpus', Integer(), nullable=False),
+        Column('memory_mb', Integer(), nullable=False),
+        Column('local_gb', Integer(), nullable=False),
+        Column('vcpus_used', Integer(), nullable=False),
+        Column('memory_mb_used', Integer(), nullable=False),
+        Column('local_gb_used', Integer(), nullable=False),
+        Column('hypervisor_type',
+               Text(convert_unicode=False, assert_unicode=None,
+               unicode_error=None, _warn_on_bytestring=False),
+               nullable=False),
+        Column('hypervisor_version', Integer(), nullable=False),
+        Column('cpu_info',
+               Text(convert_unicode=False, assert_unicode=None,
+                    unicode_error=None, _warn_on_bytestring=False),
+               nullable=False),
+        )
+
+
+#
+# Tables to alter
+#
+instances_launched_on = Column(
+         'launched_on',
+         Text(convert_unicode=False, assert_unicode=None,
+              unicode_error=None, _warn_on_bytestring=False),
+              nullable=True)
+
+
+def upgrade(migrate_engine):
+    # Upgrade operations go here. Don't create your own engine;
+    # bind migrate_engine to your metadata
+    meta.bind = migrate_engine
+
+    try:
+        compute_services.create()
+    except Exception:
+        logging.info(repr(compute_services))
+        logging.exception('Exception while creating table')
+        meta.drop_all(tables=[compute_services])
+        raise
+
+    instances.create_column(instances_launched_on)
-- 
cgit 


From d13a623625a56a029f9dd5ccba3e70f492efdb2c Mon Sep 17 00:00:00 2001
From: Kei Masumoto <masumotok@nttdata.co.jp>
Date: Tue, 1 Mar 2011 18:32:57 +0900
Subject: test_compute is changed b/c lack of import instance_types

---
 nova/tests/test_compute.py | 1 +
 1 file changed, 1 insertion(+)

(limited to 'nova')

diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index 3c88d186d..2a18dd47b 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -32,6 +32,7 @@ from nova import rpc
 from nova import test
 from nova import utils
 from nova.auth import manager
+from nova.compute import instance_types
 from nova.compute import manager as compute_manager
 from nova.compute import power_state
 from nova.db.sqlalchemy import models
-- 
cgit 


From 688acacd85e07fc578c8731df6a4421e64499c8b Mon Sep 17 00:00:00 2001
From: Kei Masumoto <masumotok@nttdata.co.jp>
Date: Tue, 1 Mar 2011 18:53:02 +0900
Subject: At previous commit, I forget to erase conflict - fixed it.

---
 nova/tests/test_compute.py | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index 75fbc9324..3438719f4 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -309,7 +309,13 @@ class ComputeTestCase(test.TestCase):
 
         self.compute.terminate_instance(self.context, instance_id)
 
-<<<<<<< TREE
+    def test_get_by_flavor_id(self):
+        type = instance_types.get_by_flavor_id(1)
+        self.assertEqual(type, 'm1.tiny')
+
+        type = instance_types.get_by_flavor_id("1")
+        self.assertEqual(type, 'm1.tiny')
+
     def _setup_other_managers(self):
         self.volume_manager = utils.import_object(FLAGS.volume_manager)
         self.network_manager = utils.import_object(FLAGS.network_manager)
@@ -562,11 +568,3 @@ class ComputeTestCase(test.TestCase):
         db.instance_destroy(c, instance_id)
         db.volume_destroy(c, v_ref['id'])
         db.floating_ip_destroy(c, flo_addr)
-=======
-    def test_get_by_flavor_id(self):
-        type = instance_types.get_by_flavor_id(1)
-        self.assertEqual(type, 'm1.tiny')
-
-        type = instance_types.get_by_flavor_id("1")
-        self.assertEqual(type, 'm1.tiny')
->>>>>>> MERGE-SOURCE
-- 
cgit 


From fbcbf5ef805748bea29e4135ee8989830064c273 Mon Sep 17 00:00:00 2001
From: Josh Kearney <josh@jk0.org>
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')

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 282a18a4c15f066e371596104f783f522309c5ee Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Tue, 1 Mar 2011 10:40:56 -0800
Subject: corrected copyrights for new files

---
 nova/compute/instance_types.py                                     | 1 +
 nova/db/sqlalchemy/migrate_repo/versions/007_add_instance_types.py | 1 +
 nova/tests/test_instance_types.py                                  | 1 +
 3 files changed, 3 insertions(+)

(limited to 'nova')

diff --git a/nova/compute/instance_types.py b/nova/compute/instance_types.py
index ce4b25964..7d401fc86 100644
--- a/nova/compute/instance_types.py
+++ b/nova/compute/instance_types.py
@@ -4,6 +4,7 @@
 # Administrator of the National Aeronautics and Space Administration.
 # All Rights Reserved.
 # Copyright (c) 2010 Citrix Systems, Inc.
+# Copyright 2011 Ken Pepple
 #
 #    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
diff --git a/nova/db/sqlalchemy/migrate_repo/versions/007_add_instance_types.py b/nova/db/sqlalchemy/migrate_repo/versions/007_add_instance_types.py
index fec191214..66609054e 100644
--- a/nova/db/sqlalchemy/migrate_repo/versions/007_add_instance_types.py
+++ b/nova/db/sqlalchemy/migrate_repo/versions/007_add_instance_types.py
@@ -1,5 +1,6 @@
 # vim: tabstop=4 shiftwidth=4 softtabstop=4
 
+# Copyright 2011 Ken Pepple
 #    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
diff --git a/nova/tests/test_instance_types.py b/nova/tests/test_instance_types.py
index 1b192ca28..edc538879 100644
--- a/nova/tests/test_instance_types.py
+++ b/nova/tests/test_instance_types.py
@@ -1,5 +1,6 @@
 # vim: tabstop=4 shiftwidth=4 softtabstop=4
 
+# Copyright 2011 Ken Pepple
 #    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
-- 
cgit 


From f9d08c16d5c620c711d962a78be3a94b99364f14 Mon Sep 17 00:00:00 2001
From: Mark Washenberger <mark.washenberger@rackspace.com>
Date: Tue, 1 Mar 2011 13:56:33 -0500
Subject: support adding a single personality in the osapi

---
 nova/api/openstack/servers.py            | 22 ++++++++++++++++++++--
 nova/tests/api/openstack/test_servers.py | 21 ++++++++++++++++-----
 2 files changed, 36 insertions(+), 7 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 73c7bfe17..92e5c9024 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -80,7 +80,6 @@ def _translate_detail_keys(inst):
 
     return dict(server=inst_dict)
 
-
 def _translate_keys(inst):
     """ Coerces into dictionary format, excluding all model attributes
     save for id and name """
@@ -154,6 +153,22 @@ class Controller(wsgi.Controller):
         image = self._image_service.show(req.environ['nova.context'], image_id)
         return lookup('kernel_id'), lookup('ramdisk_id')
 
+    
+    def _get_onset_files_from_personality_attr(self, personality_attr):
+        """
+        Create a list of onset files from the personality request attribute
+
+        At this time, onset_files must be formatted as a list of 
+        (file_path, file_content) pairs for compatibility with the 
+        underlying compute service.
+        """
+        onset_files = []
+        for personality in personality_attr:
+            path = personality['path']
+            contents = personality['contents']
+            onset_files.append((path, contents))
+        return onset_files
+
     def create(self, req):
         """ Creates a new server for a given user """
         env = self._deserialize(req.body, req)
@@ -181,6 +196,9 @@ class Controller(wsgi.Controller):
             for k, v in env['server']['metadata'].items():
                 metadata.append({'key': k, 'value': v})
 
+        personality = env['server'].get('personality', [])
+        onset_files = self._get_onset_files_from_personality_attr(personality)
+
         instances = self.compute_api.create(
             context,
             instance_types.get_by_flavor_id(env['server']['flavorId']),
@@ -192,7 +210,7 @@ class Controller(wsgi.Controller):
             key_name=key_pair['name'],
             key_data=key_pair['public_key'],
             metadata=metadata,
-            onset_files=env.get('onset_files', []))
+            onset_files=onset_files)
         return _translate_keys(instances[0])
 
     def update(self, req, id):
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 7e5bc0080..42665ba6d 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -232,6 +232,9 @@ class ServersTest(test.TestCase):
 
         self.assertEqual(res.status_int, 200)
 
+    def _personality_dict(self, path, contents):
+        return {'path': path, 'contents': contents}
+
     def _create_instance_with_personality(self, personality):
 
         class FakeComputeAPI(object):
@@ -239,7 +242,7 @@ class ServersTest(test.TestCase):
             def __init__(self):
                 self.onset_files = None
 
-            def create(*args, **kwargs):
+            def create(self, *args, **kwargs):
                 if 'onset_files' in kwargs:
                     self.onset_files = kwargs['onset_files']
                 else:
@@ -265,12 +268,20 @@ class ServersTest(test.TestCase):
         req = webob.Request.blank('/v1.0/servers')
         req.method = 'POST'
         req.body = json.dumps(body)
-        return req.get_response(fakes.wsgi_app()), compute_api.onset_files
+        return req, req.get_response(fakes.wsgi_app()), compute_api.onset_files
 
     def test_create_instance_with_no_personality(self):
-        res, onset_files = self._create_instance_with_personality(personality={})
-        self.assertEquals(res.status_int, 200)
-        self.assertEquals(onset_files, None)
+        request, response, onset_files = \
+            self._create_instance_with_personality(personality=[])
+        self.assertEquals(response.status_int, 200)
+        self.assertEquals(onset_files, [])
+
+    def test_create_instance_with_one_personality(self):
+        personality = [self._personality_dict('/my/path', 'myfilecontents')]
+        request, response, onset_files = \
+            self._create_instance_with_personality(personality)
+        self.assertEquals(response.status_int, 200)
+        self.assertEquals(onset_files, [('/my/path', 'myfilecontents')])
 
     def test_update_no_body(self):
         req = webob.Request.blank('/v1.0/servers/1')
-- 
cgit 


From 09c515ab68bbb5444554a8035cac93f261570a7d Mon Sep 17 00:00:00 2001
From: sateesh <sateesh.chodapuneedi@citrix.com>
Date: Wed, 2 Mar 2011 00:38:50 +0530
Subject: Support for guest consoles for VMs running on VMware ESX/ESXi
 servers. Uses vmrc to provide the console access to guests.

---
 nova/console/vmrc.py         | 126 +++++++++++++++++++++++++++++++++++++++
 nova/console/vmrc_manager.py | 137 +++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 263 insertions(+)
 create mode 100644 nova/console/vmrc.py
 create mode 100644 nova/console/vmrc_manager.py

(limited to 'nova')

diff --git a/nova/console/vmrc.py b/nova/console/vmrc.py
new file mode 100644
index 000000000..09f8067e5
--- /dev/null
+++ b/nova/console/vmrc.py
@@ -0,0 +1,126 @@
+# 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.
+
+"""
+VMRC console drivers.
+"""
+
+from nova import flags
+from nova import log as logging
+from nova.virt.vmwareapi import vim_util
+from nova.virt.vmwareapi_conn import VMWareAPISession
+
+flags.DEFINE_integer('console_vmrc_port',
+                     443,
+                     "port for VMware VMRC connections")
+flags.DEFINE_integer('console_vmrc_error_retries',
+                     10,
+                     "number of retries for retrieving VMRC information")
+
+FLAGS = flags.FLAGS
+
+
+class VMRCConsole(object):
+    """VMRC console driver with ESX credentials."""
+
+    def __init__(self):
+        super(VMRCConsole, self).__init__()
+
+    @property
+    def console_type(self):
+        return 'vmrc+credentials'
+
+    def get_port(self, context):
+        """Get available port for consoles."""
+        return FLAGS.console_vmrc_port
+
+    def setup_console(self, context, console):
+        """Sets up console."""
+        pass
+
+    def teardown_console(self, context, console):
+        """Tears down console."""
+        pass
+
+    def init_host(self):
+        """Perform console initialization."""
+        pass
+
+    def fix_pool_password(self, password):
+        """Encode password."""
+        #TODO:Encrypt pool password
+        return password
+
+    def generate_password(self, address, username, password, instance_name):
+        """Returns a VMRC Connection credentials
+        Return string is of the form '<VM MOID>:<ESX Username>@<ESX Password>'.
+        """
+        vim_session = VMWareAPISession(address,
+                                       username,
+                                       password,
+                                       FLAGS.console_vmrc_error_retries)
+        vms = vim_session._call_method(vim_util, "get_objects",
+                    "VirtualMachine", ["name"])
+        vm_ref = None
+        for vm in vms:
+            if vm.propSet[0].val == instance_name:
+                vm_ref = vm.obj
+        if vm_ref is None:
+            raise Exception(_("instance - %s not present") % instance_name)
+        return str(vm_ref) + ":" + username + "@" + password
+
+    def is_otp(self):
+        """Is one time password."""
+        return False
+
+
+class VMRCSessionConsole(VMRCConsole):
+    """VMRC console driver with VMRC One Time Sessions"""
+
+    def __init__(self):
+        super(VMRCSessionConsole, self).__init__()
+
+    @property
+    def console_type(self):
+        return 'vmrc+session'
+
+    def generate_password(self, address, username, password, instance_name):
+        """Returns a VMRC Session
+        Return string is of the form '<VM MOID>:<VMRC Ticket>'.
+        """
+        vim_session = VMWareAPISession(address,
+                                       username,
+                                       password,
+                                       FLAGS.console_vmrc_error_retries)
+        vms = vim_session._call_method(vim_util, "get_objects",
+                    "VirtualMachine", ["name"])
+        vm_ref = None
+        for vm in vms:
+            if vm.propSet[0].val == instance_name:
+                vm_ref = vm.obj
+        if vm_ref is None:
+            raise Exception(_("instance - %s not present") % instance_name)
+        virtual_machine_ticket = \
+                        vim_session._call_method(
+            vim_session._get_vim(),
+            "AcquireCloneTicket",
+            vim_session._get_vim().get_service_content().sessionManager)
+        return str(vm_ref) + ":" + virtual_machine_ticket
+
+    def is_otp(self):
+        """Is one time password."""
+        return True
diff --git a/nova/console/vmrc_manager.py b/nova/console/vmrc_manager.py
new file mode 100644
index 000000000..24f7f5fe2
--- /dev/null
+++ b/nova/console/vmrc_manager.py
@@ -0,0 +1,137 @@
+# 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.
+
+"""
+VMRC Console Manager
+"""
+
+from nova import exception
+from nova import flags
+from nova import log as logging
+from nova import manager
+from nova import rpc
+from nova import utils
+
+LOG = logging.getLogger("nova.console.vmrc_manager")
+
+FLAGS = flags.FLAGS
+flags.DEFINE_string('console_public_hostname',
+                    '',
+                    'Publicly visible name for this console host')
+flags.DEFINE_string('console_driver',
+                    'nova.console.vmrc.VMRCConsole',
+                    'Driver to use for the console')
+
+
+class ConsoleVMRCManager(manager.Manager):
+
+    """Manager to handle VMRC connections needed for accessing
+       instance consoles
+    """
+
+    def __init__(self, console_driver=None, *args, **kwargs):
+        self.driver = utils.import_object(FLAGS.console_driver)
+        super(ConsoleVMRCManager, self).__init__(*args, **kwargs)
+
+    def init_host(self):
+        self.driver.init_host()
+
+    def _generate_console(self, context, pool, name, instance_id, instance):
+        LOG.debug(_("Adding console"))
+        password = self.driver.generate_password(
+                        pool['address'],
+                        pool['username'],
+                        pool['password'],
+                        instance.name)
+        console_data = {'instance_name': name,
+                        'instance_id': instance_id,
+                        'password': password,
+                        'pool_id': pool['id']}
+        console_data['port'] = self.driver.get_port(context)
+        console = self.db.console_create(context, console_data)
+        self.driver.setup_console(context, console)
+        return console
+
+    @exception.wrap_exception
+    def add_console(self, context, instance_id, password=None,
+                    port=None, **kwargs):
+        instance = self.db.instance_get(context, instance_id)
+        host = instance['host']
+        name = instance['name']
+        pool = self.get_pool_for_instance_host(context, host)
+        try:
+            console = self.db.console_get_by_pool_instance(context,
+                                                      pool['id'],
+                                                      instance_id)
+            if self.driver.is_otp():
+                console = self._generate_console(
+                        context,
+                        pool,
+                        name,
+                        instance_id,
+                        instance)
+        except exception.NotFound:
+            console = self._generate_console(
+                        context,
+                        pool,
+                        name,
+                        instance_id,
+                        instance)
+        return console['id']
+
+    @exception.wrap_exception
+    def remove_console(self, context, console_id, **_kwargs):
+        try:
+            console = self.db.console_get(context, console_id)
+        except exception.NotFound:
+            LOG.debug(_("Tried to remove non-existent console "
+                            "%(console_id)s.") %
+                            {'console_id': console_id})
+            return
+        LOG.debug(_("Removing console "
+                            "%(console_id)s.") %
+                            {'console_id': console_id})
+        self.db.console_delete(context, console_id)
+        self.driver.teardown_console(context, console)
+
+    def get_pool_for_instance_host(self, context, instance_host):
+        context = context.elevated()
+        console_type = self.driver.console_type
+        try:
+            pool = self.db.console_pool_get_by_host_type(context,
+                                                         instance_host,
+                                                         self.host,
+                                                         console_type)
+        except exception.NotFound:
+            pool_info = rpc.call(context,
+                             self.db.queue_get_for(context,
+                                               FLAGS.compute_topic,
+                                               instance_host),
+                   {"method": "get_console_pool_info",
+                    "args": {"console_type": console_type}})
+            pool_info['password'] = self.driver.fix_pool_password(
+                                                    pool_info['password'])
+            pool_info['host'] = self.host
+            #ESX Address or Proxy Address
+            public_host_name = pool_info['address']
+            if FLAGS.console_public_hostname:
+                public_host_name = FLAGS.console_public_hostname
+            pool_info['public_hostname'] = public_host_name
+            pool_info['console_type'] = console_type
+            pool_info['compute_host'] = instance_host
+            pool = self.db.console_pool_create(context, pool_info)
+        return pool
-- 
cgit 


From 4376b1add894aa6d9b5568865ffb07f921e7e525 Mon Sep 17 00:00:00 2001
From: sateesh <sateesh.chodapuneedi@citrix.com>
Date: Wed, 2 Mar 2011 00:42:39 +0530
Subject: Added support for guest console access for VMs running on ESX/ESXi
 servers as computer providers in OpenStack.

---
 nova/network/vmwareapi_net.py | 124 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 124 insertions(+)
 create mode 100644 nova/network/vmwareapi_net.py

(limited to 'nova')

diff --git a/nova/network/vmwareapi_net.py b/nova/network/vmwareapi_net.py
new file mode 100644
index 000000000..d62040b0a
--- /dev/null
+++ b/nova/network/vmwareapi_net.py
@@ -0,0 +1,124 @@
+# 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.
+
+"""
+Implements vlans for vmwareapi
+"""
+
+from nova import db
+from nova import exception
+from nova import flags
+from nova import log as logging
+from nova import utils
+from nova.virt.vmwareapi_conn import VMWareAPISession
+from nova.virt.vmwareapi.network_utils import NetworkHelper
+
+LOG = logging.getLogger("nova.vmwareapi_net")
+
+FLAGS = flags.FLAGS
+flags.DEFINE_string('vlan_interface', 'vmnic0',
+                    'Physical network adapter name in VMware ESX host for '
+                    'vlan networking')
+
+
+def metadata_forward():
+    pass
+
+
+def init_host():
+    pass
+
+
+def bind_floating_ip(floating_ip, check_exit_code=True):
+    pass
+
+
+def unbind_floating_ip(floating_ip):
+    pass
+
+
+def ensure_vlan_forward(public_ip, port, private_ip):
+    pass
+
+
+def ensure_floating_forward(floating_ip, fixed_ip):
+    pass
+
+
+def remove_floating_forward(floating_ip, fixed_ip):
+    pass
+
+
+def ensure_vlan_bridge(vlan_num, bridge, net_attrs=None):
+    """Create a vlan and bridge unless they already exist"""
+    #open vmwareapi session
+    host_ip = FLAGS.vmwareapi_host_ip
+    host_username = FLAGS.vmwareapi_host_username
+    host_password = FLAGS.vmwareapi_host_password
+    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"))
+    session = VMWareAPISession(host_ip, host_username, host_password,
+                               FLAGS.vmwareapi_api_retry_count)
+    vlan_interface = FLAGS.vlan_interface
+    #check whether bridge already exists
+    #retrieve network whose name_label is "bridge"
+    network_ref = NetworkHelper.get_network_with_the_name(session, bridge)
+    if network_ref == None:
+        #Create a port group on the vSwitch associated with the vlan_interface
+        #corresponding physical network adapter on the ESX host
+        vswitches = NetworkHelper.get_vswitches_for_vlan_interface(session,
+                                           vlan_interface)
+        if len(vswitches) == 0:
+            raise Exception(_("There is no virtual switch connected "
+                "to the physical network adapter with name %s") %
+                vlan_interface)
+        #Assuming physical network interface is associated with only one
+        #virtual switch
+        NetworkHelper.create_port_group(session, bridge, vswitches[0],
+                                        vlan_num)
+    else:
+        #check VLAN tag is appropriate
+        is_vlan_proper, ret_vlan_id = NetworkHelper.check_if_vlan_id_is_proper(
+                                           session, bridge, vlan_num)
+        if not is_vlan_proper:
+            raise Exception(_("VLAN tag not appropriate for the port group "
+                              "%(bridge)s. Expected VLAN tag is %(vlan_num)s, "
+                              "but the one associated with the port group is"
+                              " %(ret_vlan_id)s") % locals())
+
+
+def ensure_vlan(vlan_num):
+    pass
+
+
+def ensure_bridge(bridge, interface, net_attrs=None):
+    pass
+
+
+def get_dhcp_hosts(context, network_id):
+    pass
+
+
+def update_dhcp(context, network_id):
+    pass
+
+
+def update_ra(context, network_id):
+    pass
-- 
cgit 


From f952992f035ec130b7608e9851ef9c3becc2047a Mon Sep 17 00:00:00 2001
From: sateesh <sateesh.chodapuneedi@citrix.com>
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')

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://<server>/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 <test/> as opposed to <test>test</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(_("<ZSI.FaultException> in"
-                           " %s:") % (attr_name), excep)
-                except ZSI.EvaluateException, excep:
-                    raise SessionFaultyException(_("<ZSI.EvaluateException> 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 <josh@jk0.org>
Date: Tue, 1 Mar 2011 13:26:31 -0600
Subject: Review feedback

---
 nova/compute/manager.py   | 42 ++++++++++++++++++++++++------------------
 nova/virt/xenapi/vmops.py | 42 ++++++++++++++++++++++--------------------
 2 files changed, 46 insertions(+), 38 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index ef7ed55c9..3af97683f 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -370,16 +370,19 @@ class ComputeManager(manager.Manager):
         context = context.elevated()
         instance_ref = self.db.instance_get(context, instance_id)
         LOG.audit(_('instance %s: rescuing'), instance_id, context=context)
-        self.db.instance_set_state(context,
-                                   instance_id,
-                                   power_state.NOSTATE,
-                                   'rescuing')
+        self.db.instance_set_state(
+            context,
+            instance_id,
+            power_state.NOSTATE,
+            'rescuing')
         self.network_manager.setup_compute_network(context, instance_id)
-        self.driver.rescue(instance_ref,
-            lambda result: self._update_state_callback(self,
-                                                       context,
-                                                       instance_id,
-                                                       result))
+        self.driver.rescue(
+            instance_ref,
+            lambda result: self._update_state_callback(
+                self,
+                context,
+                instance_id,
+                result))
         self._update_state(context, instance_id)
 
     @exception.wrap_exception
@@ -389,15 +392,18 @@ class ComputeManager(manager.Manager):
         context = context.elevated()
         instance_ref = self.db.instance_get(context, instance_id)
         LOG.audit(_('instance %s: unrescuing'), instance_id, context=context)
-        self.db.instance_set_state(context,
-                                   instance_id,
-                                   power_state.NOSTATE,
-                                   'unrescuing')
-        self.driver.unrescue(instance_ref,
-            lambda result: self._update_state_callback(self,
-                                                       context,
-                                                       instance_id,
-                                                       result))
+        self.db.instance_set_state(
+            context,
+            instance_id,
+            power_state.NOSTATE,
+            'unrescuing')
+        self.driver.unrescue(
+            instance_ref,
+            lambda result: self._update_state_callback(
+                self,
+                context,
+                instance_id,
+                result))
         self._update_state(context, instance_id)
 
     @staticmethod
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 e21763b15948603e618d4435335ef3785dc5660a Mon Sep 17 00:00:00 2001
From: sateesh <sateesh.chodapuneedi@citrix.com>
Date: Wed, 2 Mar 2011 01:00:31 +0530
Subject: Fake database module for vmware vi api. Includes false injection
 layer at the level of API calls. This module is base for unit tests for
 vmwareapi module. The unit tests runs regardless of presence of ESX/ESXi
 server as computer provider in OpenStack.

---
 nova/tests/test_vmwareapi.py     | 207 +++++++++++++++++++++++++++++++++++++++
 nova/tests/vmwareapi/__init__.py |  16 +++
 nova/tests/vmwareapi/db_fakes.py |  93 ++++++++++++++++++
 nova/tests/vmwareapi/stubs.py    |  46 +++++++++
 4 files changed, 362 insertions(+)
 create mode 100644 nova/tests/test_vmwareapi.py
 create mode 100644 nova/tests/vmwareapi/__init__.py
 create mode 100644 nova/tests/vmwareapi/db_fakes.py
 create mode 100644 nova/tests/vmwareapi/stubs.py

(limited to 'nova')

diff --git a/nova/tests/test_vmwareapi.py b/nova/tests/test_vmwareapi.py
new file mode 100644
index 000000000..ff2761e72
--- /dev/null
+++ b/nova/tests/test_vmwareapi.py
@@ -0,0 +1,207 @@
+# 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.
+
+"""
+Test suite for VMWareAPI
+"""
+import stubout
+
+from nova import context
+from nova import db
+from nova import flags
+from nova import test
+from nova import utils
+from nova.auth import manager
+from nova.compute import instance_types
+from nova.compute import power_state
+from nova.tests.glance import stubs as glance_stubs
+from nova.tests.vmwareapi import db_fakes
+from nova.tests.vmwareapi import stubs
+from nova.virt import vmwareapi_conn
+from nova.virt.vmwareapi import fake as vmwareapi_fake
+
+
+FLAGS = flags.FLAGS
+
+
+class VMWareAPIVMTestCase(test.TestCase):
+    """
+    Unit tests for Vmware API connection calls
+    """
+
+    def setUp(self):
+        super(VMWareAPIVMTestCase, self).setUp()
+        self.manager = manager.AuthManager()
+        self.user = self.manager.create_user('fake', 'fake', 'fake',
+                                             admin=True)
+        self.project = self.manager.create_project('fake', 'fake', 'fake')
+        self.network = utils.import_object(FLAGS.network_manager)
+        self.stubs = stubout.StubOutForTesting()
+        FLAGS.vmwareapi_host_ip = 'test_url'
+        FLAGS.vmwareapi_host_username = 'test_username'
+        FLAGS.vmwareapi_host_password = 'test_pass'
+        vmwareapi_fake.reset()
+        db_fakes.stub_out_db_instance_api(self.stubs)
+        stubs.set_stubs(self.stubs)
+        glance_stubs.stubout_glance_client(self.stubs,
+                                           glance_stubs.FakeGlance)
+        self.conn = vmwareapi_conn.get_connection(False)
+
+    def _create_vm(self):
+        """ Create and spawn the VM """
+        values = {'name': 1,
+                  'id': 1,
+                  'project_id': self.project.id,
+                  'user_id': self.user.id,
+                  'image_id': "1",
+                  'kernel_id': "1",
+                  'ramdisk_id': "1",
+                  'instance_type': 'm1.large',
+                  'mac_address': 'aa:bb:cc:dd:ee:ff',
+                  }
+        self.instance = db.instance_create(values)
+        self.type_data = instance_types.INSTANCE_TYPES[values['instance_type']]
+        self.conn.spawn(self.instance)
+        self._check_vm_record()
+
+    def _check_vm_record(self):
+        """ Check if the spawned VM's properties corresponds to the instance in
+        the db """
+        instances = self.conn.list_instances()
+        self.assertEquals(len(instances), 1)
+
+        # Get Nova record for VM
+        vm_info = self.conn.get_info(1)
+
+        # Get XenAPI record for VM
+        vms = vmwareapi_fake._get_objects("VirtualMachine")
+        vm = vms[0]
+
+        # Check that m1.large above turned into the right thing.
+        mem_kib = long(self.type_data['memory_mb']) << 10
+        vcpus = self.type_data['vcpus']
+        self.assertEquals(vm_info['max_mem'], mem_kib)
+        self.assertEquals(vm_info['mem'], mem_kib)
+        self.assertEquals(vm.get("summary.config.numCpu"), vcpus)
+        self.assertEquals(vm.get("summary.config.memorySizeMB"),
+                          self.type_data['memory_mb'])
+
+        # Check that the VM is running according to Nova
+        self.assertEquals(vm_info['state'], power_state.RUNNING)
+
+        # Check that the VM is running according to XenAPI.
+        self.assertEquals(vm.get("runtime.powerState"), 'poweredOn')
+
+    def _check_vm_info(self, info, pwr_state=power_state.RUNNING):
+        """ Check if the get_info returned values correspond to the instance
+        object in the db """
+        mem_kib = long(self.type_data['memory_mb']) << 10
+        self.assertEquals(info["state"], pwr_state)
+        self.assertEquals(info["max_mem"], mem_kib)
+        self.assertEquals(info["mem"], mem_kib)
+        self.assertEquals(info["num_cpu"], self.type_data['vcpus'])
+
+    def test_list_instances(self):
+        instances = self.conn.list_instances()
+        self.assertEquals(len(instances), 0)
+
+    def test_list_instances_1(self):
+        self._create_vm()
+        instances = self.conn.list_instances()
+        self.assertEquals(len(instances), 1)
+
+    def test_spawn(self):
+        self._create_vm()
+        info = self.conn.get_info(1)
+        self._check_vm_info(info, power_state.RUNNING)
+
+    def test_snapshot(self):
+        self._create_vm()
+        info = self.conn.get_info(1)
+        self._check_vm_info(info, power_state.RUNNING)
+        self.conn.snapshot(self.instance, "Test-Snapshot")
+        info = self.conn.get_info(1)
+        self._check_vm_info(info, power_state.RUNNING)
+
+    def test_reboot(self):
+        self._create_vm()
+        info = self.conn.get_info(1)
+        self._check_vm_info(info, power_state.RUNNING)
+        self.conn.reboot(self.instance)
+        info = self.conn.get_info(1)
+        self._check_vm_info(info, power_state.RUNNING)
+
+    def test_suspend(self):
+        self._create_vm()
+        info = self.conn.get_info(1)
+        self._check_vm_info(info, power_state.RUNNING)
+        self.conn.suspend(self.instance, self.dummy_callback_handler)
+        info = self.conn.get_info(1)
+        self._check_vm_info(info, power_state.PAUSED)
+
+    def test_resume(self):
+        self._create_vm()
+        info = self.conn.get_info(1)
+        self._check_vm_info(info, power_state.RUNNING)
+        self.conn.suspend(self.instance, self.dummy_callback_handler)
+        info = self.conn.get_info(1)
+        self._check_vm_info(info, power_state.PAUSED)
+        self.conn.resume(self.instance, self.dummy_callback_handler)
+        info = self.conn.get_info(1)
+        self._check_vm_info(info, power_state.RUNNING)
+
+    def test_get_info(self):
+        self._create_vm()
+        info = self.conn.get_info(1)
+        self._check_vm_info(info, power_state.RUNNING)
+
+    def test_destroy(self):
+        self._create_vm()
+        info = self.conn.get_info(1)
+        self._check_vm_info(info, power_state.RUNNING)
+        instances = self.conn.list_instances()
+        self.assertTrue(len(instances) == 1)
+        self.conn.destroy(self.instance)
+        instances = self.conn.list_instances()
+        self.assertTrue(len(instances) == 0)
+
+    def test_pause(self):
+        pass
+
+    def test_unpause(self):
+        pass
+
+    def test_diagnostics(self):
+        pass
+
+    def test_get_console_output(self):
+        pass
+
+    def test_get_ajax_console(self):
+        pass
+
+    def dummy_callback_handler(self, ret):
+        """ Dummy callback function to be passed to suspend, resume, etc.
+        calls """
+        pass
+
+    def tearDown(self):
+        super(VMWareAPIVMTestCase, self).tearDown()
+        vmwareapi_fake.cleanup()
+        self.manager.delete_project(self.project)
+        self.manager.delete_user(self.user)
+        self.stubs.UnsetAll()
diff --git a/nova/tests/vmwareapi/__init__.py b/nova/tests/vmwareapi/__init__.py
new file mode 100644
index 000000000..f346c053b
--- /dev/null
+++ b/nova/tests/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/tests/vmwareapi/db_fakes.py b/nova/tests/vmwareapi/db_fakes.py
new file mode 100644
index 000000000..555537304
--- /dev/null
+++ b/nova/tests/vmwareapi/db_fakes.py
@@ -0,0 +1,93 @@
+# 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.
+
+"""
+Stubouts, mocks and fixtures for the test suite
+"""
+
+import time
+
+from nova import db
+from nova import utils
+from nova.compute import instance_types
+
+
+def stub_out_db_instance_api(stubs):
+    """ Stubs out the db API for creating Instances """
+
+    class FakeModel(object):
+        """ Stubs out for model """
+
+        def __init__(self, values):
+            self.values = values
+
+        def __getattr__(self, name):
+            return self.values[name]
+
+        def __getitem__(self, key):
+            if key in self.values:
+                return self.values[key]
+            else:
+                raise NotImplementedError()
+
+    def fake_instance_create(values):
+        """ Stubs out the db.instance_create method """
+
+        type_data = instance_types.INSTANCE_TYPES[values['instance_type']]
+
+        base_options = {
+            'name': values['name'],
+            'id': values['id'],
+            'reservation_id': utils.generate_uid('r'),
+            'image_id': values['image_id'],
+            'kernel_id': values['kernel_id'],
+            'ramdisk_id': values['ramdisk_id'],
+            'state_description': 'scheduling',
+            'user_id': values['user_id'],
+            'project_id': values['project_id'],
+            'launch_time': time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime()),
+            'instance_type': values['instance_type'],
+            'memory_mb': type_data['memory_mb'],
+            'mac_address': values['mac_address'],
+            'vcpus': type_data['vcpus'],
+            'local_gb': type_data['local_gb'],
+            }
+        return FakeModel(base_options)
+
+    def fake_network_get_by_instance(context, instance_id):
+        """ Stubs out the db.network_get_by_instance method """
+
+        fields = {
+            'bridge': 'vmnet0',
+            'netmask': '255.255.255.0',
+            'gateway': '10.10.10.1',
+            'vlan': 100}
+        return FakeModel(fields)
+
+    def fake_instance_action_create(context, action):
+        """ Stubs out the db.instance_action_create method """
+        pass
+
+    def fake_instance_get_fixed_address(context, instance_id):
+        """ Stubs out the db.instance_get_fixed_address method """
+        return '10.10.10.10'
+
+    stubs.Set(db, 'instance_create', fake_instance_create)
+    stubs.Set(db, 'network_get_by_instance', fake_network_get_by_instance)
+    stubs.Set(db, 'instance_action_create', fake_instance_action_create)
+    stubs.Set(db, 'instance_get_fixed_address',
+                fake_instance_get_fixed_address)
diff --git a/nova/tests/vmwareapi/stubs.py b/nova/tests/vmwareapi/stubs.py
new file mode 100644
index 000000000..da2d43c29
--- /dev/null
+++ b/nova/tests/vmwareapi/stubs.py
@@ -0,0 +1,46 @@
+# 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.
+
+"""
+Stubouts for the test suite
+"""
+
+from nova.virt import vmwareapi_conn
+from nova.virt.vmwareapi import fake
+from nova.virt.vmwareapi import vmware_images
+
+
+def fake_get_vim_object(arg):
+    """ Stubs out the VMWareAPISession's get_vim_object method """
+    return fake.FakeVim()
+
+
+def fake_is_vim_object(arg, module):
+    """ Stubs out the VMWareAPISession's is_vim_object method """
+    return isinstance(module, fake.FakeVim)
+
+
+def set_stubs(stubs):
+    """ Set the stubs """
+    stubs.Set(vmware_images, 'fetch_image', fake.fake_fetch_image)
+    stubs.Set(vmware_images, 'get_vmdk_size_and_properties',
+              fake.fake_get_vmdk_size_and_properties)
+    stubs.Set(vmware_images, 'upload_image', fake.fake_upload_image)
+    stubs.Set(vmwareapi_conn.VMWareAPISession, "_get_vim_object",
+              fake_get_vim_object)
+    stubs.Set(vmwareapi_conn.VMWareAPISession, "_is_vim_object",
+              fake_is_vim_object)
-- 
cgit 


From be9004ffa4c70358c8edda1f33ffe7ba7e1ae1ee Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Tue, 1 Mar 2011 20:49:46 +0100
Subject: Use functools.wraps to make sure wrapped method's metadata (docstring
 and name) doesn't get mangled.

---
 nova/tests/test_misc.py | 12 ++++++++++--
 nova/utils.py           |  6 ++++--
 2 files changed, 14 insertions(+), 4 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/test_misc.py b/nova/tests/test_misc.py
index 154b6fae6..9f572b58e 100644
--- a/nova/tests/test_misc.py
+++ b/nova/tests/test_misc.py
@@ -14,11 +14,9 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-from datetime import datetime
 import errno
 import os
 import select
-import time
 
 from nova import test
 from nova.utils import parse_mailmap, str_dict_replace, synchronized
@@ -62,6 +60,16 @@ class ProjectTestCase(test.TestCase):
 
 
 class LockTestCase(test.TestCase):
+    def test_synchronized_wrapped_function_metadata(self):
+        @synchronized('whatever')
+        def foo():
+            """Bar"""
+            pass
+        self.assertEquals(foo.__doc__, 'Bar', "Wrapped function's docstring "
+                                              "got lost")
+        self.assertEquals(foo.__name__, 'foo', "Wrapped function's name "
+                                               "got mangled")
+
     def test_synchronized(self):
         rpipe, wpipe = os.pipe()
         pid = os.fork()
diff --git a/nova/utils.py b/nova/utils.py
index 48f12350f..9929e6fef 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -23,11 +23,14 @@ System-level utilities and helper functions.
 
 import base64
 import datetime
+import functools
 import inspect
 import json
 import lockfile
+import netaddr
 import os
 import random
+import re
 import socket
 import string
 import struct
@@ -35,8 +38,6 @@ import sys
 import time
 import types
 from xml.sax import saxutils
-import re
-import netaddr
 
 from eventlet import event
 from eventlet import greenthread
@@ -496,6 +497,7 @@ def loads(s):
 
 def synchronized(name):
     def wrap(f):
+        @functools.wraps(f)
         def inner(*args, **kwargs):
             lock = lockfile.FileLock(os.path.join(FLAGS.lock_path,
                                                   'nova-%s.lock' % name))
-- 
cgit 


From 94e42c3002f9043fc3c5b90a1cb5ad0c50ba261b Mon Sep 17 00:00:00 2001
From: Mark Washenberger <mark.washenberger@rackspace.com>
Date: Tue, 1 Mar 2011 16:21:37 -0500
Subject: ensure personality contents are b64 encoded

---
 nova/api/openstack/servers.py            | 15 ++++++++++-----
 nova/tests/api/openstack/test_servers.py | 21 +++++++++++++++++----
 2 files changed, 27 insertions(+), 9 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 8491fe697..8908bbdca 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -13,6 +13,7 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+import base64
 import hashlib
 import json
 import traceback
@@ -138,7 +139,7 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPNotFound())
         return exc.HTTPAccepted()
 
-    def _get_onset_files_from_personality_attr(self, personality_attr):
+    def _get_onset_files_from_personality(self, personality):
         """
         Create a list of onset files from the personality request attribute
 
@@ -147,9 +148,13 @@ class Controller(wsgi.Controller):
         underlying compute service.
         """
         onset_files = []
-        for personality in personality_attr:
-            path = personality['path']
-            contents = personality['contents']
+        for item in personality:
+            path = item['path']
+            try:
+                contents = base64.b64decode(item['contents'])
+            except TypeError:
+                raise exc.HTTPBadRequest(explanation=
+                        'Personality content for %s cannot be decoded' % path)
             onset_files.append((path, contents))
         return onset_files
 
@@ -181,7 +186,7 @@ class Controller(wsgi.Controller):
                 metadata.append({'key': k, 'value': v})
 
         personality = env['server'].get('personality', [])
-        onset_files = self._get_onset_files_from_personality_attr(personality)
+        onset_files = self._get_onset_files_from_personality(personality)
 
         instances = self.compute_api.create(
             context,
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 144dbd4af..4b40793a7 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -15,6 +15,7 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+import base64
 import datetime
 import json
 
@@ -272,16 +273,28 @@ class ServersTest(test.TestCase):
 
     def test_create_instance_with_no_personality(self):
         request, response, onset_files = \
-            self._create_instance_with_personality(personality=[])
+                self._create_instance_with_personality(personality=[])
         self.assertEquals(response.status_int, 200)
         self.assertEquals(onset_files, [])
 
-    def test_create_instance_with_one_personality(self):
-        personality = [self._personality_dict('/my/path', 'myfilecontents')]
+    def test_create_instance_with_personality(self):
+        path = '/my/file/path'
+        contents = '#!/bin/bash\necho "Hello, World!"\n'
+        b64contents = base64.b64encode(contents)
+        personality = [self._personality_dict(path, b64contents)]
         request, response, onset_files = \
             self._create_instance_with_personality(personality)
         self.assertEquals(response.status_int, 200)
-        self.assertEquals(onset_files, [('/my/path', 'myfilecontents')])
+        self.assertEquals(onset_files, [(path, contents)])
+    
+    def test_create_instance_with_personality_with_non_b64_content(self):
+        path = '/my/file/path'
+        contents = '#!/bin/bash\necho "Oh no!"\n'
+        personality = [self._personality_dict(path, contents)]
+        request, response, onset_files = \
+            self._create_instance_with_personality(personality)
+        self.assertEquals(response.status_int, 400)
+        self.assertEquals(onset_files, None)
 
     def test_update_no_body(self):
         req = webob.Request.blank('/v1.0/servers/1')
-- 
cgit 


From 7b3ccd5fd1636ebc437a89a3667e6e712004e87f Mon Sep 17 00:00:00 2001
From: Mark Washenberger <mark.washenberger@rackspace.com>
Date: Tue, 1 Mar 2011 16:48:01 -0500
Subject: test osapi server create with multiple personalities

---
 nova/tests/api/openstack/test_servers.py | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 4b40793a7..dd951e90c 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -296,6 +296,20 @@ class ServersTest(test.TestCase):
         self.assertEquals(response.status_int, 400)
         self.assertEquals(onset_files, None)
 
+    def test_create_instance_with_two_personalities(self):
+        files = [
+            ('/etc/sudoers', 'ALL ALL=NOPASSWD: ALL\n'),
+            ('/etc/motd', 'Enjoy your root access!\n'),
+            ]
+        personality = []
+        for path, content in files:
+            personality.append(self._personality_dict(
+                    path, base64.b64encode(content)))
+        request, response, onset_files = \
+            self._create_instance_with_personality(personality)
+        self.assertEquals(response.status_int, 200)
+        self.assertEquals(onset_files, files)
+
     def test_update_no_body(self):
         req = webob.Request.blank('/v1.0/servers/1')
         req.method = 'PUT'
-- 
cgit 


From cdb1b16a6019fd68a7969666d754c4007607ae53 Mon Sep 17 00:00:00 2001
From: Cory Wright <cory.wright@rackspace.com>
Date: Tue, 1 Mar 2011 23:18:37 +0000
Subject: * Added ability to launch XenServer instances with per-os vm-params.

---
 nova/compute/api.py                                |   5 +-
 .../versions/007_add_os_type_to_instances.py       |  45 ++++++
 nova/db/sqlalchemy/models.py                       |   2 +
 nova/virt/xenapi/vm_utils.py                       | 152 +++++++++++++++------
 nova/virt/xenapi/vmops.py                          |  17 +--
 5 files changed, 164 insertions(+), 57 deletions(-)
 create mode 100644 nova/db/sqlalchemy/migrate_repo/versions/007_add_os_type_to_instances.py

(limited to 'nova')

diff --git a/nova/compute/api.py b/nova/compute/api.py
index 625778b66..8bdf712a0 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -125,6 +125,8 @@ class API(base.Base):
                 raise quota.QuotaError(msg, "MetadataLimitExceeded")
 
         image = self.image_service.show(context, image_id)
+        os_type = image['properties'].get('os_type', 'linux')
+
         if kernel_id is None:
             kernel_id = image.get('kernel_id', None)
         if ramdisk_id is None:
@@ -180,7 +182,8 @@ class API(base.Base):
             'key_data': key_data,
             'locked': False,
             'metadata': metadata,
-            'availability_zone': availability_zone}
+            'availability_zone': availability_zone,
+            'os_type': os_type}
         elevated = context.elevated()
         instances = []
         LOG.debug(_("Going to run %s instances..."), num_instances)
diff --git a/nova/db/sqlalchemy/migrate_repo/versions/007_add_os_type_to_instances.py b/nova/db/sqlalchemy/migrate_repo/versions/007_add_os_type_to_instances.py
new file mode 100644
index 000000000..d6d964b95
--- /dev/null
+++ b/nova/db/sqlalchemy/migrate_repo/versions/007_add_os_type_to_instances.py
@@ -0,0 +1,45 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# 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.
+
+from sqlalchemy import *
+from migrate import *
+
+from nova import log as logging
+
+
+meta = MetaData()
+
+instances = Table('instances', meta,
+        Column('id', Integer(),  primary_key=True, nullable=False),
+        )
+
+# FIXME(dubs) should this be not null?  Maybe create as nullable, then
+#   populate all existing rows with 'linux', then adding not null constraint.
+instances_os_type = Column('os_type',
+                           String(length=255, convert_unicode=False,
+                                  assert_unicode=None, unicode_error=None,
+                                  _warn_on_bytestring=False),
+                           nullable=True)
+
+
+def upgrade(migrate_engine):
+    # Upgrade operations go here. Don't create your own engine;
+    # bind migrate_engine to your metadata
+    meta.bind = migrate_engine
+
+    instances.create_column(instances_os_type)
diff --git a/nova/db/sqlalchemy/models.py b/nova/db/sqlalchemy/models.py
index 1882efeba..b78c95e40 100644
--- a/nova/db/sqlalchemy/models.py
+++ b/nova/db/sqlalchemy/models.py
@@ -188,6 +188,8 @@ class Instance(BASE, NovaBase):
 
     locked = Column(Boolean)
 
+    os_type = Column(String(255))
+
     # TODO(vish): see Ewan's email about state improvements, probably
     #             should be in a driver base class or some such
     # vmstate_state = running, halted, suspended, paused
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 <cory.wright@rackspace.com>
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

---
 .../migrate_repo/versions/007_add_os_type_to_instances.py        | 4 +++-
 nova/virt/xenapi/vm_utils.py                                     | 9 ++++++---
 nova/virt/xenapi/vmops.py                                        | 4 ++--
 3 files changed, 11 insertions(+), 6 deletions(-)

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/migrate_repo/versions/007_add_os_type_to_instances.py b/nova/db/sqlalchemy/migrate_repo/versions/007_add_os_type_to_instances.py
index d6d964b95..21f21b040 100644
--- a/nova/db/sqlalchemy/migrate_repo/versions/007_add_os_type_to_instances.py
+++ b/nova/db/sqlalchemy/migrate_repo/versions/007_add_os_type_to_instances.py
@@ -34,7 +34,7 @@ instances_os_type = Column('os_type',
                            String(length=255, convert_unicode=False,
                                   assert_unicode=None, unicode_error=None,
                                   _warn_on_bytestring=False),
-                           nullable=True)
+                           nullable=False)
 
 
 def upgrade(migrate_engine):
@@ -43,3 +43,5 @@ def upgrade(migrate_engine):
     meta.bind = migrate_engine
 
     instances.create_column(instances_os_type)
+
+    
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 <tushar.vitthal.patil@gmail.com>
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/api/ec2/cloud.py                              |  4 ---
 nova/db/sqlalchemy/api.py                          | 11 +++---
 .../versions/007_add_ipv6_flatmanager.py           | 24 ++++---------
 nova/db/sqlalchemy/models.py                       |  5 ++-
 nova/network/linux_net.py                          |  2 +-
 nova/network/manager.py                            | 37 +++++---------------
 nova/virt/interfaces.template                      |  6 ++--
 nova/virt/libvirt.xml.template                     |  4 +--
 nova/virt/libvirt_conn.py                          | 40 +++++++++++-----------
 9 files changed, 47 insertions(+), 86 deletions(-)

(limited to 'nova')

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 15799670c..b3779a4da 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -701,10 +701,6 @@ class CloudController(object):
                     fixed = instance['fixed_ip']
                     floating_addr = fixed['floating_ips'][0]['address']
                 if instance['fixed_ip']['network'] and 'use_v6' in kwargs:
-                    if FLAGS.network_manager == \
-                                  'nova.network.manager.FlatManager':
-                        i['dnsNameV6'] = instance['fixed_ip']['addressv6']
-                    else:
                         i['dnsNameV6'] = utils.to_global_ipv6(
                             instance['fixed_ip']['network']['cidr_v6'],
                             instance['mac_address'])
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 9bc59de60..d8751bef4 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -833,13 +833,10 @@ def instance_get_fixed_address_v6(context, instance_id):
     session = get_session()
     with session.begin():
         instance_ref = instance_get(context, instance_id, session=session)
-        if 'nova.network.manager.FlatManager' == FLAGS.network_manager:
-            return instance_ref.fixed_ip['addressv6']
-        else:
-            network_ref = network_get_by_instance(context, instance_id)
-            prefix = network_ref.cidr_v6
-            mac = instance_ref.mac_address
-            return utils.to_global_ipv6(prefix, mac)
+        network_ref = network_get_by_instance(context, instance_id)
+        prefix = network_ref.cidr_v6
+        mac = instance_ref.mac_address
+        return utils.to_global_ipv6(prefix, mac)
 
 
 @require_context
diff --git a/nova/db/sqlalchemy/migrate_repo/versions/007_add_ipv6_flatmanager.py b/nova/db/sqlalchemy/migrate_repo/versions/007_add_ipv6_flatmanager.py
index 2951cbc0a..e09f46652 100644
--- a/nova/db/sqlalchemy/migrate_repo/versions/007_add_ipv6_flatmanager.py
+++ b/nova/db/sqlalchemy/migrate_repo/versions/007_add_ipv6_flatmanager.py
@@ -30,10 +30,6 @@ networks = Table('networks', meta,
         Column('id', Integer(),  primary_key=True, nullable=False),
         )
 
-fixed_ips = Table('fixed_ips', meta,
-        Column('id', Integer(),  primary_key=True, nullable=False),
-        )
-
 #
 # New Tables
 #
@@ -42,24 +38,19 @@ fixed_ips = Table('fixed_ips', meta,
 #
 # Tables to alter
 #
-# None
+
 
 #
 # Columns to add to existing tables
 #
 
-networks_gatewayv6 = Column(
-        'gatewayv6',
-        String(length=255, convert_unicode=False, assert_unicode=None,
-               unicode_error=None, _warn_on_bytestring=False))
-
-networks_netmaskv6 = Column(
-        'netmaskv6',
+networks_gateway_v6 = Column(
+        'gateway_v6',
         String(length=255, convert_unicode=False, assert_unicode=None,
                unicode_error=None, _warn_on_bytestring=False))
 
-fixed_ips_addressv6 = Column(
-        'addressv6',
+networks_netmask_v6 = Column(
+        'netmask_v6',
         String(length=255, convert_unicode=False, assert_unicode=None,
                unicode_error=None, _warn_on_bytestring=False))
 
@@ -70,6 +61,5 @@ def upgrade(migrate_engine):
     meta.bind = migrate_engine
 
     # Add columns to existing tables
-    networks.create_column(networks_gatewayv6)
-    networks.create_column(networks_netmaskv6)
-    fixed_ips.create_column(fixed_ips_addressv6)
+    networks.create_column(networks_gateway_v6)
+    networks.create_column(networks_netmask_v6)
diff --git a/nova/db/sqlalchemy/models.py b/nova/db/sqlalchemy/models.py
index 4fa4d443c..f235054d2 100644
--- a/nova/db/sqlalchemy/models.py
+++ b/nova/db/sqlalchemy/models.py
@@ -385,8 +385,8 @@ class Network(BASE, NovaBase):
 
     ra_server = Column(String(255))
 
-    gatewayv6 = Column(String(255))
-    netmaskv6 = Column(String(255))
+    gateway_v6 = Column(String(255))
+    netmask_v6 = Column(String(255))
     netmask = Column(String(255))
     bridge = Column(String(255))
     gateway = Column(String(255))
@@ -427,7 +427,6 @@ class FixedIp(BASE, NovaBase):
     __tablename__ = 'fixed_ips'
     id = Column(Integer, primary_key=True)
     address = Column(String(255))
-    addressv6 = Column(String(255))
     network_id = Column(Integer, ForeignKey('networks.id'), nullable=True)
     network = relationship(Network, backref=backref('fixed_ips'))
     instance_id = Column(Integer, ForeignKey('instances.id'), nullable=True)
diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index 535ce87bc..e375568f1 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -361,7 +361,7 @@ interface %s
     command = _ra_cmd(network_ref)
     _execute(command)
     db.network_update(context, network_id,
-                      {"ra_server":
+                      {"gateway_v6":
                        utils.get_my_linklocal(network_ref['bridge'])})
 
 
diff --git a/nova/network/manager.py b/nova/network/manager.py
index 61b5dc07f..bdeeae293 100644
--- a/nova/network/manager.py
+++ b/nova/network/manager.py
@@ -388,41 +388,14 @@ class FlatManager(NetworkManager):
                                      significant_bits_v6)
                 net['cidr_v6'] = cidr_v6
                 project_net_v6 = IPy.IP(cidr_v6)
-                net['gatewayv6'] = str(project_net_v6[1])
-                net['netmaskv6'] = str(project_net_v6.prefixlen())
+                net['gateway_v6'] = str(project_net_v6[1])
+                net['netmask_v6'] = str(project_net_v6.prefixlen())
 
             network_ref = self.db.network_create_safe(context, net)
 
             if network_ref:
                 self._create_fixed_ips(context, network_ref['id'])
 
-    def _create_fixed_ips(self, context, network_id):
-        """Create all fixed ips for network."""
-        network_ref = self.db.network_get(context, network_id)
-        # NOTE(vish): Should these be properties of the network as opposed
-        #             to properties of the manager class?
-        bottom_reserved = self._bottom_reserved_ips
-        top_reserved = self._top_reserved_ips
-        project_net = IPy.IP(network_ref['cidr'])
-
-        if(FLAGS.use_ipv6):
-            project_net_v6 = IPy.IP(network_ref['cidr_v6'])
-
-        num_ips = len(project_net)
-        addressv6 = None
-        for index in range(num_ips):
-            address = str(project_net[index])
-            if(FLAGS.use_ipv6):
-                addressv6 = str(project_net_v6[index])
-            if index < bottom_reserved or num_ips - index < top_reserved:
-                reserved = True
-            else:
-                reserved = False
-            self.db.fixed_ip_create(context, {'network_id': network_id,
-                                              'address': address,
-                                              'addressv6': addressv6,
-                                              'reserved': reserved})
-
     def get_network_host(self, context):
         """Get the network host for the current context."""
         network_ref = self.db.network_get_by_bridge(context,
@@ -448,6 +421,12 @@ class FlatManager(NetworkManager):
         net = {}
         net['injected'] = FLAGS.flat_injected
         net['dns'] = FLAGS.flat_network_dns
+
+        if not FLAGS.fake_network:
+            if(FLAGS.use_ipv6):
+                net['gateway_v6'] = \
+                             utils.get_my_linklocal(FLAGS.flat_network_bridge)
+
         self.db.network_update(context, network_id, net)
 
     def allocate_floating_ip(self, context, project_id):
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)
-                <parameter name="RASERVER" value="${ra_server}" />
+#if $getVar('gateway_v6', False)
+                <parameter name="RASERVER" value="${gateway_v6}" />
 #end if
             </filterref>
         </interface>
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 e0f1490e481e5b3e0e28b25049cc69eb905b74d6 Mon Sep 17 00:00:00 2001
From: Salvatore Orlando <salvatore.orlando@eu.citrix.com>
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')

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 <salvatore.orlando@eu.citrix.com>
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')

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 58ac632f8e08b248d234deffdb56fe3a33a25130 Mon Sep 17 00:00:00 2001
From: Masanori Itoh <itoumsn@nttdata.co.jp>
Date: Thu, 3 Mar 2011 00:12:48 +0900
Subject: Port Todd's lp720157 fix to the current trunk, rev 752.

---
 nova/api/ec2/__init__.py | 6 ++++++
 1 file changed, 6 insertions(+)

(limited to 'nova')

diff --git a/nova/api/ec2/__init__.py b/nova/api/ec2/__init__.py
index 5adc2c075..5a63dc8da 100644
--- a/nova/api/ec2/__init__.py
+++ b/nova/api/ec2/__init__.py
@@ -198,6 +198,12 @@ class Requestify(wsgi.Middleware):
         try:
             # Raise KeyError if omitted
             action = req.params['Action']
+           # Fix bug lp:720157 for older (version 1) clients
+            version = req.params['SignatureVersion']
+            if int(version) == 1:
+                non_args.remove('SignatureMethod')
+                if 'SignatureMethod' in args:
+                    args.pop('SignatureMethod')
             for non_arg in non_args:
                 # Remove, but raise KeyError if omitted
                 args.pop(non_arg)
-- 
cgit 


From f617fc087367a3d65bd4b826bf735f65fec9d2fd Mon Sep 17 00:00:00 2001
From: Masanori Itoh <itoumsn@nttdata.co.jp>
Date: Thu, 3 Mar 2011 00:28:04 +0900
Subject: Change DescribeKeyPairs response tag from keypairsSet to keySet, and
 fix lp720133.

---
 nova/api/ec2/cloud.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 844ccbe5e..c6309f03c 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -298,7 +298,7 @@ class CloudController(object):
                     'keyFingerprint': key_pair['fingerprint'],
                 })
 
-        return {'keypairsSet': result}
+        return {'keySet': result}
 
     def create_key_pair(self, context, key_name, **kwargs):
         LOG.audit(_("Create key pair %s"), key_name, context=context)
-- 
cgit 


From 6d62f387e39b42821f8a8f6ca560dd47b3bb9c7e Mon Sep 17 00:00:00 2001
From: Josh Kearney <josh@jk0.org>
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')

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 <matt.dietz@rackspace.com>
Date: Wed, 2 Mar 2011 15:46:50 -0600
Subject: merge fixes

---
 nova/compute/api.py          |  4 ++--
 nova/virt/xenapi/vm_utils.py |  4 ++--
 nova/virt/xenapi/vmops.py    | 48 ++++++++++++++++++++------------------------
 3 files changed, 26 insertions(+), 30 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/api.py b/nova/compute/api.py
index 52d30c7f7..fb7ef1aed 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -430,7 +430,7 @@ class API(base.Base):
         migration_ref = self.db.migration_get_by_instance_and_status(context,
                 instance_id, 'finished')
         if not migration_ref:
-            raise exception.Error(_("No finished migrations found for \
+            raise exception.NotFound(_("No finished migrations found for \
                     instance"))
 
         params = {'migration_id': migration_ref['id']}
@@ -444,7 +444,7 @@ class API(base.Base):
         migration_ref = self.db.migration_get_by_instance_and_status(context,
                 instance_id, 'finished')
         if not migration_ref:
-            raise exception.Error(_("No finished migrations found for \
+            raise exception.NotFound(_("No finished migrations found for \
                     instance"))
         instance_ref = self.db.instance_get(context, instance_id)
         params = {'migration_id': migration_ref['id']}
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 67d9051551775df73aed118a3ca307c61d284225 Mon Sep 17 00:00:00 2001
From: Josh Kearney <josh@jk0.org>
Date: Wed, 2 Mar 2011 16:20:54 -0600
Subject: Added IPv6 migrations

---
 .../versions/007_add_ipv6_to_fixed_ips.py          | 90 ++++++++++++++++++++++
 nova/db/sqlalchemy/models.py                       |  3 +
 2 files changed, 93 insertions(+)
 create mode 100644 nova/db/sqlalchemy/migrate_repo/versions/007_add_ipv6_to_fixed_ips.py

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/migrate_repo/versions/007_add_ipv6_to_fixed_ips.py b/nova/db/sqlalchemy/migrate_repo/versions/007_add_ipv6_to_fixed_ips.py
new file mode 100644
index 000000000..427934d53
--- /dev/null
+++ b/nova/db/sqlalchemy/migrate_repo/versions/007_add_ipv6_to_fixed_ips.py
@@ -0,0 +1,90 @@
+# Copyright 2011 OpenStack LLC
+# 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.
+
+from sqlalchemy import *
+from migrate import *
+
+from nova import log as logging
+
+
+meta = MetaData()
+
+
+# Table stub-definitions
+# Just for the ForeignKey and column creation to succeed, these are not the
+# actual definitions of instances or services.
+#
+fixed_ips = Table(
+    "fixed_ips",
+    meta,
+    Column(
+        "id",
+        Integer(),
+        primary_key=True,
+        nullable=False))
+
+#
+# New Tables
+#
+# None
+
+#
+# Tables to alter
+#
+# None
+
+#
+# Columns to add to existing tables
+#
+
+fixed_ips_addressV6 = Column(
+    "addressV6",
+    String(
+        length=255,
+        convert_unicode=False,
+        assert_unicode=None,
+        unicode_error=None,
+        _warn_on_bytestring=False))
+
+
+fixed_ips_netmaskV6 = Column(
+    "netmaskV6",
+    String(
+        length=3,
+        convert_unicode=False,
+        assert_unicode=None,
+        unicode_error=None,
+        _warn_on_bytestring=False))
+
+
+fixed_ips_gatewayV6 = Column(
+    "gatewayV6",
+    String(
+        length=255,
+        convert_unicode=False,
+        assert_unicode=None,
+        unicode_error=None,
+        _warn_on_bytestring=False))
+
+
+def upgrade(migrate_engine):
+    # Upgrade operations go here. Don't create your own engine;
+    # bind migrate_engine to your metadata
+    meta.bind = migrate_engine
+
+    # Add columns to existing tables
+    fixed_ips.create_column(fixed_ips_addressV6)
+    fixed_ips.create_column(fixed_ips_netmaskV6)
+    fixed_ips.create_column(fixed_ips_gatewayV6)
diff --git a/nova/db/sqlalchemy/models.py b/nova/db/sqlalchemy/models.py
index 1882efeba..821fd4a83 100644
--- a/nova/db/sqlalchemy/models.py
+++ b/nova/db/sqlalchemy/models.py
@@ -437,6 +437,9 @@ class FixedIp(BASE, NovaBase):
     allocated = Column(Boolean, default=False)
     leased = Column(Boolean, default=False)
     reserved = Column(Boolean, default=False)
+    addressV6 = Column(String(255))
+    netmaskV6 = Column(String(3))
+    gatewayV6 = Column(String(255))
 
 
 class User(BASE, NovaBase):
-- 
cgit 


From d33866923958b3529a812f4eef7dea4a6591a423 Mon Sep 17 00:00:00 2001
From: Mark Washenberger <mark.washenberger@rackspace.com>
Date: Wed, 2 Mar 2011 17:36:21 -0500
Subject: add support for quotas on file injection

---
 nova/quota.py            | 29 +++++++++++++++++++++++------
 nova/tests/test_quota.py | 10 ++++++++++
 2 files changed, 33 insertions(+), 6 deletions(-)

(limited to 'nova')

diff --git a/nova/quota.py b/nova/quota.py
index 6b52a97fa..14b388794 100644
--- a/nova/quota.py
+++ b/nova/quota.py
@@ -37,15 +37,22 @@ flags.DEFINE_integer('quota_floating_ips', 10,
                      'number of floating ips allowed per project')
 flags.DEFINE_integer('quota_metadata_items', 128,
                      'number of metadata items allowed per instance')
+flags.DEFINE_integer('quota_file_injection_max_files', 5,
+                     'number of files allowed during file injection')
+flags.DEFINE_integer('quota_file_injection_max_file_bytes', 10 * 1024,
+                     'number of bytes allowed per file during file injection')
 
 
 def get_quota(context, project_id):
-    rval = {'instances': FLAGS.quota_instances,
-            'cores': FLAGS.quota_cores,
-            'volumes': FLAGS.quota_volumes,
-            'gigabytes': FLAGS.quota_gigabytes,
-            'floating_ips': FLAGS.quota_floating_ips,
-            'metadata_items': FLAGS.quota_metadata_items}
+    rval = {
+        'instances': FLAGS.quota_instances,
+        'cores': FLAGS.quota_cores,
+        'volumes': FLAGS.quota_volumes,
+        'gigabytes': FLAGS.quota_gigabytes,
+        'floating_ips': FLAGS.quota_floating_ips,
+        'metadata_items': FLAGS.quota_metadata_items,
+        }
+
     try:
         quota = db.quota_get(context, project_id)
         for key in rval.keys():
@@ -106,6 +113,16 @@ def allowed_metadata_items(context, num_metadata_items):
     return min(num_metadata_items, num_allowed_metadata_items)
 
 
+def allowed_file_injection_files(context):
+    """Return the number of files allowed per file injection"""
+    return FLAGS.quota_file_injection_max_files
+
+
+def allowed_file_injection_file_bytes(context):
+    """Return the number of bytes allowed per file during injection"""
+    return FLAGS.quota_file_injection_max_file_bytes
+
+
 class QuotaError(exception.ApiError):
     """Quota Exceeeded"""
     pass
diff --git a/nova/tests/test_quota.py b/nova/tests/test_quota.py
index 1e42fddf3..48e5a5538 100644
--- a/nova/tests/test_quota.py
+++ b/nova/tests/test_quota.py
@@ -176,3 +176,13 @@ class QuotaTestCase(test.TestCase):
                                             instance_type='m1.small',
                                             image_id='fake',
                                             metadata=metadata)
+
+    def test_allowed_file_injection_files(self):
+        self.assertEqual(
+                quota.allowed_file_injection_files(self.context),
+                FLAGS.quota_file_injection_max_files)
+
+    def test_allowed_file_injection_file_bytes(self):
+        self.assertEqual(
+                quota.allowed_file_injection_file_bytes(self.context),
+                FLAGS.quota_file_injection_max_file_bytes)
-- 
cgit 


From e34e9dd982870915f8c4dbf84a08bece42b0c592 Mon Sep 17 00:00:00 2001
From: Josh Kearney <josh@jk0.org>
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')

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 077a77a1ab6fbec468b36e2975c1e185235c17ff Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Wed, 2 Mar 2011 15:49:51 -0800
Subject: removed create and delete method (and corresponding tests) from
 flavors.py

---
 nova/api/openstack/flavors.py            | 20 --------------------
 nova/tests/api/openstack/test_flavors.py | 14 ++------------
 2 files changed, 2 insertions(+), 32 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/flavors.py b/nova/api/openstack/flavors.py
index 375e12b18..4db812c2d 100644
--- a/nova/api/openstack/flavors.py
+++ b/nova/api/openstack/flavors.py
@@ -56,26 +56,6 @@ class Controller(wsgi.Controller):
         return dict(flavor=values)
         raise faults.Fault(exc.HTTPNotFound())
 
-    def create(self, req):
-        """Create a flavor."""
-        #TODO(jk0): Finish this later
-        #instance_types.create(
-        #    name,
-        #    memory,
-        #    vcpus,
-        #    local_gb,
-        #    flavor_id,
-        #    swap,
-        #    rxtx_quota,
-        #    rxtx_cap)
-        return "CREATE! %s" % req
-
-    def delete(self, req, id):
-        """Delete a flavor."""
-        #TODO(jk0): Finish this later
-        #instance_type.destroy(name)
-        return "DELETE! %s %s" % (req, id)
-
     def _all_ids(self):
         """Return the list of all flavorids."""
         # FIXME(kpepple) do we really need admin context here ?
diff --git a/nova/tests/api/openstack/test_flavors.py b/nova/tests/api/openstack/test_flavors.py
index 2626f92ba..319767bb5 100644
--- a/nova/tests/api/openstack/test_flavors.py
+++ b/nova/tests/api/openstack/test_flavors.py
@@ -46,17 +46,7 @@ class FlavorsTest(test.TestCase):
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 200)
 
-    def test_create_flavor(self):
-        req = webob.Request.blank("/v1.0/flavors")
-        req.method = "POST"
-        res = req.get_response(fakes.wsgi_app())
-        self.assertEqual(res.status_int, 200)
-
-    def test_delete_flavor(self):
-        req = webob.Request.blank("/v1.0/flavors/1")
-        req.method = "DELETE"
+    def test_get_flavor_by_id(self):
+        req = webob.Request.blank('/v1.0/flavors/1')
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 200)
-
-    def test_get_flavor_by_id(self):
-        pass
-- 
cgit 


From 4243e8e2b41f1438023b1184b1281474b27b5467 Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Wed, 2 Mar 2011 16:09:27 -0800
Subject: coding style change per devcamcar review

---
 nova/compute/instance_types.py | 11 ++---------
 1 file changed, 2 insertions(+), 9 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/instance_types.py b/nova/compute/instance_types.py
index 7d401fc86..20cf1faee 100644
--- a/nova/compute/instance_types.py
+++ b/nova/compute/instance_types.py
@@ -30,15 +30,8 @@ from nova import exception
 FLAGS = flags.FLAGS
 
 
-def create(
-        name,
-        memory,
-        vcpus,
-        local_gb,
-        flavorid,
-        swap=0,
-        rxtx_quota=0,
-        rxtx_cap=0):
+def create(name, memory, vcpus, local_gb, flavorid, swap=0,
+           rxtx_quota=0,rxtx_cap=0):
     """Creates instance types / flavors
        arguments: name memory vcpus local_gb flavorid swap rxtx_quota rxtx_cap
     """
-- 
cgit 


From 0bf74ef365688476b2b3a44e353c0062989d33b5 Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Wed, 2 Mar 2011 16:12:22 -0800
Subject: fixed _context typo

---
 nova/api/ec2/admin.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/api/ec2/admin.py b/nova/api/ec2/admin.py
index 51a06bb26..d9a4ef999 100644
--- a/nova/api/ec2/admin.py
+++ b/nova/api/ec2/admin.py
@@ -114,9 +114,9 @@ class AdminController(object):
     def __str__(self):
         return 'AdminController'
 
-    def describe_instance_types(self, _context, **_kwargs):
+    def describe_instance_types(self, context, **_kwargs):
         """Returns all active instance types data (vcpus, memory, etc.)"""
-        return {'instanceTypeSet': [db.instance_type_get_all(_context)]}
+        return {'instanceTypeSet': [db.instance_type_get_all(context)]}
 
     def describe_user(self, _context, name, **_kwargs):
         """Returns user data, including access and secret keys."""
-- 
cgit 


From 22ec4e190ccf9e30a7862e1ee7d90f2a0858c438 Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Wed, 2 Mar 2011 16:12:36 -0800
Subject: pep8

---
 nova/compute/instance_types.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/compute/instance_types.py b/nova/compute/instance_types.py
index 20cf1faee..f360a7ac3 100644
--- a/nova/compute/instance_types.py
+++ b/nova/compute/instance_types.py
@@ -31,7 +31,7 @@ FLAGS = flags.FLAGS
 
 
 def create(name, memory, vcpus, local_gb, flavorid, swap=0,
-           rxtx_quota=0,rxtx_cap=0):
+           rxtx_quota=0, rxtx_cap=0):
     """Creates instance types / flavors
        arguments: name memory vcpus local_gb flavorid swap rxtx_quota rxtx_cap
     """
-- 
cgit 


From 86aed7edae3dd90741d0da704a99460701b8bcc7 Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Wed, 2 Mar 2011 16:32:09 -0800
Subject: added in req.environ for context

---
 nova/api/openstack/flavors.py | 16 +++++-----------
 1 file changed, 5 insertions(+), 11 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/flavors.py b/nova/api/openstack/flavors.py
index 4db812c2d..f3d040ba3 100644
--- a/nova/api/openstack/flavors.py
+++ b/nova/api/openstack/flavors.py
@@ -41,25 +41,19 @@ class Controller(wsgi.Controller):
 
     def detail(self, req):
         """Return all flavors in detail."""
-        items = [self.show(req, id)['flavor'] for id in self._all_ids()]
+        items = [self.show(req, id)['flavor'] for id in self._all_ids(req)]
         return dict(flavors=items)
 
     def show(self, req, id):
         """Return data about the given flavor id."""
-        # FIXME(kpepple) do we really need admin context here ?
-        ctxt = context.get_admin_context()
+        ctxt = req.environ['nova.context']
         values = db.instance_type_get_by_flavor_id(ctxt, id)
-        # FIXME(kpepple) refactor db call to return dict
-        # v = val.values()[0]
-        # item = dict(ram=v['memory_mb'], disk=v['local_gb'],
-        #             id=v['flavorid'], name=val.keys()[0])
         return dict(flavor=values)
         raise faults.Fault(exc.HTTPNotFound())
 
-    def _all_ids(self):
+    def _all_ids(self, req):
         """Return the list of all flavorids."""
-        # FIXME(kpepple) do we really need admin context here ?
-        ctxt = context.get_admin_context()
+        ctxt = req.environ['nova.context']
         inst_types = db.instance_type_get_all(ctxt)
         flavor_ids = [inst_types[i]['flavorid'] for i in inst_types.keys()]
-        return flavor_ids
+        return sorted(flavor_ids)
-- 
cgit 


From 28896fcfb474662fe339fa5b05aec33b3896b4fa Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Wed, 2 Mar 2011 16:37:02 -0800
Subject: changed _context

---
 nova/db/sqlalchemy/api.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index f4cd16d9a..919dda118 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -2077,7 +2077,7 @@ def console_get(context, console_id, instance_id=None):
 
 
 @require_admin_context
-def instance_type_create(context, values):
+def instance_type_create(_context, values):
     try:
         instance_type_ref = models.InstanceTypes()
         instance_type_ref.update(values)
-- 
cgit 


From 1abd891f65ea8291dc0c3f2075de80dc92c0d431 Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Wed, 2 Mar 2011 16:46:32 -0800
Subject: corrected error message

---
 nova/compute/instance_types.py | 19 +++++++------------
 1 file changed, 7 insertions(+), 12 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/instance_types.py b/nova/compute/instance_types.py
index f360a7ac3..d31d3c304 100644
--- a/nova/compute/instance_types.py
+++ b/nova/compute/instance_types.py
@@ -58,8 +58,7 @@ def create(name, memory, vcpus, local_gb, flavorid, swap=0,
                     rxtx_quota=rxtx_quota,
                     rxtx_cap=rxtx_cap))
     except exception.DBError:
-        raise exception.ApiError(_("Cannot create instance type: %s"),
-                                 name)
+        raise exception.ApiError(_("Cannot create instance type: %s" % name))
 
 
 def destroy(name):
@@ -71,8 +70,7 @@ def destroy(name):
         try:
             db.instance_type_destroy(context.get_admin_context(), name)
         except exception.NotFound:
-            raise exception.ApiError(_("Unknown instance type: %s"),
-                                     name)
+            raise exception.ApiError(_("Unknown instance type: %s" % name))
 
 
 def purge(name):
@@ -84,8 +82,7 @@ def purge(name):
         try:
             db.instance_type_purge(context.get_admin_context(), name)
         except exception.NotFound:
-            raise exception.ApiError(_("Unknown instance type: %s"),
-                                      name)
+            raise exception.ApiError(_("Unknown instance type: %s" % name))
 
 
 def get_all_types(inactive=0):
@@ -109,8 +106,7 @@ def get_instance_type(name):
         inst_type = db.instance_type_get_by_name(ctxt, name)
         return inst_type
     except exception.DBError:
-        raise exception.ApiError(_("Unknown instance type: %s"),
-                                 name)
+        raise exception.ApiError(_("Unknown instance type: %s" % name))
 
 
 def get_by_type(instance_type):
@@ -123,8 +119,8 @@ def get_by_type(instance_type):
         inst_type = db.instance_type_get_by_name(ctxt, instance_type)
         return inst_type['name']
     except exception.DBError:
-        raise exception.ApiError(_("Unknown instance type: %s"),
-                                 instance_type)
+        raise exception.ApiError(_("Unknown instance type: %s" %\
+                                    instance_type))
 
 
 def get_by_flavor_id(flavor_id):
@@ -136,5 +132,4 @@ def get_by_flavor_id(flavor_id):
         flavor = db.instance_type_get_by_flavor_id(ctxt, flavor_id)
         return flavor['name']
     except exception.DBError:
-        raise exception.ApiError(_("Unknown flavor: %s"),
-                                 flavor_id)
+        raise exception.ApiError(_("Unknown flavor: %s" % flavor_id))
-- 
cgit 


From 45662001c477bdce7cd50b4f7f67e06479c3cbd3 Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Wed, 2 Mar 2011 16:59:38 -0800
Subject: requested style change

---
 nova/compute/instance_types.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/instance_types.py b/nova/compute/instance_types.py
index d31d3c304..09b42f319 100644
--- a/nova/compute/instance_types.py
+++ b/nova/compute/instance_types.py
@@ -48,8 +48,7 @@ def create(name, memory, vcpus, local_gb, flavorid, swap=0,
     try:
         db.instance_type_create(
                 context.get_admin_context(),
-                dict(
-                    name=name,
+                dict(name=name,
                     memory_mb=memory,
                     vcpus=vcpus,
                     local_gb=local_gb,
-- 
cgit 


From 507a13d8dcdc11ea7638c8904d6d0de22d8e109b Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Wed, 2 Mar 2011 17:14:51 -0800
Subject: added logging to instance_types for DB errors per code review

---
 nova/compute/instance_types.py | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/instance_types.py b/nova/compute/instance_types.py
index 09b42f319..79c879e8e 100644
--- a/nova/compute/instance_types.py
+++ b/nova/compute/instance_types.py
@@ -24,10 +24,12 @@ The built-in instance properties.
 
 from nova import context
 from nova import db
-from nova import flags
 from nova import exception
+from nova import flags
+from nova import log as logging
 
 FLAGS = flags.FLAGS
+LOG = logging.getLogger('nova.instance_types')
 
 
 def create(name, memory, vcpus, local_gb, flavorid, swap=0,
@@ -56,7 +58,8 @@ def create(name, memory, vcpus, local_gb, flavorid, swap=0,
                     swap=swap,
                     rxtx_quota=rxtx_quota,
                     rxtx_cap=rxtx_cap))
-    except exception.DBError:
+    except exception.DBError, e:
+        LOG.exception(_('DB error: %s' % e))
         raise exception.ApiError(_("Cannot create instance type: %s" % name))
 
 
@@ -69,6 +72,7 @@ def destroy(name):
         try:
             db.instance_type_destroy(context.get_admin_context(), name)
         except exception.NotFound:
+            LOG.exception(_('Instance type %s not found for deletion' % name))
             raise exception.ApiError(_("Unknown instance type: %s" % name))
 
 
@@ -81,6 +85,7 @@ def purge(name):
         try:
             db.instance_type_purge(context.get_admin_context(), name)
         except exception.NotFound:
+            LOG.exception(_('Instance type %s not found for purge' % name))
             raise exception.ApiError(_("Unknown instance type: %s" % name))
 
 
@@ -117,7 +122,8 @@ def get_by_type(instance_type):
         ctxt = context.get_admin_context()
         inst_type = db.instance_type_get_by_name(ctxt, instance_type)
         return inst_type['name']
-    except exception.DBError:
+    except exception.DBError, e:
+        LOG.exception(_('DB error: %s' % e))
         raise exception.ApiError(_("Unknown instance type: %s" %\
                                     instance_type))
 
@@ -130,5 +136,6 @@ def get_by_flavor_id(flavor_id):
         ctxt = context.get_admin_context()
         flavor = db.instance_type_get_by_flavor_id(ctxt, flavor_id)
         return flavor['name']
-    except exception.DBError:
+    except exception.DBError, e:
+        LOG.exception(_('DB error: %s' % e))
         raise exception.ApiError(_("Unknown flavor: %s" % flavor_id))
-- 
cgit 


From 74f2a7537e9e4b8259a4179adc21eef59e59d3c5 Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Wed, 2 Mar 2011 17:38:42 -0800
Subject: catching bare except:

---
 nova/compute/instance_types.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/compute/instance_types.py b/nova/compute/instance_types.py
index 79c879e8e..fa02a5dfa 100644
--- a/nova/compute/instance_types.py
+++ b/nova/compute/instance_types.py
@@ -40,7 +40,7 @@ def create(name, memory, vcpus, local_gb, flavorid, swap=0,
     for option in [memory, vcpus, local_gb, flavorid]:
         try:
             int(option)
-        except:
+        except ValueError:
             raise exception.InvalidInputException(
                     _("create arguments must be positive integers"))
     if (int(memory) <= 0) or (int(vcpus) <= 0) or (int(local_gb) < 0):
-- 
cgit 


From dc8e308819fb383b317ff866288965a27016557e Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Wed, 2 Mar 2011 17:54:04 -0800
Subject: moved migration to 008 (sigh)

---
 .../versions/007_add_instance_types.py             | 87 ----------------------
 .../versions/008_add_instance_types.py             | 87 ++++++++++++++++++++++
 2 files changed, 87 insertions(+), 87 deletions(-)
 delete mode 100644 nova/db/sqlalchemy/migrate_repo/versions/007_add_instance_types.py
 create mode 100644 nova/db/sqlalchemy/migrate_repo/versions/008_add_instance_types.py

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/migrate_repo/versions/007_add_instance_types.py b/nova/db/sqlalchemy/migrate_repo/versions/007_add_instance_types.py
deleted file mode 100644
index 66609054e..000000000
--- a/nova/db/sqlalchemy/migrate_repo/versions/007_add_instance_types.py
+++ /dev/null
@@ -1,87 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2011 Ken Pepple
-#    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 sqlalchemy import *
-from migrate import *
-
-from nova import api
-from nova import db
-from nova import log as logging
-
-import datetime
-
-meta = MetaData()
-
-
-#
-# New Tables
-#
-instance_types = Table('instance_types', meta,
-        Column('created_at', DateTime(timezone=False)),
-        Column('updated_at', DateTime(timezone=False)),
-        Column('deleted_at', DateTime(timezone=False)),
-        Column('deleted', Boolean(create_constraint=True, name=None)),
-        Column('name',
-               String(length=255, convert_unicode=False, assert_unicode=None,
-                      unicode_error=None, _warn_on_bytestring=False),
-                      unique=True),
-        Column('id', Integer(),  primary_key=True, nullable=False),
-        Column('memory_mb', Integer(),  nullable=False),
-        Column('vcpus', Integer(),  nullable=False),
-        Column('local_gb', Integer(),  nullable=False),
-        Column('flavorid', Integer(),  nullable=False, unique=True),
-        Column('swap', Integer(),  nullable=False, default=0),
-        Column('rxtx_quota', Integer(),  nullable=False, default=0),
-        Column('rxtx_cap', Integer(),  nullable=False, default=0))
-
-
-def upgrade(migrate_engine):
-    # Upgrade operations go here
-    # Don't create your own engine; bind migrate_engine
-    # to your metadata
-    meta.bind = migrate_engine
-    try:
-        instance_types.create()
-    except Exception:
-        logging.info(repr(table))
-        logging.exception('Exception while creating instance_types table')
-        raise
-
-    # Here are the old static instance types
-    INSTANCE_TYPES = {
-    'm1.tiny': dict(memory_mb=512, vcpus=1, local_gb=0, flavorid=1),
-    'm1.small': dict(memory_mb=2048, vcpus=1, local_gb=20, flavorid=2),
-    'm1.medium': dict(memory_mb=4096, vcpus=2, local_gb=40, flavorid=3),
-    'm1.large': dict(memory_mb=8192, vcpus=4, local_gb=80, flavorid=4),
-    'm1.xlarge': dict(memory_mb=16384, vcpus=8, local_gb=160, flavorid=5)}
-    try:
-        i = instance_types.insert()
-        for name, values in INSTANCE_TYPES.iteritems():
-            # FIXME(kpepple) should we be seeding created_at / updated_at ?
-            # now = datetime.datatime.utcnow()
-            i.execute({'name': name, 'memory_mb': values["memory_mb"],
-                        'vcpus': values["vcpus"], 'deleted': 0,
-                        'local_gb': values["local_gb"],
-                        'flavorid': values["flavorid"]})
-    except Exception:
-        logging.info(repr(table))
-        logging.exception('Exception while seeding instance_types table')
-        raise
-
-
-def downgrade(migrate_engine):
-    # Operations to reverse the above upgrade go here.
-    for table in (instance_types):
-        table.drop()
diff --git a/nova/db/sqlalchemy/migrate_repo/versions/008_add_instance_types.py b/nova/db/sqlalchemy/migrate_repo/versions/008_add_instance_types.py
new file mode 100644
index 000000000..66609054e
--- /dev/null
+++ b/nova/db/sqlalchemy/migrate_repo/versions/008_add_instance_types.py
@@ -0,0 +1,87 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 Ken Pepple
+#    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 sqlalchemy import *
+from migrate import *
+
+from nova import api
+from nova import db
+from nova import log as logging
+
+import datetime
+
+meta = MetaData()
+
+
+#
+# New Tables
+#
+instance_types = Table('instance_types', meta,
+        Column('created_at', DateTime(timezone=False)),
+        Column('updated_at', DateTime(timezone=False)),
+        Column('deleted_at', DateTime(timezone=False)),
+        Column('deleted', Boolean(create_constraint=True, name=None)),
+        Column('name',
+               String(length=255, convert_unicode=False, assert_unicode=None,
+                      unicode_error=None, _warn_on_bytestring=False),
+                      unique=True),
+        Column('id', Integer(),  primary_key=True, nullable=False),
+        Column('memory_mb', Integer(),  nullable=False),
+        Column('vcpus', Integer(),  nullable=False),
+        Column('local_gb', Integer(),  nullable=False),
+        Column('flavorid', Integer(),  nullable=False, unique=True),
+        Column('swap', Integer(),  nullable=False, default=0),
+        Column('rxtx_quota', Integer(),  nullable=False, default=0),
+        Column('rxtx_cap', Integer(),  nullable=False, default=0))
+
+
+def upgrade(migrate_engine):
+    # Upgrade operations go here
+    # Don't create your own engine; bind migrate_engine
+    # to your metadata
+    meta.bind = migrate_engine
+    try:
+        instance_types.create()
+    except Exception:
+        logging.info(repr(table))
+        logging.exception('Exception while creating instance_types table')
+        raise
+
+    # Here are the old static instance types
+    INSTANCE_TYPES = {
+    'm1.tiny': dict(memory_mb=512, vcpus=1, local_gb=0, flavorid=1),
+    'm1.small': dict(memory_mb=2048, vcpus=1, local_gb=20, flavorid=2),
+    'm1.medium': dict(memory_mb=4096, vcpus=2, local_gb=40, flavorid=3),
+    'm1.large': dict(memory_mb=8192, vcpus=4, local_gb=80, flavorid=4),
+    'm1.xlarge': dict(memory_mb=16384, vcpus=8, local_gb=160, flavorid=5)}
+    try:
+        i = instance_types.insert()
+        for name, values in INSTANCE_TYPES.iteritems():
+            # FIXME(kpepple) should we be seeding created_at / updated_at ?
+            # now = datetime.datatime.utcnow()
+            i.execute({'name': name, 'memory_mb': values["memory_mb"],
+                        'vcpus': values["vcpus"], 'deleted': 0,
+                        'local_gb': values["local_gb"],
+                        'flavorid': values["flavorid"]})
+    except Exception:
+        logging.info(repr(table))
+        logging.exception('Exception while seeding instance_types table')
+        raise
+
+
+def downgrade(migrate_engine):
+    # Operations to reverse the above upgrade go here.
+    for table in (instance_types):
+        table.drop()
-- 
cgit 


From 668cdc96b3f6fb412b9d1d4a3780744d6b2340b1 Mon Sep 17 00:00:00 2001
From: Mark Washenberger <mark.washenberger@rackspace.com>
Date: Thu, 3 Mar 2011 00:59:09 -0500
Subject: more rigorous testing and error handling for os api personality

---
 nova/api/openstack/servers.py            |  8 ++++++--
 nova/tests/api/openstack/test_servers.py | 25 +++++++++++++++++++++++--
 2 files changed, 29 insertions(+), 4 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 8908bbdca..73c787828 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -149,9 +149,13 @@ class Controller(wsgi.Controller):
         """
         onset_files = []
         for item in personality:
-            path = item['path']
             try:
-                contents = base64.b64decode(item['contents'])
+                path = item['path']
+                contents = item['contents']
+            except TypeError:
+                raise exc.HTTPBadRequest(explanation='Bad personality format')
+            try:
+                contents = base64.b64decode(contents)
             except TypeError:
                 raise exc.HTTPBadRequest(explanation=
                         'Personality content for %s cannot be decoded' % path)
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index dd951e90c..272d34e3a 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -265,6 +265,8 @@ class ServersTest(test.TestCase):
             name='server_test', imageId=2, flavorId=2,
             metadata={},
             personality=personality))
+        if personality is None:
+            del body['server']['personality']
 
         req = webob.Request.blank('/v1.0/servers')
         req.method = 'POST'
@@ -273,7 +275,7 @@ class ServersTest(test.TestCase):
 
     def test_create_instance_with_no_personality(self):
         request, response, onset_files = \
-                self._create_instance_with_personality(personality=[])
+                self._create_instance_with_personality(personality=None)
         self.assertEquals(response.status_int, 200)
         self.assertEquals(onset_files, [])
 
@@ -296,10 +298,11 @@ class ServersTest(test.TestCase):
         self.assertEquals(response.status_int, 400)
         self.assertEquals(onset_files, None)
 
-    def test_create_instance_with_two_personalities(self):
+    def test_create_instance_with_three_personalities(self):
         files = [
             ('/etc/sudoers', 'ALL ALL=NOPASSWD: ALL\n'),
             ('/etc/motd', 'Enjoy your root access!\n'),
+            ('/etc/dovecot.conf', 'dovecot\nconfig\nstuff\n'),
             ]
         personality = []
         for path, content in files:
@@ -310,6 +313,24 @@ class ServersTest(test.TestCase):
         self.assertEquals(response.status_int, 200)
         self.assertEquals(onset_files, files)
 
+    def test_create_instance_personality_empty_content(self):
+        path = '/my/file/path'
+        contents = ''
+        personality = [self._personality_dict(path, contents)]
+        request, response, onset_files = \
+            self._create_instance_with_personality(personality)
+        self.assertEquals(response.status_int, 200)
+        self.assertEquals(onset_files, [(path, contents)]) 
+
+    def test_create_instance_personality_not_a_list(self):
+        path = '/my/file/path'
+        contents = 'myfilecontents'
+        personality = self._personality_dict(path, contents)
+        request, response, onset_files = \
+            self._create_instance_with_personality(personality)
+        self.assertEquals(response.status_int, 400)
+        self.assertEquals(onset_files, None)
+
     def test_update_no_body(self):
         req = webob.Request.blank('/v1.0/servers/1')
         req.method = 'PUT'
-- 
cgit 


From f7645bc2fb46ab7649faf12c794834d94839e4d2 Mon Sep 17 00:00:00 2001
From: Thierry Carrez <thierry@openstack.org>
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')

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 <masumotok@nttdata.co.jp>
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/compute/manager.py      |  53 ++++---
 nova/scheduler/driver.py     |  74 +++++----
 nova/scheduler/manager.py    |  18 +--
 nova/tests/test_scheduler.py |  14 +-
 nova/tests/test_virt.py      | 363 +++++++++----------------------------------
 nova/virt/libvirt_conn.py    |  10 +-
 nova/volume/manager.py       |   4 +-
 7 files changed, 166 insertions(+), 370 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index d085a0b6a..7104daa1e 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -624,11 +624,12 @@ class ComputeManager(manager.Manager):
         return self.driver.compare_cpu(cpu_info)
 
     @exception.wrap_exception
-    def mktmpfile(self, context):
+    def create_shared_storage_test_file(self, context):
         """Makes tmpfile under FLAGS.instance_path.
 
         This method enables compute nodes to recognize that they mounts
-        same shared storage. mktmpfile()/confirm_tmpfile is a pair.
+        same shared storage. (create|check|creanup)_shared_storage_test_file()
+        is a pair.
 
         :param context: security context
         :returns: tmpfile name(basename)
@@ -636,26 +637,36 @@ class ComputeManager(manager.Manager):
         """
 
         dirpath = FLAGS.instances_path
-        fd, name = tempfile.mkstemp(dir=dirpath)
+        fd, tmp_file = tempfile.mkstemp(dir=dirpath)
         LOG.debug(_("Creating tmpfile %s to notify to other "
-                    "compute node that they mounts same storage.") % name)
+                    "compute node that they mounts same storage.") % tmp_file)
         os.fdopen(fd, 'w+').close()
-        return os.path.basename(name)
+        return os.path.basename(tmp_file)
 
     @exception.wrap_exception
-    def confirm_tmpfile(self, context, filename):
-        """Confirms existence of the tmpfile given by path.
+    def check_shared_storage_test_file(self, context, filename):
+        """Confirms existence of the tmpfile under FLAGS.instances_path.
 
         :param context: security context
         :param filename: confirm existence of FLAGS.instances_path/thisfile
-        :returns: depends on os.remove()
 
         """
 
-        p = os.path.join(FLAGS.instances_path, filename)
-        if not os.path.exists(p):
-            raise exception.NotFound(_('%s not found') % p)
-        return os.remove(p)
+        tmp_file = os.path.join(FLAGS.instances_path, filename)
+        if not os.path.exists(tmp_file):
+            raise exception.NotFound(_('%s not found') % tmp_file)
+
+    @exception.wrap_exception
+    def cleanup_shared_storage_test_file(self, context, filename):
+        """Removes existence of the tmpfile under FLAGS.instances_path.
+
+        :param context: security context
+        :param filename: remove existence of FLAGS.instances_path/thisfile
+
+        """
+
+        tmp_file = os.path.join(FLAGS.instances_path, filename)
+        os.remove(tmp_file)
 
     @exception.wrap_exception
     def update_available_resource(self, context):
@@ -687,7 +698,7 @@ class ComputeManager(manager.Manager):
             raise exception.NotFound(msg % locals())
 
         # If any volume is mounted, prepare here.
-        if len(instance_ref['volumes']) == 0:
+        if not instance_ref['volumes']:
             LOG.info(_("%s has no volume."), ec2_id)
         else:
             for v in instance_ref['volumes']:
@@ -701,16 +712,16 @@ class ComputeManager(manager.Manager):
         # Retry operation is necessary because continuously request comes,
         # concorrent request occurs to iptables, then it complains.
         max_retry = FLAGS.live_migration_retry_count
-        for i in range(max_retry):
+        for cnt in range(max_retry):
             try:
                 self.network_manager.setup_compute_network(context,
                                                            instance_id)
                 break
-            except exception.ProcessExecutionError, e:
-                if i == max_retry - 1:
+            except exception.ProcessExecutionError:
+                if cnt == max_retry - 1:
                     raise
                 else:
-                    LOG.warn(_("setup_compute_network() failed %(i)d."
+                    LOG.warn(_("setup_compute_network() failed %(cnt)d."
                                "Retry up to %(max_retry)d for %(ec2_id)s.")
                                % locals())
                     time.sleep(1)
@@ -739,7 +750,7 @@ class ComputeManager(manager.Manager):
         try:
             # Checking volume node is working correctly when any volumes
             # are attached to instances.
-            if len(instance_ref['volumes']) != 0:
+            if instance_ref['volumes']:
                 rpc.call(context,
                           FLAGS.volume_topic,
                           {"method": "check_for_export",
@@ -751,7 +762,7 @@ class ComputeManager(manager.Manager):
                      {"method": "pre_live_migration",
                       "args": {'instance_id': instance_id}})
 
-        except Exception, e:
+        except Exception:
             msg = _("Pre live migration for %(i_name)s failed at %(dest)s")
             LOG.error(msg % locals())
             self.recover_live_migration(context, instance_ref)
@@ -843,5 +854,5 @@ class ComputeManager(manager.Manager):
                                  'state': power_state.RUNNING,
                                  'host': host})
 
-        for v in instance_ref['volumes']:
-            self.db.volume_update(ctxt, v['id'], {'status': 'in-use'})
+        for volume in instance_ref['volumes']:
+            self.db.volume_update(ctxt, volume['id'], {'status': 'in-use'})
diff --git a/nova/scheduler/driver.py b/nova/scheduler/driver.py
index 73ce651da..4485ba39f 100644
--- a/nova/scheduler/driver.py
+++ b/nova/scheduler/driver.py
@@ -100,9 +100,9 @@ class Scheduler(object):
                               'migrating')
 
         # Changing volume state
-        for v in instance_ref['volumes']:
+        for volume_ref in instance_ref['volumes']:
             db.volume_update(context,
-                             v['id'],
+                             volume_ref['id'],
                              {'status': 'migrating'})
 
         # Return value is necessary to send request to src
@@ -121,17 +121,16 @@ class Scheduler(object):
         # Checking instance is running.
         if (power_state.RUNNING != instance_ref['state'] or \
            'running' != instance_ref['state_description']):
-            msg = _('Instance(%s) is not running')
             ec2_id = instance_ref['hostname']
-            raise exception.Invalid(msg % ec2_id)
+            raise exception.Invalid(_('Instance(%s) is not running') % ec2_id)
 
         # Checing volume node is running when any volumes are mounted
         # to the instance.
         if len(instance_ref['volumes']) != 0:
             services = db.service_get_all_by_topic(context, 'volume')
             if len(services) < 1 or  not self.service_is_up(services[0]):
-                msg = _('volume node is not alive(time synchronize problem?)')
-                raise exception.Invalid(msg)
+                raise exception.Invalid(_("volume node is not alive"
+                                          "(time synchronize problem?)"))
 
         # Checking src host exists and compute node
         src = instance_ref['host']
@@ -139,8 +138,8 @@ class Scheduler(object):
 
         # Checking src host is alive.
         if not self.service_is_up(services[0]):
-            msg = _('%s is not alive(time synchronize problem?)')
-            raise exception.Invalid(msg % src)
+            raise exception.Invalid(_("%s is not alive(time "
+                                      "synchronize problem?)") % src)
 
     def _live_migration_dest_check(self, context, instance_ref, dest):
         """Live migration check routine (for destination host).
@@ -157,8 +156,8 @@ class Scheduler(object):
 
         # Checking dest host is alive.
         if not self.service_is_up(dservice_ref):
-            msg = _('%s is not alive(time synchronize problem?)')
-            raise exception.Invalid(msg % dest)
+            raise exception.Invalid(_("%s is not alive(time "
+                                      "synchronize problem?)") % dest)
 
         # Checking whether The host where instance is running
         # and dest is not same.
@@ -170,7 +169,9 @@ class Scheduler(object):
                                        % locals())
 
         # Checking dst host still has enough capacities.
-        self.has_enough_resources(context, instance_ref, dest)
+        self.assert_compute_node_has_enough_resources(context,
+                                                      instance_ref,
+                                                      dest)
 
     def _live_migration_common_check(self, context, instance_ref, dest):
         """Live migration common check routine.
@@ -202,18 +203,20 @@ class Scheduler(object):
         oservice_ref = oservice_refs[0]['compute_service'][0]
 
         # Checking hypervisor is same.
-        o = oservice_ref['hypervisor_type']
-        d = dservice_ref['hypervisor_type']
-        if o != d:
+        orig_hypervisor = oservice_ref['hypervisor_type']
+        dest_hypervisor = dservice_ref['hypervisor_type']
+        if orig_hypervisor != dest_hypervisor:
             raise exception.Invalid(_("Different hypervisor type"
-                                      "(%(o)s->%(d)s)')" % locals()))
+                                      "(%(orig_hypervisor)s->"
+                                      "%(dest_hypervisor)s)')" % locals()))
 
         # Checkng hypervisor version.
-        o = oservice_ref['hypervisor_version']
-        d = dservice_ref['hypervisor_version']
-        if o > d:
-            raise exception.Invalid(_('Older hypervisor version(%(o)s->%(d)s)')
-                                    % locals())
+        orig_hypervisor = oservice_ref['hypervisor_version']
+        dest_hypervisor = dservice_ref['hypervisor_version']
+        if orig_hypervisor > dest_hypervisor:
+            raise exception.Invalid(_("Older hypervisor version"
+                                      "(%(orig_hypervisor)s->"
+                                      "%(dest_hypervisor)s)") % locals())
 
         # Checking cpuinfo.
         try:
@@ -222,14 +225,15 @@ class Scheduler(object):
                      {"method": 'compare_cpu',
                       "args": {'cpu_info': oservice_ref['cpu_info']}})
 
-        except rpc.RemoteError, e:
+        except rpc.RemoteError:
             ec2_id = instance_ref['hostname']
             src = instance_ref['host']
             logging.exception(_("host %(dest)s is not compatible with "
                                 "original host %(src)s.") % locals())
             raise
 
-    def has_enough_resources(self, context, instance_ref, dest):
+    def assert_compute_node_has_enough_resources(self, context,
+                                                 instance_ref, dest):
         """Checks if destination host has enough resource for live migration.
 
         Currently, only memory checking has been done.
@@ -276,22 +280,24 @@ class Scheduler(object):
         dst_t = db.queue_get_for(context, FLAGS.compute_topic, dest)
         src_t = db.queue_get_for(context, FLAGS.compute_topic, src)
 
-        # create tmpfile at dest host
         try:
-            filename = rpc.call(context, dst_t, {"method": 'mktmpfile'})
-        except rpc.RemoteError, e:
-            msg = _("Cannot create tmpfile at %s to confirm shared storage.")
-            LOG.error(msg % FLAGS.instances_path)
-            raise
+            # create tmpfile at dest host
+            filename = rpc.call(context, dst_t,
+                                {"method": 'create_shared_storage_test_file'})
 
-        # make sure existence at src host.
-        try:
+            # make sure existence at src host.
             rpc.call(context, src_t,
-                     {"method": 'confirm_tmpfile',
+                     {"method": 'check_shared_storage_test_file',
                       "args": {'filename': filename}})
 
-        except (rpc.RemoteError, exception.NotFound), e:
+        except rpc.RemoteError:
             ipath = FLAGS.instances_path
-            logging.error(_("Cannot comfirm %(ipath)s at %(dest)s is "
-                            "located at same shared storage.") % locals())
+            logging.error(_("Cannot comfirm tmpfile at %(ipath)s is on "
+                            "same shared storage between %(src)s "
+                            "and %(dest)s.") % locals())
             raise
+
+        finally:
+            rpc.call(context, dst_t,
+                     {"method": 'cleanup_shared_storage_test_file',
+                      "args": {'filename': filename}})
diff --git a/nova/scheduler/manager.py b/nova/scheduler/manager.py
index cd5012fd5..a50d3ab20 100644
--- a/nova/scheduler/manager.py
+++ b/nova/scheduler/manager.py
@@ -98,24 +98,24 @@ class SchedulerManager(manager.Manager):
         # Getting usage resource information
         usage = {}
         instance_refs = db.instance_get_all_by_host(context,
-                                                     compute_ref['host'])
-        if 0 == len(instance_refs):
+                                                    compute_ref['host'])
+        if not instance_refs:
             return {'resource': resource, 'usage': usage}
 
         project_ids = [i['project_id'] for i in instance_refs]
         project_ids = list(set(project_ids))
-        for i in project_ids:
+        for project_id in project_ids:
             vcpus = db.instance_get_vcpu_sum_by_host_and_project(context,
                                                                  host,
-                                                                 i)
+                                                                 project_id)
             mem = db.instance_get_memory_sum_by_host_and_project(context,
                                                                  host,
-                                                                 i)
+                                                                 project_id)
             hdd = db.instance_get_disk_sum_by_host_and_project(context,
                                                                host,
-                                                               i)
-            usage[i] = {'vcpus': int(vcpus),
-                        'memory_mb': int(mem),
-                        'local_gb': int(hdd)}
+                                                               project_id)
+            usage[project_id] = {'vcpus': int(vcpus),
+                                 'memory_mb': int(mem),
+                                 'local_gb': int(hdd)}
 
         return {'resource': resource, 'usage': usage}
diff --git a/nova/tests/test_scheduler.py b/nova/tests/test_scheduler.py
index c4e4d148e..62db42b11 100644
--- a/nova/tests/test_scheduler.py
+++ b/nova/tests/test_scheduler.py
@@ -661,7 +661,6 @@ class SimpleDriverTestCase(test.TestCase):
         self.scheduler.live_migration(self.context, FLAGS.compute_topic,
                                       instance_id=instance_id,
                                       dest=i_ref['host'])
-        self.mox.UnsetStubs()
 
         i_ref = db.instance_get(self.context, instance_id)
         self.assertTrue(i_ref['state_description'] == 'migrating')
@@ -824,10 +823,15 @@ class SimpleDriverTestCase(test.TestCase):
         topic = FLAGS.compute_topic
         driver.rpc.call(mox.IgnoreArg(),
             db.queue_get_for(self.context, topic, dest),
-            {"method": 'mktmpfile'}).AndReturn(fpath)
+            {"method": 'create_shared_storage_test_file'}).AndReturn(fpath)
         driver.rpc.call(mox.IgnoreArg(),
             db.queue_get_for(mox.IgnoreArg(), topic, i_ref['host']),
-            {"method": 'confirm_tmpfile', "args": {'filename': fpath}})
+            {"method": 'check_shared_storage_test_file',
+             "args": {'filename': fpath}})
+        driver.rpc.call(mox.IgnoreArg(),
+            db.queue_get_for(mox.IgnoreArg(), topic, dest),
+            {"method": 'cleanup_shared_storage_test_file',
+             "args": {'filename': fpath}})
 
         self.mox.ReplayAll()
         try:
@@ -838,7 +842,6 @@ class SimpleDriverTestCase(test.TestCase):
             c = (e.message.find('does not exist') >= 0)
 
         self.assertTrue(c)
-        self.mox.UnsetStubs()
         db.instance_destroy(self.context, instance_id)
         db.service_destroy(self.context, s_ref['id'])
 
@@ -867,7 +870,6 @@ class SimpleDriverTestCase(test.TestCase):
             c = (e.message.find(_('Different hypervisor type')) >= 0)
 
         self.assertTrue(c)
-        self.mox.UnsetStubs()
         db.instance_destroy(self.context, instance_id)
         db.service_destroy(self.context, s_ref['id'])
         db.service_destroy(self.context, s_ref2['id'])
@@ -898,7 +900,6 @@ class SimpleDriverTestCase(test.TestCase):
             c = (e.message.find(_('Older hypervisor version')) >= 0)
 
         self.assertTrue(c)
-        self.mox.UnsetStubs()
         db.instance_destroy(self.context, instance_id)
         db.service_destroy(self.context, s_ref['id'])
         db.service_destroy(self.context, s_ref2['id'])
@@ -934,7 +935,6 @@ class SimpleDriverTestCase(test.TestCase):
             c = (e.message.find(_("doesn't have compatibility to")) >= 0)
 
         self.assertTrue(c)
-        self.mox.UnsetStubs()
         db.instance_destroy(self.context, instance_id)
         db.service_destroy(self.context, s_ref['id'])
         db.service_destroy(self.context, s_ref2['id'])
diff --git a/nova/tests/test_virt.py b/nova/tests/test_virt.py
index f46b5950e..17b80c294 100644
--- a/nova/tests/test_virt.py
+++ b/nova/tests/test_virt.py
@@ -14,7 +14,6 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-import libvirt
 import mox
 
 from xml.etree.ElementTree import fromstring as xml_to_tree
@@ -60,6 +59,7 @@ class LibvirtConnTestCase(test.TestCase):
                                              admin=True)
         self.project = self.manager.create_project('fake', 'fake', 'fake')
         self.network = utils.import_object(FLAGS.network_manager)
+        self.context = context.get_admin_context()
         FLAGS.instances_path = ''
         self.call_libvirt_dependant_setup = False
 
@@ -73,22 +73,52 @@ class LibvirtConnTestCase(test.TestCase):
                      'bridge':        'br101',
                      'instance_type': 'm1.small'}
 
-    def libvirt_dependant_setup(self):
-        """A setup method of LibvirtConnection dependent test."""
-        # try to connect libvirt. if fail, skip test.
-        self.call_libvirt_dependant_setup = True
-        try:
-            libvirt.openReadOnly('qemu:///system')
-        except libvirt.libvirtError:
-            return
-        return libvirt_conn.get_connection(False)
-
-    def libvirt_dependant_teardown(self):
-        """teardown method of LibvirtConnection dependent test."""
-        if self.call_libvirt_dependant_setup:
-            libvirt_conn.libvirt = None
-            libvirt_conn.libxml2 = None
-            self.call_libvirt_dependant_setup = False
+    def create_fake_libvirt_mock(self, **kwargs):
+        """Defining mocks for LibvirtConnection(libvirt is not used)."""
+
+        # A fake libvirt.virtConnect
+        class FakeLibvirtConnection(object):
+            def getVersion(self):
+                return 12003
+
+            def getType(self):
+                return 'qemu'
+
+            def getCapabilities(self):
+                return 'qemu'
+
+            def listDomainsID(self):
+                return []
+
+            def getCapabilitied(self):
+                return
+
+        # A fake libvirt_conn.IptablesFirewallDriver
+        class FakeIptablesFirewallDriver(object):
+            def __init__(self, **kwargs):
+                pass
+
+        # Creating mocks
+        fake = FakeLibvirtConnection()
+        fakeip = FakeIptablesFirewallDriver
+        # Customizing above fake if necessary
+        for key, val in kwargs.items():
+            fake.__setattr__(key, val)
+
+        # Inevitable mocks for libvirt_conn.LibvirtConnection
+        self.mox.StubOutWithMock(libvirt_conn.utils, 'import_class')
+        libvirt_conn.utils.import_class(mox.IgnoreArg()).AndReturn(fakeip)
+        self.mox.StubOutWithMock(libvirt_conn.LibvirtConnection, '_conn')
+        libvirt_conn.LibvirtConnection._conn = fake
+
+    def create_service(self, **kwargs):
+        service_ref = {'host': kwargs.get('host', 'dummy'),
+                       'binary': 'nova-compute',
+                       'topic': 'compute',
+                       'report_count': 0,
+                       'availability_zone': 'zone'}
+
+        return db.service_create(context.get_admin_context(), service_ref)
 
     def test_xml_and_uri_no_ramdisk_no_kernel(self):
         instance_data = dict(self.test_instance)
@@ -244,306 +274,55 @@ class LibvirtConnTestCase(test.TestCase):
             self.assertEquals(uri, testuri)
         db.instance_destroy(user_context, instance_ref['id'])
 
-    def test_get_vcpu_used(self):
-        """Check if get_local_gb_total returns appropriate disk value."""
-        self.mox.StubOutWithMock(libvirt_conn.LibvirtConnection, '_conn')
-        libvirt_conn.LibvirtConnection._conn.listDomainsID().AndReturn([1, 2])
-        vdmock = self.mox.CreateMock(libvirt.virDomain)
-        self.mox.StubOutWithMock(vdmock, "vcpus")
-        vdmock.vcpus().AndReturn(['', [('dummycpu'), ('dummycpu')]])
-        vdmock.vcpus().AndReturn(['', [('dummycpu'), ('dummycpu')]])
-        arg = mox.IgnoreArg()
-        libvirt_conn.LibvirtConnection._conn.lookupByID(arg).AndReturn(vdmock)
-        libvirt_conn.LibvirtConnection._conn.lookupByID(arg).AndReturn(vdmock)
-
-        self.mox.ReplayAll()
-        conn = libvirt_conn.LibvirtConnection(False)
-        self.assertTrue(conn.get_vcpu_used() == 4)
-
-    def test_get_cpu_info_inappropreate_xml(self):
-        """Raise exception if given xml is inappropriate."""
-        conn = self.libvirt_dependant_setup()
-        if not conn:
-            return
-
-        xml = """<cccccpu>
-                     <arch>x86_64</arch>
-                     <model>Nehalem</model>
-                     <vendor>Intel</vendor>
-                     <topology sockets='2' cores='4' threads='2'/>
-                     <feature name='rdtscp'/>
-                     <feature name='dca'/>
-                     <feature name='xtpr'/>
-                     <feature name='tm2'/>
-                     <feature name='est'/>
-                     <feature name='vmx'/>
-                     <feature name='ds_cpl'/>
-                     <feature name='monitor'/>
-                     <feature name='pbe'/>
-                     <feature name='tm'/>
-                     <feature name='ht'/>
-                     <feature name='ss'/>
-                     <feature name='acpi'/>
-                     <feature name='ds'/>
-                     <feature name='vme'/>
-                 </cccccpu>
-              """
-
-        self.mox.StubOutWithMock(conn._conn, 'getCapabilities')
-        conn._conn.getCapabilities().AndReturn(xml)
-
-        self.mox.ReplayAll()
-        try:
-            conn.get_cpu_info()
-        except exception.Invalid, e:
-            c1 = (0 <= e.message.find('Invalid xml'))
-        self.assertTrue(c1)
-
-    def test_get_cpu_info_inappropreate_xml2(self):
-        """Raise exception if given xml is inappropriate(topology tag)."""
-        conn = self.libvirt_dependant_setup()
-        if not conn:
-            return
-
-        xml = """<cpu>
-                      <arch>x86_64</arch>
-                      <model>Nehalem</model>
-                      <vendor>Intel</vendor><topology cores='4' threads='2'/>
-                      <feature name='rdtscp'/>
-                      <feature name='dca'/>
-                      <feature name='xtpr'/>
-                      <feature name='tm2'/>
-                      <feature name='est'/>
-                      <feature name='vmx'/>
-                      <feature name='ds_cpl'/>
-                      <feature name='monitor'/>
-                      <feature name='pbe'/>
-                      <feature name='tm'/>
-                      <feature name='ht'/>
-                      <feature name='ss'/>
-                      <feature name='acpi'/>
-                      <feature name='ds'/>
-                      <feature name='vme'/>
-                  </cpu>
-              """
-        self.mox.StubOutWithMock(conn._conn, 'getCapabilities')
-        conn._conn.getCapabilities().AndReturn(xml)
-
-        self.mox.ReplayAll()
-        try:
-            conn.get_cpu_info()
-        except exception.Invalid, e:
-            c1 = (0 <= e.message.find('Invalid xml: topology'))
-        self.assertTrue(c1)
-
     def test_update_available_resource_works_correctly(self):
         """Confirm compute_service table is updated successfully."""
-        conn = self.libvirt_dependant_setup()
-        if not conn:
-            return
-
-        host = 'dummy'
-        zone = 'dummyzone'
-        ctxt = context.get_admin_context()
         org_path = FLAGS.instances_path = ''
         FLAGS.instances_path = '.'
 
-        service_ref = db.service_create(ctxt,
-                                        {'host': host,
-                                         'binary': 'nova-compute',
-                                         'topic': 'compute',
-                                         'report_count': 0,
-                                         'availability_zone': zone})
-        conn.update_available_resource(ctxt, host)
+        service_ref = self.create_service(host='dummy')
+        self.create_fake_libvirt_mock()
+        self.mox.StubOutWithMock(libvirt_conn.LibvirtConnection,
+                                 'get_cpu_info')
+        libvirt_conn.LibvirtConnection.get_cpu_info().AndReturn('cpuinfo')
 
-        service_ref = db.service_get(ctxt, service_ref['id'])
-        print service_ref['compute_service']
+        self.mox.ReplayAll()
+        conn = libvirt_conn.LibvirtConnection(False)
+        conn.update_available_resource(self.context, 'dummy')
+        service_ref = db.service_get(self.context, service_ref['id'])
         compute_service = service_ref['compute_service'][0]
+
         c1 = (compute_service['vcpus'] > 0)
         c2 = (compute_service['memory_mb'] > 0)
         c3 = (compute_service['local_gb'] > 0)
-        # vcpu_used is checked at test_get_vcpu_used.
-        c4 = (compute_service['memory_mb_used'] > 0)
-        c5 = (compute_service['local_gb_used'] > 0)
-        c6 = (len(compute_service['hypervisor_type']) > 0)
-        c7 = (compute_service['hypervisor_version'] > 0)
+        c4 = (compute_service['vcpus_used'] == 0)
+        c5 = (compute_service['memory_mb_used'] > 0)
+        c6 = (compute_service['local_gb_used'] > 0)
+        c7 = (len(compute_service['hypervisor_type']) > 0)
+        c8 = (compute_service['hypervisor_version'] > 0)
 
-        self.assertTrue(c1 and c2 and c3 and c4 and c5 and c6 and c7)
+        self.assertTrue(c1 and c2 and c3 and c4 and c5 and c6 and c7 and c8)
 
-        db.service_destroy(ctxt, service_ref['id'])
+        db.service_destroy(self.context, service_ref['id'])
         FLAGS.instances_path = org_path
 
-    def test_update_resource_info_raise_exception(self):
+    def test_update_resource_info_no_compute_record_found(self):
         """Raise exception if no recorde found on services table."""
-        host = 'dummy'
-        org_path = FLAGS.instances_path = ''
-        FLAGS.instances_path = '.'
-        try:
-            conn = libvirt_conn.LibvirtConnection(False)
-            conn.update_available_resource(context.get_admin_context(), host)
-        except exception.Invalid, e:
-            msg = 'Cannot update compute manager specific info'
-            c1 = (0 <= e.message.find(msg))
-        self.assertTrue(c1)
-        FLAGS.instances_path = org_path
-
-    def test_compare_cpu_works_correctly(self):
-        """Calling libvirt.compute_cpu() and works correctly."""
-        conn = self.libvirt_dependant_setup()
-        if not conn:
-            return
-        host = 'dummy'
-        zone = 'dummyzone'
-        ctxt = context.get_admin_context()
         org_path = FLAGS.instances_path = ''
         FLAGS.instances_path = '.'
-
-        service_ref = db.service_create(ctxt,
-                                        {'host': host,
-                                         'binary': 'nova-compute',
-                                         'topic': 'compute',
-                                         'report_count': 0,
-                                         'availability_zone': zone})
-        conn.update_available_resource(ctxt, host)
-        service_ref = db.service_get(ctxt, service_ref['id'])
-        ret = conn.compare_cpu(service_ref['compute_service'][0]['cpu_info'])
-        self.assertTrue(ret == None)
-
-        db.service_destroy(ctxt, service_ref['id'])
-        FLAGS.instances_path = org_path
-
-    def test_compare_cpu_no_compatibility(self):
-        """Libvirt.compare_cpu() return less than 0.(no compatibility)."""
-        conn = self.libvirt_dependant_setup()
-        if not conn:
-            return
-
-        t = {}
-        t['arch'] = 'x86'
-        t['model'] = 'model'
-        t['vendor'] = 'Intel'
-        t['topology'] = {'cores': "2", "threads": "1", "sockets": "4"}
-        t['features'] = ["tm"]
-        cpu_info = utils.dumps(t)
-        self.mox.StubOutWithMock(conn._conn, 'compareCPU')
-        conn._conn.compareCPU(mox.IgnoreArg(), 0).AndReturn(0)
-
-        self.mox.ReplayAll()
-        self.assertRaises(exception.Invalid, conn.compare_cpu, cpu_info)
-
-    def test_ensure_filtering_rules_for_instance_works_correctly(self):
-        """ensure_filtering_rules_for_instance() works successfully."""
-        conn = self.libvirt_dependant_setup()
-        if not conn:
-            return
-
-        instance_ref = models.Instance()
-        instance_ref.__setitem__('id', 1)
-        fwdriver = conn.firewall_driver
-
-        self.mox.StubOutWithMock(fwdriver, 'setup_basic_filtering')
-        fwdriver.setup_basic_filtering(instance_ref)
-        self.mox.StubOutWithMock(fwdriver, 'prepare_instance_filter')
-        fwdriver.prepare_instance_filter(instance_ref)
-        self.mox.StubOutWithMock(libvirt_conn.LibvirtConnection, '_conn')
-        n = 'nova-instance-%s' % instance_ref.name
-        conn._conn.nwfilterLookupByName(n)
-
-        self.mox.ReplayAll()
-        conn.ensure_filtering_rules_for_instance(instance_ref)
-
-    def test_ensure_filtering_rules_for_instance_timeout(self):
-        """ensure_filtering_fules_for_instance() finishes with timeout."""
-        conn = self.libvirt_dependant_setup()
-        if not conn:
-            return
-
-        instance_ref = models.Instance()
-        instance_ref.__setitem__('id', 1)
-        fwdriver = conn.firewall_driver
-
-        self.mox.StubOutWithMock(fwdriver, 'setup_basic_filtering')
-        fwdriver.setup_basic_filtering(instance_ref)
-        self.mox.StubOutWithMock(fwdriver, 'prepare_instance_filter')
-        fwdriver.prepare_instance_filter(instance_ref)
-        self.mox.StubOutWithMock(libvirt_conn.LibvirtConnection, '_conn')
-        n = 'nova-instance-%s' % instance_ref.name
-        for i in range(FLAGS.live_migration_retry_count):
-            conn._conn.nwfilterLookupByName(n).\
-                AndRaise(libvirt.libvirtError('ERR'))
-
-        self.mox.ReplayAll()
-        try:
-            conn.ensure_filtering_rules_for_instance(instance_ref)
-        except exception.Error, e:
-            c1 = (0 <= e.message.find('Timeout migrating for'))
-        self.assertTrue(c1)
-
-    def test_live_migration_works_correctly(self):
-        """_live_migration() works as expected correctly."""
-        conn = self.libvirt_dependant_setup()
-        if not conn:
-            return
-
-        class dummyCall(object):
-            f = None
-
-            def start(self, interval=0, now=False):
-                pass
-
-        i_ref = models.Instance()
-        i_ref.__setitem__('id', 1)
-        ctxt = context.get_admin_context()
-
-        vdmock = self.mox.CreateMock(libvirt.virDomain)
-        self.mox.StubOutWithMock(vdmock, "migrateToURI")
-        vdmock.migrateToURI(FLAGS.live_migration_uri % 'dest',
-                            mox.IgnoreArg(),
-                            None, FLAGS.live_migration_bandwidth).\
-                            AndReturn(None)
-        self.mox.StubOutWithMock(libvirt_conn.LibvirtConnection, '_conn')
-        conn._conn.lookupByName(i_ref.name).AndReturn(vdmock)
-        self.mox.StubOutWithMock(libvirt_conn.utils, 'LoopingCall')
-        libvirt_conn.utils.LoopingCall(f=None).AndReturn(dummyCall())
+        self.create_fake_libvirt_mock()
 
         self.mox.ReplayAll()
-        # Nothing to do with setting post_method/recover_method or not.
-        ret = conn._live_migration(ctxt, i_ref, 'dest', '', '')
-        self.assertTrue(ret == None)
-
-    def test_live_migration_raises_exception(self):
-        """Confirms recover method is called when exceptions are raised."""
-        conn = self.libvirt_dependant_setup()
-        if not conn:
-            return
-
-        i_ref = models.Instance()
-        i_ref.__setitem__('id', 1)
-        ctxt = context.get_admin_context()
-
-        def dummy_recover_method(c, instance, host=None):
-            pass
-
-        vdmock = self.mox.CreateMock(libvirt.virDomain)
-        self.mox.StubOutWithMock(vdmock, "migrateToURI")
-        vdmock.migrateToURI(FLAGS.live_migration_uri % 'dest',
-                            mox.IgnoreArg(),
-                            None, FLAGS.live_migration_bandwidth).\
-                            AndRaise(libvirt.libvirtError('ERR'))
-        self.mox.StubOutWithMock(libvirt_conn.LibvirtConnection, '_conn')
-        conn._conn.lookupByName(i_ref.name).AndReturn(vdmock)
+        conn = libvirt_conn.LibvirtConnection(False)
+        self.assertRaises(exception.Invalid,
+                          conn.update_available_resource,
+                          self.context, 'dummy')
 
-        self.mox.ReplayAll()
-        self.assertRaises(libvirt.libvirtError,
-                          conn._live_migration,
-                          ctxt, i_ref, 'dest',
-                          '', dummy_recover_method)
+        FLAGS.instances_path = org_path
 
     def tearDown(self):
         self.manager.delete_project(self.project)
         self.manager.delete_user(self.user)
         super(LibvirtConnTestCase, self).tearDown()
-        self.libvirt_dependant_teardown()
 
 
 class IptablesFirewallTestCase(test.TestCase):
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
 
diff --git a/nova/volume/manager.py b/nova/volume/manager.py
index 5dc9077b4..9dea35b35 100644
--- a/nova/volume/manager.py
+++ b/nova/volume/manager.py
@@ -175,5 +175,5 @@ class VolumeManager(manager.Manager):
     def check_for_export(self, context, instance_id):
         """Make sure whether volume is exported."""
         instance_ref = self.db.instance_get(context, instance_id)
-        for v in instance_ref['volumes']:
-            self.driver.check_for_export(context, v['id'])
+        for volume in instance_ref['volumes']:
+            self.driver.check_for_export(context, volume['id'])
-- 
cgit 


From 26c217d1f16b100b9dc615388ee315e6daf336ce Mon Sep 17 00:00:00 2001
From: Masanori Itoh <itoumsn@nttdata.co.jp>
Date: Fri, 4 Mar 2011 00:30:19 +0900
Subject: Updated DescribeKeyPairs response tag checked in
 nova/tests/test_cloud.py

---
 nova/tests/test_cloud.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/tests/test_cloud.py b/nova/tests/test_cloud.py
index 061910013..b195fa520 100644
--- a/nova/tests/test_cloud.py
+++ b/nova/tests/test_cloud.py
@@ -267,7 +267,7 @@ class CloudTestCase(test.TestCase):
         self._create_key('test1')
         self._create_key('test2')
         result = self.cloud.describe_key_pairs(self.context)
-        keys = result["keypairsSet"]
+        keys = result["keySet"]
         self.assertTrue(filter(lambda k: k['keyName'] == 'test1', keys))
         self.assertTrue(filter(lambda k: k['keyName'] == 'test2', keys))
 
-- 
cgit 


From 6797c5acc47fb5111ef821d6b074cb635692a9fb Mon Sep 17 00:00:00 2001
From: Monsyne Dragon <mdragon@rackspace.com>
Date: Thu, 3 Mar 2011 15:41:45 +0000
Subject: Add in multi-tenant support in openstack api.

---
 nova/api/openstack/__init__.py            |  25 ++++++
 nova/api/openstack/accounts.py            |  73 ++++++++++++++++
 nova/api/openstack/auth.py                |  54 ++++++++++--
 nova/api/openstack/backup_schedules.py    |   6 +-
 nova/api/openstack/consoles.py            |  10 +--
 nova/api/openstack/flavors.py             |   6 +-
 nova/api/openstack/images.py              |  12 +--
 nova/api/openstack/servers.py             |  38 ++++----
 nova/api/openstack/shared_ip_groups.py    |  12 +--
 nova/api/openstack/users.py               |  93 ++++++++++++++++++++
 nova/api/openstack/zones.py               |  12 +--
 nova/auth/novarc.template                 |   2 +-
 nova/db/sqlalchemy/api.py                 |   3 +
 nova/tests/api/openstack/fakes.py         |  82 +++++++++++++++++-
 nova/tests/api/openstack/test_accounts.py | 123 ++++++++++++++++++++++++++
 nova/tests/api/openstack/test_adminapi.py |   6 +-
 nova/tests/api/openstack/test_auth.py     |  17 ++--
 nova/tests/api/openstack/test_flavors.py  |   4 +-
 nova/tests/api/openstack/test_images.py   |   6 +-
 nova/tests/api/openstack/test_servers.py  |  51 +++++------
 nova/tests/api/openstack/test_users.py    | 139 ++++++++++++++++++++++++++++++
 nova/tests/api/openstack/test_zones.py    |  12 +--
 22 files changed, 684 insertions(+), 102 deletions(-)
 create mode 100644 nova/api/openstack/accounts.py
 create mode 100644 nova/api/openstack/users.py
 create mode 100644 nova/tests/api/openstack/test_accounts.py
 create mode 100644 nova/tests/api/openstack/test_users.py

(limited to 'nova')

diff --git a/nova/api/openstack/__init__.py b/nova/api/openstack/__init__.py
index b1b38ed2d..73d52192e 100644
--- a/nova/api/openstack/__init__.py
+++ b/nova/api/openstack/__init__.py
@@ -27,6 +27,7 @@ import webob.exc
 from nova import flags
 from nova import log as logging
 from nova import wsgi
+from nova.api.openstack import accounts
 from nova.api.openstack import faults
 from nova.api.openstack import backup_schedules
 from nova.api.openstack import consoles
@@ -34,6 +35,7 @@ from nova.api.openstack import flavors
 from nova.api.openstack import images
 from nova.api.openstack import servers
 from nova.api.openstack import shared_ip_groups
+from nova.api.openstack import users
 from nova.api.openstack import zones
 
 
@@ -71,6 +73,18 @@ class APIRouter(wsgi.Router):
     def __init__(self):
         mapper = routes.Mapper()
 
+        accounts_controller = accounts.Controller()
+        mapper.connect("account", "/{id}",
+            controller=accounts_controller, action="show",
+                conditions=dict(method=["GET"]))
+        if FLAGS.allow_admin_api:
+            mapper.connect("/{id}",
+                controller=accounts_controller, action="update",
+                    conditions=dict(method=["PUT"]))
+            mapper.connect("/{id}",
+                controller=accounts_controller, action="delete",
+                    conditions=dict(method=["DELETE"]))
+
         server_members = {'action': 'POST'}
         if FLAGS.allow_admin_api:
             LOG.debug(_("Including admin operations in API."))
@@ -84,27 +98,38 @@ class APIRouter(wsgi.Router):
             server_members['inject_network_info'] = 'POST'
 
             mapper.resource("zone", "zones", controller=zones.Controller(),
+                        path_prefix="{account_id}/",
+                        collection={'detail': 'GET'})
+
+            mapper.resource("user", "users", controller=users.Controller(),
+                        path_prefix="{account_id}/",
                         collection={'detail': 'GET'})
 
         mapper.resource("server", "servers", controller=servers.Controller(),
                         collection={'detail': 'GET'},
+                        path_prefix="{account_id}/",
                         member=server_members)
 
         mapper.resource("backup_schedule", "backup_schedule",
                         controller=backup_schedules.Controller(),
+                        path_prefix="{account_id}/servers/{server_id}/",
                         parent_resource=dict(member_name='server',
                         collection_name='servers'))
 
         mapper.resource("console", "consoles",
                         controller=consoles.Controller(),
+                        path_prefix="{account_id}/servers/{server_id}/",
                         parent_resource=dict(member_name='server',
                         collection_name='servers'))
 
         mapper.resource("image", "images", controller=images.Controller(),
+                        path_prefix="{account_id}/",
                         collection={'detail': 'GET'})
         mapper.resource("flavor", "flavors", controller=flavors.Controller(),
+                        path_prefix="{account_id}/",
                         collection={'detail': 'GET'})
         mapper.resource("shared_ip_group", "shared_ip_groups",
+                        path_prefix="{account_id}/",
                         collection={'detail': 'GET'},
                         controller=shared_ip_groups.Controller())
 
diff --git a/nova/api/openstack/accounts.py b/nova/api/openstack/accounts.py
new file mode 100644
index 000000000..264fdab99
--- /dev/null
+++ b/nova/api/openstack/accounts.py
@@ -0,0 +1,73 @@
+# Copyright 2011 OpenStack LLC.
+# 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.
+
+import common
+
+from nova import exception
+from nova import flags
+from nova import log as logging
+from nova import wsgi
+
+from nova.auth import manager
+
+FLAGS = flags.FLAGS
+LOG = logging.getLogger('nova.api.openstack')
+
+
+def _translate_keys(account):
+    return dict(id=account.id,
+                name=account.name,
+                description=account.description,
+                manager=account.project_manager_id)
+
+
+class Controller(wsgi.Controller):
+
+    _serialization_metadata = {
+        'application/xml': {
+            "attributes": {
+                "account": ["id", "name", "description", "manager"]}}}
+
+    def __init__(self):
+        self.manager = manager.AuthManager()
+
+    def _check_admin(self, context):
+        """ We cannot depend on the db layer to check for admin access
+            for the auth manager, so we do it here """
+        if not context.is_admin:
+            raise exception.NotAuthorized("Not admin user.")
+
+    def show(self, req, id):
+        """Return data about the given account id"""
+        account = self.manager.get_project(id)
+        return dict(account=_translate_keys(account))
+
+    def delete(self, req, id):
+        self._check_admin(req.environ['nova.context'])
+        self.manager.delete_project(id)
+        return {}
+
+    def update(self, req, id):
+        """ This is really create or update. """
+        self._check_admin(req.environ['nova.context'])
+        env = self._deserialize(req.body, req)
+        description = env['account'].get('description')
+        manager = env['account'].get('manager')
+        try:
+            account = self.manager.get_project(id)
+            self.manager.modify_project(id, manager, description)
+        except exception.NotFound:
+            account = self.manager.create_project(id, manager, description)
+        return dict(account=_translate_keys(account))
diff --git a/nova/api/openstack/auth.py b/nova/api/openstack/auth.py
index 6011e6115..e77910fed 100644
--- a/nova/api/openstack/auth.py
+++ b/nova/api/openstack/auth.py
@@ -28,11 +28,13 @@ 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 manager
 from nova import utils
 from nova import wsgi
 from nova.api.openstack import faults
 
+LOG = logging.getLogger('nova.api.openstack')
 FLAGS = flags.FLAGS
 
 
@@ -50,14 +52,27 @@ class AuthMiddleware(wsgi.Middleware):
     def __call__(self, req):
         if not self.has_authentication(req):
             return self.authenticate(req)
-
         user = self.get_user_by_authentication(req)
+        account_name = req.path_info_peek()
 
         if not user:
             return faults.Fault(webob.exc.HTTPUnauthorized())
 
-        project = self.auth.get_project(FLAGS.default_project)
-        req.environ['nova.context'] = context.RequestContext(user, project)
+        if not account_name:
+            if self.auth.is_admin(user):
+                account_name = FLAGS.default_project
+            else:
+                return faults.Fault(webob.exc.HTTPUnauthorized())
+        try:
+            account = self.auth.get_project(account_name)
+        except exception.NotFound:
+            return faults.Fault(webob.exc.HTTPUnauthorized())
+
+        if not self.auth.is_admin(user) and \
+           not self.auth.is_project_member(user, account):
+            return faults.Fault(webob.exc.HTTPUnauthorized())
+
+        req.environ['nova.context'] = context.RequestContext(user, account)
         return self.application
 
     def has_authentication(self, req):
@@ -70,6 +85,7 @@ class AuthMiddleware(wsgi.Middleware):
         # Unless the request is explicitly made against /<version>/ don't
         # honor it
         path_info = req.path_info
+        account_name = None
         if len(path_info) > 1:
             return faults.Fault(webob.exc.HTTPUnauthorized())
 
@@ -79,7 +95,10 @@ class AuthMiddleware(wsgi.Middleware):
         except KeyError:
             return faults.Fault(webob.exc.HTTPUnauthorized())
 
-        token, user = self._authorize_user(username, key, req)
+        if ':' in username:
+            account_name, username = username.rsplit(':', 1)
+
+        token, user = self._authorize_user(username, account_name, key, req)
         if user and token:
             res = webob.Response()
             res.headers['X-Auth-Token'] = token.token_hash
@@ -116,23 +135,44 @@ class AuthMiddleware(wsgi.Middleware):
                 return self.auth.get_user(token.user_id)
         return None
 
-    def _authorize_user(self, username, key, req):
+    def _authorize_user(self, username, account_name, key, req):
         """Generates a new token and assigns it to a user.
 
         username - string
+        account_name - string
         key - string API key
         req - webob.Request object
         """
         ctxt = context.get_admin_context()
         user = self.auth.get_user_from_access_key(key)
+        if account_name:
+            try:
+                account = self.auth.get_project(account_name)
+            except exception.NotFound:
+                return None, None
+        else:
+            # (dragondm) punt and try to determine account.
+            # this is something of a hack, but a user on 1 account is a
+            # common case, and is the way the current RS code works.
+            accounts = self.auth.get_projects(user=user)
+            if len(accounts) == 1:
+                account = accounts[0]
+            else:
+                #we can't tell what account they are logging in for.
+                return None, None
+
         if user and user.name == username:
             token_hash = hashlib.sha1('%s%s%f' % (username, key,
                 time.time())).hexdigest()
             token_dict = {}
             token_dict['token_hash'] = token_hash
             token_dict['cdn_management_url'] = ''
-            # Same as auth url, e.g. http://foo.org:8774/baz/v1.0
-            token_dict['server_management_url'] = req.url
+            # auth url + project (account) id, e.g.
+            # http://foo.org:8774/baz/v1.0/myacct/
+            os_url = '%s%s%s/' % (req.url,
+                                  '' if req.url.endswith('/') else '/',
+                                  account.id)
+            token_dict['server_management_url'] = os_url
             token_dict['storage_url'] = ''
             token_dict['user_id'] = user.id
             token = self.db.auth_token_create(ctxt, token_dict)
diff --git a/nova/api/openstack/backup_schedules.py b/nova/api/openstack/backup_schedules.py
index 7abb5f884..a4d5939df 100644
--- a/nova/api/openstack/backup_schedules.py
+++ b/nova/api/openstack/backup_schedules.py
@@ -40,15 +40,15 @@ class Controller(wsgi.Controller):
     def __init__(self):
         pass
 
-    def index(self, req, server_id):
+    def index(self, req, server_id, **kw):
         """ Returns the list of backup schedules for a given instance """
         return _translate_keys({})
 
-    def create(self, req, server_id):
+    def create(self, req, server_id, **kw):
         """ No actual update method required, since the existing API allows
         both create and update through a POST """
         return faults.Fault(exc.HTTPNotImplemented())
 
-    def delete(self, req, server_id, id):
+    def delete(self, req, server_id, id, **kw):
         """ Deletes an existing backup schedule """
         return faults.Fault(exc.HTTPNotImplemented())
diff --git a/nova/api/openstack/consoles.py b/nova/api/openstack/consoles.py
index 9ebdbe710..85b2a4140 100644
--- a/nova/api/openstack/consoles.py
+++ b/nova/api/openstack/consoles.py
@@ -55,7 +55,7 @@ class Controller(wsgi.Controller):
         self.console_api = console.API()
         super(Controller, self).__init__()
 
-    def index(self, req, server_id):
+    def index(self, req, server_id, **kw):
         """Returns a list of consoles for this instance"""
         consoles = self.console_api.get_consoles(
                                     req.environ['nova.context'],
@@ -63,14 +63,14 @@ class Controller(wsgi.Controller):
         return dict(consoles=[_translate_keys(console)
                               for console in consoles])
 
-    def create(self, req, server_id):
+    def create(self, req, server_id, **kw):
         """Creates a new console"""
         #info = self._deserialize(req.body, req)
         self.console_api.create_console(
                                 req.environ['nova.context'],
                                 int(server_id))
 
-    def show(self, req, server_id, id):
+    def show(self, req, server_id, id, **kw):
         """Shows in-depth information on a specific console"""
         try:
             console = self.console_api.get_console(
@@ -81,11 +81,11 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPNotFound())
         return _translate_detail_keys(console)
 
-    def update(self, req, server_id, id):
+    def update(self, req, server_id, id, **kw):
         """You can't update a console"""
         raise faults.Fault(exc.HTTPNotImplemented())
 
-    def delete(self, req, server_id, id):
+    def delete(self, req, server_id, id, **kw):
         """Deletes a console"""
         try:
             self.console_api.delete_console(req.environ['nova.context'],
diff --git a/nova/api/openstack/flavors.py b/nova/api/openstack/flavors.py
index f620d4107..79c3e1ab3 100644
--- a/nova/api/openstack/flavors.py
+++ b/nova/api/openstack/flavors.py
@@ -32,18 +32,18 @@ class Controller(wsgi.Controller):
             "attributes": {
                 "flavor": ["id", "name", "ram", "disk"]}}}
 
-    def index(self, req):
+    def index(self, req, **kw):
         """Return all flavors in brief."""
         return dict(flavors=[dict(id=flavor['id'], name=flavor['name'])
                              for flavor in self.detail(req)['flavors']])
 
-    def detail(self, req):
+    def detail(self, req, **kw):
         """Return all flavors in detail."""
         items = [self.show(req, id)['flavor'] for id in self._all_ids()]
         items = common.limited(items, req)
         return dict(flavors=items)
 
-    def show(self, req, id):
+    def show(self, req, id, **kw):
         """Return data about the given flavor id."""
         for name, val in instance_types.INSTANCE_TYPES.iteritems():
             if val['flavorid'] == int(id):
diff --git a/nova/api/openstack/images.py b/nova/api/openstack/images.py
index cf85a496f..5bc5b9978 100644
--- a/nova/api/openstack/images.py
+++ b/nova/api/openstack/images.py
@@ -115,14 +115,14 @@ class Controller(wsgi.Controller):
     def __init__(self):
         self._service = utils.import_object(FLAGS.image_service)
 
-    def index(self, req):
+    def index(self, req, **kw):
         """Return all public images in brief"""
         items = self._service.index(req.environ['nova.context'])
         items = common.limited(items, req)
         items = [_filter_keys(item, ('id', 'name')) for item in items]
         return dict(images=items)
 
-    def detail(self, req):
+    def detail(self, req, **kw):
         """Return all public images in detail"""
         try:
             items = self._service.detail(req.environ['nova.context'])
@@ -136,7 +136,7 @@ class Controller(wsgi.Controller):
         items = [_translate_status(item) for item in items]
         return dict(images=items)
 
-    def show(self, req, id):
+    def show(self, req, id, **kw):
         """Return data about the given image id"""
         image_id = common.get_image_id_from_image_hash(self._service,
                     req.environ['nova.context'], id)
@@ -145,11 +145,11 @@ class Controller(wsgi.Controller):
         _convert_image_id_to_hash(image)
         return dict(image=image)
 
-    def delete(self, req, id):
+    def delete(self, req, id, **kw):
         # Only public images are supported for now.
         raise faults.Fault(exc.HTTPNotFound())
 
-    def create(self, req):
+    def create(self, req, **kw):
         context = req.environ['nova.context']
         env = self._deserialize(req.body, req)
         instance_id = env["image"]["serverId"]
@@ -160,7 +160,7 @@ class Controller(wsgi.Controller):
 
         return dict(image=image_meta)
 
-    def update(self, req, id):
+    def update(self, req, id, **kw):
         # Users may not modify public images, and that's all that
         # we support for now.
         raise faults.Fault(exc.HTTPNotFound())
diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 69273ad7b..426de92be 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -105,11 +105,11 @@ class Controller(wsgi.Controller):
         self._image_service = utils.import_object(FLAGS.image_service)
         super(Controller, self).__init__()
 
-    def index(self, req):
+    def index(self, req, **kw):
         """ Returns a list of server names and ids for a given user """
         return self._items(req, entity_maker=_translate_keys)
 
-    def detail(self, req):
+    def detail(self, req, **kw):
         """ Returns a list of server details for a given user """
         return self._items(req, entity_maker=_translate_detail_keys)
 
@@ -123,7 +123,7 @@ class Controller(wsgi.Controller):
         res = [entity_maker(inst)['server'] for inst in limited_list]
         return dict(servers=res)
 
-    def show(self, req, id):
+    def show(self, req, id, **kw):
         """ Returns server details by server id """
         try:
             instance = self.compute_api.get(req.environ['nova.context'], id)
@@ -131,7 +131,7 @@ class Controller(wsgi.Controller):
         except exception.NotFound:
             return faults.Fault(exc.HTTPNotFound())
 
-    def delete(self, req, id):
+    def delete(self, req, id, **kw):
         """ Destroys a server """
         try:
             self.compute_api.delete(req.environ['nova.context'], id)
@@ -139,7 +139,7 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPNotFound())
         return exc.HTTPAccepted()
 
-    def create(self, req):
+    def create(self, req, **kw):
         """ Creates a new server for a given user """
         env = self._deserialize(req.body, req)
         if not env:
@@ -180,7 +180,7 @@ class Controller(wsgi.Controller):
             onset_files=env.get('onset_files', []))
         return _translate_keys(instances[0])
 
-    def update(self, req, id):
+    def update(self, req, id, **kw):
         """ Updates the server name or password """
         inst_dict = self._deserialize(req.body, req)
         if not inst_dict:
@@ -202,7 +202,7 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPNotFound())
         return exc.HTTPNoContent()
 
-    def action(self, req, id):
+    def action(self, req, id, **kw):
         """ Multi-purpose method used to reboot, rebuild, and
         resize a server """
         input_dict = self._deserialize(req.body, req)
@@ -219,7 +219,7 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPUnprocessableEntity())
         return exc.HTTPAccepted()
 
-    def lock(self, req, id):
+    def lock(self, req, id, **kw):
         """
         lock the instance with id
         admin only operation
@@ -234,7 +234,7 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPUnprocessableEntity())
         return exc.HTTPAccepted()
 
-    def unlock(self, req, id):
+    def unlock(self, req, id, **kw):
         """
         unlock the instance with id
         admin only operation
@@ -249,7 +249,7 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPUnprocessableEntity())
         return exc.HTTPAccepted()
 
-    def get_lock(self, req, id):
+    def get_lock(self, req, id, **kw):
         """
         return the boolean state of (instance with id)'s lock
 
@@ -263,7 +263,7 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPUnprocessableEntity())
         return exc.HTTPAccepted()
 
-    def reset_network(self, req, id):
+    def reset_network(self, req, id, **kw):
         """
         Reset networking on an instance (admin only).
 
@@ -277,7 +277,7 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPUnprocessableEntity())
         return exc.HTTPAccepted()
 
-    def inject_network_info(self, req, id):
+    def inject_network_info(self, req, id, **kw):
         """
         Inject network info for an instance (admin only).
 
@@ -291,7 +291,7 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPUnprocessableEntity())
         return exc.HTTPAccepted()
 
-    def pause(self, req, id):
+    def pause(self, req, id, **kw):
         """ Permit Admins to Pause the server. """
         ctxt = req.environ['nova.context']
         try:
@@ -302,7 +302,7 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPUnprocessableEntity())
         return exc.HTTPAccepted()
 
-    def unpause(self, req, id):
+    def unpause(self, req, id, **kw):
         """ Permit Admins to Unpause the server. """
         ctxt = req.environ['nova.context']
         try:
@@ -313,7 +313,7 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPUnprocessableEntity())
         return exc.HTTPAccepted()
 
-    def suspend(self, req, id):
+    def suspend(self, req, id, **kw):
         """permit admins to suspend the server"""
         context = req.environ['nova.context']
         try:
@@ -324,7 +324,7 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPUnprocessableEntity())
         return exc.HTTPAccepted()
 
-    def resume(self, req, id):
+    def resume(self, req, id, **kw):
         """permit admins to resume the server from suspend"""
         context = req.environ['nova.context']
         try:
@@ -335,7 +335,7 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPUnprocessableEntity())
         return exc.HTTPAccepted()
 
-    def get_ajax_console(self, req, id):
+    def get_ajax_console(self, req, id, **kw):
         """ Returns a url to an instance's ajaxterm console. """
         try:
             self.compute_api.get_ajax_console(req.environ['nova.context'],
@@ -344,12 +344,12 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPNotFound())
         return exc.HTTPAccepted()
 
-    def diagnostics(self, req, id):
+    def diagnostics(self, req, id, **kw):
         """Permit Admins to retrieve server diagnostics."""
         ctxt = req.environ["nova.context"]
         return self.compute_api.get_diagnostics(ctxt, id)
 
-    def actions(self, req, id):
+    def actions(self, req, id, **kw):
         """Permit Admins to retrieve server actions."""
         ctxt = req.environ["nova.context"]
         items = self.compute_api.get_actions(ctxt, id)
diff --git a/nova/api/openstack/shared_ip_groups.py b/nova/api/openstack/shared_ip_groups.py
index 5d78f9377..e3c917749 100644
--- a/nova/api/openstack/shared_ip_groups.py
+++ b/nova/api/openstack/shared_ip_groups.py
@@ -40,26 +40,26 @@ class Controller(wsgi.Controller):
             'attributes': {
                 'sharedIpGroup': []}}}
 
-    def index(self, req):
+    def index(self, req, **kw):
         """ Returns a list of Shared IP Groups for the user """
         return dict(sharedIpGroups=[])
 
-    def show(self, req, id):
+    def show(self, req, id, **kw):
         """ Shows in-depth information on a specific Shared IP Group """
         return _translate_keys({})
 
-    def update(self, req, id):
+    def update(self, req, id, **kw):
         """ You can't update a Shared IP Group """
         raise faults.Fault(exc.HTTPNotImplemented())
 
-    def delete(self, req, id):
+    def delete(self, req, id, **kw):
         """ Deletes a Shared IP Group """
         raise faults.Fault(exc.HTTPNotImplemented())
 
-    def detail(self, req):
+    def detail(self, req, **kw):
         """ Returns a complete list of Shared IP Groups """
         return _translate_detail_keys({})
 
-    def create(self, req):
+    def create(self, req, **kw):
         """ Creates a new Shared IP group """
         raise faults.Fault(exc.HTTPNotImplemented())
diff --git a/nova/api/openstack/users.py b/nova/api/openstack/users.py
new file mode 100644
index 000000000..c0b7544f9
--- /dev/null
+++ b/nova/api/openstack/users.py
@@ -0,0 +1,93 @@
+# Copyright 2011 OpenStack LLC.
+# 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.
+
+import common
+
+from nova import exception
+from nova import flags
+from nova import log as logging
+from nova import wsgi
+
+from nova.auth import manager
+
+FLAGS = flags.FLAGS
+LOG = logging.getLogger('nova.api.openstack')
+
+
+def _translate_keys(user):
+    return dict(id=user.id,
+                name=user.name,
+                access=user.access,
+                secret=user.secret,
+                admin=user.admin)
+
+
+class Controller(wsgi.Controller):
+
+    _serialization_metadata = {
+        'application/xml': {
+            "attributes": {
+                "user": ["id", "name", "access", "secret", "admin"]}}}
+
+    def __init__(self):
+        self.manager = manager.AuthManager()
+
+    def _check_admin(self, context):
+        """ We cannot depend on the db layer to check for admin access
+            for the auth manager, so we do it here """
+        if not context.is_admin:
+            raise exception.NotAuthorized("Not admin user")
+
+    def index(self, req, **kw):
+        """Return all users in brief"""
+        users = self.manager.get_users()
+        users = common.limited(users, req)
+        users = [_translate_keys(user) for user in users]
+        return dict(users=users)
+
+    def detail(self, req, **kw):
+        """Return all users in detail"""
+        return self.index(req)
+
+    def show(self, req, id, **kw):
+        """Return data about the given user id"""
+        user = self.manager.get_user(id)
+        return dict(user=_translate_keys(user))
+
+    def delete(self, req, id, **kw):
+        self._check_admin(req.environ['nova.context'])
+        self.manager.delete_user(id)
+        return {}
+
+    def create(self, req, **kw):
+        self._check_admin(req.environ['nova.context'])
+        env = self._deserialize(req.body, req)
+        is_admin = env['user'].get('admin') in ('T', 'True', True)
+        name = env['user'].get('name')
+        access = env['user'].get('access')
+        secret = env['user'].get('secret')
+        user = self.manager.create_user(name, access, secret, is_admin)
+        return dict(user=_translate_keys(user))
+
+    def update(self, req, id, **kw):
+        self._check_admin(req.environ['nova.context'])
+        env = self._deserialize(req.body, req)
+        is_admin = env['user'].get('admin')
+        if is_admin is not None:
+            is_admin = is_admin in ('T', 'True', True)
+        access = env['user'].get('access')
+        secret = env['user'].get('secret')
+        self.manager.modify_user(id, access, secret, is_admin)
+        return dict(user=_translate_keys(self.manager.get_user(id)))
diff --git a/nova/api/openstack/zones.py b/nova/api/openstack/zones.py
index d5206da20..30bf2b67b 100644
--- a/nova/api/openstack/zones.py
+++ b/nova/api/openstack/zones.py
@@ -43,35 +43,35 @@ class Controller(wsgi.Controller):
             "attributes": {
                 "zone": ["id", "api_url"]}}}
 
-    def index(self, req):
+    def index(self, req, **kw):
         """Return all zones in brief"""
         items = db.zone_get_all(req.environ['nova.context'])
         items = common.limited(items, req)
         items = [_scrub_zone(item) for item in items]
         return dict(zones=items)
 
-    def detail(self, req):
+    def detail(self, req, **kw):
         """Return all zones in detail"""
         return self.index(req)
 
-    def show(self, req, id):
+    def show(self, req, id, **kw):
         """Return data about the given zone id"""
         zone_id = int(id)
         zone = db.zone_get(req.environ['nova.context'], zone_id)
         return dict(zone=_scrub_zone(zone))
 
-    def delete(self, req, id):
+    def delete(self, req, id, **kw):
         zone_id = int(id)
         db.zone_delete(req.environ['nova.context'], zone_id)
         return {}
 
-    def create(self, req):
+    def create(self, req, **kw):
         context = req.environ['nova.context']
         env = self._deserialize(req.body, req)
         zone = db.zone_create(context, env["zone"])
         return dict(zone=_scrub_zone(zone))
 
-    def update(self, req, id):
+    def update(self, req, id, **kw):
         context = req.environ['nova.context']
         env = self._deserialize(req.body, req)
         zone_id = int(id)
diff --git a/nova/auth/novarc.template b/nova/auth/novarc.template
index cda2ecc28..1c917ad44 100644
--- a/nova/auth/novarc.template
+++ b/nova/auth/novarc.template
@@ -11,5 +11,5 @@ export EUCALYPTUS_CERT=${NOVA_CERT} # euca-bundle-image seems to require this se
 alias ec2-bundle-image="ec2-bundle-image --cert ${EC2_CERT} --privatekey ${EC2_PRIVATE_KEY} --user 42 --ec2cert ${NOVA_CERT}"
 alias ec2-upload-bundle="ec2-upload-bundle -a ${EC2_ACCESS_KEY} -s ${EC2_SECRET_KEY} --url ${S3_URL} --ec2cert ${NOVA_CERT}"
 export NOVA_API_KEY="%(access)s"
-export NOVA_USERNAME="%(user)s"
+export NOVA_USERNAME="%(project)s:%(user)s"
 export NOVA_URL="%(os)s"
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 6df2a8843..e311f310a 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -1861,8 +1861,11 @@ def project_get_by_user(context, user_id):
     session = get_session()
     user = session.query(models.User).\
                    filter_by(deleted=can_read_deleted(context)).\
+                   filter_by(id=user_id).\
                    options(joinedload_all('projects')).\
                    first()
+    if not user:
+        raise exception.NotFound(_('Invalid user_id %s') % user_id)
     return user.projects
 
 
diff --git a/nova/tests/api/openstack/fakes.py b/nova/tests/api/openstack/fakes.py
index 49ce8c1b5..03b26e29a 100644
--- a/nova/tests/api/openstack/fakes.py
+++ b/nova/tests/api/openstack/fakes.py
@@ -26,7 +26,6 @@ from paste import urlmap
 
 from glance import client as glance_client
 
-from nova import auth
 from nova import context
 from nova import exception as exc
 from nova import flags
@@ -35,6 +34,7 @@ import nova.api.openstack.auth
 from nova.api import openstack
 from nova.api.openstack import auth
 from nova.api.openstack import ratelimiting
+from nova.auth.manager import User, Project
 from nova.image import glance
 from nova.image import local
 from nova.image import service
@@ -227,19 +227,97 @@ class FakeAuthDatabase(object):
 
 class FakeAuthManager(object):
     auth_data = {}
+    projects = {}
+
+    @classmethod
+    def clear_fakes(cls):
+        cls.auth_data = {}
+        cls.projects = {}
+
+    @classmethod
+    def reset_fake_data(cls):
+        cls.auth_data = dict(acc1=User('guy1', 'guy1', 'acc1',
+                                       'fortytwo!', False))
+        cls.projects = dict(testacct=Project('testacct',
+                                             'testacct',
+                                             'guy1',
+                                             'test',
+                                              []))
 
     def add_user(self, key, user):
         FakeAuthManager.auth_data[key] = user
 
+    def get_users(self):
+        return FakeAuthManager.auth_data.values()
+
     def get_user(self, uid):
         for k, v in FakeAuthManager.auth_data.iteritems():
             if v.id == uid:
                 return v
         return None
 
-    def get_project(self, pid):
+    def delete_user(self, uid):
+        for k, v in FakeAuthManager.auth_data.items():
+            if v.id == uid:
+                del FakeAuthManager.auth_data[k]
         return None
 
+    def create_user(self, name, access=None, secret=None, admin=False):
+        u = User(name, name, access, secret, admin)
+        FakeAuthManager.auth_data[access] = u
+        return u
+
+    def modify_user(self, user_id, access=None, secret=None, admin=None):
+        user = None
+        for k, v in FakeAuthManager.auth_data.iteritems():
+            if v.id == user_id:
+                user = v
+        if user:
+            user.access = access
+            user.secret = secret
+            if admin is not None:
+                user.admin = admin
+
+    def is_admin(self, user):
+        return user.admin
+
+    def is_project_member(self, user, project):
+        return ((user.id in project.member_ids) or
+                (user.id == project.project_manager_id))
+
+    def create_project(self, name, manager_user, description=None,
+                       member_users=None):
+        member_ids = [User.safe_id(m) for m in member_users] \
+                     if member_users else []
+        p = Project(name, name, User.safe_id(manager_user),
+                                 description, member_ids)
+        FakeAuthManager.projects[name] = p
+        return p
+
+    def delete_project(self, pid):
+        if pid in FakeAuthManager.projects:
+            del FakeAuthManager.projects[pid]
+
+    def modify_project(self, project, manager_user=None, description=None):
+        p = FakeAuthManager.projects.get(project)
+        p.project_manager_id = User.safe_id(manager_user)
+        p.description = description
+
+    def get_project(self, pid):
+        p = FakeAuthManager.projects.get(pid)
+        if p:
+            return p
+        else:
+            raise exc.NotFound
+
+    def get_projects(self, user=None):
+        if not user:
+            return FakeAuthManager.projects.values()
+        else:
+            return [p for p in FakeAuthManager.projects.values()
+                    if (user.id in p.member_ids) or
+                       (user.id == p.project_manager_id)]
+
     def get_user_from_access_key(self, key):
         return FakeAuthManager.auth_data.get(key, None)
 
diff --git a/nova/tests/api/openstack/test_accounts.py b/nova/tests/api/openstack/test_accounts.py
new file mode 100644
index 000000000..b2e89824a
--- /dev/null
+++ b/nova/tests/api/openstack/test_accounts.py
@@ -0,0 +1,123 @@
+# Copyright 2010 OpenStack LLC.
+# 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.
+
+
+import stubout
+import webob
+import json
+
+import nova.api
+import nova.api.openstack.auth
+from nova import context
+from nova import flags
+from nova import test
+from nova.auth.manager import User
+from nova.tests.api.openstack import fakes
+
+
+FLAGS = flags.FLAGS
+FLAGS.verbose = True
+
+
+def fake_init(self):
+    self.manager = fakes.FakeAuthManager()
+
+
+def fake_admin_check(self, req):
+    return True
+
+
+class AccountsTest(test.TestCase):
+    def setUp(self):
+        super(AccountsTest, self).setUp()
+        self.stubs = stubout.StubOutForTesting()
+        self.stubs.Set(nova.api.openstack.accounts.Controller, '__init__',
+                       fake_init)
+        self.stubs.Set(nova.api.openstack.accounts.Controller, '_check_admin',
+                       fake_admin_check)
+        fakes.FakeAuthManager.auth_data = {}
+        fakes.FakeAuthManager.projects = {}
+        fakes.FakeAuthDatabase.data = {}
+        fakes.stub_out_networking(self.stubs)
+        fakes.stub_out_rate_limiting(self.stubs)
+        fakes.stub_out_auth(self.stubs)
+
+        self.allow_admin = FLAGS.allow_admin_api
+        FLAGS.allow_admin_api = True
+        fakemgr = fakes.FakeAuthManager()
+        joeuser = User('guy1', 'guy1', 'acc1', 'fortytwo!', False)
+        superuser = User('guy2', 'guy2', 'acc2', 'swordfish', True)
+        fakemgr.add_user(joeuser.access, joeuser)
+        fakemgr.add_user(superuser.access, superuser)
+        fakemgr.create_project('test1', joeuser)
+        fakemgr.create_project('test2', superuser)
+
+    def tearDown(self):
+        self.stubs.UnsetAll()
+        FLAGS.allow_admin_api = self.allow_admin
+        super(AccountsTest, self).tearDown()
+
+    def test_get_account(self):
+        req = webob.Request.blank('/v1.0/test1')
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+
+        self.assertEqual(res_dict['account']['id'], 'test1')
+        self.assertEqual(res_dict['account']['name'], 'test1')
+        self.assertEqual(res_dict['account']['manager'], 'guy1')
+        self.assertEqual(res.status_int, 200)
+
+    def test_account_delete(self):
+        req = webob.Request.blank('/v1.0/test1')
+        req.method = 'DELETE'
+        res = req.get_response(fakes.wsgi_app())
+        self.assertTrue('test1' not in fakes.FakeAuthManager.projects)
+        self.assertEqual(res.status_int, 200)
+
+    def test_account_create(self):
+        body = dict(account=dict(description='test account',
+                              manager='guy1'))
+        req = webob.Request.blank('/v1.0/newacct')
+        req.method = 'PUT'
+        req.body = json.dumps(body)
+
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+
+        self.assertEqual(res.status_int, 200)
+        self.assertEqual(res_dict['account']['id'], 'newacct')
+        self.assertEqual(res_dict['account']['name'], 'newacct')
+        self.assertEqual(res_dict['account']['description'], 'test account')
+        self.assertEqual(res_dict['account']['manager'], 'guy1')
+        self.assertTrue('newacct' in
+                        fakes.FakeAuthManager.projects)
+        self.assertEqual(len(fakes.FakeAuthManager.projects.values()), 3)
+
+    def test_account_update(self):
+        body = dict(account=dict(description='test account',
+                              manager='guy2'))
+        req = webob.Request.blank('/v1.0/test1')
+        req.method = 'PUT'
+        req.body = json.dumps(body)
+
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+
+        self.assertEqual(res.status_int, 200)
+        self.assertEqual(res_dict['account']['id'], 'test1')
+        self.assertEqual(res_dict['account']['name'], 'test1')
+        self.assertEqual(res_dict['account']['description'], 'test account')
+        self.assertEqual(res_dict['account']['manager'], 'guy2')
+        self.assertEqual(len(fakes.FakeAuthManager.projects.values()), 2)
diff --git a/nova/tests/api/openstack/test_adminapi.py b/nova/tests/api/openstack/test_adminapi.py
index dfce1b127..7cb9e8450 100644
--- a/nova/tests/api/openstack/test_adminapi.py
+++ b/nova/tests/api/openstack/test_adminapi.py
@@ -35,7 +35,7 @@ class AdminAPITest(test.TestCase):
     def setUp(self):
         super(AdminAPITest, self).setUp()
         self.stubs = stubout.StubOutForTesting()
-        fakes.FakeAuthManager.auth_data = {}
+        fakes.FakeAuthManager.reset_fake_data()
         fakes.FakeAuthDatabase.data = {}
         fakes.stub_out_networking(self.stubs)
         fakes.stub_out_rate_limiting(self.stubs)
@@ -50,7 +50,7 @@ class AdminAPITest(test.TestCase):
     def test_admin_enabled(self):
         FLAGS.allow_admin_api = True
         # We should still be able to access public operations.
-        req = webob.Request.blank('/v1.0/flavors')
+        req = webob.Request.blank('/v1.0/testacct/flavors')
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 200)
         # TODO: Confirm admin operations are available.
@@ -58,7 +58,7 @@ class AdminAPITest(test.TestCase):
     def test_admin_disabled(self):
         FLAGS.allow_admin_api = False
         # We should still be able to access public operations.
-        req = webob.Request.blank('/v1.0/flavors')
+        req = webob.Request.blank('/v1.0/testacct/flavors')
         res = req.get_response(fakes.wsgi_app())
         # TODO: Confirm admin operations are unavailable.
         self.assertEqual(res.status_int, 200)
diff --git a/nova/tests/api/openstack/test_auth.py b/nova/tests/api/openstack/test_auth.py
index ff8d42a14..8268a6fb9 100644
--- a/nova/tests/api/openstack/test_auth.py
+++ b/nova/tests/api/openstack/test_auth.py
@@ -51,7 +51,9 @@ class Test(test.TestCase):
 
     def test_authorize_user(self):
         f = fakes.FakeAuthManager()
-        f.add_user('derp', nova.auth.manager.User(1, 'herp', None, None, None))
+        u = nova.auth.manager.User(1, 'herp', None, None, None)
+        f.add_user('derp', u)
+        f.create_project('test', u)
 
         req = webob.Request.blank('/v1.0/')
         req.headers['X-Auth-User'] = 'herp'
@@ -65,7 +67,9 @@ class Test(test.TestCase):
 
     def test_authorize_token(self):
         f = fakes.FakeAuthManager()
-        f.add_user('derp', nova.auth.manager.User(1, 'herp', None, None, None))
+        u = nova.auth.manager.User(1, 'herp', None, None, None)
+        f.add_user('derp', u)
+        f.create_project('test', u)
 
         req = webob.Request.blank('/v1.0/', {'HTTP_HOST': 'foo'})
         req.headers['X-Auth-User'] = 'herp'
@@ -74,7 +78,7 @@ class Test(test.TestCase):
         self.assertEqual(result.status, '204 No Content')
         self.assertEqual(len(result.headers['X-Auth-Token']), 40)
         self.assertEqual(result.headers['X-Server-Management-Url'],
-            "http://foo/v1.0/")
+            "http://foo/v1.0/test/")
         self.assertEqual(result.headers['X-CDN-Management-Url'],
             "")
         self.assertEqual(result.headers['X-Storage-Url'], "")
@@ -82,7 +86,7 @@ class Test(test.TestCase):
         token = result.headers['X-Auth-Token']
         self.stubs.Set(nova.api.openstack, 'APIRouter',
             fakes.FakeRouter)
-        req = webob.Request.blank('/v1.0/fake')
+        req = webob.Request.blank('/v1.0/test/fake')
         req.headers['X-Auth-Token'] = token
         result = req.get_response(fakes.wsgi_app())
         self.assertEqual(result.status, '200 OK')
@@ -176,6 +180,9 @@ class TestLimiter(test.TestCase):
 
     def test_authorize_token(self):
         f = fakes.FakeAuthManager()
+        u = nova.auth.manager.User(1, 'herp', None, None, None)
+        f.add_user('derp', u)
+        f.create_project('test', u)
         f.add_user('derp', nova.auth.manager.User(1, 'herp', None, None, None))
 
         req = webob.Request.blank('/v1.0/')
@@ -187,7 +194,7 @@ class TestLimiter(test.TestCase):
         token = result.headers['X-Auth-Token']
         self.stubs.Set(nova.api.openstack, 'APIRouter',
             fakes.FakeRouter)
-        req = webob.Request.blank('/v1.0/fake')
+        req = webob.Request.blank('/v1.0/test/fake')
         req.method = 'POST'
         req.headers['X-Auth-Token'] = token
         result = req.get_response(fakes.wsgi_app())
diff --git a/nova/tests/api/openstack/test_flavors.py b/nova/tests/api/openstack/test_flavors.py
index 761265965..370dc007c 100644
--- a/nova/tests/api/openstack/test_flavors.py
+++ b/nova/tests/api/openstack/test_flavors.py
@@ -28,7 +28,7 @@ class FlavorsTest(test.TestCase):
     def setUp(self):
         super(FlavorsTest, self).setUp()
         self.stubs = stubout.StubOutForTesting()
-        fakes.FakeAuthManager.auth_data = {}
+        fakes.FakeAuthManager.reset_fake_data()
         fakes.FakeAuthDatabase.data = {}
         fakes.stub_out_networking(self.stubs)
         fakes.stub_out_rate_limiting(self.stubs)
@@ -39,7 +39,7 @@ class FlavorsTest(test.TestCase):
         super(FlavorsTest, self).tearDown()
 
     def test_get_flavor_list(self):
-        req = webob.Request.blank('/v1.0/flavors')
+        req = webob.Request.blank('/v1.0/testacct/flavors')
         res = req.get_response(fakes.wsgi_app())
 
     def test_get_flavor_by_id(self):
diff --git a/nova/tests/api/openstack/test_images.py b/nova/tests/api/openstack/test_images.py
index e232bc3d5..819ca001e 100644
--- a/nova/tests/api/openstack/test_images.py
+++ b/nova/tests/api/openstack/test_images.py
@@ -202,7 +202,7 @@ class ImageControllerWithGlanceServiceTest(test.TestCase):
         self.orig_image_service = FLAGS.image_service
         FLAGS.image_service = 'nova.image.glance.GlanceImageService'
         self.stubs = stubout.StubOutForTesting()
-        fakes.FakeAuthManager.auth_data = {}
+        fakes.FakeAuthManager.reset_fake_data()
         fakes.FakeAuthDatabase.data = {}
         fakes.stub_out_networking(self.stubs)
         fakes.stub_out_rate_limiting(self.stubs)
@@ -216,7 +216,7 @@ class ImageControllerWithGlanceServiceTest(test.TestCase):
         super(ImageControllerWithGlanceServiceTest, self).tearDown()
 
     def test_get_image_index(self):
-        req = webob.Request.blank('/v1.0/images')
+        req = webob.Request.blank('/v1.0/testacct/images')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
 
@@ -228,7 +228,7 @@ class ImageControllerWithGlanceServiceTest(test.TestCase):
                               "image %s not in fixture index!" % str(image))
 
     def test_get_image_details(self):
-        req = webob.Request.blank('/v1.0/images/detail')
+        req = webob.Request.blank('/v1.0/testacct/images/detail')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
 
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 78beb7df9..d592e06b0 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -118,7 +118,7 @@ class ServersTest(test.TestCase):
     def setUp(self):
         super(ServersTest, self).setUp()
         self.stubs = stubout.StubOutForTesting()
-        fakes.FakeAuthManager.auth_data = {}
+        fakes.FakeAuthManager.reset_fake_data()
         fakes.FakeAuthDatabase.data = {}
         fakes.stub_out_networking(self.stubs)
         fakes.stub_out_rate_limiting(self.stubs)
@@ -150,7 +150,7 @@ class ServersTest(test.TestCase):
         super(ServersTest, self).tearDown()
 
     def test_get_server_by_id(self):
-        req = webob.Request.blank('/v1.0/servers/1')
+        req = webob.Request.blank('/v1.0/testacct/servers/1')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
         self.assertEqual(res_dict['server']['id'], '1')
@@ -161,7 +161,7 @@ class ServersTest(test.TestCase):
         public = ["1.2.3.4"]
         new_return_server = return_server_with_addresses(private, public)
         self.stubs.Set(nova.db.api, 'instance_get', new_return_server)
-        req = webob.Request.blank('/v1.0/servers/1')
+        req = webob.Request.blank('/v1.0/testacct/servers/1')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
         self.assertEqual(res_dict['server']['id'], '1')
@@ -173,7 +173,7 @@ class ServersTest(test.TestCase):
         self.assertEqual(addresses["private"][0], private)
 
     def test_get_server_list(self):
-        req = webob.Request.blank('/v1.0/servers')
+        req = webob.Request.blank('/v1.0/testacct/servers')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
 
@@ -224,7 +224,7 @@ class ServersTest(test.TestCase):
             name='server_test', imageId=2, flavorId=2,
             metadata={'hello': 'world', 'open': 'stack'},
             personality={}))
-        req = webob.Request.blank('/v1.0/servers')
+        req = webob.Request.blank('/v1.0/testacct/servers')
         req.method = 'POST'
         req.body = json.dumps(body)
 
@@ -233,7 +233,7 @@ class ServersTest(test.TestCase):
         self.assertEqual(res.status_int, 200)
 
     def test_update_no_body(self):
-        req = webob.Request.blank('/v1.0/servers/1')
+        req = webob.Request.blank('/v1.0/testacct/servers/1')
         req.method = 'PUT'
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 422)
@@ -251,7 +251,7 @@ class ServersTest(test.TestCase):
         self.stubs.Set(nova.db.api, 'instance_update',
             server_update)
 
-        req = webob.Request.blank('/v1.0/servers/1')
+        req = webob.Request.blank('/v1.0/testacct/servers/1')
         req.method = 'PUT'
         req.body = self.body
         req.get_response(fakes.wsgi_app())
@@ -267,30 +267,30 @@ class ServersTest(test.TestCase):
         self.stubs.Set(nova.db.api, 'instance_update',
             server_update)
 
-        req = webob.Request.blank('/v1.0/servers/1')
+        req = webob.Request.blank('/v1.0/testacct/servers/1')
         req.method = 'PUT'
         req.body = self.body
         req.get_response(fakes.wsgi_app())
 
     def test_create_backup_schedules(self):
-        req = webob.Request.blank('/v1.0/servers/1/backup_schedules')
+        req = webob.Request.blank('/v1.0/testacct/servers/1/backup_schedules')
         req.method = 'POST'
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status, '404 Not Found')
 
     def test_delete_backup_schedules(self):
-        req = webob.Request.blank('/v1.0/servers/1/backup_schedules')
+        req = webob.Request.blank('/v1.0/testacct/servers/1/backup_schedules')
         req.method = 'DELETE'
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status, '404 Not Found')
 
     def test_get_server_backup_schedules(self):
-        req = webob.Request.blank('/v1.0/servers/1/backup_schedules')
+        req = webob.Request.blank('/v1.0/testacct/servers/1/backup_schedules')
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status, '404 Not Found')
 
     def test_get_all_server_details(self):
-        req = webob.Request.blank('/v1.0/servers/detail')
+        req = webob.Request.blank('/v1.0/testacct/servers/detail')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
 
@@ -321,7 +321,7 @@ class ServersTest(test.TestCase):
         self.stubs.Set(nova.db.api, 'instance_get_all_by_user',
             return_servers_with_host)
 
-        req = webob.Request.blank('/v1.0/servers/detail')
+        req = webob.Request.blank('/v1.0/testacct/servers/detail')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
 
@@ -341,7 +341,7 @@ class ServersTest(test.TestCase):
         body = dict(server=dict(
             name='server_test', imageId=2, flavorId=2, metadata={},
             personality={}))
-        req = webob.Request.blank('/v1.0/servers/1/pause')
+        req = webob.Request.blank('/v1.0/testacct/servers/1/pause')
         req.method = 'POST'
         req.content_type = 'application/json'
         req.body = json.dumps(body)
@@ -353,7 +353,7 @@ class ServersTest(test.TestCase):
         body = dict(server=dict(
             name='server_test', imageId=2, flavorId=2, metadata={},
             personality={}))
-        req = webob.Request.blank('/v1.0/servers/1/unpause')
+        req = webob.Request.blank('/v1.0/testacct/servers/1/unpause')
         req.method = 'POST'
         req.content_type = 'application/json'
         req.body = json.dumps(body)
@@ -365,7 +365,7 @@ class ServersTest(test.TestCase):
         body = dict(server=dict(
             name='server_test', imageId=2, flavorId=2, metadata={},
             personality={}))
-        req = webob.Request.blank('/v1.0/servers/1/suspend')
+        req = webob.Request.blank('/v1.0/testacct/servers/1/suspend')
         req.method = 'POST'
         req.content_type = 'application/json'
         req.body = json.dumps(body)
@@ -377,7 +377,7 @@ class ServersTest(test.TestCase):
         body = dict(server=dict(
             name='server_test', imageId=2, flavorId=2, metadata={},
             personality={}))
-        req = webob.Request.blank('/v1.0/servers/1/resume')
+        req = webob.Request.blank('/v1.0/testacct/servers/1/resume')
         req.method = 'POST'
         req.content_type = 'application/json'
         req.body = json.dumps(body)
@@ -389,7 +389,7 @@ class ServersTest(test.TestCase):
         body = dict(server=dict(
             name='server_test', imageId=2, flavorId=2, metadata={},
             personality={}))
-        req = webob.Request.blank('/v1.0/servers/1/reset_network')
+        req = webob.Request.blank('/v1.0/testacct/servers/1/reset_network')
         req.method = 'POST'
         req.content_type = 'application/json'
         req.body = json.dumps(body)
@@ -401,7 +401,8 @@ class ServersTest(test.TestCase):
         body = dict(server=dict(
             name='server_test', imageId=2, flavorId=2, metadata={},
             personality={}))
-        req = webob.Request.blank('/v1.0/servers/1/inject_network_info')
+        req = webob.Request.blank(
+              '/v1.0/testacct/servers/1/inject_network_info')
         req.method = 'POST'
         req.content_type = 'application/json'
         req.body = json.dumps(body)
@@ -409,13 +410,13 @@ class ServersTest(test.TestCase):
         self.assertEqual(res.status_int, 202)
 
     def test_server_diagnostics(self):
-        req = webob.Request.blank("/v1.0/servers/1/diagnostics")
+        req = webob.Request.blank("/v1.0/testacct/servers/1/diagnostics")
         req.method = "GET"
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 404)
 
     def test_server_actions(self):
-        req = webob.Request.blank("/v1.0/servers/1/actions")
+        req = webob.Request.blank("/v1.0/testacct/servers/1/actions")
         req.method = "GET"
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 404)
@@ -424,7 +425,7 @@ class ServersTest(test.TestCase):
         body = dict(server=dict(
             name='server_test', imageId=2, flavorId=2, metadata={},
             personality={}))
-        req = webob.Request.blank('/v1.0/servers/1/action')
+        req = webob.Request.blank('/v1.0/testacct/servers/1/action')
         req.method = 'POST'
         req.content_type = 'application/json'
         req.body = json.dumps(body)
@@ -434,7 +435,7 @@ class ServersTest(test.TestCase):
         body = dict(server=dict(
             name='server_test', imageId=2, flavorId=2, metadata={},
             personality={}))
-        req = webob.Request.blank('/v1.0/servers/1/action')
+        req = webob.Request.blank('/v1.0/testacct/servers/1/action')
         req.method = 'POST'
         req.content_type = 'application/json'
         req.body = json.dumps(body)
@@ -444,14 +445,14 @@ class ServersTest(test.TestCase):
         body = dict(server=dict(
             name='server_test', imageId=2, flavorId=2, metadata={},
             personality={}))
-        req = webob.Request.blank('/v1.0/servers/1/action')
+        req = webob.Request.blank('/v1.0/testacct/servers/1/action')
         req.method = 'POST'
         req.content_type = 'application/json'
         req.body = json.dumps(body)
         res = req.get_response(fakes.wsgi_app())
 
     def test_delete_server_instance(self):
-        req = webob.Request.blank('/v1.0/servers/1')
+        req = webob.Request.blank('/v1.0/testacct/servers/1')
         req.method = 'DELETE'
 
         self.server_delete_called = False
diff --git a/nova/tests/api/openstack/test_users.py b/nova/tests/api/openstack/test_users.py
new file mode 100644
index 000000000..bd32254cd
--- /dev/null
+++ b/nova/tests/api/openstack/test_users.py
@@ -0,0 +1,139 @@
+# Copyright 2010 OpenStack LLC.
+# 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.
+
+
+import stubout
+import webob
+import json
+
+import nova.api
+import nova.api.openstack.auth
+from nova import context
+from nova import flags
+from nova import test
+from nova.auth.manager import User, Project
+from nova.tests.api.openstack import fakes
+
+
+FLAGS = flags.FLAGS
+FLAGS.verbose = True
+
+
+def fake_init(self):
+    self.manager = fakes.FakeAuthManager()
+
+
+def fake_admin_check(self, req):
+    return True
+
+
+class UsersTest(test.TestCase):
+    def setUp(self):
+        super(UsersTest, self).setUp()
+        self.stubs = stubout.StubOutForTesting()
+        self.stubs.Set(nova.api.openstack.users.Controller, '__init__',
+                       fake_init)
+        self.stubs.Set(nova.api.openstack.users.Controller, '_check_admin',
+                       fake_admin_check)
+        fakes.FakeAuthManager.auth_data = {}
+        fakes.FakeAuthManager.projects = dict(testacct=Project('testacct',
+                                                               'testacct',
+                                                               'guy1',
+                                                               'test',
+                                                               []))
+        fakes.FakeAuthDatabase.data = {}
+        fakes.stub_out_networking(self.stubs)
+        fakes.stub_out_rate_limiting(self.stubs)
+        fakes.stub_out_auth(self.stubs)
+
+        self.allow_admin = FLAGS.allow_admin_api
+        FLAGS.allow_admin_api = True
+        fakemgr = fakes.FakeAuthManager()
+        fakemgr.add_user('acc1', User('guy1', 'guy1', 'acc1',
+                                      'fortytwo!', False))
+        fakemgr.add_user('acc2', User('guy2', 'guy2', 'acc2',
+                                      'swordfish', True))
+
+    def tearDown(self):
+        self.stubs.UnsetAll()
+        FLAGS.allow_admin_api = self.allow_admin
+        super(UsersTest, self).tearDown()
+
+    def test_get_user_list(self):
+        req = webob.Request.blank('/v1.0/testacct/users')
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+
+        self.assertEqual(res.status_int, 200)
+        self.assertEqual(len(res_dict['users']), 2)
+
+    def test_get_user_by_id(self):
+        req = webob.Request.blank('/v1.0/testacct/users/guy2')
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+
+        self.assertEqual(res_dict['user']['id'], 'guy2')
+        self.assertEqual(res_dict['user']['name'], 'guy2')
+        self.assertEqual(res_dict['user']['secret'], 'swordfish')
+        self.assertEqual(res_dict['user']['admin'], True)
+        self.assertEqual(res.status_int, 200)
+
+    def test_user_delete(self):
+        req = webob.Request.blank('/v1.0/testacct/users/guy1')
+        req.method = 'DELETE'
+        res = req.get_response(fakes.wsgi_app())
+        self.assertTrue('guy1' not in [u.id for u in
+                        fakes.FakeAuthManager.auth_data.values()])
+        self.assertEqual(res.status_int, 200)
+
+    def test_user_create(self):
+        body = dict(user=dict(name='test_guy',
+                              access='acc3',
+                              secret='invasionIsInNormandy',
+                              admin=True))
+        req = webob.Request.blank('/v1.0/testacct/users')
+        req.method = 'POST'
+        req.body = json.dumps(body)
+
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+
+        self.assertEqual(res.status_int, 200)
+        self.assertEqual(res_dict['user']['id'], 'test_guy')
+        self.assertEqual(res_dict['user']['name'], 'test_guy')
+        self.assertEqual(res_dict['user']['access'], 'acc3')
+        self.assertEqual(res_dict['user']['secret'], 'invasionIsInNormandy')
+        self.assertEqual(res_dict['user']['admin'], True)
+        self.assertTrue('test_guy' in [u.id for u in
+                        fakes.FakeAuthManager.auth_data.values()])
+        self.assertEqual(len(fakes.FakeAuthManager.auth_data.values()), 3)
+
+    def test_user_update(self):
+        body = dict(user=dict(name='guy2',
+                              access='acc2',
+                              secret='invasionIsInNormandy'))
+        req = webob.Request.blank('/v1.0/testacct/users/guy2')
+        req.method = 'PUT'
+        req.body = json.dumps(body)
+
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+
+        self.assertEqual(res.status_int, 200)
+        self.assertEqual(res_dict['user']['id'], 'guy2')
+        self.assertEqual(res_dict['user']['name'], 'guy2')
+        self.assertEqual(res_dict['user']['access'], 'acc2')
+        self.assertEqual(res_dict['user']['secret'], 'invasionIsInNormandy')
+        self.assertEqual(res_dict['user']['admin'], True)
diff --git a/nova/tests/api/openstack/test_zones.py b/nova/tests/api/openstack/test_zones.py
index 555b206b9..51f13af48 100644
--- a/nova/tests/api/openstack/test_zones.py
+++ b/nova/tests/api/openstack/test_zones.py
@@ -64,7 +64,7 @@ class ZonesTest(test.TestCase):
     def setUp(self):
         super(ZonesTest, self).setUp()
         self.stubs = stubout.StubOutForTesting()
-        fakes.FakeAuthManager.auth_data = {}
+        fakes.FakeAuthManager.reset_fake_data()
         fakes.FakeAuthDatabase.data = {}
         fakes.stub_out_networking(self.stubs)
         fakes.stub_out_rate_limiting(self.stubs)
@@ -85,7 +85,7 @@ class ZonesTest(test.TestCase):
         super(ZonesTest, self).tearDown()
 
     def test_get_zone_list(self):
-        req = webob.Request.blank('/v1.0/zones')
+        req = webob.Request.blank('/v1.0/testacct/zones')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
 
@@ -93,7 +93,7 @@ class ZonesTest(test.TestCase):
         self.assertEqual(len(res_dict['zones']), 2)
 
     def test_get_zone_by_id(self):
-        req = webob.Request.blank('/v1.0/zones/1')
+        req = webob.Request.blank('/v1.0/testacct/zones/1')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
 
@@ -103,7 +103,7 @@ class ZonesTest(test.TestCase):
         self.assertEqual(res.status_int, 200)
 
     def test_zone_delete(self):
-        req = webob.Request.blank('/v1.0/zones/1')
+        req = webob.Request.blank('/v1.0/testacct/zones/1')
         res = req.get_response(fakes.wsgi_app())
 
         self.assertEqual(res.status_int, 200)
@@ -111,7 +111,7 @@ class ZonesTest(test.TestCase):
     def test_zone_create(self):
         body = dict(zone=dict(api_url='http://blah.zoo', username='fred',
                         password='fubar'))
-        req = webob.Request.blank('/v1.0/zones')
+        req = webob.Request.blank('/v1.0/testacct/zones')
         req.method = 'POST'
         req.body = json.dumps(body)
 
@@ -125,7 +125,7 @@ class ZonesTest(test.TestCase):
 
     def test_zone_update(self):
         body = dict(zone=dict(username='zeb', password='sneaky'))
-        req = webob.Request.blank('/v1.0/zones/1')
+        req = webob.Request.blank('/v1.0/testacct/zones/1')
         req.method = 'PUT'
         req.body = json.dumps(body)
 
-- 
cgit 


From a62e603e8b1cedd89ca0c71f1cdc928d19c68a4d Mon Sep 17 00:00:00 2001
From: Brian Waldon <brian.waldon@rackspace.com>
Date: Thu, 3 Mar 2011 11:04:33 -0500
Subject: adding wsgi.Request class to add custom best_match; adding new class
 to wsgify decorators; replacing all references to webob.Request in non-test
 code to wsgi.Request

---
 nova/api/direct.py                          |  4 ++--
 nova/api/ec2/__init__.py                    | 14 +++++------
 nova/api/ec2/metadatarequesthandler.py      |  2 +-
 nova/api/openstack/__init__.py              |  4 ++--
 nova/api/openstack/auth.py                  |  4 ++--
 nova/api/openstack/common.py                |  2 +-
 nova/api/openstack/faults.py                |  2 +-
 nova/api/openstack/ratelimiting/__init__.py |  4 ++--
 nova/wsgi.py                                | 37 ++++++++++++++++++++++-------
 9 files changed, 47 insertions(+), 26 deletions(-)

(limited to 'nova')

diff --git a/nova/api/direct.py b/nova/api/direct.py
index 208b6d086..cd237f649 100644
--- a/nova/api/direct.py
+++ b/nova/api/direct.py
@@ -187,7 +187,7 @@ class ServiceWrapper(wsgi.Controller):
     def __init__(self, service_handle):
         self.service_handle = service_handle
 
-    @webob.dec.wsgify
+    @webob.dec.wsgify(RequestClass=wsgi.Request)
     def __call__(self, req):
         arg_dict = req.environ['wsgiorg.routing_args'][1]
         action = arg_dict['action']
@@ -218,7 +218,7 @@ class Proxy(object):
         self.prefix = prefix
 
     def __do_request(self, path, context, **kwargs):
-        req = webob.Request.blank(path)
+        req = wsgi.Request.blank(path)
         req.method = 'POST'
         req.body = urllib.urlencode({'json': utils.dumps(kwargs)})
         req.environ['openstack.context'] = context
diff --git a/nova/api/ec2/__init__.py b/nova/api/ec2/__init__.py
index 5adc2c075..58b1ecf03 100644
--- a/nova/api/ec2/__init__.py
+++ b/nova/api/ec2/__init__.py
@@ -53,7 +53,7 @@ flags.DEFINE_list('lockout_memcached_servers', None,
 class RequestLogging(wsgi.Middleware):
     """Access-Log akin logging for all EC2 API requests."""
 
-    @webob.dec.wsgify
+    @webob.dec.wsgify(RequestClass=wsgi.Request)
     def __call__(self, req):
         start = utils.utcnow()
         rv = req.get_response(self.application)
@@ -112,7 +112,7 @@ class Lockout(wsgi.Middleware):
                                   debug=0)
         super(Lockout, self).__init__(application)
 
-    @webob.dec.wsgify
+    @webob.dec.wsgify(RequestClass=wsgi.Request)
     def __call__(self, req):
         access_key = str(req.params['AWSAccessKeyId'])
         failures_key = "authfailures-%s" % access_key
@@ -141,7 +141,7 @@ class Authenticate(wsgi.Middleware):
 
     """Authenticate an EC2 request and add 'ec2.context' to WSGI environ."""
 
-    @webob.dec.wsgify
+    @webob.dec.wsgify(RequestClass=wsgi.Request)
     def __call__(self, req):
         # Read request signature and access id.
         try:
@@ -190,7 +190,7 @@ class Requestify(wsgi.Middleware):
         super(Requestify, self).__init__(app)
         self.controller = utils.import_class(controller)()
 
-    @webob.dec.wsgify
+    @webob.dec.wsgify(RequestClass=wsgi.Request)
     def __call__(self, req):
         non_args = ['Action', 'Signature', 'AWSAccessKeyId', 'SignatureMethod',
                     'SignatureVersion', 'Version', 'Timestamp']
@@ -269,7 +269,7 @@ class Authorizer(wsgi.Middleware):
             },
         }
 
-    @webob.dec.wsgify
+    @webob.dec.wsgify(RequestClass=wsgi.Request)
     def __call__(self, req):
         context = req.environ['ec2.context']
         controller = req.environ['ec2.request'].controller.__class__.__name__
@@ -303,7 +303,7 @@ class Executor(wsgi.Application):
     response, or a 400 upon failure.
     """
 
-    @webob.dec.wsgify
+    @webob.dec.wsgify(RequestClass=wsgi.Request)
     def __call__(self, req):
         context = req.environ['ec2.context']
         api_request = req.environ['ec2.request']
@@ -365,7 +365,7 @@ class Executor(wsgi.Application):
 
 class Versions(wsgi.Application):
 
-    @webob.dec.wsgify
+    @webob.dec.wsgify(RequestClass=wsgi.Request)
     def __call__(self, req):
         """Respond to a request for all EC2 versions."""
         # available api versions
diff --git a/nova/api/ec2/metadatarequesthandler.py b/nova/api/ec2/metadatarequesthandler.py
index 6fb441656..28f99b0ef 100644
--- a/nova/api/ec2/metadatarequesthandler.py
+++ b/nova/api/ec2/metadatarequesthandler.py
@@ -65,7 +65,7 @@ class MetadataRequestHandler(wsgi.Application):
                 data = data[item]
         return data
 
-    @webob.dec.wsgify
+    @webob.dec.wsgify(RequestClass=wsgi.Request)
     def __call__(self, req):
         cc = cloud.CloudController()
         remote_address = req.remote_addr
diff --git a/nova/api/openstack/__init__.py b/nova/api/openstack/__init__.py
index 274330e3b..b5439788d 100644
--- a/nova/api/openstack/__init__.py
+++ b/nova/api/openstack/__init__.py
@@ -47,7 +47,7 @@ flags.DEFINE_bool('allow_admin_api',
 class FaultWrapper(wsgi.Middleware):
     """Calls down the middleware stack, making exceptions into faults."""
 
-    @webob.dec.wsgify
+    @webob.dec.wsgify(RequestClass=wsgi.Request)
     def __call__(self, req):
         try:
             return req.get_response(self.application)
@@ -115,7 +115,7 @@ class APIRouter(wsgi.Router):
 
 
 class Versions(wsgi.Application):
-    @webob.dec.wsgify
+    @webob.dec.wsgify(RequestClass=wsgi.Request)
     def __call__(self, req):
         """Respond to a request for all OpenStack API versions."""
         response = {
diff --git a/nova/api/openstack/auth.py b/nova/api/openstack/auth.py
index 6011e6115..de8905f46 100644
--- a/nova/api/openstack/auth.py
+++ b/nova/api/openstack/auth.py
@@ -46,7 +46,7 @@ class AuthMiddleware(wsgi.Middleware):
         self.auth = auth.manager.AuthManager()
         super(AuthMiddleware, self).__init__(application)
 
-    @webob.dec.wsgify
+    @webob.dec.wsgify(RequestClass=wsgi.Request)
     def __call__(self, req):
         if not self.has_authentication(req):
             return self.authenticate(req)
@@ -121,7 +121,7 @@ class AuthMiddleware(wsgi.Middleware):
 
         username - string
         key - string API key
-        req - webob.Request object
+        req - wsgi.Request object
         """
         ctxt = context.get_admin_context()
         user = self.auth.get_user_from_access_key(key)
diff --git a/nova/api/openstack/common.py b/nova/api/openstack/common.py
index 9f85c5c8a..49b970d75 100644
--- a/nova/api/openstack/common.py
+++ b/nova/api/openstack/common.py
@@ -25,7 +25,7 @@ def limited(items, request, max_limit=1000):
     Return a slice of items according to requested offset and limit.
 
     @param items: A sliceable entity
-    @param request: `webob.Request` possibly containing 'offset' and 'limit'
+    @param request: `wsgi.Request` possibly containing 'offset' and 'limit'
                     GET variables. 'offset' is where to start in the list,
                     and 'limit' is the maximum number of items to return. If
                     'limit' is not specified, 0, or > max_limit, we default
diff --git a/nova/api/openstack/faults.py b/nova/api/openstack/faults.py
index 224a7ef0b..c70b00fa3 100644
--- a/nova/api/openstack/faults.py
+++ b/nova/api/openstack/faults.py
@@ -42,7 +42,7 @@ class Fault(webob.exc.HTTPException):
         """Create a Fault for the given webob.exc.exception."""
         self.wrapped_exc = exception
 
-    @webob.dec.wsgify
+    @webob.dec.wsgify(RequestClass=wsgi.Request)
     def __call__(self, req):
         """Generate a WSGI response based on the exception passed to ctor."""
         # Replace the body with fault details.
diff --git a/nova/api/openstack/ratelimiting/__init__.py b/nova/api/openstack/ratelimiting/__init__.py
index cbb4b897e..88ffc3246 100644
--- a/nova/api/openstack/ratelimiting/__init__.py
+++ b/nova/api/openstack/ratelimiting/__init__.py
@@ -57,7 +57,7 @@ class RateLimitingMiddleware(wsgi.Middleware):
             self.limiter = WSGIAppProxy(service_host)
         super(RateLimitingMiddleware, self).__init__(application)
 
-    @webob.dec.wsgify
+    @webob.dec.wsgify(RequestClass=wsgi.Request)
     def __call__(self, req):
         """Rate limit the request.
 
@@ -183,7 +183,7 @@ class WSGIApp(object):
         """Create the WSGI application using the given Limiter instance."""
         self.limiter = limiter
 
-    @webob.dec.wsgify
+    @webob.dec.wsgify(RequestClass=wsgi.Request)
     def __call__(self, req):
         parts = req.path_info.split('/')
         # format: /limiter/<username>/<urlencoded action>
diff --git a/nova/wsgi.py b/nova/wsgi.py
index 1eb66d067..67216d540 100644
--- a/nova/wsgi.py
+++ b/nova/wsgi.py
@@ -82,6 +82,27 @@ class Server(object):
                              log=WritableLogger(logger))
 
 
+class Request(webob.Request):
+
+    def best_match(self):
+        """
+        Determine the most acceptable content-type based on the
+        query extension then the Accept header
+        """
+
+        parts = self.path.rsplit(".", 1)
+
+        if len(parts) > 1:
+            format = parts[1]
+            if format in ["json", "xml"]:
+                return "application/{0}".format(parts[1])
+
+        ctypes = ["application/json", "application/xml"]
+        bm = self.accept.best_match(ctypes)
+
+        return bm or "application/json"
+
+
 class Application(object):
     """Base WSGI application wrapper. Subclasses need to implement __call__."""
 
@@ -113,7 +134,7 @@ class Application(object):
     def __call__(self, environ, start_response):
         r"""Subclasses will probably want to implement __call__ like this:
 
-        @webob.dec.wsgify
+        @webob.dec.wsgify(RequestClass=Request)
         def __call__(self, req):
           # Any of the following objects work as responses:
 
@@ -199,7 +220,7 @@ class Middleware(Application):
         """Do whatever you'd like to the response."""
         return response
 
-    @webob.dec.wsgify
+    @webob.dec.wsgify(RequestClass=Request)
     def __call__(self, req):
         response = self.process_request(req)
         if response:
@@ -212,7 +233,7 @@ class Debug(Middleware):
     """Helper class that can be inserted into any WSGI application chain
     to get information about the request and response."""
 
-    @webob.dec.wsgify
+    @webob.dec.wsgify(RequestClass=Request)
     def __call__(self, req):
         print ("*" * 40) + " REQUEST ENVIRON"
         for key, value in req.environ.items():
@@ -276,7 +297,7 @@ class Router(object):
         self._router = routes.middleware.RoutesMiddleware(self._dispatch,
                                                           self.map)
 
-    @webob.dec.wsgify
+    @webob.dec.wsgify(RequestClass=Request)
     def __call__(self, req):
         """
         Route the incoming request to a controller based on self.map.
@@ -285,7 +306,7 @@ class Router(object):
         return self._router
 
     @staticmethod
-    @webob.dec.wsgify
+    @webob.dec.wsgify(RequestClass=Request)
     def _dispatch(req):
         """
         Called by self._router after matching the incoming request to a route
@@ -304,11 +325,11 @@ class Controller(object):
     WSGI app that reads routing information supplied by RoutesMiddleware
     and calls the requested action method upon itself.  All action methods
     must, in addition to their normal parameters, accept a 'req' argument
-    which is the incoming webob.Request.  They raise a webob.exc exception,
+    which is the incoming wsgi.Request.  They raise a webob.exc exception,
     or return a dict which will be serialized by requested content type.
     """
 
-    @webob.dec.wsgify
+    @webob.dec.wsgify(RequestClass=Request)
     def __call__(self, req):
         """
         Call the method specified in req.environ by RoutesMiddleware.
@@ -358,7 +379,7 @@ class Serializer(object):
         needed to serialize a dictionary to that type.
         """
         self.metadata = metadata or {}
-        req = webob.Request.blank('', environ)
+        req = wsgi.Request.blank('', environ)
         suffix = req.path_info.split('.')[-1].lower()
         if suffix == 'json':
             self.handler = self._to_json
-- 
cgit 


From 137a4946785b9460aadb9fe40f2b0e18bd7f6063 Mon Sep 17 00:00:00 2001
From: Kei Masumoto <masumotok@nttdata.co.jp>
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/db/api.py                                     | 12 +++++-----
 nova/db/sqlalchemy/api.py                          | 26 +++++++++++-----------
 .../versions/009_add_live_migration.py             |  8 +++----
 nova/db/sqlalchemy/models.py                       | 10 ++++-----
 nova/scheduler/driver.py                           | 10 ++++-----
 nova/scheduler/manager.py                          | 14 ++++++------
 nova/tests/test_scheduler.py                       | 16 ++++++-------
 nova/tests/test_virt.py                            | 22 +++++++++---------
 nova/virt/libvirt_conn.py                          | 10 ++++-----
 9 files changed, 64 insertions(+), 64 deletions(-)

(limited to 'nova')

diff --git a/nova/db/api.py b/nova/db/api.py
index 13bc07ad2..3b427cefe 100644
--- a/nova/db/api.py
+++ b/nova/db/api.py
@@ -153,24 +153,24 @@ def service_update(context, service_id, values):
 ###################
 
 
-def compute_service_get(context, compute_id, session=None):
+def compute_node_get(context, compute_id, session=None):
     """Get an computeService or raise if it does not exist."""
-    return IMPL.compute_service_get(context, compute_id)
+    return IMPL.compute_node_get(context, compute_id)
 
 
-def compute_service_create(context, values):
+def compute_node_create(context, values):
     """Create a computeService from the values dictionary."""
-    return IMPL.compute_service_create(context, values)
+    return IMPL.compute_node_create(context, values)
 
 
-def compute_service_update(context, compute_id, values):
+def compute_node_update(context, compute_id, values):
     """Set the given properties on an computeService and update it.
 
     Raises NotFound if computeService does not exist.
 
     """
 
-    return IMPL.compute_service_update(context, compute_id, values)
+    return IMPL.compute_node_update(context, compute_id, values)
 
 
 ###################
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index bed621b18..69aa07279 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -119,8 +119,8 @@ def service_destroy(context, service_id):
         service_ref.delete(session=session)
 
         if service_ref.topic == 'compute' and \
-            len(service_ref.compute_service) != 0:
-            for c in service_ref.compute_service:
+            len(service_ref.compute_node) != 0:
+            for c in service_ref.compute_node:
                 c.delete(session=session)
 
 
@@ -130,7 +130,7 @@ def service_get(context, service_id, session=None):
         session = get_session()
 
     result = session.query(models.Service).\
-                     options(joinedload('compute_service')).\
+                     options(joinedload('compute_node')).\
                      filter_by(id=service_id).\
                      filter_by(deleted=can_read_deleted(context)).\
                      first()
@@ -174,7 +174,7 @@ def service_get_all_compute_by_host(context, host):
     topic = 'compute'
     session = get_session()
     result = session.query(models.Service).\
-                  options(joinedload('compute_service')).\
+                  options(joinedload('compute_node')).\
                   filter_by(deleted=False).\
                   filter_by(host=host).\
                   filter_by(topic=topic).\
@@ -298,11 +298,11 @@ def service_update(context, service_id, values):
 
 
 @require_admin_context
-def compute_service_get(context, compute_id, session=None):
+def compute_node_get(context, compute_id, session=None):
     if not session:
         session = get_session()
 
-    result = session.query(models.ComputeService).\
+    result = session.query(models.ComputeNode).\
                      filter_by(id=compute_id).\
                      filter_by(deleted=can_read_deleted(context)).\
                      first()
@@ -314,18 +314,18 @@ def compute_service_get(context, compute_id, session=None):
 
 
 @require_admin_context
-def compute_service_create(context, values):
-    compute_service_ref = models.ComputeService()
-    compute_service_ref.update(values)
-    compute_service_ref.save()
-    return compute_service_ref
+def compute_node_create(context, values):
+    compute_node_ref = models.ComputeNode()
+    compute_node_ref.update(values)
+    compute_node_ref.save()
+    return compute_node_ref
 
 
 @require_admin_context
-def compute_service_update(context, compute_id, values):
+def compute_node_update(context, compute_id, values):
     session = get_session()
     with session.begin():
-        compute_ref = compute_service_get(context, compute_id, session=session)
+        compute_ref = compute_node_get(context, compute_id, session=session)
         compute_ref.update(values)
         compute_ref.save(session=session)
 
diff --git a/nova/db/sqlalchemy/migrate_repo/versions/009_add_live_migration.py b/nova/db/sqlalchemy/migrate_repo/versions/009_add_live_migration.py
index 2689b5b74..23ccccb4e 100644
--- a/nova/db/sqlalchemy/migrate_repo/versions/009_add_live_migration.py
+++ b/nova/db/sqlalchemy/migrate_repo/versions/009_add_live_migration.py
@@ -31,7 +31,7 @@ instances = Table('instances', meta,
 # New Tables
 #
 
-compute_services = Table('compute_services', meta,
+compute_nodes = Table('compute_nodes', meta,
         Column('created_at', DateTime(timezone=False)),
         Column('updated_at', DateTime(timezone=False)),
         Column('deleted_at', DateTime(timezone=False)),
@@ -73,11 +73,11 @@ def upgrade(migrate_engine):
     meta.bind = migrate_engine
 
     try:
-        compute_services.create()
+        compute_nodes.create()
     except Exception:
-        logging.info(repr(compute_services))
+        logging.info(repr(compute_nodes))
         logging.exception('Exception while creating table')
-        meta.drop_all(tables=[compute_services])
+        meta.drop_all(tables=[compute_nodes])
         raise
 
     instances.create_column(instances_launched_on)
diff --git a/nova/db/sqlalchemy/models.py b/nova/db/sqlalchemy/models.py
index 2af7377ef..8646190f3 100644
--- a/nova/db/sqlalchemy/models.py
+++ b/nova/db/sqlalchemy/models.py
@@ -113,18 +113,18 @@ class Service(BASE, NovaBase):
     availability_zone = Column(String(255), default='nova')
 
 
-class ComputeService(BASE, NovaBase):
+class ComputeNode(BASE, NovaBase):
     """Represents a running compute service on a host."""
 
-    __tablename__ = 'compute_services'
+    __tablename__ = 'compute_nodes'
     id = Column(Integer, primary_key=True)
     service_id = Column(Integer, ForeignKey('services.id'), nullable=True)
     service = relationship(Service,
-                           backref=backref('compute_service'),
+                           backref=backref('compute_node'),
                            foreign_keys=service_id,
                            primaryjoin='and_('
-                                'ComputeService.service_id == Service.id,'
-                                'ComputeService.deleted == False)')
+                                'ComputeNode.service_id == Service.id,'
+                                'ComputeNode.deleted == False)')
 
     vcpus = Column(Integer, nullable=True)
     memory_mb = Column(Integer, nullable=True)
diff --git a/nova/scheduler/driver.py b/nova/scheduler/driver.py
index 4485ba39f..791f9000d 100644
--- a/nova/scheduler/driver.py
+++ b/nova/scheduler/driver.py
@@ -190,7 +190,7 @@ class Scheduler(object):
 
         # Checking dest exists.
         dservice_refs = db.service_get_all_compute_by_host(context, dest)
-        dservice_ref = dservice_refs[0]['compute_service'][0]
+        dservice_ref = dservice_refs[0]['compute_node'][0]
 
         # Checking original host( where instance was launched at) exists.
         try:
@@ -200,7 +200,7 @@ class Scheduler(object):
             raise exception.Invalid(_("host %s where instance was launched "
                                       "does not exist.")
                                        % instance_ref['launched_on'])
-        oservice_ref = oservice_refs[0]['compute_service'][0]
+        oservice_ref = oservice_refs[0]['compute_node'][0]
 
         # Checking hypervisor is same.
         orig_hypervisor = oservice_ref['hypervisor_type']
@@ -252,10 +252,10 @@ class Scheduler(object):
 
         # Getting host information
         service_refs = db.service_get_all_compute_by_host(context, dest)
-        compute_service_ref = service_refs[0]['compute_service'][0]
+        compute_node_ref = service_refs[0]['compute_node'][0]
 
-        mem_total = int(compute_service_ref['memory_mb'])
-        mem_used = int(compute_service_ref['memory_mb_used'])
+        mem_total = int(compute_node_ref['memory_mb'])
+        mem_used = int(compute_node_ref['memory_mb_used'])
         mem_avail = mem_total - mem_used
         mem_inst = instance_ref['memory_mb']
         if mem_avail <= mem_inst:
diff --git a/nova/scheduler/manager.py b/nova/scheduler/manager.py
index a50d3ab20..090d8b89d 100644
--- a/nova/scheduler/manager.py
+++ b/nova/scheduler/manager.py
@@ -87,13 +87,13 @@ class SchedulerManager(manager.Manager):
         compute_ref = compute_ref[0]
 
         # Getting physical resource information
-        compute_service_ref = compute_ref['compute_service'][0]
-        resource = {'vcpus': compute_service_ref['vcpus'],
-                    'memory_mb': compute_service_ref['memory_mb'],
-                    'local_gb': compute_service_ref['local_gb'],
-                    'vcpus_used': compute_service_ref['vcpus_used'],
-                    'memory_mb_used': compute_service_ref['memory_mb_used'],
-                    'local_gb_used': compute_service_ref['local_gb_used']}
+        compute_node_ref = compute_ref['compute_node'][0]
+        resource = {'vcpus': compute_node_ref['vcpus'],
+                    'memory_mb': compute_node_ref['memory_mb'],
+                    'local_gb': compute_node_ref['local_gb'],
+                    'vcpus_used': compute_node_ref['vcpus_used'],
+                    'memory_mb_used': compute_node_ref['memory_mb_used'],
+                    'local_gb_used': compute_node_ref['local_gb_used']}
 
         # Getting usage resource information
         usage = {}
diff --git a/nova/tests/test_scheduler.py b/nova/tests/test_scheduler.py
index 62db42b11..711b66af7 100644
--- a/nova/tests/test_scheduler.py
+++ b/nova/tests/test_scheduler.py
@@ -60,7 +60,7 @@ class SchedulerTestCase(test.TestCase):
         self.flags(scheduler_driver='nova.tests.test_scheduler.TestDriver')
 
     def _create_compute_service(self):
-        """Create compute-manager(ComputeService and Service record)."""
+        """Create compute-manager(ComputeNode and Service record)."""
         ctxt = context.get_admin_context()
         dic = {'host': 'dummy', 'binary': 'nova-compute', 'topic': 'compute',
                'report_count': 0, 'availability_zone': 'dummyzone'}
@@ -71,7 +71,7 @@ class SchedulerTestCase(test.TestCase):
                'vcpus_used': 16, 'memory_mb_used': 32, 'local_gb_used': 10,
                'hypervisor_type': 'qemu', 'hypervisor_version': 12003,
                'cpu_info': ''}
-        db.compute_service_create(ctxt, dic)
+        db.compute_node_create(ctxt, dic)
 
         return db.service_get(ctxt, s_ref['id'])
 
@@ -144,8 +144,8 @@ class SchedulerTestCase(test.TestCase):
 
         # result checking
         c1 = ('resource' in result and 'usage' in result)
-        compute_service = s_ref['compute_service'][0]
-        c2 = self._dic_is_equal(result['resource'], compute_service)
+        compute_node = s_ref['compute_node'][0]
+        c2 = self._dic_is_equal(result['resource'], compute_node)
         c3 = result['usage'] == {}
         self.assertTrue(c1 and c2 and c3)
         db.service_destroy(ctxt, s_ref['id'])
@@ -163,8 +163,8 @@ class SchedulerTestCase(test.TestCase):
         result = scheduler.show_host_resources(ctxt, s_ref['host'])
 
         c1 = ('resource' in result and 'usage' in result)
-        compute_service = s_ref['compute_service'][0]
-        c2 = self._dic_is_equal(result['resource'], compute_service)
+        compute_node = s_ref['compute_node'][0]
+        c2 = self._dic_is_equal(result['resource'], compute_node)
         c3 = result['usage'].keys() == ['p-01', 'p-02']
         keys = ['vcpus', 'memory_mb', 'local_gb']
         c4 = self._dic_is_equal(result['usage']['p-01'], i_ref1, keys)
@@ -301,7 +301,7 @@ class SimpleDriverTestCase(test.TestCase):
         dic['memory_mb_used'] = kwargs.get('memory_mb_used', 32)
         dic['hypervisor_type'] = kwargs.get('hypervisor_type', 'qemu')
         dic['hypervisor_version'] = kwargs.get('hypervisor_version', 12003)
-        db.compute_service_create(self.context, dic)
+        db.compute_node_create(self.context, dic)
         return db.service_get(self.context, s_ref['id'])
 
     def test_doesnt_report_disabled_hosts_as_up(self):
@@ -923,7 +923,7 @@ class SimpleDriverTestCase(test.TestCase):
         self.mox.StubOutWithMock(rpc, 'call', use_mock_anything=True)
         rpc.call(mox.IgnoreArg(), mox.IgnoreArg(),
             {"method": 'compare_cpu',
-            "args": {'cpu_info': s_ref2['compute_service'][0]['cpu_info']}}).\
+            "args": {'cpu_info': s_ref2['compute_node'][0]['cpu_info']}}).\
              AndRaise(rpc.RemoteError("doesn't have compatibility to", "", ""))
 
         self.mox.ReplayAll()
diff --git a/nova/tests/test_virt.py b/nova/tests/test_virt.py
index 17b80c294..aac55a894 100644
--- a/nova/tests/test_virt.py
+++ b/nova/tests/test_virt.py
@@ -275,7 +275,7 @@ class LibvirtConnTestCase(test.TestCase):
         db.instance_destroy(user_context, instance_ref['id'])
 
     def test_update_available_resource_works_correctly(self):
-        """Confirm compute_service table is updated successfully."""
+        """Confirm compute_node table is updated successfully."""
         org_path = FLAGS.instances_path = ''
         FLAGS.instances_path = '.'
 
@@ -289,16 +289,16 @@ class LibvirtConnTestCase(test.TestCase):
         conn = libvirt_conn.LibvirtConnection(False)
         conn.update_available_resource(self.context, 'dummy')
         service_ref = db.service_get(self.context, service_ref['id'])
-        compute_service = service_ref['compute_service'][0]
-
-        c1 = (compute_service['vcpus'] > 0)
-        c2 = (compute_service['memory_mb'] > 0)
-        c3 = (compute_service['local_gb'] > 0)
-        c4 = (compute_service['vcpus_used'] == 0)
-        c5 = (compute_service['memory_mb_used'] > 0)
-        c6 = (compute_service['local_gb_used'] > 0)
-        c7 = (len(compute_service['hypervisor_type']) > 0)
-        c8 = (compute_service['hypervisor_version'] > 0)
+        compute_node = service_ref['compute_node'][0]
+
+        c1 = (compute_node['vcpus'] > 0)
+        c2 = (compute_node['memory_mb'] > 0)
+        c3 = (compute_node['local_gb'] > 0)
+        c4 = (compute_node['vcpus_used'] == 0)
+        c5 = (compute_node['memory_mb_used'] > 0)
+        c6 = (compute_node['local_gb_used'] > 0)
+        c7 = (len(compute_node['hypervisor_type']) > 0)
+        c8 = (compute_node['hypervisor_version'] > 0)
 
         self.assertTrue(c1 and c2 and c3 and c4 and c5 and c6 and c7 and c8)
 
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 bc6cc457132b096150dcd9ff2ed2909585a80484 Mon Sep 17 00:00:00 2001
From: Kei Masumoto <masumotok@nttdata.co.jp>
Date: Fri, 4 Mar 2011 01:17:05 +0900
Subject: some comments are modified

---
 nova/db/api.py            | 8 ++++----
 nova/db/sqlalchemy/api.py | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'nova')

diff --git a/nova/db/api.py b/nova/db/api.py
index 3b427cefe..43e1c2183 100644
--- a/nova/db/api.py
+++ b/nova/db/api.py
@@ -154,19 +154,19 @@ def service_update(context, service_id, values):
 
 
 def compute_node_get(context, compute_id, session=None):
-    """Get an computeService or raise if it does not exist."""
+    """Get an computeNode or raise if it does not exist."""
     return IMPL.compute_node_get(context, compute_id)
 
 
 def compute_node_create(context, values):
-    """Create a computeService from the values dictionary."""
+    """Create a computeNode from the values dictionary."""
     return IMPL.compute_node_create(context, values)
 
 
 def compute_node_update(context, compute_id, values):
-    """Set the given properties on an computeService and update it.
+    """Set the given properties on an computeNode and update it.
 
-    Raises NotFound if computeService does not exist.
+    Raises NotFound if computeNode does not exist.
 
     """
 
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 69aa07279..b305543ff 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -308,7 +308,7 @@ def compute_node_get(context, compute_id, session=None):
                      first()
 
     if not result:
-        raise exception.NotFound(_('No computeService for id %s') % compute_id)
+        raise exception.NotFound(_('No computeNode for id %s') % compute_id)
 
     return result
 
-- 
cgit 


From 6d075754bdd4090342bf4f79c726a52923c311a8 Mon Sep 17 00:00:00 2001
From: Brian Waldon <brian.waldon@rackspace.com>
Date: Thu, 3 Mar 2011 12:45:34 -0500
Subject: adding wsgi.Controller and wsgi.Request testing; fixing format
 keyword argument exception

---
 nova/tests/api/test_wsgi.py | 120 +++++++++++++++++++++++++++++++++++++-------
 nova/wsgi.py                |   4 +-
 2 files changed, 105 insertions(+), 19 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/api/test_wsgi.py b/nova/tests/api/test_wsgi.py
index 2c7852214..cf2d0e297 100644
--- a/nova/tests/api/test_wsgi.py
+++ b/nova/tests/api/test_wsgi.py
@@ -21,11 +21,13 @@
 Test WSGI basics and provide some helper functions for other WSGI tests.
 """
 
+import json
 from nova import test
 
 import routes
 import webob
 
+from nova import exception
 from nova import wsgi
 
 
@@ -66,30 +68,112 @@ class Test(test.TestCase):
         result = webob.Request.blank('/bad').get_response(Router())
         self.assertNotEqual(result.body, "Router result")
 
-    def test_controller(self):
 
-        class Controller(wsgi.Controller):
-            """Test controller to call from router."""
-            test = self
+class ControllerTest(test.TestCase):
+
+    class TestRouter(wsgi.Router):
+
+        class TestController(wsgi.Controller):
+
+            _serialization_metadata = {
+                'application/xml': {
+                    "attributes": {
+                        "test": ["id"]}}}
 
             def show(self, req, id):  # pylint: disable-msg=W0622,C0103
-                """Default action called for requests with an ID."""
-                self.test.assertEqual(req.path_info, '/tests/123')
-                self.test.assertEqual(id, '123')
-                return id
+                return {"test": {"id": id}}
+
+        def __init__(self):
+            mapper = routes.Mapper()
+            mapper.resource("test", "tests", controller=self.TestController())
+            wsgi.Router.__init__(self, mapper)
+
+    def test_show(self):
+        request = wsgi.Request.blank('/tests/123')
+        result = request.get_response(self.TestRouter())
+        self.assertEqual(json.loads(result.body), {"test": {"id": "123"}})
+
+    def test_content_type_from_accept_xml(self):
+        request = webob.Request.blank('/tests/123')
+        request.headers["Accept"] = "application/xml"
+        result = request.get_response(self.TestRouter())
+        self.assertEqual(result.headers["Content-Type"], "application/xml")
+
+    def test_content_type_from_accept_json(self):
+        request = wsgi.Request.blank('/tests/123')
+        request.headers["Accept"] = "application/json"
+        result = request.get_response(self.TestRouter())
+        self.assertEqual(result.headers["Content-Type"], "application/json")
+
+    def test_content_type_from_query_extension_xml(self):
+        request = wsgi.Request.blank('/tests/123.xml')
+        result = request.get_response(self.TestRouter())
+        self.assertEqual(result.headers["Content-Type"], "application/xml")
+
+    def test_content_type_from_query_extension_json(self):
+        request = wsgi.Request.blank('/tests/123.json')
+        result = request.get_response(self.TestRouter())
+        self.assertEqual(result.headers["Content-Type"], "application/json")
+
+    def test_content_type_default_when_unsupported(self):
+        request = wsgi.Request.blank('/tests/123.unsupported')
+        request.headers["Accept"] = "application/unsupported1"
+        result = request.get_response(self.TestRouter())
+        self.assertEqual(result.status_int, 200)
+        self.assertEqual(result.headers["Content-Type"], "application/json")
+
+
+class RequestTest(test.TestCase):
+
+    def test_content_type_from_accept_xml(self):
+        request = wsgi.Request.blank('/tests/123')
+        request.headers["Accept"] = "application/xml"
+        result = request.best_match()
+        self.assertEqual(result, "application/xml")
+
+        request = wsgi.Request.blank('/tests/123')
+        request.headers["Accept"] = "application/json"
+        result = request.best_match()
+        self.assertEqual(result, "application/json")
+
+        request = wsgi.Request.blank('/tests/123')
+        request.headers["Accept"] = "application/xml, application/json"
+        result = request.best_match()
+        self.assertEqual(result, "application/json")
+
+        request = wsgi.Request.blank('/tests/123')
+        request.headers["Accept"] = \
+            "application/json; q=0.3, application/xml; q=0.9"
+        result = request.best_match()
+        self.assertEqual(result, "application/xml")
+
+    def test_content_type_from_query_extension(self):
+        request = wsgi.Request.blank('/tests/123.xml')
+        result = request.best_match()
+        self.assertEqual(result, "application/xml")
+
+        request = wsgi.Request.blank('/tests/123.json')
+        result = request.best_match()
+        self.assertEqual(result, "application/json")
+
+        request = wsgi.Request.blank('/tests/123.invalid')
+        result = request.best_match()
+        self.assertEqual(result, "application/json")
+
+    def test_content_type_accept_and_query_extension(self):
+        request = wsgi.Request.blank('/tests/123.xml')
+        request.headers["Accept"] = "application/json"
+        result = request.best_match()
+        self.assertEqual(result, "application/xml")
+
+    def test_content_type_accept_default(self):
+        request = wsgi.Request.blank('/tests/123.unsupported')
+        request.headers["Accept"] = "application/unsupported1"
+        result = request.best_match()
+        self.assertEqual(result, "application/json")
 
-        class Router(wsgi.Router):
-            """Test router."""
 
-            def __init__(self):
-                mapper = routes.Mapper()
-                mapper.resource("test", "tests", controller=Controller())
-                super(Router, self).__init__(mapper)
 
-        result = webob.Request.blank('/tests/123').get_response(Router())
-        self.assertEqual(result.body, "123")
-        result = webob.Request.blank('/test/123').get_response(Router())
-        self.assertNotEqual(result.body, "123")
 
 
 class SerializerTest(test.TestCase):
diff --git a/nova/wsgi.py b/nova/wsgi.py
index 67216d540..4577439cb 100644
--- a/nova/wsgi.py
+++ b/nova/wsgi.py
@@ -339,6 +339,8 @@ class Controller(object):
         method = getattr(self, action)
         del arg_dict['controller']
         del arg_dict['action']
+        if 'format' in arg_dict:
+            del arg_dict['format']
         arg_dict['req'] = req
         result = method(**arg_dict)
         if type(result) is dict:
@@ -379,7 +381,7 @@ class Serializer(object):
         needed to serialize a dictionary to that type.
         """
         self.metadata = metadata or {}
-        req = wsgi.Request.blank('', environ)
+        req = Request.blank('', environ)
         suffix = req.path_info.split('.')[-1].lower()
         if suffix == 'json':
             self.handler = self._to_json
-- 
cgit 


From c363c2aaacb01cbbe8dcdaa4bda2e5d2531ab8e8 Mon Sep 17 00:00:00 2001
From: Rick Harris <rick.harris@rackspace.com>
Date: Thu, 3 Mar 2011 18:21:54 +0000
Subject: Use %s in case instance_id came through as a string

---
 nova/compute/api.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/api.py b/nova/compute/api.py
index 35a7d7bc0..5f68fcc4d 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -319,12 +319,12 @@ class API(base.Base):
         try:
             instance = self.get(context, instance_id)
         except exception.NotFound:
-            LOG.warning(_("Instance %d was not found during terminate"),
+            LOG.warning(_("Instance %s was not found during terminate"),
                         instance_id)
             raise
 
         if (instance['state_description'] == 'terminating'):
-            LOG.warning(_("Instance %d is already being terminated"),
+            LOG.warning(_("Instance %s is already being terminated"),
                         instance_id)
             return
 
-- 
cgit 


From 0e1a458166ad1e89ca0755d88b8efec39855ee5c Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Thu, 3 Mar 2011 13:18:37 -0600
Subject: Renaming my migration yet again

---
 .../versions/007_add_instance_migrations.py        | 61 ----------------------
 .../versions/009_add_instance_migrations.py        | 61 ++++++++++++++++++++++
 2 files changed, 61 insertions(+), 61 deletions(-)
 delete mode 100644 nova/db/sqlalchemy/migrate_repo/versions/007_add_instance_migrations.py
 create mode 100644 nova/db/sqlalchemy/migrate_repo/versions/009_add_instance_migrations.py

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/migrate_repo/versions/007_add_instance_migrations.py b/nova/db/sqlalchemy/migrate_repo/versions/007_add_instance_migrations.py
deleted file mode 100644
index 4fda525f1..000000000
--- a/nova/db/sqlalchemy/migrate_repo/versions/007_add_instance_migrations.py
+++ /dev/null
@@ -1,61 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 OpenStack LLC.
-# 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.from sqlalchemy import *
-
-from sqlalchemy import *
-from migrate import *
-
-from nova import log as logging
-
-
-meta = MetaData()
-
-# Just for the ForeignKey and column creation to succeed, these are not the
-# actual definitions of instances or services.
-instances = Table('instances', meta,
-        Column('id', Integer(),  primary_key=True, nullable=False),
-        )
-
-#
-# New Tables
-#
-
-migrations = Table('migrations', meta,
-            Column('created_at', DateTime(timezone=False)),
-            Column('updated_at', DateTime(timezone=False)),
-            Column('deleted_at', DateTime(timezone=False)),
-            Column('deleted', Boolean(create_constraint=True, name=None)),
-            Column('id', Integer(), primary_key=True, nullable=False),
-            Column('source_compute', String(255)),
-            Column('dest_compute', String(255)),
-            Column('dest_host', String(255)),
-            Column('instance_id', Integer, ForeignKey('instances.id'),
-                nullable=True),
-            Column('status', String(255)),
-      )
-
-
-def upgrade(migrate_engine):
-    # Upgrade operations go here. Don't create your own engine;
-    # bind migrate_engine to your metadata
-    meta.bind = migrate_engine
-    for table in (migrations, ):
-        try:
-            table.create()
-        except Exception:
-            logging.info(repr(table))
-            logging.exception('Exception while creating table')
-            raise
diff --git a/nova/db/sqlalchemy/migrate_repo/versions/009_add_instance_migrations.py b/nova/db/sqlalchemy/migrate_repo/versions/009_add_instance_migrations.py
new file mode 100644
index 000000000..4fda525f1
--- /dev/null
+++ b/nova/db/sqlalchemy/migrate_repo/versions/009_add_instance_migrations.py
@@ -0,0 +1,61 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 OpenStack LLC.
+# 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.from sqlalchemy import *
+
+from sqlalchemy import *
+from migrate import *
+
+from nova import log as logging
+
+
+meta = MetaData()
+
+# Just for the ForeignKey and column creation to succeed, these are not the
+# actual definitions of instances or services.
+instances = Table('instances', meta,
+        Column('id', Integer(),  primary_key=True, nullable=False),
+        )
+
+#
+# New Tables
+#
+
+migrations = Table('migrations', meta,
+            Column('created_at', DateTime(timezone=False)),
+            Column('updated_at', DateTime(timezone=False)),
+            Column('deleted_at', DateTime(timezone=False)),
+            Column('deleted', Boolean(create_constraint=True, name=None)),
+            Column('id', Integer(), primary_key=True, nullable=False),
+            Column('source_compute', String(255)),
+            Column('dest_compute', String(255)),
+            Column('dest_host', String(255)),
+            Column('instance_id', Integer, ForeignKey('instances.id'),
+                nullable=True),
+            Column('status', String(255)),
+      )
+
+
+def upgrade(migrate_engine):
+    # Upgrade operations go here. Don't create your own engine;
+    # bind migrate_engine to your metadata
+    meta.bind = migrate_engine
+    for table in (migrations, ):
+        try:
+            table.create()
+        except Exception:
+            logging.info(repr(table))
+            logging.exception('Exception while creating table')
+            raise
-- 
cgit 


From 9cfe8ff2e8e66952c3202b852a88ee6fca6fb736 Mon Sep 17 00:00:00 2001
From: Mark Washenberger <mark.washenberger@rackspace.com>
Date: Thu, 3 Mar 2011 16:31:01 -0500
Subject: pep8

---
 nova/api/openstack/servers.py            | 9 +++++----
 nova/tests/api/openstack/test_servers.py | 6 +++---
 2 files changed, 8 insertions(+), 7 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 73c787828..ea13116fa 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -85,6 +85,7 @@ def _translate_detail_keys(inst):
 
     return dict(server=inst_dict)
 
+
 def _translate_keys(inst):
     """ Coerces into dictionary format, excluding all model attributes
     save for id and name """
@@ -143,8 +144,8 @@ class Controller(wsgi.Controller):
         """
         Create a list of onset files from the personality request attribute
 
-        At this time, onset_files must be formatted as a list of 
-        (file_path, file_content) pairs for compatibility with the 
+        At this time, onset_files must be formatted as a list of
+        (file_path, file_content) pairs for compatibility with the
         underlying compute service.
         """
         onset_files = []
@@ -157,8 +158,8 @@ class Controller(wsgi.Controller):
             try:
                 contents = base64.b64decode(contents)
             except TypeError:
-                raise exc.HTTPBadRequest(explanation=
-                        'Personality content for %s cannot be decoded' % path)
+                msg = 'Personality content for %s cannot be decoded' % path
+                raise exc.HTTPBadRequest(explanation=msg)
             onset_files.append((path, contents))
         return onset_files
 
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 272d34e3a..53cfa3a6e 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -287,8 +287,8 @@ class ServersTest(test.TestCase):
         request, response, onset_files = \
             self._create_instance_with_personality(personality)
         self.assertEquals(response.status_int, 200)
-        self.assertEquals(onset_files, [(path, contents)])
-    
+        self.assertEquals(onset_files, [(path, contents)]) 
+
     def test_create_instance_with_personality_with_non_b64_content(self):
         path = '/my/file/path'
         contents = '#!/bin/bash\necho "Oh no!"\n'
@@ -320,7 +320,7 @@ class ServersTest(test.TestCase):
         request, response, onset_files = \
             self._create_instance_with_personality(personality)
         self.assertEquals(response.status_int, 200)
-        self.assertEquals(onset_files, [(path, contents)]) 
+        self.assertEquals(onset_files, [(path, contents)])
 
     def test_create_instance_personality_not_a_list(self):
         path = '/my/file/path'
-- 
cgit 


From 848aced747a60c47d76efcb2147041339df4a628 Mon Sep 17 00:00:00 2001
From: Brian Waldon <brian.waldon@rackspace.com>
Date: Thu, 3 Mar 2011 17:21:21 -0500
Subject: Refactor wsgi.Serializer away from handling Requests directly; now
 require Content-Type in all requests; fix tests according to new code

---
 nova/api/direct.py                       |  2 +-
 nova/api/openstack/__init__.py           |  4 +-
 nova/api/openstack/consoles.py           |  2 +-
 nova/api/openstack/faults.py             |  5 +-
 nova/api/openstack/images.py             |  2 +-
 nova/api/openstack/servers.py            |  9 ++-
 nova/api/openstack/zones.py              |  4 +-
 nova/exception.py                        |  4 ++
 nova/tests/api/openstack/test_servers.py |  1 +
 nova/tests/api/openstack/test_zones.py   | 15 +++--
 nova/tests/api/test_wsgi.py              | 95 +++++++++++++++++++------------
 nova/tests/test_direct.py                |  3 +
 nova/wsgi.py                             | 96 ++++++++++++++++++++------------
 13 files changed, 152 insertions(+), 90 deletions(-)

(limited to 'nova')

diff --git a/nova/api/direct.py b/nova/api/direct.py
index cd237f649..1d699f947 100644
--- a/nova/api/direct.py
+++ b/nova/api/direct.py
@@ -206,7 +206,7 @@ class ServiceWrapper(wsgi.Controller):
         params = dict([(str(k), v) for (k, v) in params.iteritems()])
         result = method(context, **params)
         if type(result) is dict or type(result) is list:
-            return self._serialize(result, req)
+            return self._serialize(result, req.best_match())
         else:
             return result
 
diff --git a/nova/api/openstack/__init__.py b/nova/api/openstack/__init__.py
index b5439788d..6e1a2a06c 100644
--- a/nova/api/openstack/__init__.py
+++ b/nova/api/openstack/__init__.py
@@ -124,4 +124,6 @@ class Versions(wsgi.Application):
         metadata = {
             "application/xml": {
                 "attributes": dict(version=["status", "id"])}}
-        return wsgi.Serializer(req.environ, metadata).to_content_type(response)
+
+        content_type = req.best_match()
+        return wsgi.Serializer(metadata).serialize(response, content_type)
diff --git a/nova/api/openstack/consoles.py b/nova/api/openstack/consoles.py
index 9ebdbe710..8c291c2eb 100644
--- a/nova/api/openstack/consoles.py
+++ b/nova/api/openstack/consoles.py
@@ -65,7 +65,7 @@ class Controller(wsgi.Controller):
 
     def create(self, req, server_id):
         """Creates a new console"""
-        #info = self._deserialize(req.body, req)
+        #info = self._deserialize(req.body, req.get_content_type())
         self.console_api.create_console(
                                 req.environ['nova.context'],
                                 int(server_id))
diff --git a/nova/api/openstack/faults.py b/nova/api/openstack/faults.py
index c70b00fa3..075fdb997 100644
--- a/nova/api/openstack/faults.py
+++ b/nova/api/openstack/faults.py
@@ -57,6 +57,7 @@ class Fault(webob.exc.HTTPException):
             fault_data[fault_name]['retryAfter'] = retry
         # 'code' is an attribute on the fault tag itself
         metadata = {'application/xml': {'attributes': {fault_name: 'code'}}}
-        serializer = wsgi.Serializer(req.environ, metadata)
-        self.wrapped_exc.body = serializer.to_content_type(fault_data)
+        serializer = wsgi.Serializer(metadata)
+        content_type = req.best_match()
+        self.wrapped_exc.body = serializer.serialize(fault_data, content_type)
         return self.wrapped_exc
diff --git a/nova/api/openstack/images.py b/nova/api/openstack/images.py
index cf85a496f..98f0dd96b 100644
--- a/nova/api/openstack/images.py
+++ b/nova/api/openstack/images.py
@@ -151,7 +151,7 @@ class Controller(wsgi.Controller):
 
     def create(self, req):
         context = req.environ['nova.context']
-        env = self._deserialize(req.body, req)
+        env = self._deserialize(req.body, req.get_content_type())
         instance_id = env["image"]["serverId"]
         name = env["image"]["name"]
 
diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 08b95b46a..24d2826af 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -141,7 +141,7 @@ class Controller(wsgi.Controller):
 
     def create(self, req):
         """ Creates a new server for a given user """
-        env = self._deserialize(req.body, req)
+        env = self._deserialize(req.body, req.get_content_type())
         if not env:
             return faults.Fault(exc.HTTPUnprocessableEntity())
 
@@ -182,7 +182,10 @@ class Controller(wsgi.Controller):
 
     def update(self, req, id):
         """ Updates the server name or password """
-        inst_dict = self._deserialize(req.body, req)
+        if len(req.body) == 0:
+            raise exc.HTTPUnprocessableEntity()
+
+        inst_dict = self._deserialize(req.body, req.get_content_type())
         if not inst_dict:
             return faults.Fault(exc.HTTPUnprocessableEntity())
 
@@ -205,7 +208,7 @@ class Controller(wsgi.Controller):
     def action(self, req, id):
         """ Multi-purpose method used to reboot, rebuild, and
         resize a server """
-        input_dict = self._deserialize(req.body, req)
+        input_dict = self._deserialize(req.body, req.get_content_type())
         #TODO(sandy): rebuild/resize not supported.
         try:
             reboot_type = input_dict['reboot']['type']
diff --git a/nova/api/openstack/zones.py b/nova/api/openstack/zones.py
index d5206da20..cf6cd789f 100644
--- a/nova/api/openstack/zones.py
+++ b/nova/api/openstack/zones.py
@@ -67,13 +67,13 @@ class Controller(wsgi.Controller):
 
     def create(self, req):
         context = req.environ['nova.context']
-        env = self._deserialize(req.body, req)
+        env = self._deserialize(req.body, req.get_content_type())
         zone = db.zone_create(context, env["zone"])
         return dict(zone=_scrub_zone(zone))
 
     def update(self, req, id):
         context = req.environ['nova.context']
-        env = self._deserialize(req.body, req)
+        env = self._deserialize(req.body, req.get_content_type())
         zone_id = int(id)
         zone = db.zone_update(context, zone_id, env["zone"])
         return dict(zone=_scrub_zone(zone))
diff --git a/nova/exception.py b/nova/exception.py
index 7d65bd6a5..93c5fe3d7 100644
--- a/nova/exception.py
+++ b/nova/exception.py
@@ -88,6 +88,10 @@ class InvalidInputException(Error):
     pass
 
 
+class InvalidContentType(Error):
+    pass
+
+
 class TimeoutException(Error):
     pass
 
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 78beb7df9..fae08d0be 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -227,6 +227,7 @@ class ServersTest(test.TestCase):
         req = webob.Request.blank('/v1.0/servers')
         req.method = 'POST'
         req.body = json.dumps(body)
+        req.headers["Content-Type"] = "application/json"
 
         res = req.get_response(fakes.wsgi_app())
 
diff --git a/nova/tests/api/openstack/test_zones.py b/nova/tests/api/openstack/test_zones.py
index 555b206b9..d0da8eaaf 100644
--- a/nova/tests/api/openstack/test_zones.py
+++ b/nova/tests/api/openstack/test_zones.py
@@ -86,24 +86,27 @@ class ZonesTest(test.TestCase):
 
     def test_get_zone_list(self):
         req = webob.Request.blank('/v1.0/zones')
+        req.headers["Content-Type"] = "application/json"
         res = req.get_response(fakes.wsgi_app())
-        res_dict = json.loads(res.body)
 
         self.assertEqual(res.status_int, 200)
+        res_dict = json.loads(res.body)
         self.assertEqual(len(res_dict['zones']), 2)
 
     def test_get_zone_by_id(self):
         req = webob.Request.blank('/v1.0/zones/1')
+        req.headers["Content-Type"] = "application/json"
         res = req.get_response(fakes.wsgi_app())
-        res_dict = json.loads(res.body)
 
+        self.assertEqual(res.status_int, 200)
+        res_dict = json.loads(res.body)
         self.assertEqual(res_dict['zone']['id'], 1)
         self.assertEqual(res_dict['zone']['api_url'], 'http://foo.com')
         self.assertFalse('password' in res_dict['zone'])
-        self.assertEqual(res.status_int, 200)
 
     def test_zone_delete(self):
         req = webob.Request.blank('/v1.0/zones/1')
+        req.headers["Content-Type"] = "application/json"
         res = req.get_response(fakes.wsgi_app())
 
         self.assertEqual(res.status_int, 200)
@@ -112,13 +115,14 @@ class ZonesTest(test.TestCase):
         body = dict(zone=dict(api_url='http://blah.zoo', username='fred',
                         password='fubar'))
         req = webob.Request.blank('/v1.0/zones')
+        req.headers["Content-Type"] = "application/json"
         req.method = 'POST'
         req.body = json.dumps(body)
 
         res = req.get_response(fakes.wsgi_app())
-        res_dict = json.loads(res.body)
 
         self.assertEqual(res.status_int, 200)
+        res_dict = json.loads(res.body)
         self.assertEqual(res_dict['zone']['id'], 1)
         self.assertEqual(res_dict['zone']['api_url'], 'http://blah.zoo')
         self.assertFalse('username' in res_dict['zone'])
@@ -126,13 +130,14 @@ class ZonesTest(test.TestCase):
     def test_zone_update(self):
         body = dict(zone=dict(username='zeb', password='sneaky'))
         req = webob.Request.blank('/v1.0/zones/1')
+        req.headers["Content-Type"] = "application/json"
         req.method = 'PUT'
         req.body = json.dumps(body)
 
         res = req.get_response(fakes.wsgi_app())
-        res_dict = json.loads(res.body)
 
         self.assertEqual(res.status_int, 200)
+        res_dict = json.loads(res.body)
         self.assertEqual(res_dict['zone']['id'], 1)
         self.assertEqual(res_dict['zone']['api_url'], 'http://foo.com')
         self.assertFalse('username' in res_dict['zone'])
diff --git a/nova/tests/api/test_wsgi.py b/nova/tests/api/test_wsgi.py
index cf2d0e297..7c0135656 100644
--- a/nova/tests/api/test_wsgi.py
+++ b/nova/tests/api/test_wsgi.py
@@ -93,29 +93,29 @@ class ControllerTest(test.TestCase):
         result = request.get_response(self.TestRouter())
         self.assertEqual(json.loads(result.body), {"test": {"id": "123"}})
 
-    def test_content_type_from_accept_xml(self):
+    def test_response_content_type_from_accept_xml(self):
         request = webob.Request.blank('/tests/123')
         request.headers["Accept"] = "application/xml"
         result = request.get_response(self.TestRouter())
         self.assertEqual(result.headers["Content-Type"], "application/xml")
 
-    def test_content_type_from_accept_json(self):
+    def test_response_content_type_from_accept_json(self):
         request = wsgi.Request.blank('/tests/123')
         request.headers["Accept"] = "application/json"
         result = request.get_response(self.TestRouter())
         self.assertEqual(result.headers["Content-Type"], "application/json")
 
-    def test_content_type_from_query_extension_xml(self):
+    def test_response_content_type_from_query_extension_xml(self):
         request = wsgi.Request.blank('/tests/123.xml')
         result = request.get_response(self.TestRouter())
         self.assertEqual(result.headers["Content-Type"], "application/xml")
 
-    def test_content_type_from_query_extension_json(self):
+    def test_response_content_type_from_query_extension_json(self):
         request = wsgi.Request.blank('/tests/123.json')
         result = request.get_response(self.TestRouter())
         self.assertEqual(result.headers["Content-Type"], "application/json")
 
-    def test_content_type_default_when_unsupported(self):
+    def test_response_content_type_default_when_unsupported(self):
         request = wsgi.Request.blank('/tests/123.unsupported')
         request.headers["Accept"] = "application/unsupported1"
         result = request.get_response(self.TestRouter())
@@ -125,6 +125,17 @@ class ControllerTest(test.TestCase):
 
 class RequestTest(test.TestCase):
 
+    def test_request_content_type_missing(self):
+        request = wsgi.Request.blank('/tests/123')
+        request.body = "<body />"
+        self.assertRaises(webob.exc.HTTPBadRequest, request.get_content_type)
+
+    def test_request_content_type_unsupported(self):
+        request = wsgi.Request.blank('/tests/123')
+        request.headers["Content-Type"] = "text/html"
+        request.body = "asdf<br />"
+        self.assertRaises(webob.exc.HTTPBadRequest, request.get_content_type)
+
     def test_content_type_from_accept_xml(self):
         request = wsgi.Request.blank('/tests/123')
         request.headers["Accept"] = "application/xml"
@@ -173,40 +184,48 @@ class RequestTest(test.TestCase):
         self.assertEqual(result, "application/json")
 
 
-
-
-
 class SerializerTest(test.TestCase):
 
-    def match(self, url, accept, expect):
+    def test_xml(self):
         input_dict = dict(servers=dict(a=(2, 3)))
         expected_xml = '<servers><a>(2,3)</a></servers>'
+        serializer = wsgi.Serializer()
+        result = serializer.serialize(input_dict, "application/xml")
+        result = result.replace('\n', '').replace(' ', '')
+        self.assertEqual(result, expected_xml)
+
+    def test_json(self):
+        input_dict = dict(servers=dict(a=(2, 3)))
         expected_json = '{"servers":{"a":[2,3]}}'
-        req = webob.Request.blank(url, headers=dict(Accept=accept))
-        result = wsgi.Serializer(req.environ).to_content_type(input_dict)
+        serializer = wsgi.Serializer()
+        result = serializer.serialize(input_dict, "application/json")
         result = result.replace('\n', '').replace(' ', '')
-        if expect == 'xml':
-            self.assertEqual(result, expected_xml)
-        elif expect == 'json':
-            self.assertEqual(result, expected_json)
-        else:
-            raise "Bad expect value"
-
-    def test_basic(self):
-        self.match('/servers/4.json', None, expect='json')
-        self.match('/servers/4', 'application/json', expect='json')
-        self.match('/servers/4', 'application/xml', expect='xml')
-        self.match('/servers/4.xml', None, expect='xml')
-
-    def test_defaults_to_json(self):
-        self.match('/servers/4', None, expect='json')
-        self.match('/servers/4', 'text/html', expect='json')
-
-    def test_suffix_takes_precedence_over_accept_header(self):
-        self.match('/servers/4.xml', 'application/json', expect='xml')
-        self.match('/servers/4.xml.', 'application/json', expect='json')
-
-    def test_deserialize(self):
+        self.assertEqual(result, expected_json)
+
+    def test_unsupported_content_type(self):
+        serializer = wsgi.Serializer()
+        self.assertRaises(exception.InvalidContentType, serializer.serialize,
+                          {}, "text/null")
+
+    def test_deserialize_json(self):
+        data = """{"a": {
+                "a1": "1",
+                "a2": "2",
+                "bs": ["1", "2", "3", {"c": {"c1": "1"}}],
+                "d": {"e": "1"},
+                "f": "1"}}"""
+        as_dict = dict(a={
+                'a1': '1',
+                'a2': '2',
+                'bs': ['1', '2', '3', {'c': dict(c1='1')}],
+                'd': {'e': '1'},
+                'f': '1'})
+        metadata = {}
+        serializer = wsgi.Serializer(metadata)
+        self.assertEqual(serializer.deserialize(data, "application/json"),
+                         as_dict)
+
+    def test_deserialize_xml(self):
         xml = """
             <a a1="1" a2="2">
               <bs><b>1</b><b>2</b><b>3</b><b><c c1="1"/></b></bs>
@@ -221,11 +240,13 @@ class SerializerTest(test.TestCase):
                 'd': {'e': '1'},
                 'f': '1'})
         metadata = {'application/xml': dict(plurals={'bs': 'b', 'ts': 't'})}
-        serializer = wsgi.Serializer({}, metadata)
-        self.assertEqual(serializer.deserialize(xml), as_dict)
+        serializer = wsgi.Serializer(metadata)
+        self.assertEqual(serializer.deserialize(xml, "application/xml"),
+                         as_dict)
 
     def test_deserialize_empty_xml(self):
         xml = """<a></a>"""
         as_dict = {"a": {}}
-        serializer = wsgi.Serializer({})
-        self.assertEqual(serializer.deserialize(xml), as_dict)
+        serializer = wsgi.Serializer()
+        self.assertEqual(serializer.deserialize(xml, "application/xml"),
+                         as_dict)
diff --git a/nova/tests/test_direct.py b/nova/tests/test_direct.py
index b6bfab534..85bfcfd85 100644
--- a/nova/tests/test_direct.py
+++ b/nova/tests/test_direct.py
@@ -59,6 +59,7 @@ class DirectTestCase(test.TestCase):
         req.headers['X-OpenStack-User'] = 'user1'
         req.headers['X-OpenStack-Project'] = 'proj1'
         resp = req.get_response(self.auth_router)
+        self.assertEqual(resp.status_int, 200)
         data = json.loads(resp.body)
         self.assertEqual(data['user'], 'user1')
         self.assertEqual(data['project'], 'proj1')
@@ -69,6 +70,7 @@ class DirectTestCase(test.TestCase):
         req.method = 'POST'
         req.body = 'json=%s' % json.dumps({'data': 'foo'})
         resp = req.get_response(self.router)
+        self.assertEqual(resp.status_int, 200)
         resp_parsed = json.loads(resp.body)
         self.assertEqual(resp_parsed['data'], 'foo')
 
@@ -78,6 +80,7 @@ class DirectTestCase(test.TestCase):
         req.method = 'POST'
         req.body = 'data=foo'
         resp = req.get_response(self.router)
+        self.assertEqual(resp.status_int, 200)
         resp_parsed = json.loads(resp.body)
         self.assertEqual(resp_parsed['data'], 'foo')
 
diff --git a/nova/wsgi.py b/nova/wsgi.py
index 4577439cb..c3e08522d 100644
--- a/nova/wsgi.py
+++ b/nova/wsgi.py
@@ -36,6 +36,7 @@ import webob.exc
 
 from paste import deploy
 
+from nova import exception
 from nova import flags
 from nova import log as logging
 from nova import utils
@@ -102,6 +103,14 @@ class Request(webob.Request):
 
         return bm or "application/json"
 
+    def get_content_type(self):
+        try:
+            ct = self.headers["Content-Type"]
+            assert ct in ("application/xml", "application/json")
+            return ct
+        except Exception:
+            raise webob.exc.HTTPBadRequest("Invalid content type")
+
 
 class Application(object):
     """Base WSGI application wrapper. Subclasses need to implement __call__."""
@@ -343,30 +352,41 @@ class Controller(object):
             del arg_dict['format']
         arg_dict['req'] = req
         result = method(**arg_dict)
+
         if type(result) is dict:
-            return self._serialize(result, req)
+            content_type = req.best_match()
+            body = self._serialize(result, content_type)
+
+            response = webob.Response()
+            response.headers["Content-Type"] = content_type
+            response.body = body
+            return response
+
         else:
             return result
 
-    def _serialize(self, data, request):
+    def _serialize(self, data, content_type):
         """
-        Serialize the given dict to the response type requested in request.
+        Serialize the given dict to the provided content_type.
         Uses self._serialization_metadata if it exists, which is a dict mapping
         MIME types to information needed to serialize to that type.
         """
         _metadata = getattr(type(self), "_serialization_metadata", {})
-        serializer = Serializer(request.environ, _metadata)
-        return serializer.to_content_type(data)
+        serializer = Serializer(_metadata)
+        try:
+            return serializer.serialize(data, content_type)
+        except exception.InvalidContentType:
+            raise webob.exc.HTTPNotAcceptable()
 
-    def _deserialize(self, data, request):
+    def _deserialize(self, data, content_type):
         """
-        Deserialize the request body to the response type requested in request.
+        Deserialize the request body to the specefied content type.
         Uses self._serialization_metadata if it exists, which is a dict mapping
         MIME types to information needed to serialize to that type.
         """
         _metadata = getattr(type(self), "_serialization_metadata", {})
-        serializer = Serializer(request.environ, _metadata)
-        return serializer.deserialize(data)
+        serializer = Serializer(_metadata)
+        return serializer.deserialize(data, content_type)
 
 
 class Serializer(object):
@@ -374,50 +394,52 @@ class Serializer(object):
     Serializes and deserializes dictionaries to certain MIME types.
     """
 
-    def __init__(self, environ, metadata=None):
+    def __init__(self, metadata=None):
         """
         Create a serializer based on the given WSGI environment.
         'metadata' is an optional dict mapping MIME types to information
         needed to serialize a dictionary to that type.
         """
         self.metadata = metadata or {}
-        req = Request.blank('', environ)
-        suffix = req.path_info.split('.')[-1].lower()
-        if suffix == 'json':
-            self.handler = self._to_json
-        elif suffix == 'xml':
-            self.handler = self._to_xml
-        elif 'application/json' in req.accept:
-            self.handler = self._to_json
-        elif 'application/xml' in req.accept:
-            self.handler = self._to_xml
-        else:
-            # This is the default
-            self.handler = self._to_json
 
-    def to_content_type(self, data):
-        """
-        Serialize a dictionary into a string.
+    def _get_serialize_handler(self, content_type):
+        handlers = {
+            "application/json": self._to_json,
+            "application/xml": self._to_xml,
+        }
+
+        try:
+            return handlers[content_type]
+        except Exception:
+            raise exception.InvalidContentType()
 
-        The format of the string will be decided based on the Content Type
-        requested in self.environ: by Accept: header, or by URL suffix.
+    def serialize(self, data, content_type):
+        """
+        Serialize a dictionary into a string of the specified content type.
         """
-        return self.handler(data)
+        return self._get_serialize_handler(content_type)(data)
 
-    def deserialize(self, datastring):
+    def deserialize(self, datastring, content_type):
         """
         Deserialize a string to a dictionary.
 
         The string must be in the format of a supported MIME type.
         """
-        datastring = datastring.strip()
+        return self.get_deserialize_handler(content_type)(datastring)
+
+    def get_deserialize_handler(self, content_type):
+        handlers = {
+            "application/json": self._from_json,
+            "application/xml": self._from_xml,
+        }
+
         try:
-            is_xml = (datastring[0] == '<')
-            if not is_xml:
-                return utils.loads(datastring)
-            return self._from_xml(datastring)
-        except:
-            return None
+            return handlers[content_type]
+        except Exception:
+            raise exception.InvalidContentType()
+
+    def _from_json(self, datastring):
+        return utils.loads(datastring)
 
     def _from_xml(self, datastring):
         xmldata = self.metadata.get('application/xml', {})
-- 
cgit 


From 417f6ca5c54878a6bea4d545126f93ecb6a043b4 Mon Sep 17 00:00:00 2001
From: Monsyne Dragon <mdragon@rackspace.com>
Date: Thu, 3 Mar 2011 22:22:00 +0000
Subject: localize a few error messages.

---
 nova/api/openstack/accounts.py | 2 +-
 nova/api/openstack/users.py    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/accounts.py b/nova/api/openstack/accounts.py
index 264fdab99..3b90d2776 100644
--- a/nova/api/openstack/accounts.py
+++ b/nova/api/openstack/accounts.py
@@ -47,7 +47,7 @@ class Controller(wsgi.Controller):
         """ We cannot depend on the db layer to check for admin access
             for the auth manager, so we do it here """
         if not context.is_admin:
-            raise exception.NotAuthorized("Not admin user.")
+            raise exception.NotAuthorized(_("Not admin user."))
 
     def show(self, req, id):
         """Return data about the given account id"""
diff --git a/nova/api/openstack/users.py b/nova/api/openstack/users.py
index c0b7544f9..ae3bf7791 100644
--- a/nova/api/openstack/users.py
+++ b/nova/api/openstack/users.py
@@ -48,7 +48,7 @@ class Controller(wsgi.Controller):
         """ We cannot depend on the db layer to check for admin access
             for the auth manager, so we do it here """
         if not context.is_admin:
-            raise exception.NotAuthorized("Not admin user")
+            raise exception.NotAuthorized(_("Not admin user"))
 
     def index(self, req, **kw):
         """Return all users in brief"""
-- 
cgit 


From e14f524eb92ae07704a2ec7dac0f97c60940a6ab Mon Sep 17 00:00:00 2001
From: Mark Washenberger <mark.washenberger@rackspace.com>
Date: Thu, 3 Mar 2011 17:49:41 -0500
Subject: enforce personality quotas

---
 nova/compute/api.py      | 24 ++++++++++++++++++
 nova/quota.py            | 27 ++++++++++++--------
 nova/tests/test_quota.py | 66 +++++++++++++++++++++++++++++++++++++++++++-----
 3 files changed, 101 insertions(+), 16 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/api.py b/nova/compute/api.py
index 625778b66..44e583cd4 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -80,6 +80,26 @@ class API(base.Base):
                         topic,
                         {"method": "get_network_topic", "args": {'fake': 1}})
 
+    def _check_personality_file_quota(self, context, personality_files):
+        limit = quota.allowed_personality_files(context)
+        if len(personality_files) > limit:
+            raise quota.QuotaError(_("Personality limit exceeded. You can "
+                                     "only have %d personalities when "
+                                     "creating an instance.") % limit,
+                                   "PersonalityLimitExceeded")
+        path_limit = quota.allowed_personality_path_bytes(context)
+        content_limit = quota.allowed_personality_content_bytes(context)
+        for path, content in personality_files:
+            if len(path) > path_limit:
+                raise quota.QuotaError(
+                        _("Personality file path limit exceeded."),
+                        "PersonalityLimitExceeded")
+            if len(content) > content_limit:
+                raise quota.QuotaError(
+                        _("Personality file content limit exceeded."),
+                        "PersonalityLimitExceeded")
+        return personality_files
+
     def create(self, context, instance_type,
                image_id, kernel_id=None, ramdisk_id=None,
                min_count=1, max_count=1,
@@ -124,6 +144,10 @@ class API(base.Base):
                 LOG.warn(msg)
                 raise quota.QuotaError(msg, "MetadataLimitExceeded")
 
+        if onset_files is not None:
+            onset_files = \
+                self._check_personality_file_quota(context, onset_files)
+
         image = self.image_service.show(context, image_id)
         if kernel_id is None:
             kernel_id = image.get('kernel_id', None)
diff --git a/nova/quota.py b/nova/quota.py
index 14b388794..4b777624c 100644
--- a/nova/quota.py
+++ b/nova/quota.py
@@ -37,10 +37,12 @@ flags.DEFINE_integer('quota_floating_ips', 10,
                      'number of floating ips allowed per project')
 flags.DEFINE_integer('quota_metadata_items', 128,
                      'number of metadata items allowed per instance')
-flags.DEFINE_integer('quota_file_injection_max_files', 5,
-                     'number of files allowed during file injection')
-flags.DEFINE_integer('quota_file_injection_max_file_bytes', 10 * 1024,
-                     'number of bytes allowed per file during file injection')
+flags.DEFINE_integer('quota_personality_max_files', 5,
+                     'number of personality files allowed')
+flags.DEFINE_integer('quota_personality_max_content_bytes', 10 * 1024,
+                     'number of bytes allowed per personality file')
+flags.DEFINE_integer('quota_personality_max_path_bytes', 255,
+                     'number of bytes allowed per personality file path')
 
 
 def get_quota(context, project_id):
@@ -113,14 +115,19 @@ def allowed_metadata_items(context, num_metadata_items):
     return min(num_metadata_items, num_allowed_metadata_items)
 
 
-def allowed_file_injection_files(context):
-    """Return the number of files allowed per file injection"""
-    return FLAGS.quota_file_injection_max_files
+def allowed_personality_files(context):
+    """Return the number of personality files allowed"""
+    return FLAGS.quota_personality_max_files
 
 
-def allowed_file_injection_file_bytes(context):
-    """Return the number of bytes allowed per file during injection"""
-    return FLAGS.quota_file_injection_max_file_bytes
+def allowed_personality_content_bytes(context):
+    """Return the number of bytes allowed per personality content"""
+    return FLAGS.quota_personality_max_content_bytes
+
+
+def allowed_personality_path_bytes(context):
+    """Return the number of bytes allowed in a personality file path"""
+    return FLAGS.quota_personality_max_path_bytes
 
 
 class QuotaError(exception.ApiError):
diff --git a/nova/tests/test_quota.py b/nova/tests/test_quota.py
index 48e5a5538..16a083788 100644
--- a/nova/tests/test_quota.py
+++ b/nova/tests/test_quota.py
@@ -177,12 +177,66 @@ class QuotaTestCase(test.TestCase):
                                             image_id='fake',
                                             metadata=metadata)
 
-    def test_allowed_file_injection_files(self):
+    def test_allowed_personality_files(self):
         self.assertEqual(
-                quota.allowed_file_injection_files(self.context),
-                FLAGS.quota_file_injection_max_files)
+                quota.allowed_personality_files(self.context),
+                FLAGS.quota_personality_max_files)
+
+    def _create_with_personality(self, files):
+        api = compute.API()
+        api.create(self.context, min_count=1, max_count=1,
+                instance_type='m1.small', image_id='fake',
+                onset_files=files)
+
+    def test_no_personality_files(self):
+        api = compute.API()
+        api.create(self.context, instance_type='m1.small', image_id='fake')
+
+    def test_max_personality_files(self):
+        files = []
+        for i in xrange(FLAGS.quota_personality_max_files):
+            files.append(('/my/path%d' % i, 'config = test\n'))
+        self._create_with_personality(files)  # no QuotaError
+
+    def test_too_many_personality_files(self):
+        files = []
+        for i in xrange(FLAGS.quota_personality_max_files + 1):
+            files.append(('/my/path%d' % i, 'my\ncontent%d\n' % i))
+        self.assertRaises(quota.QuotaError,
+                          self._create_with_personality, files)
 
-    def test_allowed_file_injection_file_bytes(self):
+    def test_allowed_personality_content_bytes(self):
         self.assertEqual(
-                quota.allowed_file_injection_file_bytes(self.context),
-                FLAGS.quota_file_injection_max_file_bytes)
+                quota.allowed_personality_content_bytes(self.context),
+                FLAGS.quota_personality_max_content_bytes)
+
+    def test_max_personality_content_bytes(self):
+        max = FLAGS.quota_personality_max_content_bytes
+        content = ''.join(['a' for i in xrange(max)])
+        files = [('/test/path', content)]
+        self._create_with_personality(files)  # no QuotaError
+
+    def test_too_many_personality_content_bytes(self):
+        max = FLAGS.quota_personality_max_content_bytes
+        content = ''.join(['a' for i in xrange(max + 1)])
+        files = [('/test/path', content)]
+        self.assertRaises(quota.QuotaError,
+                          self._create_with_personality, files)
+
+    def test_allowed_personality_path_bytes(self):
+        self.assertEqual(
+                quota.allowed_personality_path_bytes(self.context),
+                FLAGS.quota_personality_max_path_bytes)
+
+    def test_max_personality_path_bytes(self):
+        max = FLAGS.quota_personality_max_path_bytes
+        path = ''.join(['a' for i in xrange(max)])
+        files = [(path, 'config = quotatest')]
+        self._create_with_personality(files)  # no QuotaError
+
+    def test_too_many_personality_path_bytes(self):
+        max = FLAGS.quota_personality_max_path_bytes
+        path = ''.join(['a' for i in xrange(max + 1)])
+        files = [(path, 'config = quotatest')]
+        self.assertRaises(quota.QuotaError,
+                          self._create_with_personality, files)
-- 
cgit 


From c5bfab9a0d213cee549371f05e74747cfcd8f998 Mon Sep 17 00:00:00 2001
From: Ryan Lane <rlane@wikimedia.org>
Date: Thu, 3 Mar 2011 23:05:00 +0000
Subject: Changing output of status from showing the user as the owner, to
 showing the project

---
 nova/api/ec2/cloud.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index b1917e9ea..cadda97db 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -562,7 +562,7 @@ class CloudController(object):
         if context.is_admin:
             v['status'] = '%s (%s, %s, %s, %s)' % (
                 volume['status'],
-                volume['user_id'],
+                volume['project_id'],
                 volume['host'],
                 instance_data,
                 volume['mountpoint'])
-- 
cgit 


From 5ae13551990be67e3509ddcd10d1872a91634d83 Mon Sep 17 00:00:00 2001
From: Mark Washenberger <mark.washenberger@rackspace.com>
Date: Thu, 3 Mar 2011 18:27:57 -0500
Subject: rename onset_files to personality_files all the way down to compute
 manager

---
 nova/api/openstack/servers.py            | 16 +++++++--------
 nova/compute/api.py                      | 10 ++++-----
 nova/compute/manager.py                  |  2 +-
 nova/tests/api/openstack/test_servers.py | 35 ++++++++++++++++----------------
 nova/tests/test_quota.py                 |  2 +-
 5 files changed, 33 insertions(+), 32 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index ea13116fa..8f6d8de66 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -140,15 +140,15 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPNotFound())
         return exc.HTTPAccepted()
 
-    def _get_onset_files_from_personality(self, personality):
+    def _get_personality_files(self, personality):
         """
-        Create a list of onset files from the personality request attribute
+        Create a list of personality files from the personality attribute
 
-        At this time, onset_files must be formatted as a list of
+        At this time, personality_files must be formatted as a list of
         (file_path, file_content) pairs for compatibility with the
         underlying compute service.
         """
-        onset_files = []
+        personality_files = []
         for item in personality:
             try:
                 path = item['path']
@@ -160,8 +160,8 @@ class Controller(wsgi.Controller):
             except TypeError:
                 msg = 'Personality content for %s cannot be decoded' % path
                 raise exc.HTTPBadRequest(explanation=msg)
-            onset_files.append((path, contents))
-        return onset_files
+            personality_files.append((path, contents))
+        return personality_files
 
     def create(self, req):
         """ Creates a new server for a given user """
@@ -191,7 +191,7 @@ class Controller(wsgi.Controller):
                 metadata.append({'key': k, 'value': v})
 
         personality = env['server'].get('personality', [])
-        onset_files = self._get_onset_files_from_personality(personality)
+        personality_files = self._get_personality_files(personality)
 
         instances = self.compute_api.create(
             context,
@@ -204,7 +204,7 @@ class Controller(wsgi.Controller):
             key_name=key_pair['name'],
             key_data=key_pair['public_key'],
             metadata=metadata,
-            onset_files=onset_files)
+            personality_files=personality_files)
         return _translate_keys(instances[0])
 
     def update(self, req, id):
diff --git a/nova/compute/api.py b/nova/compute/api.py
index 44e583cd4..13938dcde 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -106,7 +106,7 @@ class API(base.Base):
                display_name='', display_description='',
                key_name=None, key_data=None, security_group='default',
                availability_zone=None, user_data=None, metadata=[],
-               onset_files=None):
+               personality_files=None):
         """Create the number of instances requested if quota and
         other arguments check out ok.
         """
@@ -144,9 +144,9 @@ class API(base.Base):
                 LOG.warn(msg)
                 raise quota.QuotaError(msg, "MetadataLimitExceeded")
 
-        if onset_files is not None:
-            onset_files = \
-                self._check_personality_file_quota(context, onset_files)
+        if personality_files is not None:
+            personality_files = \
+                self._check_personality_file_quota(context, personality_files)
 
         image = self.image_service.show(context, image_id)
         if kernel_id is None:
@@ -242,7 +242,7 @@ class API(base.Base):
                       "args": {"topic": FLAGS.compute_topic,
                                "instance_id": instance_id,
                                "availability_zone": availability_zone,
-                               "onset_files": onset_files}})
+                               "personality_files": personality_files}})
 
         for group_id in security_groups:
             self.trigger_security_group_members_refresh(elevated, group_id)
diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index d659712ad..1a392dda8 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -174,7 +174,7 @@ class ComputeManager(manager.Manager):
         """Launch a new instance with specified options."""
         context = context.elevated()
         instance_ref = self.db.instance_get(context, instance_id)
-        instance_ref.onset_files = kwargs.get('onset_files', [])
+        instance_ref.onset_files = kwargs.get('personality_files', [])
         if instance_ref['name'] in self.driver.list_instances():
             raise exception.Error(_("Instance has already been created"))
         LOG.audit(_("instance %s: starting..."), instance_id,
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 53cfa3a6e..bf934113a 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -241,13 +241,13 @@ class ServersTest(test.TestCase):
         class FakeComputeAPI(object):
 
             def __init__(self):
-                self.onset_files = None
+                self.personality_files = None
 
             def create(self, *args, **kwargs):
-                if 'onset_files' in kwargs:
-                    self.onset_files = kwargs['onset_files']
+                if 'personality_files' in kwargs:
+                    self.personality_files = kwargs['personality_files']
                 else:
-                    self.onset_files = None
+                    self.personality_files = None
                 return [{'id': '1234', 'display_name': 'fakeinstance'}]
 
         def make_stub_method(canned_return):
@@ -271,32 +271,33 @@ class ServersTest(test.TestCase):
         req = webob.Request.blank('/v1.0/servers')
         req.method = 'POST'
         req.body = json.dumps(body)
-        return req, req.get_response(fakes.wsgi_app()), compute_api.onset_files
+        return (req, req.get_response(fakes.wsgi_app()),
+                compute_api.personality_files)
 
     def test_create_instance_with_no_personality(self):
-        request, response, onset_files = \
+        request, response, personality_files = \
                 self._create_instance_with_personality(personality=None)
         self.assertEquals(response.status_int, 200)
-        self.assertEquals(onset_files, [])
+        self.assertEquals(personality_files, [])
 
     def test_create_instance_with_personality(self):
         path = '/my/file/path'
         contents = '#!/bin/bash\necho "Hello, World!"\n'
         b64contents = base64.b64encode(contents)
         personality = [self._personality_dict(path, b64contents)]
-        request, response, onset_files = \
+        request, response, personality_files = \
             self._create_instance_with_personality(personality)
         self.assertEquals(response.status_int, 200)
-        self.assertEquals(onset_files, [(path, contents)]) 
+        self.assertEquals(personality_files, [(path, contents)])
 
     def test_create_instance_with_personality_with_non_b64_content(self):
         path = '/my/file/path'
         contents = '#!/bin/bash\necho "Oh no!"\n'
         personality = [self._personality_dict(path, contents)]
-        request, response, onset_files = \
+        request, response, personality_files = \
             self._create_instance_with_personality(personality)
         self.assertEquals(response.status_int, 400)
-        self.assertEquals(onset_files, None)
+        self.assertEquals(personality_files, None)
 
     def test_create_instance_with_three_personalities(self):
         files = [
@@ -308,28 +309,28 @@ class ServersTest(test.TestCase):
         for path, content in files:
             personality.append(self._personality_dict(
                     path, base64.b64encode(content)))
-        request, response, onset_files = \
+        request, response, personality_files = \
             self._create_instance_with_personality(personality)
         self.assertEquals(response.status_int, 200)
-        self.assertEquals(onset_files, files)
+        self.assertEquals(personality_files, files)
 
     def test_create_instance_personality_empty_content(self):
         path = '/my/file/path'
         contents = ''
         personality = [self._personality_dict(path, contents)]
-        request, response, onset_files = \
+        request, response, personality_files = \
             self._create_instance_with_personality(personality)
         self.assertEquals(response.status_int, 200)
-        self.assertEquals(onset_files, [(path, contents)])
+        self.assertEquals(personality_files, [(path, contents)])
 
     def test_create_instance_personality_not_a_list(self):
         path = '/my/file/path'
         contents = 'myfilecontents'
         personality = self._personality_dict(path, contents)
-        request, response, onset_files = \
+        request, response, personality_files = \
             self._create_instance_with_personality(personality)
         self.assertEquals(response.status_int, 400)
-        self.assertEquals(onset_files, None)
+        self.assertEquals(personality_files, None)
 
     def test_update_no_body(self):
         req = webob.Request.blank('/v1.0/servers/1')
diff --git a/nova/tests/test_quota.py b/nova/tests/test_quota.py
index 16a083788..b26dec61a 100644
--- a/nova/tests/test_quota.py
+++ b/nova/tests/test_quota.py
@@ -186,7 +186,7 @@ class QuotaTestCase(test.TestCase):
         api = compute.API()
         api.create(self.context, min_count=1, max_count=1,
                 instance_type='m1.small', image_id='fake',
-                onset_files=files)
+                personality_files=files)
 
     def test_no_personality_files(self):
         api = compute.API()
-- 
cgit 


From 0a9ba675c88ae0b2a18f47524d24075409261658 Mon Sep 17 00:00:00 2001
From: Tushar Patil <tushar.vitthal.patil@gmail.com>
Date: Thu, 3 Mar 2011 15:39:23 -0800
Subject: altered ra_server name to gateway_v6

---
 .../versions/007_add_ipv6_flatmanager.py           | 14 ++--
 .../versions/007_add_ipv6_to_fixed_ips.py          | 90 ----------------------
 2 files changed, 6 insertions(+), 98 deletions(-)
 delete mode 100644 nova/db/sqlalchemy/migrate_repo/versions/007_add_ipv6_to_fixed_ips.py

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/migrate_repo/versions/007_add_ipv6_flatmanager.py b/nova/db/sqlalchemy/migrate_repo/versions/007_add_ipv6_flatmanager.py
index e09f46652..937712970 100644
--- a/nova/db/sqlalchemy/migrate_repo/versions/007_add_ipv6_flatmanager.py
+++ b/nova/db/sqlalchemy/migrate_repo/versions/007_add_ipv6_flatmanager.py
@@ -28,7 +28,10 @@ meta = MetaData()
 #
 networks = Table('networks', meta,
         Column('id', Integer(),  primary_key=True, nullable=False),
-        )
+        Column('ra_server', String(length=255, convert_unicode=False,
+               assert_unicode=None, unicode_error=None,
+               _warn_on_bytestring=False))
+              )
 
 #
 # New Tables
@@ -43,12 +46,6 @@ networks = Table('networks', meta,
 #
 # Columns to add to existing tables
 #
-
-networks_gateway_v6 = Column(
-        'gateway_v6',
-        String(length=255, convert_unicode=False, assert_unicode=None,
-               unicode_error=None, _warn_on_bytestring=False))
-
 networks_netmask_v6 = Column(
         'netmask_v6',
         String(length=255, convert_unicode=False, assert_unicode=None,
@@ -60,6 +57,7 @@ def upgrade(migrate_engine):
     # bind migrate_engine to your metadata
     meta.bind = migrate_engine
 
+    # Alter column name
+    networks.c.ra_server.alter(name='gateway_v6')
     # Add columns to existing tables
-    networks.create_column(networks_gateway_v6)
     networks.create_column(networks_netmask_v6)
diff --git a/nova/db/sqlalchemy/migrate_repo/versions/007_add_ipv6_to_fixed_ips.py b/nova/db/sqlalchemy/migrate_repo/versions/007_add_ipv6_to_fixed_ips.py
deleted file mode 100644
index 427934d53..000000000
--- a/nova/db/sqlalchemy/migrate_repo/versions/007_add_ipv6_to_fixed_ips.py
+++ /dev/null
@@ -1,90 +0,0 @@
-# Copyright 2011 OpenStack LLC
-# 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.
-
-from sqlalchemy import *
-from migrate import *
-
-from nova import log as logging
-
-
-meta = MetaData()
-
-
-# Table stub-definitions
-# Just for the ForeignKey and column creation to succeed, these are not the
-# actual definitions of instances or services.
-#
-fixed_ips = Table(
-    "fixed_ips",
-    meta,
-    Column(
-        "id",
-        Integer(),
-        primary_key=True,
-        nullable=False))
-
-#
-# New Tables
-#
-# None
-
-#
-# Tables to alter
-#
-# None
-
-#
-# Columns to add to existing tables
-#
-
-fixed_ips_addressV6 = Column(
-    "addressV6",
-    String(
-        length=255,
-        convert_unicode=False,
-        assert_unicode=None,
-        unicode_error=None,
-        _warn_on_bytestring=False))
-
-
-fixed_ips_netmaskV6 = Column(
-    "netmaskV6",
-    String(
-        length=3,
-        convert_unicode=False,
-        assert_unicode=None,
-        unicode_error=None,
-        _warn_on_bytestring=False))
-
-
-fixed_ips_gatewayV6 = Column(
-    "gatewayV6",
-    String(
-        length=255,
-        convert_unicode=False,
-        assert_unicode=None,
-        unicode_error=None,
-        _warn_on_bytestring=False))
-
-
-def upgrade(migrate_engine):
-    # Upgrade operations go here. Don't create your own engine;
-    # bind migrate_engine to your metadata
-    meta.bind = migrate_engine
-
-    # Add columns to existing tables
-    fixed_ips.create_column(fixed_ips_addressV6)
-    fixed_ips.create_column(fixed_ips_netmaskV6)
-    fixed_ips.create_column(fixed_ips_gatewayV6)
-- 
cgit 


From 35be7d39866f6ac1017dd94d33d9c01f47a6bc74 Mon Sep 17 00:00:00 2001
From: Tushar Patil <tushar.vitthal.patil@gmail.com>
Date: Thu, 3 Mar 2011 15:44:01 -0800
Subject: Removed properties added to fixed_ips by xs-ipv6 BP

---
 nova/db/sqlalchemy/models.py | 3 ---
 nova/network/manager.py      | 2 +-
 2 files changed, 1 insertion(+), 4 deletions(-)

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/models.py b/nova/db/sqlalchemy/models.py
index 4c94cd3db..7b4683427 100644
--- a/nova/db/sqlalchemy/models.py
+++ b/nova/db/sqlalchemy/models.py
@@ -458,9 +458,6 @@ class FixedIp(BASE, NovaBase):
     allocated = Column(Boolean, default=False)
     leased = Column(Boolean, default=False)
     reserved = Column(Boolean, default=False)
-    addressV6 = Column(String(255))
-    netmaskV6 = Column(String(3))
-    gatewayV6 = Column(String(255))
 
 
 class User(BASE, NovaBase):
diff --git a/nova/network/manager.py b/nova/network/manager.py
index fb6e16772..686ab9732 100644
--- a/nova/network/manager.py
+++ b/nova/network/manager.py
@@ -167,7 +167,7 @@ class NetworkManager(manager.Manager):
         #             with a network, or a cluster of computes with a network
         #             and use that network here with a method like
         #             network_get_by_compute_host
-        network_ref = self.db.network_get_by_bridge(context,
+        network_ref = self.db.network_get_by_bridge(context.elevated(),
                                                     FLAGS.flat_network_bridge)
         address = self.db.fixed_ip_associate_pool(context.elevated(),
                                                   network_ref['id'],
-- 
cgit 


From aa09f87060c1d1885b7a557ff26a3c421ad42df8 Mon Sep 17 00:00:00 2001
From: Tushar Patil <tushar.vitthal.patil@gmail.com>
Date: Thu, 3 Mar 2011 17:31:37 -0800
Subject: remove ra_server from model and fix migration issue while running
 unit tests

---
 .../versions/007_add_ipv6_flatmanager.py           | 60 +++++++++++++++++++---
 nova/db/sqlalchemy/models.py                       |  2 -
 2 files changed, 54 insertions(+), 8 deletions(-)

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/migrate_repo/versions/007_add_ipv6_flatmanager.py b/nova/db/sqlalchemy/migrate_repo/versions/007_add_ipv6_flatmanager.py
index 937712970..d14f52af1 100644
--- a/nova/db/sqlalchemy/migrate_repo/versions/007_add_ipv6_flatmanager.py
+++ b/nova/db/sqlalchemy/migrate_repo/versions/007_add_ipv6_flatmanager.py
@@ -12,6 +12,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.
+from lib2to3.fixer_util import String
 
 from sqlalchemy import *
 from migrate import *
@@ -27,12 +28,59 @@ meta = MetaData()
 # actual definitions of instances or services.
 #
 networks = Table('networks', meta,
+        Column('created_at', DateTime(timezone=False)),
+        Column('updated_at', DateTime(timezone=False)),
+        Column('deleted_at', DateTime(timezone=False)),
+        Column('deleted', Boolean(create_constraint=True, name=None)),
         Column('id', Integer(),  primary_key=True, nullable=False),
-        Column('ra_server', String(length=255, convert_unicode=False,
-               assert_unicode=None, unicode_error=None,
-               _warn_on_bytestring=False))
-              )
-
+        Column('injected', Boolean(create_constraint=True, name=None)),
+        Column('cidr',
+               String(length=255, convert_unicode=False, assert_unicode=None,
+                      unicode_error=None, _warn_on_bytestring=False)),
+        Column('netmask',
+               String(length=255, convert_unicode=False, assert_unicode=None,
+                      unicode_error=None, _warn_on_bytestring=False)),
+        Column('bridge',
+               String(length=255, convert_unicode=False, assert_unicode=None,
+                      unicode_error=None, _warn_on_bytestring=False)),
+        Column('gateway',
+               String(length=255, convert_unicode=False, assert_unicode=None,
+                      unicode_error=None, _warn_on_bytestring=False)),
+        Column('broadcast',
+               String(length=255, convert_unicode=False, assert_unicode=None,
+                      unicode_error=None, _warn_on_bytestring=False)),
+        Column('dns',
+               String(length=255, convert_unicode=False, assert_unicode=None,
+                      unicode_error=None, _warn_on_bytestring=False)),
+        Column('vlan', Integer()),
+        Column('vpn_public_address',
+               String(length=255, convert_unicode=False, assert_unicode=None,
+                      unicode_error=None, _warn_on_bytestring=False)),
+        Column('vpn_public_port', Integer()),
+        Column('vpn_private_address',
+               String(length=255, convert_unicode=False, assert_unicode=None,
+                      unicode_error=None, _warn_on_bytestring=False)),
+        Column('dhcp_start',
+               String(length=255, convert_unicode=False, assert_unicode=None,
+                      unicode_error=None, _warn_on_bytestring=False)),
+        Column('project_id',
+               String(length=255, convert_unicode=False, assert_unicode=None,
+                      unicode_error=None, _warn_on_bytestring=False)),
+        Column('host',
+               String(length=255, convert_unicode=False, assert_unicode=None,
+                      unicode_error=None, _warn_on_bytestring=False)),
+        Column('cidr_v6',
+        String(length=255, convert_unicode=False, assert_unicode=None,
+               unicode_error=None, _warn_on_bytestring=False)),
+        Column(
+        'ra_server',
+        String(length=255, convert_unicode=False, assert_unicode=None,
+               unicode_error=None, _warn_on_bytestring=False)),
+        Column(
+        'label',
+        String(length=255, convert_unicode=False, assert_unicode=None,
+               unicode_error=None, _warn_on_bytestring=False))
+        )
 #
 # New Tables
 #
@@ -59,5 +107,5 @@ def upgrade(migrate_engine):
 
     # Alter column name
     networks.c.ra_server.alter(name='gateway_v6')
-    # Add columns to existing tables
+    # Add new column to existing table
     networks.create_column(networks_netmask_v6)
diff --git a/nova/db/sqlalchemy/models.py b/nova/db/sqlalchemy/models.py
index 7b4683427..14ff46647 100644
--- a/nova/db/sqlalchemy/models.py
+++ b/nova/db/sqlalchemy/models.py
@@ -402,8 +402,6 @@ class Network(BASE, NovaBase):
     cidr = Column(String(255), unique=True)
     cidr_v6 = Column(String(255), unique=True)
 
-    ra_server = Column(String(255))
-
     gateway_v6 = Column(String(255))
     netmask_v6 = Column(String(255))
     netmask = Column(String(255))
-- 
cgit 


From a433ddeda77aaa4462694661ecdca71eed6db669 Mon Sep 17 00:00:00 2001
From: Vishvananda Ishaya <vishvananda@gmail.com>
Date: Fri, 4 Mar 2011 02:36:55 +0000
Subject: Replace objectstore images with S3 image service backending to glance
 or local

---
 nova/api/ec2/cloud.py             | 127 +++++++++--------
 nova/flags.py                     |   2 +-
 nova/image/glance.py              |  29 ++--
 nova/image/s3.py                  | 280 ++++++++++++++++++++++++++++----------
 nova/image/service.py             |   4 +-
 nova/tests/api/openstack/fakes.py |  11 +-
 nova/tests/fake_flags.py          |   1 +
 nova/tests/test_cloud.py          |  22 ++-
 nova/tests/test_compute.py        |   7 +-
 nova/tests/test_direct.py         |   3 +-
 nova/tests/test_quota.py          |   6 +-
 11 files changed, 333 insertions(+), 159 deletions(-)

(limited to 'nova')

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 844ccbe5e..8c2e77d86 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -39,7 +39,9 @@ from nova import log as logging
 from nova import network
 from nova import utils
 from nova import volume
+from nova.api.ec2 import ec2utils
 from nova.compute import instance_types
+from nova.image import s3
 
 
 FLAGS = flags.FLAGS
@@ -73,30 +75,19 @@ def _gen_key(context, user_id, key_name):
     return {'private_key': private_key, 'fingerprint': fingerprint}
 
 
-def ec2_id_to_id(ec2_id):
-    """Convert an ec2 ID (i-[base 16 number]) to an instance id (int)"""
-    return int(ec2_id.split('-')[-1], 16)
-
-
-def id_to_ec2_id(instance_id, template='i-%08x'):
-    """Convert an instance ID (int) to an ec2 ID (i-[base 16 number])"""
-    return template % instance_id
-
-
 class CloudController(object):
     """ CloudController provides the critical dispatch between
  inbound API calls through the endpoint and messages
  sent to the other nodes.
 """
     def __init__(self):
-        self.image_service = utils.import_object(FLAGS.image_service)
+        self.image_service = s3.S3ImageService()
         self.network_api = network.API()
         self.volume_api = volume.API()
         self.compute_api = compute.API(
                 network_api=self.network_api,
-                image_service=self.image_service,
                 volume_api=self.volume_api,
-                hostname_factory=id_to_ec2_id)
+                hostname_factory=ec2utils.id_to_ec2_id)
         self.setup()
 
     def __str__(self):
@@ -154,7 +145,7 @@ class CloudController(object):
         availability_zone = self._get_availability_zone_by_host(ctxt, host)
         floating_ip = db.instance_get_floating_address(ctxt,
                                                        instance_ref['id'])
-        ec2_id = id_to_ec2_id(instance_ref['id'])
+        ec2_id = ec2utils.id_to_ec2_id(instance_ref['id'])
         data = {
             'user-data': base64.b64decode(instance_ref['user_data']),
             'meta-data': {
@@ -525,7 +516,7 @@ class CloudController(object):
             ec2_id = instance_id[0]
         else:
             ec2_id = instance_id
-        instance_id = ec2_id_to_id(ec2_id)
+        instance_id = ec2utils.ec2_id_to_id(ec2_id)
         output = self.compute_api.get_console_output(
                 context, instance_id=instance_id)
         now = datetime.datetime.utcnow()
@@ -535,7 +526,7 @@ class CloudController(object):
 
     def get_ajax_console(self, context, instance_id, **kwargs):
         ec2_id = instance_id[0]
-        instance_id = ec2_id_to_id(ec2_id)
+        instance_id = ec2utils.ec2_id_to_id(ec2_id)
         return self.compute_api.get_ajax_console(context,
                                                  instance_id=instance_id)
 
@@ -543,7 +534,7 @@ class CloudController(object):
         if volume_id:
             volumes = []
             for ec2_id in volume_id:
-                internal_id = ec2_id_to_id(ec2_id)
+                internal_id = ec2utils.ec2_id_to_id(ec2_id)
                 volume = self.volume_api.get(context, internal_id)
                 volumes.append(volume)
         else:
@@ -556,11 +547,11 @@ class CloudController(object):
         instance_data = None
         if volume.get('instance', None):
             instance_id = volume['instance']['id']
-            instance_ec2_id = id_to_ec2_id(instance_id)
+            instance_ec2_id = ec2utils.id_to_ec2_id(instance_id)
             instance_data = '%s[%s]' % (instance_ec2_id,
                                         volume['instance']['host'])
         v = {}
-        v['volumeId'] = id_to_ec2_id(volume['id'], 'vol-%08x')
+        v['volumeId'] = ec2utils.id_to_ec2_id(volume['id'], 'vol-%08x')
         v['status'] = volume['status']
         v['size'] = volume['size']
         v['availabilityZone'] = volume['availability_zone']
@@ -578,8 +569,7 @@ class CloudController(object):
                                    'device': volume['mountpoint'],
                                    'instanceId': instance_ec2_id,
                                    'status': 'attached',
-                                   'volumeId': id_to_ec2_id(volume['id'],
-                                                            'vol-%08x')}]
+                                   'volumeId': v['volumeId']}]
         else:
             v['attachmentSet'] = [{}]
 
@@ -598,12 +588,12 @@ class CloudController(object):
         return {'volumeSet': [self._format_volume(context, dict(volume))]}
 
     def delete_volume(self, context, volume_id, **kwargs):
-        volume_id = ec2_id_to_id(volume_id)
+        volume_id = ec2utils.ec2_id_to_id(volume_id)
         self.volume_api.delete(context, volume_id=volume_id)
         return True
 
     def update_volume(self, context, volume_id, **kwargs):
-        volume_id = ec2_id_to_id(volume_id)
+        volume_id = ec2utils.ec2_id_to_id(volume_id)
         updatable_fields = ['display_name', 'display_description']
         changes = {}
         for field in updatable_fields:
@@ -614,8 +604,8 @@ class CloudController(object):
         return True
 
     def attach_volume(self, context, volume_id, instance_id, device, **kwargs):
-        volume_id = ec2_id_to_id(volume_id)
-        instance_id = ec2_id_to_id(instance_id)
+        volume_id = ec2utils.ec2_id_to_id(volume_id)
+        instance_id = ec2utils.ec2_id_to_id(instance_id)
         msg = _("Attach volume %(volume_id)s to instance %(instance_id)s"
                 " at %(device)s") % locals()
         LOG.audit(msg, context=context)
@@ -626,22 +616,22 @@ class CloudController(object):
         volume = self.volume_api.get(context, volume_id)
         return {'attachTime': volume['attach_time'],
                 'device': volume['mountpoint'],
-                'instanceId': id_to_ec2_id(instance_id),
+                'instanceId': ec2utils.id_to_ec2_id(instance_id),
                 'requestId': context.request_id,
                 'status': volume['attach_status'],
-                'volumeId': id_to_ec2_id(volume_id, 'vol-%08x')}
+                'volumeId': ec2utils.id_to_ec2_id(volume_id, 'vol-%08x')}
 
     def detach_volume(self, context, volume_id, **kwargs):
-        volume_id = ec2_id_to_id(volume_id)
+        volume_id = ec2utils.ec2_id_to_id(volume_id)
         LOG.audit(_("Detach volume %s"), volume_id, context=context)
         volume = self.volume_api.get(context, volume_id)
         instance = self.compute_api.detach_volume(context, volume_id=volume_id)
         return {'attachTime': volume['attach_time'],
                 'device': volume['mountpoint'],
-                'instanceId': id_to_ec2_id(instance['id']),
+                'instanceId': ec2utils.id_to_ec2_id(instance['id']),
                 'requestId': context.request_id,
                 'status': volume['attach_status'],
-                'volumeId': id_to_ec2_id(volume_id, 'vol-%08x')}
+                'volumeId': ec2utils.id_to_ec2_id(volume_id, 'vol-%08x')}
 
     def _convert_to_set(self, lst, label):
         if lst == None or lst == []:
@@ -675,7 +665,7 @@ class CloudController(object):
         if instance_id:
             instances = []
             for ec2_id in instance_id:
-                internal_id = ec2_id_to_id(ec2_id)
+                internal_id = ec2utils.ec2_id_to_id(ec2_id)
                 instance = self.compute_api.get(context,
                                                 instance_id=internal_id)
                 instances.append(instance)
@@ -687,7 +677,7 @@ class CloudController(object):
                     continue
             i = {}
             instance_id = instance['id']
-            ec2_id = id_to_ec2_id(instance_id)
+            ec2_id = ec2utils.id_to_ec2_id(instance_id)
             i['instanceId'] = ec2_id
             i['imageId'] = instance['image_id']
             i['instanceState'] = {
@@ -755,7 +745,7 @@ class CloudController(object):
             if (floating_ip_ref['fixed_ip']
                 and floating_ip_ref['fixed_ip']['instance']):
                 instance_id = floating_ip_ref['fixed_ip']['instance']['id']
-                ec2_id = id_to_ec2_id(instance_id)
+                ec2_id = ec2utils.id_to_ec2_id(instance_id)
             address_rv = {'public_ip': address,
                           'instance_id': ec2_id}
             if context.is_admin:
@@ -778,7 +768,7 @@ class CloudController(object):
     def associate_address(self, context, instance_id, public_ip, **kwargs):
         LOG.audit(_("Associate address %(public_ip)s to"
                 " instance %(instance_id)s") % locals(), context=context)
-        instance_id = ec2_id_to_id(instance_id)
+        instance_id = ec2utils.ec2_id_to_id(instance_id)
         self.compute_api.associate_floating_ip(context,
                                                instance_id=instance_id,
                                                address=public_ip)
@@ -791,13 +781,17 @@ class CloudController(object):
 
     def run_instances(self, context, **kwargs):
         max_count = int(kwargs.get('max_count', 1))
+        if kwargs.get('kernel_id'):
+            kwargs['kernel_id'] = ec2utils.ec2_id_to_id(kwargs['kernel_id'])
+        if kwargs.get('ramdisk_id'):
+            kwargs['ramdisk_id'] = ec2utils.ec2_id_to_id(kwargs['ramdisk_id'])
         instances = self.compute_api.create(context,
             instance_type=instance_types.get_by_type(
                 kwargs.get('instance_type', None)),
-            image_id=kwargs['image_id'],
+            image_id=ec2utils.ec2_id_to_id(kwargs['image_id']),
             min_count=int(kwargs.get('min_count', max_count)),
             max_count=max_count,
-            kernel_id=kwargs.get('kernel_id', None),
+            kernel_id=kwargs.get('kernel_id'),
             ramdisk_id=kwargs.get('ramdisk_id'),
             display_name=kwargs.get('display_name'),
             display_description=kwargs.get('display_description'),
@@ -814,7 +808,7 @@ class CloudController(object):
         instance_id is a kwarg so its name cannot be modified."""
         LOG.debug(_("Going to start terminating instances"))
         for ec2_id in instance_id:
-            instance_id = ec2_id_to_id(ec2_id)
+            instance_id = ec2utils.ec2_id_to_id(ec2_id)
             self.compute_api.delete(context, instance_id=instance_id)
         return True
 
@@ -822,19 +816,19 @@ class CloudController(object):
         """instance_id is a list of instance ids"""
         LOG.audit(_("Reboot instance %r"), instance_id, context=context)
         for ec2_id in instance_id:
-            instance_id = ec2_id_to_id(ec2_id)
+            instance_id = ec2utils.ec2_id_to_id(ec2_id)
             self.compute_api.reboot(context, instance_id=instance_id)
         return True
 
     def rescue_instance(self, context, instance_id, **kwargs):
         """This is an extension to the normal ec2_api"""
-        instance_id = ec2_id_to_id(instance_id)
+        instance_id = ec2utils.ec2_id_to_id(instance_id)
         self.compute_api.rescue(context, instance_id=instance_id)
         return True
 
     def unrescue_instance(self, context, instance_id, **kwargs):
         """This is an extension to the normal ec2_api"""
-        instance_id = ec2_id_to_id(instance_id)
+        instance_id = ec2utils.ec2_id_to_id(instance_id)
         self.compute_api.unrescue(context, instance_id=instance_id)
         return True
 
@@ -845,41 +839,50 @@ class CloudController(object):
             if field in kwargs:
                 changes[field] = kwargs[field]
         if changes:
-            instance_id = ec2_id_to_id(ec2_id)
+            instance_id = ec2utils.ec2_id_to_id(ec2_id)
             self.compute_api.update(context, instance_id=instance_id, **kwargs)
         return True
 
-    def _format_image(self, context, image):
+    def _format_image(self, image):
         """Convert from format defined by BaseImageService to S3 format."""
         i = {}
         i['imageId'] = image.get('id')
-        i['kernelId'] = image.get('kernel_id')
-        i['ramdiskId'] = image.get('ramdisk_id')
-        i['imageOwnerId'] = image.get('owner_id')
-        i['imageLocation'] = image.get('location')
-        i['imageState'] = image.get('status')
+        i['kernelId'] = image['properties'].get('kernel_id')
+        i['ramdiskId'] = image['properties'].get('ramdisk_id')
+        i['imageOwnerId'] = image['properties'].get('owner_id')
+        i['imageLocation'] = image['properties'].get('image_location')
+        i['imageState'] = image['properties'].get('image_state')
         i['type'] = image.get('type')
-        i['isPublic'] = image.get('is_public')
-        i['architecture'] = image.get('architecture')
+        i['isPublic'] = image['properties'].get('is_public') == 'True'
+        i['architecture'] = image['properties'].get('architecture')
         return i
 
     def describe_images(self, context, image_id=None, **kwargs):
         # NOTE: image_id is a list!
-        images = self.image_service.index(context)
         if image_id:
-            images = filter(lambda x: x['id'] in image_id, images)
-        images = [self._format_image(context, i) for i in images]
+            images = []
+            for ec2_id in image_id:
+                try:
+                    image = self.image_service.show(context, ec2_id)
+                except exception.NotFound:
+                    raise exception.NotFound(_('Image %s not found') %
+                                             ec2_id)
+                images.append(image)
+        else:
+            images = self.image_service.detail(context)
+        images = [self._format_image(i) for i in images]
         return {'imagesSet': images}
 
     def deregister_image(self, context, image_id, **kwargs):
         LOG.audit(_("De-registering image %s"), image_id, context=context)
-        self.image_service.deregister(context, image_id)
+        self.image_service.delete(context, image_id)
         return {'imageId': image_id}
 
     def register_image(self, context, image_location=None, **kwargs):
         if image_location is None and 'name' in kwargs:
             image_location = kwargs['name']
-        image_id = self.image_service.register(context, image_location)
+        image = {"image_location": image_location}
+        image_id = self.image_service.create(context, image)
         msg = _("Registered image %(image_location)s with"
                 " id %(image_id)s") % locals()
         LOG.audit(msg, context=context)
@@ -890,11 +893,10 @@ class CloudController(object):
             raise exception.ApiError(_('attribute not supported: %s')
                                      % attribute)
         try:
-            image = self._format_image(context,
-                                       self.image_service.show(context,
+            image = self._format_image(self.image_service.show(context,
                                                                image_id))
-        except IndexError:
-            raise exception.ApiError(_('invalid id: %s') % image_id)
+        except (IndexError, exception.NotFound):
+            raise exception.NotFound(_('Image %s not found') % image_id)
         result = {'image_id': image_id, 'launchPermission': []}
         if image['isPublic']:
             result['launchPermission'].append({'group': 'all'})
@@ -913,7 +915,14 @@ class CloudController(object):
         if not operation_type in ['add', 'remove']:
             raise exception.ApiError(_('operation_type must be add or remove'))
         LOG.audit(_("Updating image %s publicity"), image_id, context=context)
-        return self.image_service.modify(context, image_id, operation_type)
+
+        try:
+            metadata = self.image_service.show(context, image_id)
+        except exception.NotFound:
+            raise exception.NotFound(_('Image %s not found') % image_id)
+        del(metadata['id'])
+        metadata['properties']['is_public'] = (operation_type == 'add')
+        return self.image_service.update(context, image_id, metadata)
 
     def update_image(self, context, image_id, **kwargs):
         result = self.image_service.update(context, image_id, dict(kwargs))
diff --git a/nova/flags.py b/nova/flags.py
index 8cf199b2f..f01a4d096 100644
--- a/nova/flags.py
+++ b/nova/flags.py
@@ -346,7 +346,7 @@ DEFINE_string('scheduler_manager', 'nova.scheduler.manager.SchedulerManager',
               'Manager for scheduler')
 
 # The service to use for image search and retrieval
-DEFINE_string('image_service', 'nova.image.s3.S3ImageService',
+DEFINE_string('image_service', 'nova.image.glance.GlanceImageService',
               'The service to use for retrieving and searching for images.')
 
 DEFINE_string('host', socket.gethostname(),
diff --git a/nova/image/glance.py b/nova/image/glance.py
index 593c4bce6..7db94c0d4 100644
--- a/nova/image/glance.py
+++ b/nova/image/glance.py
@@ -21,6 +21,8 @@ import httplib
 import json
 import urlparse
 
+from glance.common import exception as glance_exception
+
 from nova import exception
 from nova import flags
 from nova import log as logging
@@ -57,27 +59,32 @@ class GlanceImageService(service.BaseImageService):
         """
         Returns a dict containing image data for the given opaque image id.
         """
-        image = self.client.get_image_meta(id)
-        if image:
-            return image
-        raise exception.NotFound
+        try:
+            image = self.client.get_image_meta(id)
+        except glance_exception.NotFound:
+            raise exception.NotFound
+        return image
 
-    def create(self, context, data):
+    def create(self, context, metadata, data=None):
         """
         Store the image data and return the new image id.
 
         :raises AlreadyExists if the image already exist.
 
         """
-        return self.client.add_image(image_meta=data)
+        return self.client.add_image(metadata, data)
 
-    def update(self, context, image_id, data):
+    def update(self, context, image_id, metadata, data=None):
         """Replace the contents of the given image with the new data.
 
         :raises NotFound if the image does not exist.
 
         """
-        return self.client.update_image(image_id, data)
+        try:
+            result = self.client.update_image(image_id, metadata, data)
+        except glance_exception.NotFound:
+            raise exception.NotFound
+        return result
 
     def delete(self, context, image_id):
         """
@@ -86,7 +93,11 @@ class GlanceImageService(service.BaseImageService):
         :raises NotFound if the image does not exist.
 
         """
-        return self.client.delete_image(image_id)
+        try:
+            result = self.client.delete_image(image_id)
+        except glance_exception.NotFound:
+            raise exception.NotFound
+        return result
 
     def delete_all(self):
         """
diff --git a/nova/image/s3.py b/nova/image/s3.py
index 14135a1ee..a740b010c 100644
--- a/nova/image/s3.py
+++ b/nova/image/s3.py
@@ -21,8 +21,12 @@ Proxy AMI-related calls from the cloud controller, to the running
 objectstore service.
 """
 
-import json
-import urllib
+import binascii
+import os
+import shutil
+import tarfile
+import tempfile
+from xml.etree import ElementTree
 
 import boto.s3.connection
 
@@ -31,84 +35,89 @@ from nova import flags
 from nova import utils
 from nova.auth import manager
 from nova.image import service
+from nova.api.ec2 import ec2utils
 
 
 FLAGS = flags.FLAGS
+flags.DEFINE_string('image_decryption_dir', '/tmp',
+                    'parent dir for tempdir used for image decryption')
 
 
-def map_s3_to_base(image):
-    """Convert from S3 format to format defined by BaseImageService."""
-    i = {}
-    i['id'] = image.get('imageId')
-    i['name'] = image.get('imageId')
-    i['kernel_id'] = image.get('kernelId')
-    i['ramdisk_id'] = image.get('ramdiskId')
-    i['location'] = image.get('imageLocation')
-    i['owner_id'] = image.get('imageOwnerId')
-    i['status'] = image.get('imageState')
-    i['type'] = image.get('type')
-    i['is_public'] = image.get('isPublic')
-    i['architecture'] = image.get('architecture')
-    return i
+_type_prefix_map = {'machine': 'ami',
+                    'kernel': 'aki',
+                    'ramdisk': 'ari'}
+
+
+def image_ec2_id(image_id, image_type):
+    prefix = _type_prefix_map[image_type]
+    template = prefix + '-%08x'
+    return ec2utils.id_to_ec2_id(int(image_id), template=template)
 
 
 class S3ImageService(service.BaseImageService):
+    def __init__(self, service=None, *args, **kwargs):
+        if service == None:
+            service = utils.import_object(FLAGS.image_service)
+        self.service = service
+        self.service.__init__(*args, **kwargs)
+
+    def create(self, context, properties, data=None):
+        """image should contain image_location"""
+        image_id, metadata = self._s3_create(context, properties)
+        return image_ec2_id(image_id, metadata['type'])
+
+    def delete(self, context, image_id):
+        # FIXME(vish): call to show is to check filter
+        self.show(context, image_id)
+        image_id = ec2utils.ec2_id_to_id(image_id)
+        self.service.delete(context, image_id)
 
-    def modify(self, context, image_id, operation):
-        self._conn(context).make_request(
-            method='POST',
-            bucket='_images',
-            query_args=self._qs({'image_id': image_id,
-                                 'operation': operation}))
-        return True
-
-    def update(self, context, image_id, attributes):
-        """update an image's attributes / info.json"""
-        attributes.update({"image_id": image_id})
-        self._conn(context).make_request(
-            method='POST',
-            bucket='_images',
-            query_args=self._qs(attributes))
-        return True
-
-    def register(self, context, image_location):
-        """ rpc call to register a new image based from a manifest """
-        image_id = utils.generate_uid('ami')
-        self._conn(context).make_request(
-            method='PUT',
-            bucket='_images',
-            query_args=self._qs({'image_location': image_location,
-                                 'image_id': image_id}))
-        return image_id
+    def update(self, context, image_id, metadata, data=None):
+        # FIXME(vish): call to show is to check filter
+        self.show(context, image_id)
+        image_id = ec2utils.ec2_id_to_id(image_id)
+        image = self.service.update(context, image_id, metadata, data)
+        image['id'] = image_ec2_id(image['id'], image['type'])
+        return image
 
     def index(self, context):
-        """Return a list of all images that a user can see."""
-        response = self._conn(context).make_request(
-            method='GET',
-            bucket='_images')
-        images = json.loads(response.read())
-        return [map_s3_to_base(i) for i in images]
+        images = self.service.index(context)
+        # FIXME(vish): index doesn't filter so we do it manually
+        return self._filter(context, images)
+
+    def detail(self, context):
+        images = self.service.detail(context)
+        # FIXME(vish): detail doesn't filter so we do it manually
+        return self._filter(context, images)
+
+    @staticmethod
+    def _is_visible(context, image):
+        return (context.is_admin
+                or context.project_id == image['properties']['owner_id']
+                or image['properties']['is_public'] == 'True')
+
+    @staticmethod
+    def _filter(context, images):
+        filtered = []
+        for image in images:
+            if not S3ImageService._is_visible(context, image):
+                continue
+            image['id'] = image_ec2_id(image['id'], image['type'])
+            filtered.append(image)
+        return filtered
 
     def show(self, context, image_id):
-        """return a image object if the context has permissions"""
-        if FLAGS.connection_type == 'fake':
-            return {'imageId': 'bar'}
-        result = self.index(context)
-        result = [i for i in result if i['id'] == image_id]
-        if not result:
-            raise exception.NotFound(_('Image %s could not be found')
-                                     % image_id)
-        image = result[0]
+        image_id = ec2utils.ec2_id_to_id(image_id)
+        image = self.service.show(context, image_id)
+        if not self._is_visible(context, image):
+            raise exception.NotFound
+        image['id'] = image_ec2_id(image['id'], image['type'])
         return image
 
-    def deregister(self, context, image_id):
-        """ unregister an image """
-        self._conn(context).make_request(
-             method='DELETE',
-             bucket='_images',
-             query_args=self._qs({'image_id': image_id}))
-
-    def _conn(self, context):
+    @staticmethod
+    def _conn(context):
+        # TODO(vish): is there a better way to get creds to sign
+        #             for the user?
         access = manager.AuthManager().get_access_key(context.user,
                                                       context.project)
         secret = str(context.user.secret)
@@ -120,8 +129,139 @@ class S3ImageService(service.BaseImageService):
                                                port=FLAGS.s3_port,
                                                host=FLAGS.s3_host)
 
-    def _qs(self, params):
-        pairs = []
-        for key in params.keys():
-            pairs.append(key + '=' + urllib.quote(params[key]))
-        return '&'.join(pairs)
+    @staticmethod
+    def _download_file(bucket, filename, local_dir):
+        key = bucket.get_key(filename)
+        local_filename = os.path.join(local_dir, filename)
+        key.get_contents_to_filename(local_filename)
+        return local_filename
+
+    def _s3_create(self, context, properties):
+        image_path = tempfile.mkdtemp(dir=FLAGS.image_decryption_dir)
+
+        image_location = properties['image_location']
+        bucket_name = image_location.split("/")[0]
+        manifest_path = image_location[len(bucket_name) + 1:]
+        bucket = self._conn(context).get_bucket(bucket_name)
+        key = bucket.get_key(manifest_path)
+        manifest = key.get_contents_as_string()
+
+        manifest = ElementTree.fromstring(manifest)
+        image_type = 'machine'
+
+        try:
+            kernel_id = manifest.find("machine_configuration/kernel_id").text
+            if kernel_id == 'true':
+                image_type = 'kernel'
+                kernel_id = None
+        except:
+            kernel_id = None
+
+        try:
+            ramdisk_id = manifest.find("machine_configuration/ramdisk_id").text
+            if ramdisk_id == 'true':
+                image_type = 'ramdisk'
+                ramdisk_id = None
+        except:
+            ramdisk_id = None
+
+        try:
+            arch = manifest.find("machine_configuration/architecture").text
+        except:
+            arch = 'x86_64'
+
+        properties.update({'owner_id': context.project_id,
+                           'architecture': arch})
+
+        if kernel_id:
+            properties['kernel_id'] = kernel_id
+
+        if ramdisk_id:
+            properties['ramdisk_id'] = ramdisk_id
+
+        properties['is_public'] = False
+        metadata = {'type': image_type,
+                    'status': 'queued',
+                    'is_public': True,
+                    'properties': properties}
+        metadata['properties']['image_state'] = 'pending'
+        image = self.service.create(context, metadata)
+        image_id = image['id']
+
+        parts = []
+        for fn_element in manifest.find("image").getiterator("filename"):
+            part = self._download_file(bucket, fn_element.text, image_path)
+            parts.append(part)
+
+        # NOTE(vish): this may be suboptimal, should we use cat?
+        encrypted_filename = os.path.join(image_path, 'image.encrypted')
+        with open(encrypted_filename, 'w') as combined:
+            for filename in parts:
+                with open(filename) as part:
+                    shutil.copyfileobj(part, combined)
+
+        metadata['properties']['image_state'] = 'decrypting'
+        self.service.update(context, image_id, metadata)
+
+        hex_key = manifest.find("image/ec2_encrypted_key").text
+        encrypted_key = binascii.a2b_hex(hex_key)
+        hex_iv = manifest.find("image/ec2_encrypted_iv").text
+        encrypted_iv = binascii.a2b_hex(hex_iv)
+
+        # FIXME(vish): grab key from common service so this can run on
+        #              any host.
+        cloud_private_key = os.path.join(FLAGS.ca_path, "private/cakey.pem")
+
+        decrypted_filename = os.path.join(image_path, 'image.tar.gz')
+        self._decrypt_image(encrypted_filename, encrypted_key, encrypted_iv,
+                            cloud_private_key, decrypted_filename)
+
+        metadata['properties']['image_state'] = 'untarring'
+        self.service.update(context, image_id, metadata)
+
+        unz_filename = self._untarzip_image(image_path, decrypted_filename)
+
+        metadata['properties']['image_state'] = 'uploading'
+        with open(unz_filename) as image_file:
+            self.service.update(context, image_id, metadata, image_file)
+        metadata['properties']['image_state'] = 'available'
+        self.service.update(context, image_id, metadata)
+
+        shutil.rmtree(image_path)
+        return image_id, metadata
+
+    @staticmethod
+    def _decrypt_image(encrypted_filename, encrypted_key, encrypted_iv,
+                      cloud_private_key, decrypted_filename):
+        key, err = utils.execute(
+                'openssl rsautl -decrypt -inkey %s' % cloud_private_key,
+                process_input=encrypted_key,
+                check_exit_code=False)
+        if err:
+            raise exception.Error(_("Failed to decrypt private key: %s")
+                                  % err)
+        iv, err = utils.execute(
+                'openssl rsautl -decrypt -inkey %s' % cloud_private_key,
+                process_input=encrypted_iv,
+                check_exit_code=False)
+        if err:
+            raise exception.Error(_("Failed to decrypt initialization "
+                                    "vector: %s") % err)
+
+        _out, err = utils.execute(
+                'openssl enc -d -aes-128-cbc -in %s -K %s -iv %s -out %s'
+                 % (encrypted_filename, key, iv, decrypted_filename),
+                 check_exit_code=False)
+        if err:
+            raise exception.Error(_("Failed to decrypt image file "
+                                    "%(image_file)s: %(err)s") %
+                                    {'image_file': encrypted_filename,
+                                     'err': err})
+
+    @staticmethod
+    def _untarzip_image(path, filename):
+        tar_file = tarfile.open(filename, "r|gz")
+        tar_file.extractall(path)
+        image_file = tar_file.getnames()[0]
+        tar_file.close()
+        return os.path.join(path, image_file)
diff --git a/nova/image/service.py b/nova/image/service.py
index ebee2228d..e429955f4 100644
--- a/nova/image/service.py
+++ b/nova/image/service.py
@@ -76,7 +76,7 @@ class BaseImageService(object):
         """
         raise NotImplementedError
 
-    def create(self, context, data):
+    def create(self, context, metadata, data=None):
         """
         Store the image data and return the new image id.
 
@@ -85,7 +85,7 @@ class BaseImageService(object):
         """
         raise NotImplementedError
 
-    def update(self, context, image_id, data):
+    def update(self, context, image_id, metadata, data=None):
         """Replace the contents of the given image with the new data.
 
         :raises NotFound if the image does not exist.
diff --git a/nova/tests/api/openstack/fakes.py b/nova/tests/api/openstack/fakes.py
index 49ce8c1b5..7b016db08 100644
--- a/nova/tests/api/openstack/fakes.py
+++ b/nova/tests/api/openstack/fakes.py
@@ -25,6 +25,7 @@ import webob.dec
 from paste import urlmap
 
 from glance import client as glance_client
+from glance.common import exception as glance_exc
 
 from nova import auth
 from nova import context
@@ -149,25 +150,25 @@ def stub_out_glance(stubs, initial_fixtures=None):
             for f in self.fixtures:
                 if f['id'] == image_id:
                     return f
-            return None
+            raise glance_exc.NotFound
 
-        def fake_add_image(self, image_meta):
+        def fake_add_image(self, image_meta, data=None):
             id = ''.join(random.choice(string.letters) for _ in range(20))
             image_meta['id'] = id
             self.fixtures.append(image_meta)
             return id
 
-        def fake_update_image(self, image_id, image_meta):
+        def fake_update_image(self, image_id, image_meta, data=None):
             f = self.fake_get_image_meta(image_id)
             if not f:
-                raise exc.NotFound
+                raise glance_exc.NotFound
 
             f.update(image_meta)
 
         def fake_delete_image(self, image_id):
             f = self.fake_get_image_meta(image_id)
             if not f:
-                raise exc.NotFound
+                raise glance_exc.NotFound
 
             self.fixtures.remove(f)
 
diff --git a/nova/tests/fake_flags.py b/nova/tests/fake_flags.py
index cbd949477..5d7ca98b5 100644
--- a/nova/tests/fake_flags.py
+++ b/nova/tests/fake_flags.py
@@ -32,6 +32,7 @@ flags.DECLARE('fake_network', 'nova.network.manager')
 FLAGS.network_size = 8
 FLAGS.num_networks = 2
 FLAGS.fake_network = True
+FLAGS.image_service = 'nova.image.local.LocalImageService'
 flags.DECLARE('num_shelves', 'nova.volume.driver')
 flags.DECLARE('blades_per_shelf', 'nova.volume.driver')
 flags.DECLARE('iscsi_num_targets', 'nova.volume.driver')
diff --git a/nova/tests/test_cloud.py b/nova/tests/test_cloud.py
index 061910013..7d7b91658 100644
--- a/nova/tests/test_cloud.py
+++ b/nova/tests/test_cloud.py
@@ -38,6 +38,8 @@ from nova import test
 from nova.auth import manager
 from nova.compute import power_state
 from nova.api.ec2 import cloud
+from nova.api.ec2 import ec2utils
+from nova.image import local
 from nova.objectstore import image
 
 
@@ -76,6 +78,11 @@ class CloudTestCase(test.TestCase):
                                               project=self.project)
         host = self.network.get_network_host(self.context.elevated())
 
+        def fake_image_show(meh, context, id):
+            return dict(kernelId=1, ramdiskId=1)
+
+        self.stubs.Set(local.LocalImageService, 'show', fake_image_show)
+
     def tearDown(self):
         network_ref = db.project_get_network(self.context,
                                              self.project.id)
@@ -122,7 +129,7 @@ class CloudTestCase(test.TestCase):
         self.cloud.allocate_address(self.context)
         inst = db.instance_create(self.context, {'host': self.compute.host})
         fixed = self.network.allocate_fixed_ip(self.context, inst['id'])
-        ec2_id = cloud.id_to_ec2_id(inst['id'])
+        ec2_id = ec2utils.id_to_ec2_id(inst['id'])
         self.cloud.associate_address(self.context,
                                      instance_id=ec2_id,
                                      public_ip=address)
@@ -158,12 +165,12 @@ class CloudTestCase(test.TestCase):
         vol2 = db.volume_create(self.context, {})
         result = self.cloud.describe_volumes(self.context)
         self.assertEqual(len(result['volumeSet']), 2)
-        volume_id = cloud.id_to_ec2_id(vol2['id'], 'vol-%08x')
+        volume_id = ec2utils.id_to_ec2_id(vol2['id'], 'vol-%08x')
         result = self.cloud.describe_volumes(self.context,
                                              volume_id=[volume_id])
         self.assertEqual(len(result['volumeSet']), 1)
         self.assertEqual(
-                cloud.ec2_id_to_id(result['volumeSet'][0]['volumeId']),
+                ec2utils.ec2_id_to_id(result['volumeSet'][0]['volumeId']),
                 vol2['id'])
         db.volume_destroy(self.context, vol1['id'])
         db.volume_destroy(self.context, vol2['id'])
@@ -200,7 +207,7 @@ class CloudTestCase(test.TestCase):
         result = self.cloud.describe_instances(self.context)
         result = result['reservationSet'][0]
         self.assertEqual(len(result['instancesSet']), 2)
-        instance_id = cloud.id_to_ec2_id(inst2['id'])
+        instance_id = ec2utils.id_to_ec2_id(inst2['id'])
         result = self.cloud.describe_instances(self.context,
                                              instance_id=[instance_id])
         result = result['reservationSet'][0]
@@ -216,6 +223,7 @@ class CloudTestCase(test.TestCase):
 
     def test_console_output(self):
         image_id = FLAGS.default_image
+        print image_id
         instance_type = FLAGS.default_instance_type
         max_count = 1
         kwargs = {'image_id': image_id,
@@ -347,7 +355,7 @@ class CloudTestCase(test.TestCase):
 
     def test_update_of_instance_display_fields(self):
         inst = db.instance_create(self.context, {})
-        ec2_id = cloud.id_to_ec2_id(inst['id'])
+        ec2_id = ec2utils.id_to_ec2_id(inst['id'])
         self.cloud.update_instance(self.context, ec2_id,
                                    display_name='c00l 1m4g3')
         inst = db.instance_get(self.context, inst['id'])
@@ -365,7 +373,7 @@ class CloudTestCase(test.TestCase):
     def test_update_of_volume_display_fields(self):
         vol = db.volume_create(self.context, {})
         self.cloud.update_volume(self.context,
-                                 cloud.id_to_ec2_id(vol['id'], 'vol-%08x'),
+                                 ec2utils.id_to_ec2_id(vol['id'], 'vol-%08x'),
                                  display_name='c00l v0lum3')
         vol = db.volume_get(self.context, vol['id'])
         self.assertEqual('c00l v0lum3', vol['display_name'])
@@ -374,7 +382,7 @@ class CloudTestCase(test.TestCase):
     def test_update_of_volume_wont_update_private_fields(self):
         vol = db.volume_create(self.context, {})
         self.cloud.update_volume(self.context,
-                                 cloud.id_to_ec2_id(vol['id'], 'vol-%08x'),
+                                 ec2utils.id_to_ec2_id(vol['id'], 'vol-%08x'),
                                  mountpoint='/not/here')
         vol = db.volume_get(self.context, vol['id'])
         self.assertEqual(None, vol['mountpoint'])
diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index 949b5e6eb..1f49baaf6 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -31,7 +31,7 @@ from nova import test
 from nova import utils
 from nova.auth import manager
 from nova.compute import instance_types
-
+from nova.image import local
 
 LOG = logging.getLogger('nova.tests.compute')
 FLAGS = flags.FLAGS
@@ -47,6 +47,11 @@ class ComputeTestCase(test.TestCase):
                    network_manager='nova.network.manager.FlatManager')
         self.compute = utils.import_object(FLAGS.compute_manager)
         self.compute_api = compute.API()
+
+        def fake_image_show(meh, context, id):
+            return dict(kernelId=1, ramdiskId=1)
+
+        self.stubs.Set(local.LocalImageService, 'show', fake_image_show)
         self.manager = manager.AuthManager()
         self.user = self.manager.create_user('fake', 'fake', 'fake')
         self.project = self.manager.create_project('fake', 'fake', 'fake')
diff --git a/nova/tests/test_direct.py b/nova/tests/test_direct.py
index b6bfab534..b130e3f53 100644
--- a/nova/tests/test_direct.py
+++ b/nova/tests/test_direct.py
@@ -90,8 +90,7 @@ class DirectTestCase(test.TestCase):
 class DirectCloudTestCase(test_cloud.CloudTestCase):
     def setUp(self):
         super(DirectCloudTestCase, self).setUp()
-        compute_handle = compute.API(image_service=self.cloud.image_service,
-                                     network_api=self.cloud.network_api,
+        compute_handle = compute.API(network_api=self.cloud.network_api,
                                      volume_api=self.cloud.volume_api)
         direct.register_service('compute', compute_handle)
         self.router = direct.JsonParamsMiddleware(direct.Router())
diff --git a/nova/tests/test_quota.py b/nova/tests/test_quota.py
index 4ecb36b54..ca8abdb36 100644
--- a/nova/tests/test_quota.py
+++ b/nova/tests/test_quota.py
@@ -57,7 +57,7 @@ class QuotaTestCase(test.TestCase):
     def _create_instance(self, cores=2):
         """Create a test instance"""
         inst = {}
-        inst['image_id'] = 'ami-test'
+        inst['image_id'] = 'ami-1'
         inst['reservation_id'] = 'r-fakeres'
         inst['user_id'] = self.user.id
         inst['project_id'] = self.project.id
@@ -123,7 +123,7 @@ class QuotaTestCase(test.TestCase):
                                             min_count=1,
                                             max_count=1,
                                             instance_type='m1.small',
-                                            image_id='fake')
+                                            image_id='ami-1')
         for instance_id in instance_ids:
             db.instance_destroy(self.context, instance_id)
 
@@ -136,7 +136,7 @@ class QuotaTestCase(test.TestCase):
                                             min_count=1,
                                             max_count=1,
                                             instance_type='m1.small',
-                                            image_id='fake')
+                                            image_id='ami-1')
         for instance_id in instance_ids:
             db.instance_destroy(self.context, instance_id)
 
-- 
cgit 


From bc94ec23100de9f07e04b0348823d4f103a9daa5 Mon Sep 17 00:00:00 2001
From: Vishvananda Ishaya <vishvananda@gmail.com>
Date: Fri, 4 Mar 2011 02:49:12 +0000
Subject: use LocalImageServiceByDefault

---
 nova/flags.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/flags.py b/nova/flags.py
index f01a4d096..cb47ca8d1 100644
--- a/nova/flags.py
+++ b/nova/flags.py
@@ -346,7 +346,7 @@ DEFINE_string('scheduler_manager', 'nova.scheduler.manager.SchedulerManager',
               'Manager for scheduler')
 
 # The service to use for image search and retrieval
-DEFINE_string('image_service', 'nova.image.glance.GlanceImageService',
+DEFINE_string('image_service', 'nova.image.local.LocalImageService',
               'The service to use for retrieving and searching for images.')
 
 DEFINE_string('host', socket.gethostname(),
-- 
cgit 


From 13307e02258a5a08bedb1ed933a107668aac6457 Mon Sep 17 00:00:00 2001
From: Vishvananda Ishaya <vishvananda@gmail.com>
Date: Fri, 4 Mar 2011 05:04:49 +0000
Subject: make local image service work

---
 nova/api/ec2/cloud.py     |  2 +-
 nova/image/local.py       | 64 ++++++++++++++++++++++++++++++++---------------
 nova/objectstore/image.py |  3 +--
 3 files changed, 46 insertions(+), 23 deletions(-)

(limited to 'nova')

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 8c2e77d86..aa1dcbe33 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -853,7 +853,7 @@ class CloudController(object):
         i['imageLocation'] = image['properties'].get('image_location')
         i['imageState'] = image['properties'].get('image_state')
         i['type'] = image.get('type')
-        i['isPublic'] = image['properties'].get('is_public') == 'True'
+        i['isPublic'] = str(image['properties'].get('is_public', '')) == 'True'
         i['architecture'] = image['properties'].get('architecture')
         return i
 
diff --git a/nova/image/local.py b/nova/image/local.py
index f78b9aa89..b4616729a 100644
--- a/nova/image/local.py
+++ b/nova/image/local.py
@@ -15,57 +15,81 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-import cPickle as pickle
+import json
 import os.path
 import random
-import tempfile
+import shutil
 
+from nova import flags
 from nova import exception
 from nova.image import service
 
 
-class LocalImageService(service.BaseImageService):
+FLAGS = flags.FLAGS
+flags.DEFINE_string('images_path', '$state_path/images',
+                    'path to decrypted images')
 
+class LocalImageService(service.BaseImageService):
     """Image service storing images to local disk.
+
     It assumes that image_ids are integers.
 
     """
 
     def __init__(self):
-        self._path = tempfile.mkdtemp()
+        self._path = FLAGS.images_path
 
-    def _path_to(self, image_id):
+    def _path_to(self, image_id, fname='info.json'):
+        if fname:
+            return os.path.join(self._path, str(image_id), fname)
         return os.path.join(self._path, str(image_id))
 
     def _ids(self):
         """The list of all image ids."""
-        return [int(i) for i in os.listdir(self._path)]
+        return [int(i) for i in os.listdir(self._path)
+                if unicode(i).isnumeric()]
 
     def index(self, context):
-        return [dict(id=i['id'], name=i['name']) for i in self.detail(context)]
+        return [dict(image_id=i['id'], name=i.get('name'))
+                for i in self.detail(context)]
 
     def detail(self, context):
-        return [self.show(context, id) for id in self._ids()]
-
-    def show(self, context, id):
+        images = []
+        for image_id in self._ids():
+            try:
+                image = self.show(context, image_id)
+                images.append(image)
+            except exception.NotFound:
+                continue
+        return images
+
+    def show(self, context, image_id):
         try:
-            return pickle.load(open(self._path_to(id)))
+            with open(self._path_to(image_id)) as metadata_file:
+                return json.load(metadata_file)
         except IOError:
             raise exception.NotFound
 
-    def create(self, context, data):
+    def create(self, context, metadata, data=None):
         """Store the image data and return the new image id."""
-        id = random.randint(0, 2 ** 31 - 1)
-        data['id'] = id
-        self.update(context, id, data)
-        return id
+        image_id = random.randint(0, 2 ** 31 - 1)
+        image_path = self._path_to(image_id, None)
+        if not os.path.exists(image_path):
+            os.mkdir(image_path)
+        return  self.update(context, image_id, metadata, data)
 
-    def update(self, context, image_id, data):
+    def update(self, context, image_id, metadata, data=None):
         """Replace the contents of the given image with the new data."""
+        metadata['id'] = image_id
         try:
-            pickle.dump(data, open(self._path_to(image_id), 'w'))
+            with open(self._path_to(image_id), 'w') as metadata_file:
+                json.dump(metadata, metadata_file)
+            if data:
+                with open(self._path_to(image_id, 'image'), 'w') as image_file:
+                    shutil.copyfileobj(data, image_file)
         except IOError:
             raise exception.NotFound
+        return metadata
 
     def delete(self, context, image_id):
         """Delete the given image.
@@ -79,8 +103,8 @@ class LocalImageService(service.BaseImageService):
 
     def delete_all(self):
         """Clears out all images in local directory."""
-        for id in self._ids():
-            os.unlink(self._path_to(id))
+        for image_id in self._ids():
+            os.unlink(self._path_to(image_id))
 
     def delete_imagedir(self):
         """Deletes the local directory.
diff --git a/nova/objectstore/image.py b/nova/objectstore/image.py
index 27227e2ca..8013cbd9c 100644
--- a/nova/objectstore/image.py
+++ b/nova/objectstore/image.py
@@ -37,8 +37,7 @@ from nova.objectstore import bucket
 
 
 FLAGS = flags.FLAGS
-flags.DEFINE_string('images_path', '$state_path/images',
-                    'path to decrypted images')
+flags.DECLARE('images_path', 'nova.image.local')
 
 
 class Image(object):
-- 
cgit 


From cf9bc248f0fc318c4a9fb5087f257216312e39d1 Mon Sep 17 00:00:00 2001
From: Vishvananda Ishaya <vishvananda@gmail.com>
Date: Fri, 4 Mar 2011 05:21:28 +0000
Subject: fix a couple issues with local, update the glance fake to actually
 return the same types as the real client, fix the image tests

---
 nova/image/local.py                     | 12 +++---------
 nova/tests/api/openstack/fakes.py       |  3 ++-
 nova/tests/api/openstack/test_images.py | 15 +++++++++------
 3 files changed, 14 insertions(+), 16 deletions(-)

(limited to 'nova')

diff --git a/nova/image/local.py b/nova/image/local.py
index b4616729a..6fa648b6b 100644
--- a/nova/image/local.py
+++ b/nova/image/local.py
@@ -29,6 +29,7 @@ FLAGS = flags.FLAGS
 flags.DEFINE_string('images_path', '$state_path/images',
                     'path to decrypted images')
 
+
 class LocalImageService(service.BaseImageService):
     """Image service storing images to local disk.
 
@@ -97,18 +98,11 @@ class LocalImageService(service.BaseImageService):
 
         """
         try:
-            os.unlink(self._path_to(image_id))
+            shutil.rmtree(self._path_to(image_id, None))
         except IOError:
             raise exception.NotFound
 
     def delete_all(self):
         """Clears out all images in local directory."""
         for image_id in self._ids():
-            os.unlink(self._path_to(image_id))
-
-    def delete_imagedir(self):
-        """Deletes the local directory.
-        Raises OSError if directory is not empty.
-
-        """
-        os.rmdir(self._path)
+            shutil.rmtree(self._path_to(image_id, None))
diff --git a/nova/tests/api/openstack/fakes.py b/nova/tests/api/openstack/fakes.py
index 7b016db08..2c4e57246 100644
--- a/nova/tests/api/openstack/fakes.py
+++ b/nova/tests/api/openstack/fakes.py
@@ -156,7 +156,7 @@ def stub_out_glance(stubs, initial_fixtures=None):
             id = ''.join(random.choice(string.letters) for _ in range(20))
             image_meta['id'] = id
             self.fixtures.append(image_meta)
-            return id
+            return image_meta
 
         def fake_update_image(self, image_id, image_meta, data=None):
             f = self.fake_get_image_meta(image_id)
@@ -164,6 +164,7 @@ def stub_out_glance(stubs, initial_fixtures=None):
                 raise glance_exc.NotFound
 
             f.update(image_meta)
+            return f
 
         def fake_delete_image(self, image_id):
             f = self.fake_get_image_meta(image_id)
diff --git a/nova/tests/api/openstack/test_images.py b/nova/tests/api/openstack/test_images.py
index e232bc3d5..eb5039bdb 100644
--- a/nova/tests/api/openstack/test_images.py
+++ b/nova/tests/api/openstack/test_images.py
@@ -22,6 +22,8 @@ and as a WSGI layer
 
 import json
 import datetime
+import shutil
+import tempfile
 
 import stubout
 import webob
@@ -54,7 +56,7 @@ class BaseImageServiceTests(object):
 
         num_images = len(self.service.index(self.context))
 
-        id = self.service.create(self.context, fixture)
+        id = self.service.create(self.context, fixture)['id']
 
         self.assertNotEquals(None, id)
         self.assertEquals(num_images + 1,
@@ -71,7 +73,7 @@ class BaseImageServiceTests(object):
 
         num_images = len(self.service.index(self.context))
 
-        id = self.service.create(self.context, fixture)
+        id = self.service.create(self.context, fixture)['id']
 
         self.assertNotEquals(None, id)
 
@@ -89,7 +91,7 @@ class BaseImageServiceTests(object):
                    'instance_id': None,
                    'progress': None}
 
-        id = self.service.create(self.context, fixture)
+        id = self.service.create(self.context, fixture)['id']
 
         fixture['status'] = 'in progress'
 
@@ -118,7 +120,7 @@ class BaseImageServiceTests(object):
 
         ids = []
         for fixture in fixtures:
-            new_id = self.service.create(self.context, fixture)
+            new_id = self.service.create(self.context, fixture)['id']
             ids.append(new_id)
 
         num_images = len(self.service.index(self.context))
@@ -137,14 +139,15 @@ class LocalImageServiceTest(test.TestCase,
 
     def setUp(self):
         super(LocalImageServiceTest, self).setUp()
+        self.tempdir = tempfile.mkdtemp()
+        self.flags(images_path=self.tempdir)
         self.stubs = stubout.StubOutForTesting()
         service_class = 'nova.image.local.LocalImageService'
         self.service = utils.import_object(service_class)
         self.context = context.RequestContext(None, None)
 
     def tearDown(self):
-        self.service.delete_all()
-        self.service.delete_imagedir()
+        shutil.rmtree(self.tempdir)
         self.stubs.UnsetAll()
         super(LocalImageServiceTest, self).tearDown()
 
-- 
cgit 


From e2c95e198f1982bc50bc95bc61ef3211b17937a2 Mon Sep 17 00:00:00 2001
From: Vishvananda Ishaya <vishvananda@gmail.com>
Date: Fri, 4 Mar 2011 05:55:41 +0000
Subject: spawn a greenthread for image registration because it is slow

---
 nova/image/s3.py | 67 ++++++++++++++++++++++++++++++--------------------------
 1 file changed, 36 insertions(+), 31 deletions(-)

(limited to 'nova')

diff --git a/nova/image/s3.py b/nova/image/s3.py
index a740b010c..e9542c7bd 100644
--- a/nova/image/s3.py
+++ b/nova/image/s3.py
@@ -22,6 +22,7 @@ objectstore service.
 """
 
 import binascii
+import eventlet
 import os
 import shutil
 import tarfile
@@ -188,46 +189,50 @@ class S3ImageService(service.BaseImageService):
         image = self.service.create(context, metadata)
         image_id = image['id']
 
-        parts = []
-        for fn_element in manifest.find("image").getiterator("filename"):
-            part = self._download_file(bucket, fn_element.text, image_path)
-            parts.append(part)
+        def delayed_create():
+            parts = []
+            for fn_element in manifest.find("image").getiterator("filename"):
+                part = self._download_file(bucket, fn_element.text, image_path)
+                parts.append(part)
 
-        # NOTE(vish): this may be suboptimal, should we use cat?
-        encrypted_filename = os.path.join(image_path, 'image.encrypted')
-        with open(encrypted_filename, 'w') as combined:
-            for filename in parts:
-                with open(filename) as part:
-                    shutil.copyfileobj(part, combined)
+            # NOTE(vish): this may be suboptimal, should we use cat?
+            encrypted_filename = os.path.join(image_path, 'image.encrypted')
+            with open(encrypted_filename, 'w') as combined:
+                for filename in parts:
+                    with open(filename) as part:
+                        shutil.copyfileobj(part, combined)
 
-        metadata['properties']['image_state'] = 'decrypting'
-        self.service.update(context, image_id, metadata)
+            metadata['properties']['image_state'] = 'decrypting'
+            self.service.update(context, image_id, metadata)
 
-        hex_key = manifest.find("image/ec2_encrypted_key").text
-        encrypted_key = binascii.a2b_hex(hex_key)
-        hex_iv = manifest.find("image/ec2_encrypted_iv").text
-        encrypted_iv = binascii.a2b_hex(hex_iv)
+            hex_key = manifest.find("image/ec2_encrypted_key").text
+            encrypted_key = binascii.a2b_hex(hex_key)
+            hex_iv = manifest.find("image/ec2_encrypted_iv").text
+            encrypted_iv = binascii.a2b_hex(hex_iv)
 
-        # FIXME(vish): grab key from common service so this can run on
-        #              any host.
-        cloud_private_key = os.path.join(FLAGS.ca_path, "private/cakey.pem")
+            # FIXME(vish): grab key from common service so this can run on
+            #              any host.
+            cloud_pk = os.path.join(FLAGS.ca_path, "private/cakey.pem")
 
-        decrypted_filename = os.path.join(image_path, 'image.tar.gz')
-        self._decrypt_image(encrypted_filename, encrypted_key, encrypted_iv,
-                            cloud_private_key, decrypted_filename)
+            decrypted_filename = os.path.join(image_path, 'image.tar.gz')
+            self._decrypt_image(encrypted_filename, encrypted_key,
+                                encrypted_iv, cloud_pk, decrypted_filename)
 
-        metadata['properties']['image_state'] = 'untarring'
-        self.service.update(context, image_id, metadata)
+            metadata['properties']['image_state'] = 'untarring'
+            self.service.update(context, image_id, metadata)
 
-        unz_filename = self._untarzip_image(image_path, decrypted_filename)
+            unz_filename = self._untarzip_image(image_path, decrypted_filename)
 
-        metadata['properties']['image_state'] = 'uploading'
-        with open(unz_filename) as image_file:
-            self.service.update(context, image_id, metadata, image_file)
-        metadata['properties']['image_state'] = 'available'
-        self.service.update(context, image_id, metadata)
+            metadata['properties']['image_state'] = 'uploading'
+            with open(unz_filename) as image_file:
+                self.service.update(context, image_id, metadata, image_file)
+            metadata['properties']['image_state'] = 'available'
+            self.service.update(context, image_id, metadata)
+
+            shutil.rmtree(image_path)
+
+        eventlet.spawn_n(delayed_create)
 
-        shutil.rmtree(image_path)
         return image_id, metadata
 
     @staticmethod
-- 
cgit 


From 517a571f8905c32efd45f7b3410fb263ad705545 Mon Sep 17 00:00:00 2001
From: Vishvananda Ishaya <vishvananda@gmail.com>
Date: Fri, 4 Mar 2011 05:58:49 +0000
Subject: add the ec2utils file i forgot

---
 nova/api/ec2/ec2utils.py | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 nova/api/ec2/ec2utils.py

(limited to 'nova')

diff --git a/nova/api/ec2/ec2utils.py b/nova/api/ec2/ec2utils.py
new file mode 100644
index 000000000..0ea22c0e6
--- /dev/null
+++ b/nova/api/ec2/ec2utils.py
@@ -0,0 +1,27 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# 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.
+
+
+def ec2_id_to_id(ec2_id):
+    """Convert an ec2 ID (i-[base 16 number]) to an instance id (int)"""
+    return int(ec2_id.split('-')[-1], 16)
+
+
+def id_to_ec2_id(instance_id, template='i-%08x'):
+    """Convert an instance ID (int) to an ec2 ID (i-[base 16 number])"""
+    return template % instance_id
-- 
cgit 


From abd5779068f3b979fc79dec7a68549999c58092d Mon Sep 17 00:00:00 2001
From: Mark Washenberger <mark.washenberger@rackspace.com>
Date: Fri, 4 Mar 2011 01:36:29 -0500
Subject: remove ensure_b64_encoding

---
 nova/compute/manager.py   | 10 ++--------
 nova/utils.py             | 12 ------------
 nova/virt/xenapi/vmops.py | 10 +++++-----
 3 files changed, 7 insertions(+), 25 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index d915dc069..3a712fd97 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -34,7 +34,6 @@ terminating it.
                   :func:`nova.utils.import_object`
 """
 
-import base64
 import datetime
 import random
 import string
@@ -353,15 +352,10 @@ class ComputeManager(manager.Manager):
             LOG.warn(_('trying to inject a file into a non-running '
                     'instance: %(instance_id)s (state: %(instance_state)s '
                     'expected: %(expected_state)s)') % locals())
-        # Files/paths *should* be base64-encoded at this point, but
-        # double-check to make sure.
-        b64_path = utils.ensure_b64_encoding(path)
-        b64_contents = utils.ensure_b64_encoding(file_contents)
-        plain_path = base64.b64decode(b64_path)
         nm = instance_ref['name']
-        msg = _('instance %(nm)s: injecting file to %(plain_path)s') % locals()
+        msg = _('instance %(nm)s: injecting file to %(path)s') % locals()
         LOG.audit(msg)
-        self.driver.inject_file(instance_ref, b64_path, b64_contents)
+        self.driver.inject_file(instance_ref, path, file_contents)
 
     @exception.wrap_exception
     @checks_instance_lock
diff --git a/nova/utils.py b/nova/utils.py
index 0cf91e0cc..02b71900c 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -491,18 +491,6 @@ def loads(s):
     return json.loads(s)
 
 
-def ensure_b64_encoding(val):
-    """Safety method to ensure that values expected to be base64-encoded
-    actually are. If they are, the value is returned unchanged. Otherwise,
-    the encoded value is returned.
-    """
-    try:
-        dummy = base64.decode(val)
-        return val
-    except TypeError:
-        return base64.b64encode(val)
-
-
 def get_from_path(items, path):
     """ Returns a list of items matching the specified path.  Takes an
     XPath-like expression e.g. prop1/prop2/prop3, and for each item in items,
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 1f0df07baac52379b122a9928200305dd9d2151f Mon Sep 17 00:00:00 2001
From: Kei Masumoto <masumotok@nttdata.co.jp>
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/tests/test_virt.py   | 163 ++++++++++++++++++++++++++++++++++++++--------
 nova/virt/libvirt_conn.py |  12 +++-
 2 files changed, 146 insertions(+), 29 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/test_virt.py b/nova/tests/test_virt.py
index aac55a894..5bb31659b 100644
--- a/nova/tests/test_virt.py
+++ b/nova/tests/test_virt.py
@@ -15,6 +15,7 @@
 #    under the License.
 
 import mox
+import sys
 
 from xml.etree.ElementTree import fromstring as xml_to_tree
 from xml.dom.minidom import parseString as xml_to_dom
@@ -27,11 +28,15 @@ from nova import test
 from nova import utils
 from nova.api.ec2 import cloud
 from nova.auth import manager
+from nova.compute import manager as compute_manager
+from nova.compute import power_state
 from nova.db.sqlalchemy import models
 from nova.virt import libvirt_conn
 
+libvirt = None
 FLAGS = flags.FLAGS
 flags.DECLARE('instances_path', 'nova.compute.manager')
+flags.DECLARE('compute_driver', 'nova.compute.manager')
 
 
 class LibvirtConnTestCase(test.TestCase):
@@ -73,31 +78,36 @@ class LibvirtConnTestCase(test.TestCase):
                      'bridge':        'br101',
                      'instance_type': 'm1.small'}
 
+    def lazy_load_library_exists(self):
+        """check if libvirt is available."""
+        # try to connect libvirt. if fail, skip test.
+        try:
+            import libvirt
+            import libxml2
+        except ImportError:
+            return False
+        global libvirt
+        libvirt = __import__('libvirt')
+        libvirt_conn.libvirt = __import__('libvirt')
+        libvirt_conn.libxml2 = __import__('libxml2')
+        return True
+
     def create_fake_libvirt_mock(self, **kwargs):
         """Defining mocks for LibvirtConnection(libvirt is not used)."""
 
-        # A fake libvirt.virtConnect
+        # A fake libvirt.virConnect
         class FakeLibvirtConnection(object):
-            def getVersion(self):
-                return 12003
-
-            def getType(self):
-                return 'qemu'
-
-            def getCapabilities(self):
-                return 'qemu'
-
-            def listDomainsID(self):
-                return []
-
-            def getCapabilitied(self):
-                return
+            pass
 
         # A fake libvirt_conn.IptablesFirewallDriver
         class FakeIptablesFirewallDriver(object):
+
             def __init__(self, **kwargs):
                 pass
 
+            def setattr(self, key, val):
+                self.__setattr__(key, val)
+
         # Creating mocks
         fake = FakeLibvirtConnection()
         fakeip = FakeIptablesFirewallDriver
@@ -274,33 +284,54 @@ class LibvirtConnTestCase(test.TestCase):
             self.assertEquals(uri, testuri)
         db.instance_destroy(user_context, instance_ref['id'])
 
-    def test_update_available_resource_works_correctly(self):
+    def tes1t_update_available_resource_works_correctly(self):
         """Confirm compute_node table is updated successfully."""
         org_path = FLAGS.instances_path = ''
         FLAGS.instances_path = '.'
 
+        # Prepare mocks
+        def getVersion():
+            return 12003
+
+        def getType():
+            return 'qemu'
+
+        def listDomainsID():
+            return []
+
         service_ref = self.create_service(host='dummy')
-        self.create_fake_libvirt_mock()
+        self.create_fake_libvirt_mock(getVersion=getVersion,
+                                      getType=getType,
+                                      listDomainsID=listDomainsID)
         self.mox.StubOutWithMock(libvirt_conn.LibvirtConnection,
                                  'get_cpu_info')
         libvirt_conn.LibvirtConnection.get_cpu_info().AndReturn('cpuinfo')
 
+        # Start test
         self.mox.ReplayAll()
         conn = libvirt_conn.LibvirtConnection(False)
         conn.update_available_resource(self.context, 'dummy')
         service_ref = db.service_get(self.context, service_ref['id'])
         compute_node = service_ref['compute_node'][0]
 
-        c1 = (compute_node['vcpus'] > 0)
-        c2 = (compute_node['memory_mb'] > 0)
-        c3 = (compute_node['local_gb'] > 0)
-        c4 = (compute_node['vcpus_used'] == 0)
-        c5 = (compute_node['memory_mb_used'] > 0)
-        c6 = (compute_node['local_gb_used'] > 0)
-        c7 = (len(compute_node['hypervisor_type']) > 0)
-        c8 = (compute_node['hypervisor_version'] > 0)
-
-        self.assertTrue(c1 and c2 and c3 and c4 and c5 and c6 and c7 and c8)
+        if sys.platform.upper() == 'LINUX2':
+            self.assertTrue(compute_node['vcpus'] > 0)
+            self.assertTrue(compute_node['memory_mb'] > 0)
+            self.assertTrue(compute_node['local_gb'] > 0)
+            self.assertTrue(compute_node['vcpus_used'] == 0)
+            self.assertTrue(compute_node['memory_mb_used'] > 0)
+            self.assertTrue(compute_node['local_gb_used'] > 0)
+            self.assertTrue(len(compute_node['hypervisor_type']) > 0)
+            self.assertTrue(compute_node['hypervisor_version'] > 0)
+        else:
+            self.assertTrue(compute_node['vcpus'] > 0)
+            self.assertTrue(compute_node['memory_mb'] == 0)
+            self.assertTrue(compute_node['local_gb'] > 0)
+            self.assertTrue(compute_node['vcpus_used'] == 0)
+            self.assertTrue(compute_node['memory_mb_used'] == 0)
+            self.assertTrue(compute_node['local_gb_used'] > 0)
+            self.assertTrue(len(compute_node['hypervisor_type']) > 0)
+            self.assertTrue(compute_node['hypervisor_version'] > 0)
 
         db.service_destroy(self.context, service_ref['id'])
         FLAGS.instances_path = org_path
@@ -319,6 +350,84 @@ class LibvirtConnTestCase(test.TestCase):
 
         FLAGS.instances_path = org_path
 
+    def test_ensure_filtering_rules_for_instance_timeout(self):
+        """ensure_filtering_fules_for_instance() finishes with timeout."""
+        # Skip if non-libvirt environment
+        if not self.lazy_load_library_exists():
+            return
+
+        # Preparing mocks
+        def fake_none(self):
+            return
+
+        def fake_raise(self):
+            raise libvirt.libvirtError('ERR')
+
+        self.create_fake_libvirt_mock(nwfilterLookupByName=fake_raise)
+        instance_ref = db.instance_create(self.context, self.test_instance)
+
+        # Start test
+        self.mox.ReplayAll()
+        try:
+            conn = libvirt_conn.LibvirtConnection(False)
+            conn.firewall_driver.setattr('setup_basic_filtering', fake_none)
+            conn.firewall_driver.setattr('prepare_instance_filter', fake_none)
+            conn.ensure_filtering_rules_for_instance(instance_ref)
+        except exception.Error, e:
+            c1 = (0 <= e.message.find('Timeout migrating for'))
+        self.assertTrue(c1)
+
+        db.instance_destroy(self.context, instance_ref['id'])
+
+    def test_live_migration_raises_exception(self):
+        """Confirms recover method is called when exceptions are raised."""
+        # Skip if non-libvirt environment
+        if not self.lazy_load_library_exists():
+            return
+
+        # Preparing data
+        self.compute = utils.import_object(FLAGS.compute_manager)
+        instance_dict = {'host': 'fake', 'state': power_state.RUNNING,
+                         'state_description': 'running'}
+        instance_ref = db.instance_create(self.context, self.test_instance)
+        instance_ref = db.instance_update(self.context, instance_ref['id'],
+                                          instance_dict)
+        vol_dict = {'status': 'migrating', 'size': 1}
+        volume_ref = db.volume_create(self.context, vol_dict)
+        db.volume_attached(self.context, volume_ref['id'], instance_ref['id'],
+                           '/dev/fake')
+
+        # Preparing mocks
+        vdmock = self.mox.CreateMock(libvirt.virDomain)
+        self.mox.StubOutWithMock(vdmock, "migrateToURI")
+        vdmock.migrateToURI(FLAGS.live_migration_uri % 'dest',
+                            mox.IgnoreArg(),
+                            None, FLAGS.live_migration_bandwidth).\
+                            AndRaise(libvirt.libvirtError('ERR'))
+
+        def fake_lookup(instance_name):
+            if instance_name == instance_ref.name:
+                return vdmock
+
+        self.create_fake_libvirt_mock(lookupByName=fake_lookup)
+
+        # Start test
+        self.mox.ReplayAll()
+        conn = libvirt_conn.LibvirtConnection(False)
+        self.assertRaises(libvirt.libvirtError,
+                      conn._live_migration,
+                      self.context, instance_ref, 'dest', '',
+                      self.compute.recover_live_migration)
+
+        instance_ref = db.instance_get(self.context, instance_ref['id'])
+        self.assertTrue(instance_ref['state_description'] == 'running')
+        self.assertTrue(instance_ref['state'] == power_state.RUNNING)
+        volume_ref = db.volume_get(self.context, volume_ref['id'])
+        self.assertTrue(volume_ref['status'] == 'in-use')
+
+        db.volume_destroy(self.context, volume_ref['id'])
+        db.instance_destroy(self.context, instance_ref['id'])
+
     def tearDown(self):
         self.manager.delete_project(self.project)
         self.manager.delete_user(self.user)
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 23291a5e1a0134aff5fe030b52d4335a6f2a18d9 Mon Sep 17 00:00:00 2001
From: Kei Masumoto <masumotok@nttdata.co.jp>
Date: Sat, 5 Mar 2011 01:07:12 +0900
Subject: delete unnecessary DECLARE

---
 nova/tests/test_virt.py | 1 -
 1 file changed, 1 deletion(-)

(limited to 'nova')

diff --git a/nova/tests/test_virt.py b/nova/tests/test_virt.py
index 5bb31659b..7ea8c0fb5 100644
--- a/nova/tests/test_virt.py
+++ b/nova/tests/test_virt.py
@@ -36,7 +36,6 @@ from nova.virt import libvirt_conn
 libvirt = None
 FLAGS = flags.FLAGS
 flags.DECLARE('instances_path', 'nova.compute.manager')
-flags.DECLARE('compute_driver', 'nova.compute.manager')
 
 
 class LibvirtConnTestCase(test.TestCase):
-- 
cgit 


From 1d8914fc752f7182f942cdd40f2ba18baedeed0c Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Fri, 4 Mar 2011 11:19:35 -0600
Subject: More fixes

---
 nova/api/openstack/servers.py |  4 ++--
 nova/compute/api.py           |  8 ++++----
 nova/compute/manager.py       |  2 +-
 nova/tests/xenapi/stubs.py    |  2 +-
 nova/virt/xenapi/vm_utils.py  | 16 ++++++++--------
 nova/virt/xenapi/vmops.py     | 11 ++++++-----
 6 files changed, 22 insertions(+), 21 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index ceb17c9e4..c2bf42b72 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -203,8 +203,8 @@ class Controller(wsgi.Controller):
         return exc.HTTPNoContent()
 
     def action(self, req, id):
-        """ Multi-purpose method used to reboot, rebuild, or
-        resize a server """
+        """Multi-purpose method used to reboot, rebuild, or
+        resize a server"""
 
         actions = {
             'reboot':        self._action_reboot,
diff --git a/nova/compute/api.py b/nova/compute/api.py
index bfa5c7dba..ce9da727d 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -430,8 +430,8 @@ class API(base.Base):
         migration_ref = self.db.migration_get_by_instance_and_status(context,
                 instance_id, 'finished')
         if not migration_ref:
-            raise exception.NotFound(_("No finished migrations found for \
-                    instance"))
+            raise exception.NotFound(_("No finished migrations found for "
+                    "instance"))
 
         params = {'migration_id': migration_ref['id']}
         self._cast_compute_message('revert_resize', context, instance_id,
@@ -444,8 +444,8 @@ class API(base.Base):
         migration_ref = self.db.migration_get_by_instance_and_status(context,
                 instance_id, 'finished')
         if not migration_ref:
-            raise exception.NotFound(_("No finished migrations found for \
-                    instance"))
+            raise exception.NotFound(_("No finished migrations found for "
+                    "instance"))
         instance_ref = self.db.instance_get(context, instance_id)
         params = {'migration_id': migration_ref['id']}
         self._cast_compute_message('confirm_resize', context, instance_id,
diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 1c42b383c..b3e864154 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -414,7 +414,7 @@ class ComputeManager(manager.Manager):
     @exception.wrap_exception
     @checks_instance_lock
     def confirm_resize(self, context, instance_id, migration_id):
-        """ Destroys the source instance """
+        """Destroys the source instance"""
         context = context.elevated()
         instance_ref = self.db.instance_get(context, instance_id)
         migration_ref = self.db.migration_get(context, migration_id)
diff --git a/nova/tests/xenapi/stubs.py b/nova/tests/xenapi/stubs.py
index d17951b81..caefcff34 100644
--- a/nova/tests/xenapi/stubs.py
+++ b/nova/tests/xenapi/stubs.py
@@ -221,7 +221,7 @@ class FakeSessionForVolumeFailedTests(FakeSessionForVolumeTests):
 
 
 class FakeSessionForMigrationTests(fake.SessionBase):
-    """ Stubs out a XenAPISession for Migration tests """
+    """Stubs out a XenAPISession for Migration tests"""
     def __init__(self, uri):
         super(FakeSessionForMigrationTests, self).__init__(uri)
 
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 <cory.wright@rackspace.com>
Date: Fri, 4 Mar 2011 17:48:28 +0000
Subject: * Tests to verify correct vm-params for Windows and Linux instances

---
 nova/compute/api.py                                |  5 +-
 .../versions/007_add_os_type_to_instances.py       |  4 +-
 nova/tests/db/fakes.py                             |  1 +
 nova/tests/test_xenapi.py                          | 99 ++++++++++++++++++----
 nova/virt/xenapi/vm_utils.py                       | 14 +--
 nova/virt/xenapi/vmops.py                          |  8 +-
 6 files changed, 101 insertions(+), 30 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/api.py b/nova/compute/api.py
index 8bdf712a0..d79371e94 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -125,7 +125,10 @@ class API(base.Base):
                 raise quota.QuotaError(msg, "MetadataLimitExceeded")
 
         image = self.image_service.show(context, image_id)
-        os_type = image['properties'].get('os_type', 'linux')
+
+        os_type = None
+        if 'properties' in image and 'os_type' in image['properties']:
+            os_type = image['properties']['os_type']
 
         if kernel_id is None:
             kernel_id = image.get('kernel_id', None)
diff --git a/nova/db/sqlalchemy/migrate_repo/versions/007_add_os_type_to_instances.py b/nova/db/sqlalchemy/migrate_repo/versions/007_add_os_type_to_instances.py
index 21f21b040..d6d964b95 100644
--- a/nova/db/sqlalchemy/migrate_repo/versions/007_add_os_type_to_instances.py
+++ b/nova/db/sqlalchemy/migrate_repo/versions/007_add_os_type_to_instances.py
@@ -34,7 +34,7 @@ instances_os_type = Column('os_type',
                            String(length=255, convert_unicode=False,
                                   assert_unicode=None, unicode_error=None,
                                   _warn_on_bytestring=False),
-                           nullable=False)
+                           nullable=True)
 
 
 def upgrade(migrate_engine):
@@ -43,5 +43,3 @@ def upgrade(migrate_engine):
     meta.bind = migrate_engine
 
     instances.create_column(instances_os_type)
-
-    
diff --git a/nova/tests/db/fakes.py b/nova/tests/db/fakes.py
index 05bdd172e..facd6efae 100644
--- a/nova/tests/db/fakes.py
+++ b/nova/tests/db/fakes.py
@@ -62,6 +62,7 @@ def stub_out_db_instance_api(stubs):
             'mac_address': values['mac_address'],
             'vcpus': type_data['vcpus'],
             'local_gb': type_data['local_gb'],
+            'os_type': values['os_type']
             }
         return FakeModel(base_options)
 
diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index b9bb6d5b4..24a5698e5 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -18,6 +18,7 @@
 Test suite for XenAPI
 """
 
+import functools
 import stubout
 
 from nova import db
@@ -41,6 +42,21 @@ from nova.tests.glance import stubs as glance_stubs
 FLAGS = flags.FLAGS
 
 
+def stub_vm_utils_with_vdi_attached_here(function, should_return=True):
+    """
+    vm_utils.with_vdi_attached_here needs to be stubbed out because it
+    calls down to the filesystem to attach a vdi. This provides a
+    decorator to handle that.
+    """
+    @functools.wraps(function)
+    def decorated_function(self, *args, **kwargs):
+        orig_with_vdi_attached_here = vm_utils.with_vdi_attached_here
+        vm_utils.with_vdi_attached_here = lambda *x: should_return
+        function(self, *args, **kwargs)
+        vm_utils.with_vdi_attached_here = orig_with_vdi_attached_here
+    return decorated_function
+
+
 class XenAPIVolumeTestCase(test.TestCase):
     """
     Unit tests for Volume operations
@@ -62,6 +78,7 @@ class XenAPIVolumeTestCase(test.TestCase):
                   'ramdisk_id': 3,
                   'instance_type': 'm1.large',
                   'mac_address': 'aa:bb:cc:dd:ee:ff',
+                  'os_type': 'linux'
                   }
 
     def _create_volume(self, size='0'):
@@ -219,7 +236,7 @@ class XenAPIVMTestCase(test.TestCase):
 
         check()
 
-    def check_vm_record(self, conn):
+    def create_vm_record(self, conn, os_type):
         instances = conn.list_instances()
         self.assertEquals(instances, [1])
 
@@ -231,28 +248,63 @@ class XenAPIVMTestCase(test.TestCase):
                in xenapi_fake.get_all_records('VM').iteritems()
                if not rec['is_control_domain']]
         vm = vms[0]
+        self.vm_info = vm_info
+        self.vm = vm
 
+    def check_vm_record(self):
         # Check that m1.large above turned into the right thing.
         instance_type = instance_types.INSTANCE_TYPES['m1.large']
         mem_kib = long(instance_type['memory_mb']) << 10
         mem_bytes = str(mem_kib << 10)
         vcpus = instance_type['vcpus']
-        self.assertEquals(vm_info['max_mem'], mem_kib)
-        self.assertEquals(vm_info['mem'], mem_kib)
-        self.assertEquals(vm['memory_static_max'], mem_bytes)
-        self.assertEquals(vm['memory_dynamic_max'], mem_bytes)
-        self.assertEquals(vm['memory_dynamic_min'], mem_bytes)
-        self.assertEquals(vm['VCPUs_max'], str(vcpus))
-        self.assertEquals(vm['VCPUs_at_startup'], str(vcpus))
+        self.assertEquals(self.vm_info['max_mem'], mem_kib)
+        self.assertEquals(self.vm_info['mem'], mem_kib)
+        self.assertEquals(self.vm['memory_static_max'], mem_bytes)
+        self.assertEquals(self.vm['memory_dynamic_max'], mem_bytes)
+        self.assertEquals(self.vm['memory_dynamic_min'], mem_bytes)
+        self.assertEquals(self.vm['VCPUs_max'], str(vcpus))
+        self.assertEquals(self.vm['VCPUs_at_startup'], str(vcpus))
 
         # Check that the VM is running according to Nova
-        self.assertEquals(vm_info['state'], power_state.RUNNING)
+        self.assertEquals(self.vm_info['state'], power_state.RUNNING)
 
         # Check that the VM is running according to XenAPI.
-        self.assertEquals(vm['power_state'], 'Running')
+        self.assertEquals(self.vm['power_state'], 'Running')
+
+    def check_vm_params_for_windows(self):
+        self.assertEquals(self.vm['platform']['nx'], 'true')
+        self.assertEquals(self.vm['HVM_boot_params'], {'order': 'dc'})
+        self.assertEquals(self.vm['HVM_boot_policy'], 'BIOS order')
+
+        # check that these are not set
+        self.assertEquals(self.vm['PV_args'], '')
+        self.assertEquals(self.vm['PV_bootloader'], '')
+        self.assertEquals(self.vm['PV_kernel'], '')
+        self.assertEquals(self.vm['PV_ramdisk'], '')
+
+    def check_vm_params_for_linux(self):
+        self.assertEquals(self.vm['platform']['nx'], 'false')
+        self.assertEquals(self.vm['PV_args'], 'clocksource=jiffies')
+        self.assertEquals(self.vm['PV_bootloader'], 'pygrub')
+
+        # check that these are not set
+        self.assertEquals(self.vm['PV_kernel'], '')
+        self.assertEquals(self.vm['PV_ramdisk'], '')
+        self.assertEquals(self.vm['HVM_boot_params'], {})
+        self.assertEquals(self.vm['HVM_boot_policy'], '')
+
+    def check_vm_params_for_linux_with_external_kernel(self):
+        self.assertEquals(self.vm['platform']['nx'], 'false')
+        self.assertEquals(self.vm['PV_args'], 'root=/dev/xvda1')
+        self.assertNotEquals(self.vm['PV_kernel'], '')
+        self.assertNotEquals(self.vm['PV_ramdisk'], '')
+
+        # check that these are not set
+        self.assertEquals(self.vm['HVM_boot_params'], {})
+        self.assertEquals(self.vm['HVM_boot_policy'], '')
 
     def _test_spawn(self, image_id, kernel_id, ramdisk_id,
-                    instance_type="m1.large"):
+                    instance_type="m1.large", os_type="linux"):
         stubs.stubout_session(self.stubs, stubs.FakeSessionForVMTests)
         values = {'name': 1,
                   'id': 1,
@@ -263,11 +315,13 @@ class XenAPIVMTestCase(test.TestCase):
                   'ramdisk_id': ramdisk_id,
                   'instance_type': instance_type,
                   'mac_address': 'aa:bb:cc:dd:ee:ff',
+                  'os_type': os_type
                   }
         conn = xenapi_conn.get_connection(False)
         instance = db.instance_create(values)
         conn.spawn(instance)
-        self.check_vm_record(conn)
+        self.create_vm_record(conn, os_type)
+        self.check_vm_record()
 
     def test_spawn_not_enough_memory(self):
         FLAGS.xenapi_image_service = 'glance'
@@ -283,24 +337,37 @@ class XenAPIVMTestCase(test.TestCase):
         FLAGS.xenapi_image_service = 'objectstore'
         self._test_spawn(1, 2, 3)
 
+    @stub_vm_utils_with_vdi_attached_here
     def test_spawn_raw_glance(self):
         FLAGS.xenapi_image_service = 'glance'
         self._test_spawn(glance_stubs.FakeGlance.IMAGE_RAW, None, None)
+        self.check_vm_params_for_linux()
+
+    def test_spawn_vhd_glance_linux(self):
+        FLAGS.xenapi_image_service = 'glance'
+        self._test_spawn(glance_stubs.FakeGlance.IMAGE_VHD, None, None,
+                         os_type="linux")
+        self.check_vm_params_for_linux()
 
-    def test_spawn_vhd_glance(self):
+    def test_spawn_vhd_glance_windows(self):
         FLAGS.xenapi_image_service = 'glance'
-        self._test_spawn(glance_stubs.FakeGlance.IMAGE_VHD, None, None)
+        self._test_spawn(glance_stubs.FakeGlance.IMAGE_VHD, None, None,
+                         os_type="windows")
+        self.check_vm_params_for_windows()
 
     def test_spawn_glance(self):
         FLAGS.xenapi_image_service = 'glance'
         self._test_spawn(glance_stubs.FakeGlance.IMAGE_MACHINE,
                          glance_stubs.FakeGlance.IMAGE_KERNEL,
                          glance_stubs.FakeGlance.IMAGE_RAMDISK)
+        self.check_vm_params_for_linux_with_external_kernel()
 
     def tearDown(self):
         super(XenAPIVMTestCase, self).tearDown()
         self.manager.delete_project(self.project)
         self.manager.delete_user(self.user)
+        self.vm_info = None
+        self.vm = None
         self.stubs.UnsetAll()
 
     def _create_instance(self):
@@ -314,7 +381,8 @@ class XenAPIVMTestCase(test.TestCase):
             'kernel_id': 2,
             'ramdisk_id': 3,
             'instance_type': 'm1.large',
-            'mac_address': 'aa:bb:cc:dd:ee:ff'}
+            'mac_address': 'aa:bb:cc:dd:ee:ff',
+            'os_type': 'linux'}
         instance = db.instance_create(values)
         self.conn.spawn(instance)
         return instance
@@ -360,6 +428,7 @@ class XenAPIDetermineDiskImageTestCase(test.TestCase):
 
         self.fake_instance = FakeInstance()
         self.fake_instance.id = 42
+        self.fake_instance.os_type = 'linux'
 
     def assert_disk_type(self, disk_type):
         dt = vm_utils.VMHelper.determine_disk_image_type(
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 7afebad78de462918b89d61f5d8e0cee8bc11068 Mon Sep 17 00:00:00 2001
From: Todd Willey <todd@ansolabs.com>
Date: Fri, 4 Mar 2011 13:45:43 -0500
Subject: Fix api logging to show proper path and controller:action.

---
 nova/api/ec2/__init__.py | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

(limited to 'nova')

diff --git a/nova/api/ec2/__init__.py b/nova/api/ec2/__init__.py
index 5adc2c075..2493adc95 100644
--- a/nova/api/ec2/__init__.py
+++ b/nova/api/ec2/__init__.py
@@ -61,10 +61,13 @@ class RequestLogging(wsgi.Middleware):
         return rv
 
     def log_request_completion(self, response, request, start):
-        controller = request.environ.get('ec2.controller', None)
-        if controller:
-            controller = controller.__class__.__name__
-        action = request.environ.get('ec2.action', None)
+        apireq = request.environ.get('ec2.request', None)
+        if apirequest:
+            controller = apireq.controller
+            action = apireq.action
+        else:
+            controller = None
+            action = None
         ctxt = request.environ.get('ec2.context', None)
         delta = utils.utcnow() - start
         seconds = delta.seconds
@@ -75,7 +78,7 @@ class RequestLogging(wsgi.Middleware):
             microseconds,
             request.remote_addr,
             request.method,
-            request.path_info,
+            "%s%s" % (request.script_name, request.path_info),
             controller,
             action,
             response.status_int,
-- 
cgit 


From 831f398653cc99253bfeeb232165d3f9c043bd0b Mon Sep 17 00:00:00 2001
From: Todd Willey <todd@ansolabs.com>
Date: Fri, 4 Mar 2011 14:01:25 -0500
Subject: Fix renaming of instance fields using update_instance method.

---
 nova/api/ec2/apirequest.py | 18 +++++++++++++++++-
 nova/api/ec2/cloud.py      |  4 ++--
 2 files changed, 19 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/api/ec2/apirequest.py b/nova/api/ec2/apirequest.py
index 2b1acba5a..d7ad08d2f 100644
--- a/nova/api/ec2/apirequest.py
+++ b/nova/api/ec2/apirequest.py
@@ -52,7 +52,23 @@ def _database_to_isoformat(datetimeobj):
 
 
 def _try_convert(value):
-    """Return a non-string if possible"""
+    """Return a non-string from a string or unicode, if possible.
+
+    ============= =====================================================
+    When value is returns
+    ============= =====================================================
+    zero-length   ''
+    'None'        None
+    'True'        True
+    'False'       False
+    '0', '-0'     0
+    0xN, -0xN     int from hex (postitive) (N is any number)
+    0bN, -0bN     int from binary (positive) (N is any number)
+    *             try conversion to int, float, complex, fallback value
+
+    """
+    if len(value) == 0:
+        return ''
     if value == 'None':
         return None
     if value == 'True':
diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index c6309f03c..0d22a3f46 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -838,14 +838,14 @@ class CloudController(object):
         self.compute_api.unrescue(context, instance_id=instance_id)
         return True
 
-    def update_instance(self, context, ec2_id, **kwargs):
+    def update_instance(self, context, instance_id, **kwargs):
         updatable_fields = ['display_name', 'display_description']
         changes = {}
         for field in updatable_fields:
             if field in kwargs:
                 changes[field] = kwargs[field]
         if changes:
-            instance_id = ec2_id_to_id(ec2_id)
+            instance_id = ec2_id_to_id(instance_id)
             self.compute_api.update(context, instance_id=instance_id, **kwargs)
         return True
 
-- 
cgit 


From f36b4fe22bcb187d5f426320bbe43fcf3cb1a30a Mon Sep 17 00:00:00 2001
From: Mark Washenberger <mark.washenberger@rackspace.com>
Date: Fri, 4 Mar 2011 14:44:29 -0500
Subject: refactor server tests to support xml and json separately

---
 nova/tests/api/openstack/test_servers.py | 103 ++++++++++++++++++++-----------
 1 file changed, 68 insertions(+), 35 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index bf934113a..9e7bc3aac 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -233,12 +233,9 @@ class ServersTest(test.TestCase):
 
         self.assertEqual(res.status_int, 200)
 
-    def _personality_dict(self, path, contents):
-        return {'path': path, 'contents': contents}
+    def _setup_mock_compute_api_for_personality(self):
 
-    def _create_instance_with_personality(self, personality):
-
-        class FakeComputeAPI(object):
+        class MockComputeAPI(object):
 
             def __init__(self):
                 self.personality_files = None
@@ -255,28 +252,74 @@ class ServersTest(test.TestCase):
                 return canned_return
             return stub_method
 
-        compute_api = FakeComputeAPI()
+        compute_api = MockComputeAPI()
         self.stubs.Set(nova.compute, 'API', make_stub_method(compute_api))
         self.stubs.Set(nova.api.openstack.servers.Controller,
             '_get_kernel_ramdisk_from_image', make_stub_method((1, 1)))
         self.stubs.Set(nova.api.openstack.common,
             'get_image_id_from_image_hash', make_stub_method(2))
-        body = dict(server=dict(
-            name='server_test', imageId=2, flavorId=2,
-            metadata={},
-            personality=personality))
-        if personality is None:
-            del body['server']['personality']
-
+        return compute_api
+
+    def _create_personality_request_dict(self, personality_files):
+        server = {}
+        server['name'] = 'new-server-test'
+        server['imageId'] = 1
+        server['flavorId'] = 1
+        if personality_files is not None:
+            personalities = []
+            for path, contents in personality_files:
+                personalities.append({'path': path, 'contents': contents})
+            server['personality'] = personalities
+        return {'server': server}
+
+    def _create_personality_request_json(self, personality_files):
+        body_dict = self._create_personality_request_dict(personality_files)
         req = webob.Request.blank('/v1.0/servers')
+        req.content_type = 'application/json'
         req.method = 'POST'
-        req.body = json.dumps(body)
-        return (req, req.get_response(fakes.wsgi_app()),
-                compute_api.personality_files)
+        req.body = json.dumps(body_dict)
+        return req
+
+    def _format_xml_request_body(self, body_dict):
+        server = body_dict['server']
+        body_parts = []
+        body_parts.extend([
+            '<?xml version="1.0" encoding="UTF-8"?>',
+            '<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"',
+            ' name="%s" imageId="%s" flavorId="%s">' % (
+                    server['name'], server['imageId'], server['flavorId'])])
+        if 'metadata' in server:
+            metadata = server['metadata']
+            body_parts.append('<metadata>')
+            for item in metadata.iteritems():
+                body_parts.append('<meta key="%s">%s</meta>' % item)
+            body_parts.append('</metadata>')
+        if 'personality' in server:
+            personalities = server['personality']
+            body_parts.append('<personality>')
+            for item in personalities.iteritems():
+                body_parts.append('<file path="%s">%s</file>' % item)
+            body_parts.append('</personality>')
+        body_parts.append('</server>')
+        return ''.join(body_parts)
+
+    def _create_personality_request_xml(self, personality_files):
+        body_dict = self._create_personality_request_dict(personality_files)
+        req = webob.Request.blank('/v1.0/servers')
+        req.content_type = 'application/xml'
+        req.method = 'POST'
+        req.body = self._format_xml_request_body(body_dict)
+        return req
+
+    def _create_instance_with_personality_json(self, personality):
+        compute_api = self._setup_mock_compute_api_for_personality()
+        request = self._create_personality_request_json(personality)
+        response = request.get_response(fakes.wsgi_app())
+        return (request, response, compute_api.personality_files)
 
     def test_create_instance_with_no_personality(self):
         request, response, personality_files = \
-                self._create_instance_with_personality(personality=None)
+                self._create_instance_with_personality_json(personality=None)
         self.assertEquals(response.status_int, 200)
         self.assertEquals(personality_files, [])
 
@@ -284,18 +327,18 @@ class ServersTest(test.TestCase):
         path = '/my/file/path'
         contents = '#!/bin/bash\necho "Hello, World!"\n'
         b64contents = base64.b64encode(contents)
-        personality = [self._personality_dict(path, b64contents)]
+        personality = [(path, b64contents)]
         request, response, personality_files = \
-            self._create_instance_with_personality(personality)
+            self._create_instance_with_personality_json(personality)
         self.assertEquals(response.status_int, 200)
         self.assertEquals(personality_files, [(path, contents)])
 
     def test_create_instance_with_personality_with_non_b64_content(self):
         path = '/my/file/path'
         contents = '#!/bin/bash\necho "Oh no!"\n'
-        personality = [self._personality_dict(path, contents)]
+        personality = [(path, contents)]
         request, response, personality_files = \
-            self._create_instance_with_personality(personality)
+            self._create_instance_with_personality_json(personality)
         self.assertEquals(response.status_int, 400)
         self.assertEquals(personality_files, None)
 
@@ -307,31 +350,21 @@ class ServersTest(test.TestCase):
             ]
         personality = []
         for path, content in files:
-            personality.append(self._personality_dict(
-                    path, base64.b64encode(content)))
+            personality.append((path, base64.b64encode(content)))
         request, response, personality_files = \
-            self._create_instance_with_personality(personality)
+            self._create_instance_with_personality_json(personality)
         self.assertEquals(response.status_int, 200)
         self.assertEquals(personality_files, files)
 
     def test_create_instance_personality_empty_content(self):
         path = '/my/file/path'
         contents = ''
-        personality = [self._personality_dict(path, contents)]
+        personality = [(path, contents)]
         request, response, personality_files = \
-            self._create_instance_with_personality(personality)
+            self._create_instance_with_personality_json(personality)
         self.assertEquals(response.status_int, 200)
         self.assertEquals(personality_files, [(path, contents)])
 
-    def test_create_instance_personality_not_a_list(self):
-        path = '/my/file/path'
-        contents = 'myfilecontents'
-        personality = self._personality_dict(path, contents)
-        request, response, personality_files = \
-            self._create_instance_with_personality(personality)
-        self.assertEquals(response.status_int, 400)
-        self.assertEquals(personality_files, None)
-
     def test_update_no_body(self):
         req = webob.Request.blank('/v1.0/servers/1')
         req.method = 'PUT'
-- 
cgit 


From a38e6c67c37a4d3336cf1dc3717fd5612a474183 Mon Sep 17 00:00:00 2001
From: Mark Washenberger <mark.washenberger@rackspace.com>
Date: Fri, 4 Mar 2011 14:45:31 -0500
Subject: remove xml testing infrastructure since it is not feasible to use at
 present

---
 nova/tests/api/openstack/test_servers.py | 31 -------------------------------
 1 file changed, 31 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 9e7bc3aac..c125e6192 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -280,37 +280,6 @@ class ServersTest(test.TestCase):
         req.body = json.dumps(body_dict)
         return req
 
-    def _format_xml_request_body(self, body_dict):
-        server = body_dict['server']
-        body_parts = []
-        body_parts.extend([
-            '<?xml version="1.0" encoding="UTF-8"?>',
-            '<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"',
-            ' name="%s" imageId="%s" flavorId="%s">' % (
-                    server['name'], server['imageId'], server['flavorId'])])
-        if 'metadata' in server:
-            metadata = server['metadata']
-            body_parts.append('<metadata>')
-            for item in metadata.iteritems():
-                body_parts.append('<meta key="%s">%s</meta>' % item)
-            body_parts.append('</metadata>')
-        if 'personality' in server:
-            personalities = server['personality']
-            body_parts.append('<personality>')
-            for item in personalities.iteritems():
-                body_parts.append('<file path="%s">%s</file>' % item)
-            body_parts.append('</personality>')
-        body_parts.append('</server>')
-        return ''.join(body_parts)
-
-    def _create_personality_request_xml(self, personality_files):
-        body_dict = self._create_personality_request_dict(personality_files)
-        req = webob.Request.blank('/v1.0/servers')
-        req.content_type = 'application/xml'
-        req.method = 'POST'
-        req.body = self._format_xml_request_body(body_dict)
-        return req
-
     def _create_instance_with_personality_json(self, personality):
         compute_api = self._setup_mock_compute_api_for_personality()
         request = self._create_personality_request_json(personality)
-- 
cgit 


From 1831f31af0ac21ded3535f15777bd5147c615c34 Mon Sep 17 00:00:00 2001
From: Tushar Patil <tushar.vitthal.patil@gmail.com>
Date: Fri, 4 Mar 2011 11:52:18 -0800
Subject: added flatmanager unit testcases and renamed test_network.py to
 test_vlan_network.py

---
 nova/tests/test_flat_network.py | 276 +++++++++++++++++++++++++++++
 nova/tests/test_network.py      | 369 ---------------------------------------
 nova/tests/test_vlan_network.py | 373 ++++++++++++++++++++++++++++++++++++++++
 3 files changed, 649 insertions(+), 369 deletions(-)
 create mode 100644 nova/tests/test_flat_network.py
 delete mode 100644 nova/tests/test_network.py
 create mode 100644 nova/tests/test_vlan_network.py

(limited to 'nova')

diff --git a/nova/tests/test_flat_network.py b/nova/tests/test_flat_network.py
new file mode 100644
index 000000000..91a49920d
--- /dev/null
+++ b/nova/tests/test_flat_network.py
@@ -0,0 +1,276 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# 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.
+"""
+Unit Tests for network code
+"""
+import IPy
+import os
+import unittest
+
+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 test
+from nova import utils
+from nova.auth import manager
+
+FLAGS = flags.FLAGS
+LOG = logging.getLogger('nova.tests.network')
+
+
+class FlatNetworkTestCase(test.TestCase):
+    """Test cases for network code"""
+    def setUp(self):
+        super(FlatNetworkTestCase, self).setUp()
+        # NOTE(vish): if you change these flags, make sure to change the
+        #             flags in the corresponding section in nova-dhcpbridge
+        self.flags(connection_type='fake',
+                   fake_call=True,
+                   fake_network=True)
+        self.manager = manager.AuthManager()
+        self.user = self.manager.create_user('netuser', 'netuser', 'netuser')
+        self.projects = []
+        self.network = utils.import_object(FLAGS.network_manager)
+        self.context = context.RequestContext(project=None, user=self.user)
+        for i in range(5):
+            name = 'project%s' % i
+            project = self.manager.create_project(name, 'netuser', name)
+            self.projects.append(project)
+            # create the necessary network data for the project
+            user_context = context.RequestContext(project=self.projects[i],
+                                                     user=self.user)
+            host = self.network.get_network_host(user_context.elevated())
+        instance_ref = self._create_instance(0)
+        self.instance_id = instance_ref['id']
+        instance_ref = self._create_instance(1)
+        self.instance2_id = instance_ref['id']
+
+    def tearDown(self):
+        # TODO(termie): this should really be instantiating clean datastores
+        #               in between runs, one failure kills all the tests
+        db.instance_destroy(context.get_admin_context(), self.instance_id)
+        db.instance_destroy(context.get_admin_context(), self.instance2_id)
+        for project in self.projects:
+            self.manager.delete_project(project)
+        self.manager.delete_user(self.user)
+        super(FlatNetworkTestCase, self).tearDown()
+
+    def _create_instance(self, project_num, mac=None):
+        if not mac:
+            mac = utils.generate_mac()
+        project = self.projects[project_num]
+        self.context._project = project
+        self.context.project_id = project.id
+        return db.instance_create(self.context,
+                                  {'project_id': project.id,
+                                   'mac_address': mac})
+
+    def _create_address(self, project_num, instance_id=None):
+        """Create an address in given project num"""
+        if instance_id is None:
+            instance_id = self.instance_id
+        self.context._project = self.projects[project_num]
+        self.context.project_id = self.projects[project_num].id
+        return self.network.allocate_fixed_ip(self.context, instance_id)
+
+    def _deallocate_address(self, project_num, address):
+        self.context._project = self.projects[project_num]
+        self.context.project_id = self.projects[project_num].id
+        self.network.deallocate_fixed_ip(self.context, address)
+
+    def test_private_ipv6(self):
+        """Make sure ipv6 is OK"""
+        if FLAGS.use_ipv6:
+            instance_ref = self._create_instance(0)
+            address = self._create_address(0, instance_ref['id'])
+            network_ref = db.project_get_network(
+                                                 context.get_admin_context(),
+                                                 self.context.project_id)
+            address_v6 = db.instance_get_fixed_address_v6(
+                                                 context.get_admin_context(),
+                                                 instance_ref['id'])
+            self.assertEqual(instance_ref['mac_address'],
+                             utils.to_mac(address_v6))
+            instance_ref2 = db.fixed_ip_get_instance_v6(
+                                                 context.get_admin_context(),
+                                                 address_v6)
+            self.assertEqual(instance_ref['id'], instance_ref2['id'])
+            self.assertEqual(address_v6,
+                             utils.to_global_ipv6(
+                                                 network_ref['cidr_v6'],
+                                                 instance_ref['mac_address']))
+            self._deallocate_address(0, address)
+            db.instance_destroy(context.get_admin_context(),
+                                instance_ref['id'])
+
+    def test_public_network_association(self):
+        """Makes sure that we can allocate a public ip"""
+        # TODO(vish): better way of adding floating ips
+
+        self.context._project = self.projects[0]
+        self.context.project_id = self.projects[0].id
+        pubnet = IPy.IP(flags.FLAGS.floating_range)
+        address = str(pubnet[0])
+        try:
+            db.floating_ip_get_by_address(context.get_admin_context(), address)
+        except exception.NotFound:
+            db.floating_ip_create(context.get_admin_context(),
+                                  {'address': address,
+                                   'host': FLAGS.host})
+
+        self.assertRaises(NotImplementedError,
+                          self.network.allocate_floating_ip,
+                          self.context, self.projects[0].id)
+
+        fix_addr = self._create_address(0)
+        float_addr = address
+        self.assertRaises(NotImplementedError,
+                          self.network.associate_floating_ip,
+                          self.context, float_addr, fix_addr)
+
+        address = db.instance_get_floating_address(context.get_admin_context(),
+                                                   self.instance_id)
+        self.assertEqual(address, None)
+
+        self.assertRaises(NotImplementedError,
+                          self.network.disassociate_floating_ip,
+                          self.context, float_addr)
+
+        address = db.instance_get_floating_address(context.get_admin_context(),
+                                                   self.instance_id)
+        self.assertEqual(address, None)
+
+        self.assertRaises(NotImplementedError,
+                          self.network.deallocate_floating_ip,
+                          self.context, float_addr)
+
+        self.network.deallocate_fixed_ip(self.context, fix_addr)
+        db.floating_ip_destroy(context.get_admin_context(), float_addr)
+
+    def test_allocate_deallocate_fixed_ip(self):
+        """Makes sure that we can allocate and deallocate a fixed ip"""
+        address = self._create_address(0)
+        self.assertTrue(is_allocated_in_project(address, self.projects[0].id))
+        self._deallocate_address(0, address)
+
+        # check if the fixed ip address is really deallocated
+        self.assertFalse(is_allocated_in_project(address, self.projects[0].id))
+
+    def test_side_effects(self):
+        """Ensures allocating and releasing has no side effects"""
+        address = self._create_address(0)
+        address2 = self._create_address(1, self.instance2_id)
+
+        self.assertTrue(is_allocated_in_project(address, self.projects[0].id))
+        self.assertTrue(is_allocated_in_project(address2, self.projects[1].id))
+
+        self._deallocate_address(0, address)
+        self.assertFalse(is_allocated_in_project(address, self.projects[0].id))
+
+        # First address release shouldn't affect the second
+        self.assertTrue(is_allocated_in_project(address2, self.projects[0].id))
+
+        self._deallocate_address(1, address2)
+        self.assertFalse(is_allocated_in_project(address2,
+                                                 self.projects[1].id))
+
+    def test_ips_are_reused(self):
+        """Makes sure that ip addresses that are deallocated get reused"""
+        address = self._create_address(0)
+        self.network.deallocate_fixed_ip(self.context, address)
+
+        address2 = self._create_address(0)
+        self.assertEqual(address, address2)
+
+        self.network.deallocate_fixed_ip(self.context, address2)
+
+    def test_available_ips(self):
+        """Make sure the number of available ips for the network is correct
+
+        The number of available IP addresses depends on the test
+        environment's setup.
+
+        Network size is set in test fixture's setUp method.
+
+        There are ips reserved at the bottom and top of the range.
+        services (network, gateway, CloudPipe, broadcast)
+        """
+        network = db.project_get_network(context.get_admin_context(),
+                                         self.projects[0].id)
+        net_size = flags.FLAGS.network_size
+        admin_context = context.get_admin_context()
+        total_ips = (db.network_count_available_ips(admin_context,
+                                                    network['id']) +
+                     db.network_count_reserved_ips(admin_context,
+                                                   network['id']) +
+                     db.network_count_allocated_ips(admin_context,
+                                                    network['id']))
+        self.assertEqual(total_ips, net_size)
+
+    def test_too_many_addresses(self):
+        """Test for a NoMoreAddresses exception when all fixed ips are used.
+        """
+        admin_context = context.get_admin_context()
+        network = db.project_get_network(admin_context, self.projects[0].id)
+        num_available_ips = db.network_count_available_ips(admin_context,
+                                                           network['id'])
+        addresses = []
+        instance_ids = []
+        for i in range(num_available_ips):
+            instance_ref = self._create_instance(0)
+            instance_ids.append(instance_ref['id'])
+            address = self._create_address(0, instance_ref['id'])
+            addresses.append(address)
+
+        ip_count = db.network_count_available_ips(context.get_admin_context(),
+                                                  network['id'])
+        self.assertEqual(ip_count, 0)
+        self.assertRaises(db.NoMoreAddresses,
+                          self.network.allocate_fixed_ip,
+                          self.context,
+                          'foo')
+
+        for i in range(num_available_ips):
+            self.network.deallocate_fixed_ip(self.context, addresses[i])
+            db.instance_destroy(context.get_admin_context(), instance_ids[i])
+        ip_count = db.network_count_available_ips(context.get_admin_context(),
+                                                  network['id'])
+        self.assertEqual(ip_count, num_available_ips)
+
+    def run(self, result=None):
+        if(FLAGS.network_manager == 'nova.network.manager.FlatManager'):
+            super(FlatNetworkTestCase, self).run(result)
+
+
+def is_allocated_in_project(address, project_id):
+    """Returns true if address is in specified project"""
+    #project_net = db.project_get_network(context.get_admin_context(),
+    #                                     project_id)
+    project_net = db.network_get_by_bridge(context.get_admin_context(),
+                                           FLAGS.flat_network_bridge)
+    network = db.fixed_ip_get_network(context.get_admin_context(), address)
+    instance = db.fixed_ip_get_instance(context.get_admin_context(), address)
+    # instance exists until release
+    return instance is not None and network['id'] == project_net['id']
+
+
+def binpath(script):
+    """Returns the absolute path to a script in bin"""
+    return os.path.abspath(os.path.join(__file__, "../../../bin", script))
diff --git a/nova/tests/test_network.py b/nova/tests/test_network.py
deleted file mode 100644
index ce1c77210..000000000
--- a/nova/tests/test_network.py
+++ /dev/null
@@ -1,369 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 United States Government as represented by the
-# Administrator of the National Aeronautics and Space Administration.
-# 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.
-"""
-Unit Tests for network code
-"""
-import IPy
-import os
-
-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 test
-from nova import utils
-from nova.auth import manager
-
-FLAGS = flags.FLAGS
-LOG = logging.getLogger('nova.tests.network')
-
-
-class NetworkTestCase(test.TestCase):
-    """Test cases for network code"""
-    def setUp(self):
-        super(NetworkTestCase, self).setUp()
-        # NOTE(vish): if you change these flags, make sure to change the
-        #             flags in the corresponding section in nova-dhcpbridge
-        self.flags(connection_type='fake',
-                   fake_call=True,
-                   fake_network=True)
-        self.manager = manager.AuthManager()
-        self.user = self.manager.create_user('netuser', 'netuser', 'netuser')
-        self.projects = []
-        self.network = utils.import_object(FLAGS.network_manager)
-        self.context = context.RequestContext(project=None, user=self.user)
-        for i in range(FLAGS.num_networks):
-            name = 'project%s' % i
-            project = self.manager.create_project(name, 'netuser', name)
-            self.projects.append(project)
-            # create the necessary network data for the project
-            user_context = context.RequestContext(project=self.projects[i],
-                                                     user=self.user)
-            host = self.network.get_network_host(user_context.elevated())
-        instance_ref = self._create_instance(0)
-        self.instance_id = instance_ref['id']
-        instance_ref = self._create_instance(1)
-        self.instance2_id = instance_ref['id']
-
-    def tearDown(self):
-        # TODO(termie): this should really be instantiating clean datastores
-        #               in between runs, one failure kills all the tests
-        db.instance_destroy(context.get_admin_context(), self.instance_id)
-        db.instance_destroy(context.get_admin_context(), self.instance2_id)
-        for project in self.projects:
-            self.manager.delete_project(project)
-        self.manager.delete_user(self.user)
-        super(NetworkTestCase, self).tearDown()
-
-    def _create_instance(self, project_num, mac=None):
-        if not mac:
-            mac = utils.generate_mac()
-        project = self.projects[project_num]
-        self.context._project = project
-        self.context.project_id = project.id
-        return db.instance_create(self.context,
-                                  {'project_id': project.id,
-                                   'mac_address': mac})
-
-    def _create_address(self, project_num, instance_id=None):
-        """Create an address in given project num"""
-        if instance_id is None:
-            instance_id = self.instance_id
-        self.context._project = self.projects[project_num]
-        self.context.project_id = self.projects[project_num].id
-        return self.network.allocate_fixed_ip(self.context, instance_id)
-
-    def _deallocate_address(self, project_num, address):
-        self.context._project = self.projects[project_num]
-        self.context.project_id = self.projects[project_num].id
-        self.network.deallocate_fixed_ip(self.context, address)
-
-    def test_private_ipv6(self):
-        """Make sure ipv6 is OK"""
-        if FLAGS.use_ipv6:
-            instance_ref = self._create_instance(0)
-            address = self._create_address(0, instance_ref['id'])
-            network_ref = db.project_get_network(
-                                                 context.get_admin_context(),
-                                                 self.context.project_id)
-            address_v6 = db.instance_get_fixed_address_v6(
-                                                 context.get_admin_context(),
-                                                 instance_ref['id'])
-            self.assertEqual(instance_ref['mac_address'],
-                             utils.to_mac(address_v6))
-            instance_ref2 = db.fixed_ip_get_instance_v6(
-                                                 context.get_admin_context(),
-                                                 address_v6)
-            self.assertEqual(instance_ref['id'], instance_ref2['id'])
-            self.assertEqual(address_v6,
-                             utils.to_global_ipv6(
-                                                 network_ref['cidr_v6'],
-                                                 instance_ref['mac_address']))
-            self._deallocate_address(0, address)
-            db.instance_destroy(context.get_admin_context(),
-                                instance_ref['id'])
-
-    def test_public_network_association(self):
-        """Makes sure that we can allocaate a public ip"""
-        # TODO(vish): better way of adding floating ips
-        self.context._project = self.projects[0]
-        self.context.project_id = self.projects[0].id
-        pubnet = IPy.IP(flags.FLAGS.floating_range)
-        address = str(pubnet[0])
-        try:
-            db.floating_ip_get_by_address(context.get_admin_context(), address)
-        except exception.NotFound:
-            db.floating_ip_create(context.get_admin_context(),
-                                  {'address': address,
-                                   'host': FLAGS.host})
-        float_addr = self.network.allocate_floating_ip(self.context,
-                                                       self.projects[0].id)
-        fix_addr = self._create_address(0)
-        lease_ip(fix_addr)
-        self.assertEqual(float_addr, str(pubnet[0]))
-        self.network.associate_floating_ip(self.context, float_addr, fix_addr)
-        address = db.instance_get_floating_address(context.get_admin_context(),
-                                                   self.instance_id)
-        self.assertEqual(address, float_addr)
-        self.network.disassociate_floating_ip(self.context, float_addr)
-        address = db.instance_get_floating_address(context.get_admin_context(),
-                                                   self.instance_id)
-        self.assertEqual(address, None)
-        self.network.deallocate_floating_ip(self.context, float_addr)
-        self.network.deallocate_fixed_ip(self.context, fix_addr)
-        release_ip(fix_addr)
-        db.floating_ip_destroy(context.get_admin_context(), float_addr)
-
-    def test_allocate_deallocate_fixed_ip(self):
-        """Makes sure that we can allocate and deallocate a fixed ip"""
-        address = self._create_address(0)
-        self.assertTrue(is_allocated_in_project(address, self.projects[0].id))
-        lease_ip(address)
-        self._deallocate_address(0, address)
-
-        # Doesn't go away until it's dhcp released
-        self.assertTrue(is_allocated_in_project(address, self.projects[0].id))
-
-        release_ip(address)
-        self.assertFalse(is_allocated_in_project(address, self.projects[0].id))
-
-    def test_side_effects(self):
-        """Ensures allocating and releasing has no side effects"""
-        address = self._create_address(0)
-        address2 = self._create_address(1, self.instance2_id)
-
-        self.assertTrue(is_allocated_in_project(address, self.projects[0].id))
-        self.assertTrue(is_allocated_in_project(address2, self.projects[1].id))
-        self.assertFalse(is_allocated_in_project(address, self.projects[1].id))
-
-        # Addresses are allocated before they're issued
-        lease_ip(address)
-        lease_ip(address2)
-
-        self._deallocate_address(0, address)
-        release_ip(address)
-        self.assertFalse(is_allocated_in_project(address, self.projects[0].id))
-
-        # First address release shouldn't affect the second
-        self.assertTrue(is_allocated_in_project(address2, self.projects[1].id))
-
-        self._deallocate_address(1, address2)
-        release_ip(address2)
-        self.assertFalse(is_allocated_in_project(address2,
-                                                 self.projects[1].id))
-
-    def test_subnet_edge(self):
-        """Makes sure that private ips don't overlap"""
-        first = self._create_address(0)
-        lease_ip(first)
-        instance_ids = []
-        for i in range(1, FLAGS.num_networks):
-            instance_ref = self._create_instance(i, mac=utils.generate_mac())
-            instance_ids.append(instance_ref['id'])
-            address = self._create_address(i, instance_ref['id'])
-            instance_ref = self._create_instance(i, mac=utils.generate_mac())
-            instance_ids.append(instance_ref['id'])
-            address2 = self._create_address(i, instance_ref['id'])
-            instance_ref = self._create_instance(i, mac=utils.generate_mac())
-            instance_ids.append(instance_ref['id'])
-            address3 = self._create_address(i, instance_ref['id'])
-            lease_ip(address)
-            lease_ip(address2)
-            lease_ip(address3)
-            self.context._project = self.projects[i]
-            self.context.project_id = self.projects[i].id
-            self.assertFalse(is_allocated_in_project(address,
-                                                     self.projects[0].id))
-            self.assertFalse(is_allocated_in_project(address2,
-                                                     self.projects[0].id))
-            self.assertFalse(is_allocated_in_project(address3,
-                                                     self.projects[0].id))
-            self.network.deallocate_fixed_ip(self.context, address)
-            self.network.deallocate_fixed_ip(self.context, address2)
-            self.network.deallocate_fixed_ip(self.context, address3)
-            release_ip(address)
-            release_ip(address2)
-            release_ip(address3)
-        for instance_id in instance_ids:
-            db.instance_destroy(context.get_admin_context(), instance_id)
-        self.context._project = self.projects[0]
-        self.context.project_id = self.projects[0].id
-        self.network.deallocate_fixed_ip(self.context, first)
-        self._deallocate_address(0, first)
-        release_ip(first)
-
-    def test_vpn_ip_and_port_looks_valid(self):
-        """Ensure the vpn ip and port are reasonable"""
-        self.assert_(self.projects[0].vpn_ip)
-        self.assert_(self.projects[0].vpn_port >= FLAGS.vpn_start)
-        self.assert_(self.projects[0].vpn_port <= FLAGS.vpn_start +
-                                                  FLAGS.num_networks)
-
-    def test_too_many_networks(self):
-        """Ensure error is raised if we run out of networks"""
-        projects = []
-        networks_left = (FLAGS.num_networks -
-                         db.network_count(context.get_admin_context()))
-        for i in range(networks_left):
-            project = self.manager.create_project('many%s' % i, self.user)
-            projects.append(project)
-            db.project_get_network(context.get_admin_context(), project.id)
-        project = self.manager.create_project('last', self.user)
-        projects.append(project)
-        self.assertRaises(db.NoMoreNetworks,
-                          db.project_get_network,
-                          context.get_admin_context(),
-                          project.id)
-        for project in projects:
-            self.manager.delete_project(project)
-
-    def test_ips_are_reused(self):
-        """Makes sure that ip addresses that are deallocated get reused"""
-        address = self._create_address(0)
-        lease_ip(address)
-        self.network.deallocate_fixed_ip(self.context, address)
-        release_ip(address)
-
-        address2 = self._create_address(0)
-        self.assertEqual(address, address2)
-        lease_ip(address)
-        self.network.deallocate_fixed_ip(self.context, address2)
-        release_ip(address)
-
-    def test_available_ips(self):
-        """Make sure the number of available ips for the network is correct
-
-        The number of available IP addresses depends on the test
-        environment's setup.
-
-        Network size is set in test fixture's setUp method.
-
-        There are ips reserved at the bottom and top of the range.
-        services (network, gateway, CloudPipe, broadcast)
-        """
-        network = db.project_get_network(context.get_admin_context(),
-                                         self.projects[0].id)
-        net_size = flags.FLAGS.network_size
-        admin_context = context.get_admin_context()
-        total_ips = (db.network_count_available_ips(admin_context,
-                                                    network['id']) +
-                     db.network_count_reserved_ips(admin_context,
-                                                   network['id']) +
-                     db.network_count_allocated_ips(admin_context,
-                                                    network['id']))
-        self.assertEqual(total_ips, net_size)
-
-    def test_too_many_addresses(self):
-        """Test for a NoMoreAddresses exception when all fixed ips are used.
-        """
-        admin_context = context.get_admin_context()
-        network = db.project_get_network(admin_context, self.projects[0].id)
-        num_available_ips = db.network_count_available_ips(admin_context,
-                                                           network['id'])
-        addresses = []
-        instance_ids = []
-        for i in range(num_available_ips):
-            instance_ref = self._create_instance(0)
-            instance_ids.append(instance_ref['id'])
-            address = self._create_address(0, instance_ref['id'])
-            addresses.append(address)
-            lease_ip(address)
-
-        ip_count = db.network_count_available_ips(context.get_admin_context(),
-                                                  network['id'])
-        self.assertEqual(ip_count, 0)
-        self.assertRaises(db.NoMoreAddresses,
-                          self.network.allocate_fixed_ip,
-                          self.context,
-                          'foo')
-
-        for i in range(num_available_ips):
-            self.network.deallocate_fixed_ip(self.context, addresses[i])
-            release_ip(addresses[i])
-            db.instance_destroy(context.get_admin_context(), instance_ids[i])
-        ip_count = db.network_count_available_ips(context.get_admin_context(),
-                                                  network['id'])
-        self.assertEqual(ip_count, num_available_ips)
-
-
-def is_allocated_in_project(address, project_id):
-    """Returns true if address is in specified project"""
-    project_net = db.project_get_network(context.get_admin_context(),
-                                         project_id)
-    network = db.fixed_ip_get_network(context.get_admin_context(), address)
-    instance = db.fixed_ip_get_instance(context.get_admin_context(), address)
-    # instance exists until release
-    return instance is not None and network['id'] == project_net['id']
-
-
-def binpath(script):
-    """Returns the absolute path to a script in bin"""
-    return os.path.abspath(os.path.join(__file__, "../../../bin", script))
-
-
-def lease_ip(private_ip):
-    """Run add command on dhcpbridge"""
-    network_ref = db.fixed_ip_get_network(context.get_admin_context(),
-                                          private_ip)
-    instance_ref = db.fixed_ip_get_instance(context.get_admin_context(),
-                                            private_ip)
-    cmd = "%s add %s %s fake" % (binpath('nova-dhcpbridge'),
-                                 instance_ref['mac_address'],
-                                 private_ip)
-    env = {'DNSMASQ_INTERFACE': network_ref['bridge'],
-           'TESTING': '1',
-           'FLAGFILE': FLAGS.dhcpbridge_flagfile}
-    (out, err) = utils.execute(cmd, addl_env=env)
-    LOG.debug("ISSUE_IP: %s, %s ", out, err)
-
-
-def release_ip(private_ip):
-    """Run del command on dhcpbridge"""
-    network_ref = db.fixed_ip_get_network(context.get_admin_context(),
-                                          private_ip)
-    instance_ref = db.fixed_ip_get_instance(context.get_admin_context(),
-                                            private_ip)
-    cmd = "%s del %s %s fake" % (binpath('nova-dhcpbridge'),
-                                 instance_ref['mac_address'],
-                                 private_ip)
-    env = {'DNSMASQ_INTERFACE': network_ref['bridge'],
-           'TESTING': '1',
-           'FLAGFILE': FLAGS.dhcpbridge_flagfile}
-    (out, err) = utils.execute(cmd, addl_env=env)
-    LOG.debug("RELEASE_IP: %s, %s ", out, err)
diff --git a/nova/tests/test_vlan_network.py b/nova/tests/test_vlan_network.py
new file mode 100644
index 000000000..be39313bb
--- /dev/null
+++ b/nova/tests/test_vlan_network.py
@@ -0,0 +1,373 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# 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.
+"""
+Unit Tests for network code
+"""
+import IPy
+import os
+
+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 test
+from nova import utils
+from nova.auth import manager
+
+FLAGS = flags.FLAGS
+LOG = logging.getLogger('nova.tests.network')
+
+
+class VlanNetworkTestCase(test.TestCase):
+    """Test cases for network code"""
+    def setUp(self):
+        super(VlanNetworkTestCase, self).setUp()
+        # NOTE(vish): if you change these flags, make sure to change the
+        #             flags in the corresponding section in nova-dhcpbridge
+        self.flags(connection_type='fake',
+                   fake_call=True,
+                   fake_network=True)
+        self.manager = manager.AuthManager()
+        self.user = self.manager.create_user('netuser', 'netuser', 'netuser')
+        self.projects = []
+        self.network = utils.import_object(FLAGS.network_manager)
+        self.context = context.RequestContext(project=None, user=self.user)
+        for i in range(FLAGS.num_networks):
+            name = 'project%s' % i
+            project = self.manager.create_project(name, 'netuser', name)
+            self.projects.append(project)
+            # create the necessary network data for the project
+            user_context = context.RequestContext(project=self.projects[i],
+                                                     user=self.user)
+            host = self.network.get_network_host(user_context.elevated())
+        instance_ref = self._create_instance(0)
+        self.instance_id = instance_ref['id']
+        instance_ref = self._create_instance(1)
+        self.instance2_id = instance_ref['id']
+
+    def tearDown(self):
+        # TODO(termie): this should really be instantiating clean datastores
+        #               in between runs, one failure kills all the tests
+        db.instance_destroy(context.get_admin_context(), self.instance_id)
+        db.instance_destroy(context.get_admin_context(), self.instance2_id)
+        for project in self.projects:
+            self.manager.delete_project(project)
+        self.manager.delete_user(self.user)
+        super(VlanNetworkTestCase, self).tearDown()
+
+    def run(self, result=None):
+        if(FLAGS.network_manager == 'nova.network.manager.VlanManager'):
+            super(VlanNetworkTestCase, self).run(result)
+
+    def _create_instance(self, project_num, mac=None):
+        if not mac:
+            mac = utils.generate_mac()
+        project = self.projects[project_num]
+        self.context._project = project
+        self.context.project_id = project.id
+        return db.instance_create(self.context,
+                                  {'project_id': project.id,
+                                   'mac_address': mac})
+
+    def _create_address(self, project_num, instance_id=None):
+        """Create an address in given project num"""
+        if instance_id is None:
+            instance_id = self.instance_id
+        self.context._project = self.projects[project_num]
+        self.context.project_id = self.projects[project_num].id
+        return self.network.allocate_fixed_ip(self.context, instance_id)
+
+    def _deallocate_address(self, project_num, address):
+        self.context._project = self.projects[project_num]
+        self.context.project_id = self.projects[project_num].id
+        self.network.deallocate_fixed_ip(self.context, address)
+
+    def test_private_ipv6(self):
+        """Make sure ipv6 is OK"""
+        if FLAGS.use_ipv6:
+            instance_ref = self._create_instance(0)
+            address = self._create_address(0, instance_ref['id'])
+            network_ref = db.project_get_network(
+                                                 context.get_admin_context(),
+                                                 self.context.project_id)
+            address_v6 = db.instance_get_fixed_address_v6(
+                                                 context.get_admin_context(),
+                                                 instance_ref['id'])
+            self.assertEqual(instance_ref['mac_address'],
+                             utils.to_mac(address_v6))
+            instance_ref2 = db.fixed_ip_get_instance_v6(
+                                                 context.get_admin_context(),
+                                                 address_v6)
+            self.assertEqual(instance_ref['id'], instance_ref2['id'])
+            self.assertEqual(address_v6,
+                             utils.to_global_ipv6(
+                                                 network_ref['cidr_v6'],
+                                                 instance_ref['mac_address']))
+            self._deallocate_address(0, address)
+            db.instance_destroy(context.get_admin_context(),
+                                instance_ref['id'])
+
+    def test_public_network_association(self):
+        """Makes sure that we can allocaate a public ip"""
+        # TODO(vish): better way of adding floating ips
+        self.context._project = self.projects[0]
+        self.context.project_id = self.projects[0].id
+        pubnet = IPy.IP(flags.FLAGS.floating_range)
+        address = str(pubnet[0])
+        try:
+            db.floating_ip_get_by_address(context.get_admin_context(), address)
+        except exception.NotFound:
+            db.floating_ip_create(context.get_admin_context(),
+                                  {'address': address,
+                                   'host': FLAGS.host})
+        float_addr = self.network.allocate_floating_ip(self.context,
+                                                       self.projects[0].id)
+        fix_addr = self._create_address(0)
+        lease_ip(fix_addr)
+        self.assertEqual(float_addr, str(pubnet[0]))
+        self.network.associate_floating_ip(self.context, float_addr, fix_addr)
+        address = db.instance_get_floating_address(context.get_admin_context(),
+                                                   self.instance_id)
+        self.assertEqual(address, float_addr)
+        self.network.disassociate_floating_ip(self.context, float_addr)
+        address = db.instance_get_floating_address(context.get_admin_context(),
+                                                   self.instance_id)
+        self.assertEqual(address, None)
+        self.network.deallocate_floating_ip(self.context, float_addr)
+        self.network.deallocate_fixed_ip(self.context, fix_addr)
+        release_ip(fix_addr)
+        db.floating_ip_destroy(context.get_admin_context(), float_addr)
+
+    def test_allocate_deallocate_fixed_ip(self):
+        """Makes sure that we can allocate and deallocate a fixed ip"""
+        address = self._create_address(0)
+        self.assertTrue(is_allocated_in_project(address, self.projects[0].id))
+        lease_ip(address)
+        self._deallocate_address(0, address)
+
+        # Doesn't go away until it's dhcp released
+        self.assertTrue(is_allocated_in_project(address, self.projects[0].id))
+
+        release_ip(address)
+        self.assertFalse(is_allocated_in_project(address, self.projects[0].id))
+
+    def test_side_effects(self):
+        """Ensures allocating and releasing has no side effects"""
+        address = self._create_address(0)
+        address2 = self._create_address(1, self.instance2_id)
+
+        self.assertTrue(is_allocated_in_project(address, self.projects[0].id))
+        self.assertTrue(is_allocated_in_project(address2, self.projects[1].id))
+        self.assertFalse(is_allocated_in_project(address, self.projects[1].id))
+
+        # Addresses are allocated before they're issued
+        lease_ip(address)
+        lease_ip(address2)
+
+        self._deallocate_address(0, address)
+        release_ip(address)
+        self.assertFalse(is_allocated_in_project(address, self.projects[0].id))
+
+        # First address release shouldn't affect the second
+        self.assertTrue(is_allocated_in_project(address2, self.projects[1].id))
+
+        self._deallocate_address(1, address2)
+        release_ip(address2)
+        self.assertFalse(is_allocated_in_project(address2,
+                                                 self.projects[1].id))
+
+    def test_subnet_edge(self):
+        """Makes sure that private ips don't overlap"""
+        first = self._create_address(0)
+        lease_ip(first)
+        instance_ids = []
+        for i in range(1, FLAGS.num_networks):
+            instance_ref = self._create_instance(i, mac=utils.generate_mac())
+            instance_ids.append(instance_ref['id'])
+            address = self._create_address(i, instance_ref['id'])
+            instance_ref = self._create_instance(i, mac=utils.generate_mac())
+            instance_ids.append(instance_ref['id'])
+            address2 = self._create_address(i, instance_ref['id'])
+            instance_ref = self._create_instance(i, mac=utils.generate_mac())
+            instance_ids.append(instance_ref['id'])
+            address3 = self._create_address(i, instance_ref['id'])
+            lease_ip(address)
+            lease_ip(address2)
+            lease_ip(address3)
+            self.context._project = self.projects[i]
+            self.context.project_id = self.projects[i].id
+            self.assertFalse(is_allocated_in_project(address,
+                                                     self.projects[0].id))
+            self.assertFalse(is_allocated_in_project(address2,
+                                                     self.projects[0].id))
+            self.assertFalse(is_allocated_in_project(address3,
+                                                     self.projects[0].id))
+            self.network.deallocate_fixed_ip(self.context, address)
+            self.network.deallocate_fixed_ip(self.context, address2)
+            self.network.deallocate_fixed_ip(self.context, address3)
+            release_ip(address)
+            release_ip(address2)
+            release_ip(address3)
+        for instance_id in instance_ids:
+            db.instance_destroy(context.get_admin_context(), instance_id)
+        self.context._project = self.projects[0]
+        self.context.project_id = self.projects[0].id
+        self.network.deallocate_fixed_ip(self.context, first)
+        self._deallocate_address(0, first)
+        release_ip(first)
+
+    def test_vpn_ip_and_port_looks_valid(self):
+        """Ensure the vpn ip and port are reasonable"""
+        self.assert_(self.projects[0].vpn_ip)
+        self.assert_(self.projects[0].vpn_port >= FLAGS.vpn_start)
+        self.assert_(self.projects[0].vpn_port <= FLAGS.vpn_start +
+                                                  FLAGS.num_networks)
+
+    def test_too_many_networks(self):
+        """Ensure error is raised if we run out of networks"""
+        projects = []
+        networks_left = (FLAGS.num_networks -
+                         db.network_count(context.get_admin_context()))
+        for i in range(networks_left):
+            project = self.manager.create_project('many%s' % i, self.user)
+            projects.append(project)
+            db.project_get_network(context.get_admin_context(), project.id)
+        project = self.manager.create_project('last', self.user)
+        projects.append(project)
+        self.assertRaises(db.NoMoreNetworks,
+                          db.project_get_network,
+                          context.get_admin_context(),
+                          project.id)
+        for project in projects:
+            self.manager.delete_project(project)
+
+    def test_ips_are_reused(self):
+        """Makes sure that ip addresses that are deallocated get reused"""
+        address = self._create_address(0)
+        lease_ip(address)
+        self.network.deallocate_fixed_ip(self.context, address)
+        release_ip(address)
+
+        address2 = self._create_address(0)
+        self.assertEqual(address, address2)
+        lease_ip(address)
+        self.network.deallocate_fixed_ip(self.context, address2)
+        release_ip(address)
+
+    def test_available_ips(self):
+        """Make sure the number of available ips for the network is correct
+
+        The number of available IP addresses depends on the test
+        environment's setup.
+
+        Network size is set in test fixture's setUp method.
+
+        There are ips reserved at the bottom and top of the range.
+        services (network, gateway, CloudPipe, broadcast)
+        """
+        network = db.project_get_network(context.get_admin_context(),
+                                         self.projects[0].id)
+        net_size = flags.FLAGS.network_size
+        admin_context = context.get_admin_context()
+        total_ips = (db.network_count_available_ips(admin_context,
+                                                    network['id']) +
+                     db.network_count_reserved_ips(admin_context,
+                                                   network['id']) +
+                     db.network_count_allocated_ips(admin_context,
+                                                    network['id']))
+        self.assertEqual(total_ips, net_size)
+
+    def test_too_many_addresses(self):
+        """Test for a NoMoreAddresses exception when all fixed ips are used.
+        """
+        admin_context = context.get_admin_context()
+        network = db.project_get_network(admin_context, self.projects[0].id)
+        num_available_ips = db.network_count_available_ips(admin_context,
+                                                           network['id'])
+        addresses = []
+        instance_ids = []
+        for i in range(num_available_ips):
+            instance_ref = self._create_instance(0)
+            instance_ids.append(instance_ref['id'])
+            address = self._create_address(0, instance_ref['id'])
+            addresses.append(address)
+            lease_ip(address)
+
+        ip_count = db.network_count_available_ips(context.get_admin_context(),
+                                                  network['id'])
+        self.assertEqual(ip_count, 0)
+        self.assertRaises(db.NoMoreAddresses,
+                          self.network.allocate_fixed_ip,
+                          self.context,
+                          'foo')
+
+        for i in range(num_available_ips):
+            self.network.deallocate_fixed_ip(self.context, addresses[i])
+            release_ip(addresses[i])
+            db.instance_destroy(context.get_admin_context(), instance_ids[i])
+        ip_count = db.network_count_available_ips(context.get_admin_context(),
+                                                  network['id'])
+        self.assertEqual(ip_count, num_available_ips)
+
+
+def is_allocated_in_project(address, project_id):
+    """Returns true if address is in specified project"""
+    project_net = db.project_get_network(context.get_admin_context(),
+                                         project_id)
+    network = db.fixed_ip_get_network(context.get_admin_context(), address)
+    instance = db.fixed_ip_get_instance(context.get_admin_context(), address)
+    # instance exists until release
+    return instance is not None and network['id'] == project_net['id']
+
+
+def binpath(script):
+    """Returns the absolute path to a script in bin"""
+    return os.path.abspath(os.path.join(__file__, "../../../bin", script))
+
+
+def lease_ip(private_ip):
+    """Run add command on dhcpbridge"""
+    network_ref = db.fixed_ip_get_network(context.get_admin_context(),
+                                          private_ip)
+    instance_ref = db.fixed_ip_get_instance(context.get_admin_context(),
+                                            private_ip)
+    cmd = "%s add %s %s fake" % (binpath('nova-dhcpbridge'),
+                                 instance_ref['mac_address'],
+                                 private_ip)
+    env = {'DNSMASQ_INTERFACE': network_ref['bridge'],
+           'TESTING': '1',
+           'FLAGFILE': FLAGS.dhcpbridge_flagfile}
+    (out, err) = utils.execute(cmd, addl_env=env)
+    LOG.debug("ISSUE_IP: %s, %s ", out, err)
+
+
+def release_ip(private_ip):
+    """Run del command on dhcpbridge"""
+    network_ref = db.fixed_ip_get_network(context.get_admin_context(),
+                                          private_ip)
+    instance_ref = db.fixed_ip_get_instance(context.get_admin_context(),
+                                            private_ip)
+    cmd = "%s del %s %s fake" % (binpath('nova-dhcpbridge'),
+                                 instance_ref['mac_address'],
+                                 private_ip)
+    env = {'DNSMASQ_INTERFACE': network_ref['bridge'],
+           'TESTING': '1',
+           'FLAGFILE': FLAGS.dhcpbridge_flagfile}
+    (out, err) = utils.execute(cmd, addl_env=env)
+    LOG.debug("RELEASE_IP: %s, %s ", out, err)
-- 
cgit 


From f3c1c99ca0f6f3164430b33f46772ef8bdc87b70 Mon Sep 17 00:00:00 2001
From: Vishvananda Ishaya <vishvananda@gmail.com>
Date: Fri, 4 Mar 2011 19:54:19 +0000
Subject: move the id wrapping into cloud layer instead of image_service

---
 nova/api/ec2/cloud.py | 33 ++++++++++++++++++++++++---------
 nova/image/s3.py      | 28 +++++-----------------------
 2 files changed, 29 insertions(+), 32 deletions(-)

(limited to 'nova')

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index aa1dcbe33..3ea3fa07e 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -843,10 +843,19 @@ class CloudController(object):
             self.compute_api.update(context, instance_id=instance_id, **kwargs)
         return True
 
+    _type_prefix_map = {'machine': 'ami',
+                        'kernel': 'aki',
+                        'ramdisk': 'ari'}
+
+    def _image_ec2_id(self, image_id, image_type):
+        prefix = self._type_prefix_map[image_type]
+        template = prefix + '-%08x'
+        return ec2utils.id_to_ec2_id(int(image_id), template=template)
+
     def _format_image(self, image):
         """Convert from format defined by BaseImageService to S3 format."""
         i = {}
-        i['imageId'] = image.get('id')
+        i['imageId'] = self._image_ec2_id(image.get('id'), image.get('type'))
         i['kernelId'] = image['properties'].get('kernel_id')
         i['ramdiskId'] = image['properties'].get('ramdisk_id')
         i['imageOwnerId'] = image['properties'].get('owner_id')
@@ -863,7 +872,8 @@ class CloudController(object):
             images = []
             for ec2_id in image_id:
                 try:
-                    image = self.image_service.show(context, ec2_id)
+                    internal_id = ec2utils.ec2_id_to_id(ec2_id)
+                    image = self.image_service.show(context, internal_id)
                 except exception.NotFound:
                     raise exception.NotFound(_('Image %s not found') %
                                              ec2_id)
@@ -875,14 +885,16 @@ class CloudController(object):
 
     def deregister_image(self, context, image_id, **kwargs):
         LOG.audit(_("De-registering image %s"), image_id, context=context)
-        self.image_service.delete(context, image_id)
+        internal_id = ec2utils.ec2_id_to_id(image_id)
+        self.image_service.delete(context, internal_id)
         return {'imageId': image_id}
 
     def register_image(self, context, image_location=None, **kwargs):
         if image_location is None and 'name' in kwargs:
             image_location = kwargs['name']
-        image = {"image_location": image_location}
-        image_id = self.image_service.create(context, image)
+        metadata = {"image_location": image_location}
+        image = self.image_service.create(context, metadata)
+        image_id =  self._image_ec2_id(image['id'], image['type'])
         msg = _("Registered image %(image_location)s with"
                 " id %(image_id)s") % locals()
         LOG.audit(msg, context=context)
@@ -893,8 +905,9 @@ class CloudController(object):
             raise exception.ApiError(_('attribute not supported: %s')
                                      % attribute)
         try:
+            internal_id = ec2utils.ec2_id_to_id(image_id)
             image = self._format_image(self.image_service.show(context,
-                                                               image_id))
+                                                               internal_id))
         except (IndexError, exception.NotFound):
             raise exception.NotFound(_('Image %s not found') % image_id)
         result = {'image_id': image_id, 'launchPermission': []}
@@ -917,13 +930,15 @@ class CloudController(object):
         LOG.audit(_("Updating image %s publicity"), image_id, context=context)
 
         try:
-            metadata = self.image_service.show(context, image_id)
+            internal_id = ec2utils.ec2_id_to_id(image_id)
+            metadata = self.image_service.show(context, internal_id)
         except exception.NotFound:
             raise exception.NotFound(_('Image %s not found') % image_id)
         del(metadata['id'])
         metadata['properties']['is_public'] = (operation_type == 'add')
-        return self.image_service.update(context, image_id, metadata)
+        return self.image_service.update(context, internal_id, metadata)
 
     def update_image(self, context, image_id, **kwargs):
-        result = self.image_service.update(context, image_id, dict(kwargs))
+        internal_id = ec2utils.ec2_id_to_id(image_id)
+        result = self.image_service.update(context, internal_id, dict(kwargs))
         return result
diff --git a/nova/image/s3.py b/nova/image/s3.py
index e9542c7bd..c7446f4b0 100644
--- a/nova/image/s3.py
+++ b/nova/image/s3.py
@@ -36,7 +36,6 @@ from nova import flags
 from nova import utils
 from nova.auth import manager
 from nova.image import service
-from nova.api.ec2 import ec2utils
 
 
 FLAGS = flags.FLAGS
@@ -44,17 +43,6 @@ flags.DEFINE_string('image_decryption_dir', '/tmp',
                     'parent dir for tempdir used for image decryption')
 
 
-_type_prefix_map = {'machine': 'ami',
-                    'kernel': 'aki',
-                    'ramdisk': 'ari'}
-
-
-def image_ec2_id(image_id, image_type):
-    prefix = _type_prefix_map[image_type]
-    template = prefix + '-%08x'
-    return ec2utils.id_to_ec2_id(int(image_id), template=template)
-
-
 class S3ImageService(service.BaseImageService):
     def __init__(self, service=None, *args, **kwargs):
         if service == None:
@@ -62,23 +50,20 @@ class S3ImageService(service.BaseImageService):
         self.service = service
         self.service.__init__(*args, **kwargs)
 
-    def create(self, context, properties, data=None):
-        """image should contain image_location"""
-        image_id, metadata = self._s3_create(context, properties)
-        return image_ec2_id(image_id, metadata['type'])
+    def create(self, context, metadata, data=None):
+        """metadata should contain image_location"""
+        image = self._s3_create(context, metadata)
+        return image
 
     def delete(self, context, image_id):
         # FIXME(vish): call to show is to check filter
         self.show(context, image_id)
-        image_id = ec2utils.ec2_id_to_id(image_id)
         self.service.delete(context, image_id)
 
     def update(self, context, image_id, metadata, data=None):
         # FIXME(vish): call to show is to check filter
         self.show(context, image_id)
-        image_id = ec2utils.ec2_id_to_id(image_id)
         image = self.service.update(context, image_id, metadata, data)
-        image['id'] = image_ec2_id(image['id'], image['type'])
         return image
 
     def index(self, context):
@@ -103,16 +88,13 @@ class S3ImageService(service.BaseImageService):
         for image in images:
             if not S3ImageService._is_visible(context, image):
                 continue
-            image['id'] = image_ec2_id(image['id'], image['type'])
             filtered.append(image)
         return filtered
 
     def show(self, context, image_id):
-        image_id = ec2utils.ec2_id_to_id(image_id)
         image = self.service.show(context, image_id)
         if not self._is_visible(context, image):
             raise exception.NotFound
-        image['id'] = image_ec2_id(image['id'], image['type'])
         return image
 
     @staticmethod
@@ -233,7 +215,7 @@ class S3ImageService(service.BaseImageService):
 
         eventlet.spawn_n(delayed_create)
 
-        return image_id, metadata
+        return image
 
     @staticmethod
     def _decrypt_image(encrypted_filename, encrypted_key, encrypted_iv,
-- 
cgit 


From 10668b87f46a1fb5d039f6e7d7a7a55b89d7602a Mon Sep 17 00:00:00 2001
From: Mark Washenberger <mark.washenberger@rackspace.com>
Date: Fri, 4 Mar 2011 17:04:41 -0500
Subject: respond well if personality attribute is incomplete

---
 nova/api/openstack/servers.py            |  3 ++
 nova/tests/api/openstack/test_servers.py | 48 ++++++++++++++++++++++++++++----
 2 files changed, 46 insertions(+), 5 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 8b7b20b92..7c620dbc6 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -153,6 +153,9 @@ class Controller(wsgi.Controller):
             try:
                 path = item['path']
                 contents = item['contents']
+            except KeyError, key:
+                expl = 'Bad personality format: missing %s' % key
+                raise exc.HTTPBadRequest(explanation=expl)
             except TypeError:
                 raise exc.HTTPBadRequest(explanation='Bad personality format')
             try:
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index c125e6192..8fb5a9aec 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -272,19 +272,24 @@ class ServersTest(test.TestCase):
             server['personality'] = personalities
         return {'server': server}
 
-    def _create_personality_request_json(self, personality_files):
-        body_dict = self._create_personality_request_dict(personality_files)
+    def _get_create_request_json(self, body_dict):
         req = webob.Request.blank('/v1.0/servers')
         req.content_type = 'application/json'
         req.method = 'POST'
         req.body = json.dumps(body_dict)
         return req
 
-    def _create_instance_with_personality_json(self, personality):
+    def _run_create_instance_with_mock_compute_api(self, request):
         compute_api = self._setup_mock_compute_api_for_personality()
-        request = self._create_personality_request_json(personality)
         response = request.get_response(fakes.wsgi_app())
-        return (request, response, compute_api.personality_files)
+        return compute_api, response
+
+    def _create_instance_with_personality_json(self, personality):
+        body_dict = self._create_personality_request_dict(personality)
+        request = self._get_create_request_json(body_dict)
+        compute_api, response = \
+            self._run_create_instance_with_mock_compute_api(request)
+        return request, response, compute_api.personality_files
 
     def test_create_instance_with_no_personality(self):
         request, response, personality_files = \
@@ -302,6 +307,39 @@ class ServersTest(test.TestCase):
         self.assertEquals(response.status_int, 200)
         self.assertEquals(personality_files, [(path, contents)])
 
+    def test_create_instance_with_personality_no_path(self):
+        personality = [('/remove/this/path',
+            base64.b64encode('my\n\file\ncontents'))]
+        body_dict = self._create_personality_request_dict(personality)
+        del body_dict['server']['personality'][0]['path']
+        request = self._get_create_request_json(body_dict)
+        compute_api, response = \
+            self._run_create_instance_with_mock_compute_api(request)
+        self.assertEquals(response.status_int, 400)
+        self.assertEquals(compute_api.personality_files, None)
+
+    def test_create_instance_with_personality_no_contents(self):
+        personality = [('/test/path',
+            base64.b64encode('remove\nthese\ncontents'))]
+        body_dict = self._create_personality_request_dict(personality)
+        del body_dict['server']['personality'][0]['contents']
+        request = self._get_create_request_json(body_dict)
+        compute_api, response = \
+            self._run_create_instance_with_mock_compute_api(request)
+        self.assertEquals(response.status_int, 400)
+        self.assertEquals(compute_api.personality_files, None)
+
+    def test_create_instance_with_personality_not_a_list(self):
+        personality = [('/test/path', base64.b64encode('test\ncontents\n'))]
+        body_dict = self._create_personality_request_dict(personality)
+        body_dict['server']['personality'] = \
+            body_dict['server']['personality'][0]
+        request = self._get_create_request_json(body_dict)
+        compute_api, response = \
+            self._run_create_instance_with_mock_compute_api(request)
+        self.assertEquals(response.status_int, 400)
+        self.assertEquals(compute_api.personality_files, None)
+
     def test_create_instance_with_personality_with_non_b64_content(self):
         path = '/my/file/path'
         contents = '#!/bin/bash\necho "Oh no!"\n'
-- 
cgit 


From e63cd9d5dc856f81477cf6c0e6c77ed7d1f4d70c Mon Sep 17 00:00:00 2001
From: Cory Wright <cory.wright@rackspace.com>
Date: Fri, 4 Mar 2011 22:17:53 +0000
Subject:  * os_type is no longer `not null`

---
 .../versions/007_add_os_type_to_instances.py       | 45 -----------------
 .../versions/009_add_os_type_to_instances.py       | 56 ++++++++++++++++++++++
 nova/virt/xenapi/vm_utils.py                       |  8 ++--
 3 files changed, 60 insertions(+), 49 deletions(-)
 delete mode 100644 nova/db/sqlalchemy/migrate_repo/versions/007_add_os_type_to_instances.py
 create mode 100644 nova/db/sqlalchemy/migrate_repo/versions/009_add_os_type_to_instances.py

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/migrate_repo/versions/007_add_os_type_to_instances.py b/nova/db/sqlalchemy/migrate_repo/versions/007_add_os_type_to_instances.py
deleted file mode 100644
index d6d964b95..000000000
--- a/nova/db/sqlalchemy/migrate_repo/versions/007_add_os_type_to_instances.py
+++ /dev/null
@@ -1,45 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 United States Government as represented by the
-# Administrator of the National Aeronautics and Space Administration.
-# 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.
-
-from sqlalchemy import *
-from migrate import *
-
-from nova import log as logging
-
-
-meta = MetaData()
-
-instances = Table('instances', meta,
-        Column('id', Integer(),  primary_key=True, nullable=False),
-        )
-
-# FIXME(dubs) should this be not null?  Maybe create as nullable, then
-#   populate all existing rows with 'linux', then adding not null constraint.
-instances_os_type = Column('os_type',
-                           String(length=255, convert_unicode=False,
-                                  assert_unicode=None, unicode_error=None,
-                                  _warn_on_bytestring=False),
-                           nullable=True)
-
-
-def upgrade(migrate_engine):
-    # Upgrade operations go here. Don't create your own engine;
-    # bind migrate_engine to your metadata
-    meta.bind = migrate_engine
-
-    instances.create_column(instances_os_type)
diff --git a/nova/db/sqlalchemy/migrate_repo/versions/009_add_os_type_to_instances.py b/nova/db/sqlalchemy/migrate_repo/versions/009_add_os_type_to_instances.py
new file mode 100644
index 000000000..a50f31e16
--- /dev/null
+++ b/nova/db/sqlalchemy/migrate_repo/versions/009_add_os_type_to_instances.py
@@ -0,0 +1,56 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# 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.
+
+from sqlalchemy import *
+from sqlalchemy.sql import text
+from migrate import *
+
+from nova import log as logging
+
+
+meta = MetaData()
+
+instances = Table('instances', meta,
+        Column('id', Integer(),  primary_key=True, nullable=False),
+        )
+
+# FIXME(dubs) should this be not null?  Maybe create as nullable, then
+#   populate all existing rows with 'linux', then adding not null constraint.
+instances_os_type = Column('os_type',
+                           String(length=255, convert_unicode=False,
+                                  assert_unicode=None, unicode_error=None,
+                                  _warn_on_bytestring=False),
+                           nullable=True)
+
+
+def upgrade(migrate_engine):
+    # Upgrade operations go here. Don't create your own engine;
+    # bind migrate_engine to your metadata
+    meta.bind = migrate_engine
+
+    instances.create_column(instances_os_type)
+    migrate_engine.execute(instances.update()\
+                           .where(instances.c.os_type==None)\
+                           .values(os_type='linux'))
+
+
+def downgrade(migrate_engine):
+    meta.bind = migrate_engine
+
+    instances.drop_column('os_type')
+
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 ceccffaab6fb5fce3b0951b5a8eea65f523e8563 Mon Sep 17 00:00:00 2001
From: Todd Willey <todd@ansolabs.com>
Date: Fri, 4 Mar 2011 19:13:27 -0500
Subject: apirequest -> apireq.

---
 nova/api/ec2/__init__.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/api/ec2/__init__.py b/nova/api/ec2/__init__.py
index 2493adc95..b06289e67 100644
--- a/nova/api/ec2/__init__.py
+++ b/nova/api/ec2/__init__.py
@@ -62,7 +62,7 @@ class RequestLogging(wsgi.Middleware):
 
     def log_request_completion(self, response, request, start):
         apireq = request.environ.get('ec2.request', None)
-        if apirequest:
+        if apireq:
             controller = apireq.controller
             action = apireq.action
         else:
-- 
cgit 


From 7af17cbef6f3e1c5b052133e40e0edbd8ca9ffb3 Mon Sep 17 00:00:00 2001
From: Mark Washenberger <mark.washenberger@rackspace.com>
Date: Sun, 6 Mar 2011 10:41:24 -0500
Subject: select cleanups

---
 nova/api/openstack/servers.py |  2 +-
 nova/quota.py                 | 14 ++++++--------
 nova/virt/xenapi/vmops.py     |  2 +-
 3 files changed, 8 insertions(+), 10 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 7c620dbc6..93f504f91 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -153,7 +153,7 @@ class Controller(wsgi.Controller):
             try:
                 path = item['path']
                 contents = item['contents']
-            except KeyError, key:
+            except KeyError as key:
                 expl = 'Bad personality format: missing %s' % key
                 raise exc.HTTPBadRequest(explanation=expl)
             except TypeError:
diff --git a/nova/quota.py b/nova/quota.py
index 4b777624c..1d79f9ef2 100644
--- a/nova/quota.py
+++ b/nova/quota.py
@@ -46,14 +46,12 @@ flags.DEFINE_integer('quota_personality_max_path_bytes', 255,
 
 
 def get_quota(context, project_id):
-    rval = {
-        'instances': FLAGS.quota_instances,
-        'cores': FLAGS.quota_cores,
-        'volumes': FLAGS.quota_volumes,
-        'gigabytes': FLAGS.quota_gigabytes,
-        'floating_ips': FLAGS.quota_floating_ips,
-        'metadata_items': FLAGS.quota_metadata_items,
-        }
+    rval = {'instances': FLAGS.quota_instances,
+            'cores': FLAGS.quota_cores,
+            'volumes': FLAGS.quota_volumes,
+            'gigabytes': FLAGS.quota_gigabytes,
+            'floating_ips': FLAGS.quota_floating_ips,
+            'metadata_items': FLAGS.quota_metadata_items}
 
     try:
         quota = db.quota_get(context, project_id)
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 aa4b8a557505108341d603659a5456d10d5f9632 Mon Sep 17 00:00:00 2001
From: Mark Washenberger <mark.washenberger@rackspace.com>
Date: Sun, 6 Mar 2011 12:06:39 -0500
Subject: avoid possible string/int comparison problems

---
 nova/quota.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/quota.py b/nova/quota.py
index 1d79f9ef2..fdef42bc5 100644
--- a/nova/quota.py
+++ b/nova/quota.py
@@ -115,17 +115,17 @@ def allowed_metadata_items(context, num_metadata_items):
 
 def allowed_personality_files(context):
     """Return the number of personality files allowed"""
-    return FLAGS.quota_personality_max_files
+    return int(FLAGS.quota_personality_max_files)
 
 
 def allowed_personality_content_bytes(context):
     """Return the number of bytes allowed per personality content"""
-    return FLAGS.quota_personality_max_content_bytes
+    return int(FLAGS.quota_personality_max_content_bytes)
 
 
 def allowed_personality_path_bytes(context):
     """Return the number of bytes allowed in a personality file path"""
-    return FLAGS.quota_personality_max_path_bytes
+    return int(FLAGS.quota_personality_max_path_bytes)
 
 
 class QuotaError(exception.ApiError):
-- 
cgit 


From a5bee00af4d6ec3eed6ed0abd866948f4510f041 Mon Sep 17 00:00:00 2001
From: Vishvananda Ishaya <vishvananda@gmail.com>
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/api/ec2/cloud.py        | 74 ++++++++++++++++++++++++++++----------------
 nova/api/ec2/ec2utils.py     |  6 +++-
 nova/compute/api.py          |  4 +--
 nova/image/glance.py         | 35 ++++++++++++++++++---
 nova/image/local.py          | 52 ++++++++++++++++++++++++-------
 nova/image/s3.py             | 33 +++++++++++++-------
 nova/image/service.py        | 18 ++++++++---
 nova/tests/test_cloud.py     | 16 +++++-----
 nova/tests/test_compute.py   | 12 +++----
 nova/tests/test_console.py   |  2 +-
 nova/tests/test_quota.py     | 32 +++++++++++--------
 nova/tests/test_scheduler.py |  4 +--
 nova/tests/test_volume.py    |  2 +-
 nova/virt/images.py          | 25 +++++++++------
 nova/virt/libvirt_conn.py    |  8 +++--
 15 files changed, 216 insertions(+), 107 deletions(-)

(limited to 'nova')

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 3ea3fa07e..496e944fe 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -146,10 +146,13 @@ class CloudController(object):
         floating_ip = db.instance_get_floating_address(ctxt,
                                                        instance_ref['id'])
         ec2_id = ec2utils.id_to_ec2_id(instance_ref['id'])
+        image_ec2_id = self._image_ec2_id(instance_ref['image_id'], 'machine')
+        k_ec2_id = self._image_ec2_id(instance_ref['kernel_id'], 'kernel')
+        r_ec2_id = self._image_ec2_id(instance_ref['ramdisk_id'], 'ramdisk')
         data = {
             'user-data': base64.b64decode(instance_ref['user_data']),
             'meta-data': {
-                'ami-id': instance_ref['image_id'],
+                'ami-id': image_ec2_id,
                 'ami-launch-index': instance_ref['launch_index'],
                 'ami-manifest-path': 'FIXME',
                 'block-device-mapping': {
@@ -164,12 +167,12 @@ class CloudController(object):
                 'instance-type': instance_ref['instance_type'],
                 'local-hostname': hostname,
                 'local-ipv4': address,
-                'kernel-id': instance_ref['kernel_id'],
+                'kernel-id': k_ec2_id,
+                'ramdisk-id': r_ec2_id,
                 'placement': {'availability-zone': availability_zone},
                 'public-hostname': hostname,
                 'public-ipv4': floating_ip or '',
                 'public-keys': keys,
-                'ramdisk-id': instance_ref['ramdisk_id'],
                 'reservation-id': instance_ref['reservation_id'],
                 'security-groups': '',
                 'mpi': mpi}}
@@ -679,7 +682,7 @@ class CloudController(object):
             instance_id = instance['id']
             ec2_id = ec2utils.id_to_ec2_id(instance_id)
             i['instanceId'] = ec2_id
-            i['imageId'] = instance['image_id']
+            i['imageId'] = self._image_ec2_id(instance['image_id'])
             i['instanceState'] = {
                 'code': instance['state'],
                 'name': instance['state_description']}
@@ -782,13 +785,15 @@ class CloudController(object):
     def run_instances(self, context, **kwargs):
         max_count = int(kwargs.get('max_count', 1))
         if kwargs.get('kernel_id'):
-            kwargs['kernel_id'] = ec2utils.ec2_id_to_id(kwargs['kernel_id'])
+            kernel = self._get_image(context, kwargs['kernel_id'])
+            kwargs['kernel_id'] = kernel['id']
         if kwargs.get('ramdisk_id'):
-            kwargs['ramdisk_id'] = ec2utils.ec2_id_to_id(kwargs['ramdisk_id'])
+            ramdisk = self._get_image(context, kwargs['ramdisk_id'])
+            kwargs['ramdisk_id'] = ramdisk['id']
         instances = self.compute_api.create(context,
             instance_type=instance_types.get_by_type(
                 kwargs.get('instance_type', None)),
-            image_id=ec2utils.ec2_id_to_id(kwargs['image_id']),
+            image_id=self._get_image(context, kwargs['image_id'])['id'],
             min_count=int(kwargs.get('min_count', max_count)),
             max_count=max_count,
             kernel_id=kwargs.get('kernel_id'),
@@ -847,17 +852,34 @@ class CloudController(object):
                         'kernel': 'aki',
                         'ramdisk': 'ari'}
 
-    def _image_ec2_id(self, image_id, image_type):
+    def _image_ec2_id(self, image_id, image_type='machine'):
         prefix = self._type_prefix_map[image_type]
         template = prefix + '-%08x'
         return ec2utils.id_to_ec2_id(int(image_id), template=template)
 
+    def _get_image(self, context, ec2_id):
+        try:
+            internal_id = ec2utils.ec2_id_to_id(ec2_id)
+            return self.image_service.show(context, internal_id)
+        except exception.NotFound:
+            return self.image_service.show_by_name(context, ec2_id)
+
+
     def _format_image(self, image):
         """Convert from format defined by BaseImageService to S3 format."""
         i = {}
-        i['imageId'] = self._image_ec2_id(image.get('id'), image.get('type'))
-        i['kernelId'] = image['properties'].get('kernel_id')
-        i['ramdiskId'] = image['properties'].get('ramdisk_id')
+        ec2_id = self._image_ec2_id(image.get('id'), image.get('type'))
+        name = image.get('name')
+        if name:
+            i['imageId'] = "%s (%s)" % (ec2_id, name)
+        else:
+            i['imageId'] = ec2_id
+        kernel_id = image['properties'].get('kernel_id')
+        if kernel_id:
+            i['kernelId'] = self._image_ec2_id(kernel_id, 'kernel')
+        ramdisk_id = image['properties'].get('ramdisk_id')
+        if ramdisk_id:
+            i['ramdiskId'] = self._image_ec2_id(ramdisk_id, 'ramdisk')
         i['imageOwnerId'] = image['properties'].get('owner_id')
         i['imageLocation'] = image['properties'].get('image_location')
         i['imageState'] = image['properties'].get('image_state')
@@ -872,8 +894,7 @@ class CloudController(object):
             images = []
             for ec2_id in image_id:
                 try:
-                    internal_id = ec2utils.ec2_id_to_id(ec2_id)
-                    image = self.image_service.show(context, internal_id)
+                    image = self._get_image(context, ec2_id)
                 except exception.NotFound:
                     raise exception.NotFound(_('Image %s not found') %
                                              ec2_id)
@@ -885,16 +906,17 @@ class CloudController(object):
 
     def deregister_image(self, context, image_id, **kwargs):
         LOG.audit(_("De-registering image %s"), image_id, context=context)
-        internal_id = ec2utils.ec2_id_to_id(image_id)
+        image = self._get_image(context, image_id)
+        internal_id = image['id']
         self.image_service.delete(context, internal_id)
         return {'imageId': image_id}
 
     def register_image(self, context, image_location=None, **kwargs):
         if image_location is None and 'name' in kwargs:
             image_location = kwargs['name']
-        metadata = {"image_location": image_location}
+        metadata = {'properties': {'image_location': image_location}}
         image = self.image_service.create(context, metadata)
-        image_id =  self._image_ec2_id(image['id'], image['type'])
+        image_id = self._image_ec2_id(image['id'], image['type'])
         msg = _("Registered image %(image_location)s with"
                 " id %(image_id)s") % locals()
         LOG.audit(msg, context=context)
@@ -905,13 +927,11 @@ class CloudController(object):
             raise exception.ApiError(_('attribute not supported: %s')
                                      % attribute)
         try:
-            internal_id = ec2utils.ec2_id_to_id(image_id)
-            image = self._format_image(self.image_service.show(context,
-                                                               internal_id))
-        except (IndexError, exception.NotFound):
+            image = self._get_image(context, image_id)
+        except exception.NotFound:
             raise exception.NotFound(_('Image %s not found') % image_id)
-        result = {'image_id': image_id, 'launchPermission': []}
-        if image['isPublic']:
+        result = {'imageId': image_id, 'launchPermission': []}
+        if image['properties']['is_public']:
             result['launchPermission'].append({'group': 'all'})
         return result
 
@@ -930,13 +950,13 @@ class CloudController(object):
         LOG.audit(_("Updating image %s publicity"), image_id, context=context)
 
         try:
-            internal_id = ec2utils.ec2_id_to_id(image_id)
-            metadata = self.image_service.show(context, internal_id)
+            image = self._get_image(context, image_id)
         except exception.NotFound:
             raise exception.NotFound(_('Image %s not found') % image_id)
-        del(metadata['id'])
-        metadata['properties']['is_public'] = (operation_type == 'add')
-        return self.image_service.update(context, internal_id, metadata)
+        internal_id = image['id']
+        del(image['id'])
+        image['properties']['is_public'] = (operation_type == 'add')
+        return self.image_service.update(context, internal_id, image)
 
     def update_image(self, context, image_id, **kwargs):
         internal_id = ec2utils.ec2_id_to_id(image_id)
diff --git a/nova/api/ec2/ec2utils.py b/nova/api/ec2/ec2utils.py
index 0ea22c0e6..e4df80cf8 100644
--- a/nova/api/ec2/ec2utils.py
+++ b/nova/api/ec2/ec2utils.py
@@ -16,10 +16,14 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+from nova import exception
 
 def ec2_id_to_id(ec2_id):
     """Convert an ec2 ID (i-[base 16 number]) to an instance id (int)"""
-    return int(ec2_id.split('-')[-1], 16)
+    try:
+        return int(ec2_id.split('-')[-1], 16)
+    except ValueError:
+        raise exception.NotFound(_("Id %s Not Found") % ec2_id)
 
 
 def id_to_ec2_id(instance_id, template='i-%08x'):
diff --git a/nova/compute/api.py b/nova/compute/api.py
index 35a7d7bc0..58118121a 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -126,9 +126,9 @@ class API(base.Base):
 
         image = self.image_service.show(context, image_id)
         if kernel_id is None:
-            kernel_id = image.get('kernel_id', None)
+            kernel_id = image['properties'].get('kernel_id', None)
         if ramdisk_id is None:
-            ramdisk_id = image.get('ramdisk_id', None)
+            ramdisk_id = image['properties'].get('ramdisk_id', None)
         # FIXME(sirp): is there a way we can remove null_kernel?
         # No kernel and ramdisk for raw images
         if kernel_id == str(FLAGS.null_kernel):
diff --git a/nova/image/glance.py b/nova/image/glance.py
index 7db94c0d4..fb383f5e6 100644
--- a/nova/image/glance.py
+++ b/nova/image/glance.py
@@ -17,9 +17,6 @@
 """Implementation of an image service that uses Glance as the backend"""
 
 from __future__ import absolute_import
-import httplib
-import json
-import urlparse
 
 from glance.common import exception as glance_exception
 
@@ -55,16 +52,44 @@ class GlanceImageService(service.BaseImageService):
         """
         return self.client.get_images_detailed()
 
-    def show(self, context, id):
+    def show(self, context, image_id):
         """
         Returns a dict containing image data for the given opaque image id.
         """
         try:
-            image = self.client.get_image_meta(id)
+            image = self.client.get_image_meta(image_id)
         except glance_exception.NotFound:
             raise exception.NotFound
         return image
 
+    def show_by_name(self, context, name):
+        """
+        Returns a dict containing image data for the given name.
+        """
+        # TODO(vish): replace this with more efficient call when glance
+        #             supports it.
+        images = self.detail(context)
+        image = None
+        for cantidate in images:
+            if name == cantidate.get('name'):
+                image = cantidate
+                break
+        if image == None:
+            raise exception.NotFound
+        return image
+
+    def get(self, context, image_id, data):
+        """
+        Calls out to Glance for metadata and data and writes data.
+        """
+        try:
+            metadata, image_chunks = self.client.get_image(image_id)
+        except glance_exception.NotFound:
+            raise exception.NotFound
+        for chunk in image_chunks:
+            data.write(chunk)
+        return metadata
+
     def create(self, context, metadata, data=None):
         """
         Store the image data and return the new image id.
diff --git a/nova/image/local.py b/nova/image/local.py
index 6fa648b6b..c4ac3baaa 100644
--- a/nova/image/local.py
+++ b/nova/image/local.py
@@ -42,13 +42,12 @@ class LocalImageService(service.BaseImageService):
 
     def _path_to(self, image_id, fname='info.json'):
         if fname:
-            return os.path.join(self._path, str(image_id), fname)
-        return os.path.join(self._path, str(image_id))
+            return os.path.join(self._path, '%08x' % int(image_id), fname)
+        return os.path.join(self._path, '%08x' % int(image_id))
 
     def _ids(self):
         """The list of all image ids."""
-        return [int(i) for i in os.listdir(self._path)
-                if unicode(i).isnumeric()]
+        return [int(i, 16) for i in os.listdir(self._path)]
 
     def index(self, context):
         return [dict(image_id=i['id'], name=i.get('name'))
@@ -68,27 +67,56 @@ class LocalImageService(service.BaseImageService):
         try:
             with open(self._path_to(image_id)) as metadata_file:
                 return json.load(metadata_file)
-        except IOError:
+        except (IOError, ValueError):
             raise exception.NotFound
 
+    def show_by_name(self, context, name):
+        """Returns a dict containing image data for the given name."""
+        # NOTE(vish): Not very efficient, but the local image service
+        #             is for testing so it should be fine.
+        images = self.detail(context)
+        image = None
+        for cantidate in images:
+            if name == cantidate.get('name'):
+                image = cantidate
+                break
+        if image == None:
+            raise exception.NotFound
+        return image
+
+    def get(self, context, image_id, data):
+        """Get image and metadata."""
+        try:
+            with open(self._path_to(image_id)) as metadata_file:
+                metadata = json.load(metadata_file)
+            with open(self._path_to(image_id, 'image')) as image_file:
+                shutil.copyfileobj(image_file, data)
+        except (IOError, ValueError):
+            raise exception.NotFound
+        return metadata
+
     def create(self, context, metadata, data=None):
-        """Store the image data and return the new image id."""
+        """Store the image data and return the new image."""
         image_id = random.randint(0, 2 ** 31 - 1)
         image_path = self._path_to(image_id, None)
         if not os.path.exists(image_path):
             os.mkdir(image_path)
-        return  self.update(context, image_id, metadata, data)
+        return self.update(context, image_id, metadata, data)
 
     def update(self, context, image_id, metadata, data=None):
         """Replace the contents of the given image with the new data."""
         metadata['id'] = image_id
         try:
-            with open(self._path_to(image_id), 'w') as metadata_file:
-                json.dump(metadata, metadata_file)
             if data:
-                with open(self._path_to(image_id, 'image'), 'w') as image_file:
+                location = self._path_to(image_id, 'image')
+                with open(location, 'w') as image_file:
                     shutil.copyfileobj(data, image_file)
-        except IOError:
+                # NOTE(vish): update metadata similarly to glance
+                metadata['status'] = 'active'
+                metadata['location'] = location
+            with open(self._path_to(image_id), 'w') as metadata_file:
+                json.dump(metadata, metadata_file)
+        except (IOError, ValueError):
             raise exception.NotFound
         return metadata
 
@@ -99,7 +127,7 @@ class LocalImageService(service.BaseImageService):
         """
         try:
             shutil.rmtree(self._path_to(image_id, None))
-        except IOError:
+        except (IOError, ValueError):
             raise exception.NotFound
 
     def delete_all(self):
diff --git a/nova/image/s3.py b/nova/image/s3.py
index c7446f4b0..ab6eea8cf 100644
--- a/nova/image/s3.py
+++ b/nova/image/s3.py
@@ -36,6 +36,7 @@ from nova import flags
 from nova import utils
 from nova.auth import manager
 from nova.image import service
+from nova.api.ec2 import ec2utils
 
 
 FLAGS = flags.FLAGS
@@ -51,7 +52,7 @@ class S3ImageService(service.BaseImageService):
         self.service.__init__(*args, **kwargs)
 
     def create(self, context, metadata, data=None):
-        """metadata should contain image_location"""
+        """metadata['properties'] should contain image_location"""
         image = self._s3_create(context, metadata)
         return image
 
@@ -97,6 +98,12 @@ class S3ImageService(service.BaseImageService):
             raise exception.NotFound
         return image
 
+    def show_by_name(self, context, name):
+        image = self.service.show_by_name(context, name)
+        if not self._is_visible(context, image):
+            raise exception.NotFound
+        return image
+
     @staticmethod
     def _conn(context):
         # TODO(vish): is there a better way to get creds to sign
@@ -119,10 +126,12 @@ class S3ImageService(service.BaseImageService):
         key.get_contents_to_filename(local_filename)
         return local_filename
 
-    def _s3_create(self, context, properties):
+    def _s3_create(self, context, metadata):
+        """Gets a manifext from s3 and makes an image"""
+
         image_path = tempfile.mkdtemp(dir=FLAGS.image_decryption_dir)
 
-        image_location = properties['image_location']
+        image_location = metadata['properties']['image_location']
         bucket_name = image_location.split("/")[0]
         manifest_path = image_location[len(bucket_name) + 1:]
         bucket = self._conn(context).get_bucket(bucket_name)
@@ -153,25 +162,27 @@ class S3ImageService(service.BaseImageService):
         except:
             arch = 'x86_64'
 
-        properties.update({'owner_id': context.project_id,
-                           'architecture': arch})
+        properties = metadata['properties']
+        properties['owner_id'] = context.project_id
+        properties['architecture'] = arch
 
         if kernel_id:
-            properties['kernel_id'] = kernel_id
+            properties['kernel_id'] = ec2utils.ec2_id_to_id(kernel_id)
 
         if ramdisk_id:
-            properties['ramdisk_id'] = ramdisk_id
+            properties['ramdisk_id'] = ec2utils.ec2_id_to_id(ramdisk_id)
 
         properties['is_public'] = False
-        metadata = {'type': image_type,
-                    'status': 'queued',
-                    'is_public': True,
-                    'properties': properties}
+        metadata.update({'type': image_type,
+                         'status': 'queued',
+                         'is_public': True,
+                         'properties': properties})
         metadata['properties']['image_state'] = 'pending'
         image = self.service.create(context, metadata)
         image_id = image['id']
 
         def delayed_create():
+            """This handles the fetching and decrypting of the part files."""
             parts = []
             for fn_element in manifest.find("image").getiterator("filename"):
                 part = self._download_file(bucket, fn_element.text, image_path)
diff --git a/nova/image/service.py b/nova/image/service.py
index e429955f4..c09052cab 100644
--- a/nova/image/service.py
+++ b/nova/image/service.py
@@ -56,9 +56,9 @@ class BaseImageService(object):
         """
         raise NotImplementedError
 
-    def show(self, context, id):
+    def show(self, context, image_id):
         """
-        Returns a dict containing image data for the given opaque image id.
+        Returns a dict containing image metadata for the given opaque image id.
 
         :retval a mapping with the following signature:
 
@@ -76,9 +76,19 @@ class BaseImageService(object):
         """
         raise NotImplementedError
 
+    def get(self, context, data):
+        """
+        Returns a dict containing image metadata and writes image data to data.
+
+        :param data: a file-like object to hold binary image data
+
+        :raises NotFound if the image does not exist
+        """
+        raise NotImplementedError
+
     def create(self, context, metadata, data=None):
         """
-        Store the image data and return the new image id.
+        Store the image metadata and data and return the new image id.
 
         :raises AlreadyExists if the image already exist.
 
@@ -86,7 +96,7 @@ class BaseImageService(object):
         raise NotImplementedError
 
     def update(self, context, image_id, metadata, data=None):
-        """Replace the contents of the given image with the new data.
+        """Update the given image with the new metadata and data.
 
         :raises NotFound if the image does not exist.
 
diff --git a/nova/tests/test_cloud.py b/nova/tests/test_cloud.py
index 7d7b91658..8d2cd9573 100644
--- a/nova/tests/test_cloud.py
+++ b/nova/tests/test_cloud.py
@@ -78,10 +78,11 @@ class CloudTestCase(test.TestCase):
                                               project=self.project)
         host = self.network.get_network_host(self.context.elevated())
 
-        def fake_image_show(meh, context, id):
-            return dict(kernelId=1, ramdiskId=1)
+        def fake_show(meh, context, id):
+            return {'id': 1, 'properties': {'kernel_id': 1, 'ramdisk_id': 1}}
 
-        self.stubs.Set(local.LocalImageService, 'show', fake_image_show)
+        self.stubs.Set(local.LocalImageService, 'show', fake_show)
+        self.stubs.Set(local.LocalImageService, 'show_by_name', fake_show)
 
     def tearDown(self):
         network_ref = db.project_get_network(self.context,
@@ -195,8 +196,10 @@ class CloudTestCase(test.TestCase):
     def test_describe_instances(self):
         """Makes sure describe_instances works and filters results."""
         inst1 = db.instance_create(self.context, {'reservation_id': 'a',
+                                                  'image_id': 1,
                                                   'host': 'host1'})
         inst2 = db.instance_create(self.context, {'reservation_id': 'a',
+                                                  'image_id': 1,
                                                   'host': 'host2'})
         comp1 = db.service_create(self.context, {'host': 'host1',
                                                  'availability_zone': 'zone1',
@@ -222,11 +225,9 @@ class CloudTestCase(test.TestCase):
         db.service_destroy(self.context, comp2['id'])
 
     def test_console_output(self):
-        image_id = FLAGS.default_image
-        print image_id
         instance_type = FLAGS.default_instance_type
         max_count = 1
-        kwargs = {'image_id': image_id,
+        kwargs = {'image_id': 'ami-1',
                   'instance_type': instance_type,
                   'max_count': max_count}
         rv = self.cloud.run_instances(self.context, **kwargs)
@@ -242,8 +243,7 @@ class CloudTestCase(test.TestCase):
         greenthread.sleep(0.3)
 
     def test_ajax_console(self):
-        image_id = FLAGS.default_image
-        kwargs = {'image_id': image_id}
+        kwargs = {'image_id': 'ami-1'}
         rv = self.cloud.run_instances(self.context, **kwargs)
         instance_id = rv['instancesSet'][0]['instanceId']
         greenthread.sleep(0.3)
diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index 1f49baaf6..8c18fafc6 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -47,16 +47,16 @@ class ComputeTestCase(test.TestCase):
                    network_manager='nova.network.manager.FlatManager')
         self.compute = utils.import_object(FLAGS.compute_manager)
         self.compute_api = compute.API()
-
-        def fake_image_show(meh, context, id):
-            return dict(kernelId=1, ramdiskId=1)
-
-        self.stubs.Set(local.LocalImageService, 'show', fake_image_show)
         self.manager = manager.AuthManager()
         self.user = self.manager.create_user('fake', 'fake', 'fake')
         self.project = self.manager.create_project('fake', 'fake', 'fake')
         self.context = context.RequestContext('fake', 'fake', False)
 
+        def fake_show(meh, context, id):
+            return {'id': 1, 'properties': {'kernel_id': 1, 'ramdisk_id': 1}}
+
+        self.stubs.Set(local.LocalImageService, 'show', fake_show)
+
     def tearDown(self):
         self.manager.delete_user(self.user)
         self.manager.delete_project(self.project)
@@ -65,7 +65,7 @@ class ComputeTestCase(test.TestCase):
     def _create_instance(self):
         """Create a test instance"""
         inst = {}
-        inst['image_id'] = 'ami-test'
+        inst['image_id'] = 1
         inst['reservation_id'] = 'r-fakeres'
         inst['launch_time'] = '10'
         inst['user_id'] = self.user.id
diff --git a/nova/tests/test_console.py b/nova/tests/test_console.py
index 49ff24413..d47c70d88 100644
--- a/nova/tests/test_console.py
+++ b/nova/tests/test_console.py
@@ -57,7 +57,7 @@ class ConsoleTestCase(test.TestCase):
         inst = {}
         #inst['host'] = self.host
         #inst['name'] = 'instance-1234'
-        inst['image_id'] = 'ami-test'
+        inst['image_id'] = 1
         inst['reservation_id'] = 'r-fakeres'
         inst['launch_time'] = '10'
         inst['user_id'] = self.user.id
diff --git a/nova/tests/test_quota.py b/nova/tests/test_quota.py
index ca8abdb36..45b544753 100644
--- a/nova/tests/test_quota.py
+++ b/nova/tests/test_quota.py
@@ -20,11 +20,12 @@ from nova import compute
 from nova import context
 from nova import db
 from nova import flags
+from nova import network
 from nova import quota
 from nova import test
 from nova import utils
+from nova import volume
 from nova.auth import manager
-from nova.api.ec2 import cloud
 from nova.compute import instance_types
 
 
@@ -41,7 +42,6 @@ class QuotaTestCase(test.TestCase):
                    quota_gigabytes=20,
                    quota_floating_ips=1)
 
-        self.cloud = cloud.CloudController()
         self.manager = manager.AuthManager()
         self.user = self.manager.create_user('admin', 'admin', 'admin', True)
         self.project = self.manager.create_project('admin', 'admin', 'admin')
@@ -57,7 +57,7 @@ class QuotaTestCase(test.TestCase):
     def _create_instance(self, cores=2):
         """Create a test instance"""
         inst = {}
-        inst['image_id'] = 'ami-1'
+        inst['image_id'] = 1
         inst['reservation_id'] = 'r-fakeres'
         inst['user_id'] = self.user.id
         inst['project_id'] = self.project.id
@@ -118,12 +118,12 @@ class QuotaTestCase(test.TestCase):
         for i in range(FLAGS.quota_instances):
             instance_id = self._create_instance()
             instance_ids.append(instance_id)
-        self.assertRaises(quota.QuotaError, self.cloud.run_instances,
+        self.assertRaises(quota.QuotaError, compute.API().create,
                                             self.context,
                                             min_count=1,
                                             max_count=1,
                                             instance_type='m1.small',
-                                            image_id='ami-1')
+                                            image_id=1)
         for instance_id in instance_ids:
             db.instance_destroy(self.context, instance_id)
 
@@ -131,12 +131,12 @@ class QuotaTestCase(test.TestCase):
         instance_ids = []
         instance_id = self._create_instance(cores=4)
         instance_ids.append(instance_id)
-        self.assertRaises(quota.QuotaError, self.cloud.run_instances,
+        self.assertRaises(quota.QuotaError, compute.API().create,
                                             self.context,
                                             min_count=1,
                                             max_count=1,
                                             instance_type='m1.small',
-                                            image_id='ami-1')
+                                            image_id=1)
         for instance_id in instance_ids:
             db.instance_destroy(self.context, instance_id)
 
@@ -145,9 +145,12 @@ class QuotaTestCase(test.TestCase):
         for i in range(FLAGS.quota_volumes):
             volume_id = self._create_volume()
             volume_ids.append(volume_id)
-        self.assertRaises(quota.QuotaError, self.cloud.create_volume,
-                                            self.context,
-                                            size=10)
+        self.assertRaises(quota.QuotaError,
+                          volume.API().create,
+                          self.context,
+                          size=10,
+                          name='',
+                          description='')
         for volume_id in volume_ids:
             db.volume_destroy(self.context, volume_id)
 
@@ -156,9 +159,11 @@ class QuotaTestCase(test.TestCase):
         volume_id = self._create_volume(size=20)
         volume_ids.append(volume_id)
         self.assertRaises(quota.QuotaError,
-                          self.cloud.create_volume,
+                          volume.API().create,
                           self.context,
-                          size=10)
+                          size=10,
+                          name='',
+                          description='')
         for volume_id in volume_ids:
             db.volume_destroy(self.context, volume_id)
 
@@ -172,7 +177,8 @@ class QuotaTestCase(test.TestCase):
         #             make an rpc.call, the test just finishes with OK. It
         #             appears to be something in the magic inline callbacks
         #             that is breaking.
-        self.assertRaises(quota.QuotaError, self.cloud.allocate_address,
+        self.assertRaises(quota.QuotaError,
+                          network.API().allocate_floating_ip,
                           self.context)
         db.floating_ip_destroy(context.get_admin_context(), address)
 
diff --git a/nova/tests/test_scheduler.py b/nova/tests/test_scheduler.py
index b6888c4d2..bb279ac4b 100644
--- a/nova/tests/test_scheduler.py
+++ b/nova/tests/test_scheduler.py
@@ -155,7 +155,7 @@ class SimpleDriverTestCase(test.TestCase):
     def _create_instance(self, **kwargs):
         """Create a test instance"""
         inst = {}
-        inst['image_id'] = 'ami-test'
+        inst['image_id'] = 1
         inst['reservation_id'] = 'r-fakeres'
         inst['user_id'] = self.user.id
         inst['project_id'] = self.project.id
@@ -169,8 +169,6 @@ class SimpleDriverTestCase(test.TestCase):
     def _create_volume(self):
         """Create a test volume"""
         vol = {}
-        vol['image_id'] = 'ami-test'
-        vol['reservation_id'] = 'r-fakeres'
         vol['size'] = 1
         vol['availability_zone'] = 'test'
         return db.volume_create(self.context, vol)['id']
diff --git a/nova/tests/test_volume.py b/nova/tests/test_volume.py
index b40ca004b..f698c85b5 100644
--- a/nova/tests/test_volume.py
+++ b/nova/tests/test_volume.py
@@ -99,7 +99,7 @@ class VolumeTestCase(test.TestCase):
     def test_run_attach_detach_volume(self):
         """Make sure volume can be attached and detached from instance."""
         inst = {}
-        inst['image_id'] = 'ami-test'
+        inst['image_id'] = 1
         inst['reservation_id'] = 'r-fakeres'
         inst['launch_time'] = '10'
         inst['user_id'] = 'fake'
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 <sateesh.chodapuneedi@citrix.com>
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')

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 81fe66bb19d16c387705e144c9941096cc497cf0 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Mon, 7 Mar 2011 15:12:26 +0100
Subject: Make "dhcpbridge init" output correctly formatted leases information.

---
 nova/network/linux_net.py | 30 +++++++++++++++++++++++++++---
 1 file changed, 27 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index 535ce87bc..0bcc36081 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -18,6 +18,7 @@ Implements vlans, bridges, and iptables rules using linux utilities.
 """
 
 import os
+import time
 
 from nova import db
 from nova import exception
@@ -56,6 +57,8 @@ flags.DEFINE_bool('use_nova_chains', False,
                   'use the nova_ routing chains instead of default')
 flags.DEFINE_string('input_chain', 'INPUT',
                     'chain to add nova_input to')
+flags.DEFINE_integer('dhcp_lease_time', 120,
+                     'Lifetime of a DHCP lease')
 
 flags.DEFINE_string('dns_server', None,
                     'if set, uses specific dns server for dnsmasq')
@@ -273,8 +276,17 @@ def ensure_bridge(bridge, interface, net_attrs=None):
     _confirm_rule("FORWARD", "-j nova-local")
 
 
+def get_dhcp_leases(context, network_id):
+    """Return a network's hosts config in dnsmasq leasefile format"""
+    hosts = []
+    for fixed_ip_ref in db.network_get_associated_fixed_ips(context,
+                                                            network_id):
+        hosts.append(_host_lease(fixed_ip_ref))
+    return '\n'.join(hosts)
+
+
 def get_dhcp_hosts(context, network_id):
-    """Get a string containing a network's hosts config in dnsmasq format"""
+    """Get a string containing a network's hosts config in dhcp-host format"""
     hosts = []
     for fixed_ip_ref in db.network_get_associated_fixed_ips(context,
                                                             network_id):
@@ -365,8 +377,19 @@ interface %s
                        utils.get_my_linklocal(network_ref['bridge'])})
 
 
+def _host_lease(fixed_ip_ref):
+    """Return a host string for an address in leasefile format"""
+    instance_ref = fixed_ip_ref['instance']
+    timestamp = time.mktime(instance_ref['updated_at'].timetuple())
+
+    return "%d %s %s %s" % (timestamp + FLAGS.dhcp_lease_time,
+                            instance_ref['mac_address'],
+                            instance_ref['hostname'],
+                            fixed_ip_ref['address'])
+
+
 def _host_dhcp(fixed_ip_ref):
-    """Return a host string for an address"""
+    """Return a host string for an address in dhcp-host format"""
     instance_ref = fixed_ip_ref['instance']
     return "%s,%s.%s,%s" % (instance_ref['mac_address'],
                                    instance_ref['hostname'],
@@ -420,7 +443,8 @@ def _dnsmasq_cmd(net):
            ' --pid-file=%s' % _dhcp_file(net['bridge'], 'pid'),
            ' --listen-address=%s' % net['gateway'],
            ' --except-interface=lo',
-           ' --dhcp-range=%s,static,120s' % net['dhcp_start'],
+           ' --dhcp-range=%s,static,%ds' % (net['dhcp_start'],
+                                            FLAGS.dhcp_lease_time),
            ' --dhcp-hostsfile=%s' % _dhcp_file(net['bridge'], 'conf'),
            ' --dhcp-script=%s' % FLAGS.dhcpbridge,
            ' --leasefile-ro']
-- 
cgit 


From b3d3366b8fd4eaf81bb9e03ad808c1a139e5b5b0 Mon Sep 17 00:00:00 2001
From: Dan Prince <dan.prince@rackspace.com>
Date: Mon, 7 Mar 2011 12:07:23 -0500
Subject: Generate 'adminPass' and call set_password when creating servers.

---
 nova/api/openstack/servers.py            | 10 +++++++---
 nova/tests/api/openstack/test_servers.py |  8 +++++++-
 2 files changed, 14 insertions(+), 4 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 08b95b46a..6cd8bb451 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -84,13 +84,11 @@ def _translate_detail_keys(inst):
 
     return dict(server=inst_dict)
 
-
 def _translate_keys(inst):
     """ Coerces into dictionary format, excluding all model attributes
     save for id and name """
     return dict(server=dict(id=inst['id'], name=inst['display_name']))
 
-
 class Controller(wsgi.Controller):
     """ The Server API controller for the OpenStack API """
 
@@ -178,7 +176,13 @@ class Controller(wsgi.Controller):
             key_data=key_pair['public_key'],
             metadata=metadata,
             onset_files=env.get('onset_files', []))
-        return _translate_keys(instances[0])
+
+        server = _translate_keys(instances[0])
+        password = "%s%s" % (server['server']['name'][:4],
+                             utils.generate_password(12))
+        server['server']['adminPass'] = password
+        self.compute_api.set_admin_password(context, server['server']['id'])
+        return server
 
     def update(self, req, id):
         """ Updates the server name or password """
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 78beb7df9..16b48a13b 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -186,7 +186,7 @@ class ServersTest(test.TestCase):
 
     def test_create_instance(self):
         def instance_create(context, inst):
-            return {'id': '1', 'display_name': ''}
+            return {'id': '1', 'display_name': 'server_test'}
 
         def server_update(context, id, params):
             return instance_create(context, id)
@@ -230,6 +230,12 @@ class ServersTest(test.TestCase):
 
         res = req.get_response(fakes.wsgi_app())
 
+        server = json.loads(res.body)['server']
+        self.assertEqual('serv', server['adminPass'][:4])
+        self.assertEqual(16, len(server['adminPass']))
+        self.assertEqual('server_test', server['name'])
+        self.assertEqual('1', server['id'])
+
         self.assertEqual(res.status_int, 200)
 
     def test_update_no_body(self):
-- 
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/tests/xenapi/stubs.py   | 26 +++++++++++++-------------
 nova/virt/xenapi/vm_utils.py | 30 ++++++++++++------------------
 nova/virt/xenapi/vmops.py    |  4 ++--
 3 files changed, 27 insertions(+), 33 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/xenapi/stubs.py b/nova/tests/xenapi/stubs.py
index caefcff34..11e89c9b4 100644
--- a/nova/tests/xenapi/stubs.py
+++ b/nova/tests/xenapi/stubs.py
@@ -227,18 +227,8 @@ class FakeSessionForMigrationTests(fake.SessionBase):
 
 
 def stub_out_migration_methods(stubs):
-    class FakeSnapshot(object):
-        def __getattr__(self, key):
-            return str(key)
-
-        def __enter__(self):
-            return self
-
-        def __exit__(self, type, value, traceback):
-            pass
-
     def fake_get_snapshot(self, instance):
-        return FakeSnapshot()
+        return 'foo', 'bar'
 
     @classmethod
     def fake_get_vdi(cls, session, vm_ref):
@@ -251,11 +241,21 @@ def stub_out_migration_methods(stubs):
         pass
 
     @classmethod
-    def fake_scan_sr(cls, session):
+    def fake_sr(cls, session, *args):
+        pass
+
+    @classmethod
+    def fake_get_sr_path(cls, *args):
+        return "fake"
+
+    def fake_destroy(*args, **kwargs):
         pass
 
-    stubs.Set(vm_utils.VMHelper, 'scan_sr', fake_scan_sr)
+    stubs.Set(vmops.VMOps, '_destroy', fake_destroy)
+    stubs.Set(vm_utils.VMHelper, 'scan_default_sr', fake_sr)
+    stubs.Set(vm_utils.VMHelper, 'scan_sr', fake_sr)
     stubs.Set(vmops.VMOps, '_get_snapshot', fake_get_snapshot)
     stubs.Set(vm_utils.VMHelper, 'get_vdi_for_vm_safely', fake_get_vdi)
     stubs.Set(xenapi_conn.XenAPISession, 'wait_for_task', lambda x, y, z: None)
+    stubs.Set(vm_utils.VMHelper, 'get_sr_path', fake_get_sr_path)
     stubs.Set(vmops.VMOps, '_shutdown', fake_shutdown)
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 bcb18ee3d0d095b616c0909c92a151a599d4e17f Mon Sep 17 00:00:00 2001
From: Naveed Massjouni <naveedm9@gmail.com>
Date: Mon, 7 Mar 2011 15:05:07 -0500
Subject: Invalid values for offset and limit params in http requests now
 return a 400 response with a useful message in the body. Also added and
 updated tests.

---
 nova/api/openstack/common.py             | 11 +++++++----
 nova/tests/api/openstack/test_common.py  | 20 ++++----------------
 nova/tests/api/openstack/test_servers.py | 28 ++++++++++++++++++++++++++++
 3 files changed, 39 insertions(+), 20 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/common.py b/nova/api/openstack/common.py
index 9f85c5c8a..f7a9cc3f0 100644
--- a/nova/api/openstack/common.py
+++ b/nova/api/openstack/common.py
@@ -36,15 +36,18 @@ def limited(items, request, max_limit=1000):
     try:
         offset = int(request.GET.get('offset', 0))
     except ValueError:
-        offset = 0
+        raise webob.exc.HTTPBadRequest(_('offset param must be an integer'))
 
     try:
         limit = int(request.GET.get('limit', max_limit))
     except ValueError:
-        limit = max_limit
+        raise webob.exc.HTTPBadRequest(_('limit param must be an integer'))
 
-    if offset < 0 or limit < 0:
-        raise webob.exc.HTTPBadRequest()
+    if limit < 0:
+        raise webob.exc.HTTPBadRequest(_('limit param must be positive'))
+
+    if offset < 0:
+        raise webob.exc.HTTPBadRequest(_('offset param must be positive'))
 
     limit = min(max_limit, limit or max_limit)
     range_end = offset + limit
diff --git a/nova/tests/api/openstack/test_common.py b/nova/tests/api/openstack/test_common.py
index 92023362c..8f57c5b67 100644
--- a/nova/tests/api/openstack/test_common.py
+++ b/nova/tests/api/openstack/test_common.py
@@ -79,20 +79,14 @@ class LimiterTest(test.TestCase):
         Test offset key works with a blank offset.
         """
         req = Request.blank('/?offset=')
-        self.assertEqual(limited(self.tiny, req), self.tiny)
-        self.assertEqual(limited(self.small, req), self.small)
-        self.assertEqual(limited(self.medium, req), self.medium)
-        self.assertEqual(limited(self.large, req), self.large[:1000])
+        self.assertRaises(webob.exc.HTTPBadRequest, limited, self.tiny, req)
 
     def test_limiter_offset_bad(self):
         """
         Test offset key works with a BAD offset.
         """
         req = Request.blank(u'/?offset=\u0020aa')
-        self.assertEqual(limited(self.tiny, req), self.tiny)
-        self.assertEqual(limited(self.small, req), self.small)
-        self.assertEqual(limited(self.medium, req), self.medium)
-        self.assertEqual(limited(self.large, req), self.large[:1000])
+        self.assertRaises(webob.exc.HTTPBadRequest, limited, self.tiny, req)
 
     def test_limiter_nothing(self):
         """
@@ -166,18 +160,12 @@ class LimiterTest(test.TestCase):
         """
         Test a negative limit.
         """
-        def _limit_large():
-            limited(self.large, req, max_limit=2000)
-
         req = Request.blank('/?limit=-3000')
-        self.assertRaises(webob.exc.HTTPBadRequest, _limit_large)
+        self.assertRaises(webob.exc.HTTPBadRequest, limited, self.tiny, req)
 
     def test_limiter_negative_offset(self):
         """
         Test a negative offset.
         """
-        def _limit_large():
-            limited(self.large, req, max_limit=2000)
-
         req = Request.blank('/?offset=-30')
-        self.assertRaises(webob.exc.HTTPBadRequest, _limit_large)
+        self.assertRaises(webob.exc.HTTPBadRequest, limited, self.tiny, req)
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 78beb7df9..10fb2bafb 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -184,6 +184,34 @@ class ServersTest(test.TestCase):
             self.assertEqual(s.get('imageId', None), None)
             i += 1
 
+    def test_get_servers_with_limit(self):
+        req = webob.Request.blank('/v1.0/servers?limit=3')
+        res = req.get_response(fakes.wsgi_app())
+        servers = json.loads(res.body)['servers']
+        self.assertEqual([s['id'] for s in servers], [0, 1, 2])
+
+        req = webob.Request.blank('/v1.0/servers?limit=aaa')
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 400)
+        self.assertTrue('limit' in res.body)
+
+    def test_get_servers_with_offset(self):
+        req = webob.Request.blank('/v1.0/servers?offset=2')
+        res = req.get_response(fakes.wsgi_app())
+        servers = json.loads(res.body)['servers']
+        self.assertEqual([s['id'] for s in servers], [2, 3, 4])
+
+        req = webob.Request.blank('/v1.0/servers?offset=aaa')
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 400)
+        self.assertTrue('offset' in res.body)
+
+    def test_get_servers_with_limit_and_offset(self):
+        req = webob.Request.blank('/v1.0/servers?limit=2&offset=1')
+        res = req.get_response(fakes.wsgi_app())
+        servers = json.loads(res.body)['servers']
+        self.assertEqual([s['id'] for s in servers], [1, 2])
+
     def test_create_instance(self):
         def instance_create(context, inst):
             return {'id': '1', 'display_name': ''}
-- 
cgit 


From 8c3bc15c96c6a6f1c99d829337921f2645608410 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Mon, 7 Mar 2011 21:43:31 +0100
Subject: Make iptables rules class __ne__ just be inverted __eq__.

---
 nova/network/linux_net.py | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

(limited to 'nova')

diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index 8832f7c68..57e77f8d5 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -85,10 +85,7 @@ class IptablesRule(object):
                 (self.wrap == other.wrap))
 
     def __ne__(self, other):
-        return ((self.chain != other.chain) or
-                (self.rule != other.rule) or
-                (self.top != other.top) or
-                (self.wrap != other.wrap))
+        return not self == other
 
     def __str__(self):
         if self.wrap:
-- 
cgit 


From 7b7abe7e7a25c0cd07c64c34f69ce050c669cfc3 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Mon, 7 Mar 2011 21:54:25 +0100
Subject: Log failed command execution if there are more retry attempts left.

---
 nova/utils.py | 1 +
 1 file changed, 1 insertion(+)

(limited to 'nova')

diff --git a/nova/utils.py b/nova/utils.py
index 829adfb9e..80e5b6bbe 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -166,6 +166,7 @@ def execute(cmd, process_input=None, addl_env=None, check_exit_code=True,
             if not attempts:
                 raise
             else:
+                LOG.debug(_("%r failed. Retrying."), cmd)
                 greenthread.sleep(random.randint(20, 200) / 100.0)
 
 
-- 
cgit 


From 4e9c570fbf8b3987d556da085b61f159f32c16f1 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
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')

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 0abd5bfecd279272e5fe1b0de04478909cd77010 Mon Sep 17 00:00:00 2001
From: Ricardo Carrillo Cruz <emaildericky@gmail.com>
Date: Mon, 7 Mar 2011 22:18:15 +0100
Subject: added network_get_by_cidr method to nova.db api

---
 nova/db/api.py            |  7 +++++++
 nova/db/sqlalchemy/api.py | 18 ++++++++++++++++++
 2 files changed, 25 insertions(+)

(limited to 'nova')

diff --git a/nova/db/api.py b/nova/db/api.py
index d23f14a3c..c73796487 100644
--- a/nova/db/api.py
+++ b/nova/db/api.py
@@ -459,6 +459,10 @@ def network_associate(context, project_id):
     """Associate a free network to a project."""
     return IMPL.network_associate(context, project_id)
 
+def network_is_associated(context, project_id):
+    """Returns true the the network is associated to a project"""
+    return IMPL.network_is_associated(context, project_id)
+
 
 def network_count(context):
     """Return the number of networks."""
@@ -525,6 +529,9 @@ def network_get_by_bridge(context, bridge):
     """Get a network by bridge or raise if it does not exist."""
     return IMPL.network_get_by_bridge(context, bridge)
 
+def network_get_by_cidr(context, cidr):
+    """Get a network by cidr or raise if it does not exist"""
+    return IMPL.network_get_by_cidr(context, cidr)
 
 def network_get_by_instance(context, instance_id):
     """Get a network by instance id or raise if it does not exist."""
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 919dda118..bd2de70c7 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -993,6 +993,13 @@ def network_associate(context, project_id):
     return network_ref
 
 
+@require_admin_context
+def network_is_associated(context, project_id):
+    session = get_session()
+    network = session.query(models.Network.project_id).filter(project_id=1).first()
+    print network 
+
+
 @require_admin_context
 def network_count(context):
     session = get_session()
@@ -1116,6 +1123,17 @@ def network_get_by_bridge(context, bridge):
     return result
 
 
+@require_admin_context
+def network_get_by_cidr(context, cidr):
+    session = get_session()
+    result = session.query(models.Network).\
+                filter_by(cidr=cidr).first()
+
+    if not result:
+        raise exception.NotFound(_('Network with cidr %s does not exist') %
+                                  cidr)
+    return result.id
+
 @require_admin_context
 def network_get_by_instance(_context, instance_id):
     session = get_session()
-- 
cgit 


From fd95523689b80f53972c59c3738e6b786a7160ff Mon Sep 17 00:00:00 2001
From: Vishvananda Ishaya <vishvananda@gmail.com>
Date: Mon, 7 Mar 2011 21:22:06 +0000
Subject: pep8

---
 nova/api/ec2/cloud.py    | 1 -
 nova/api/ec2/ec2utils.py | 1 +
 2 files changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 496e944fe..6479c9445 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -864,7 +864,6 @@ class CloudController(object):
         except exception.NotFound:
             return self.image_service.show_by_name(context, ec2_id)
 
-
     def _format_image(self, image):
         """Convert from format defined by BaseImageService to S3 format."""
         i = {}
diff --git a/nova/api/ec2/ec2utils.py b/nova/api/ec2/ec2utils.py
index e4df80cf8..3b34f6ea5 100644
--- a/nova/api/ec2/ec2utils.py
+++ b/nova/api/ec2/ec2utils.py
@@ -18,6 +18,7 @@
 
 from nova import exception
 
+
 def ec2_id_to_id(ec2_id):
     """Convert an ec2 ID (i-[base 16 number]) to an instance id (int)"""
     try:
-- 
cgit 


From 56ee811efd52d0971d7fea4c232a904b3ee78ac6 Mon Sep 17 00:00:00 2001
From: Ricardo Carrillo Cruz <emaildericky@gmail.com>
Date: Mon, 7 Mar 2011 22:37:26 +0100
Subject: deleted network_is_associated from nova.db api

---
 nova/db/api.py            | 5 -----
 nova/db/sqlalchemy/api.py | 9 +--------
 2 files changed, 1 insertion(+), 13 deletions(-)

(limited to 'nova')

diff --git a/nova/db/api.py b/nova/db/api.py
index c73796487..04f5fd72f 100644
--- a/nova/db/api.py
+++ b/nova/db/api.py
@@ -459,11 +459,6 @@ def network_associate(context, project_id):
     """Associate a free network to a project."""
     return IMPL.network_associate(context, project_id)
 
-def network_is_associated(context, project_id):
-    """Returns true the the network is associated to a project"""
-    return IMPL.network_is_associated(context, project_id)
-
-
 def network_count(context):
     """Return the number of networks."""
     return IMPL.network_count(context)
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index bd2de70c7..c8f42425d 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -993,13 +993,6 @@ def network_associate(context, project_id):
     return network_ref
 
 
-@require_admin_context
-def network_is_associated(context, project_id):
-    session = get_session()
-    network = session.query(models.Network.project_id).filter(project_id=1).first()
-    print network 
-
-
 @require_admin_context
 def network_count(context):
     session = get_session()
@@ -1132,7 +1125,7 @@ def network_get_by_cidr(context, cidr):
     if not result:
         raise exception.NotFound(_('Network with cidr %s does not exist') %
                                   cidr)
-    return result.id
+    return result
 
 @require_admin_context
 def network_get_by_instance(_context, instance_id):
-- 
cgit 


From f79220a1f6a12621463b410d26e31e29a9e6ea3e Mon Sep 17 00:00:00 2001
From: Trey Morris <trey.morris@rackspace.com>
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')

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 <trey.morris@rackspace.com>
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')

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 <trey.morris@rackspace.com>
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')

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 <matt.dietz@rackspace.com>
Date: Mon, 7 Mar 2011 16:40:19 -0600
Subject: First part of the bug fix

---
 nova/compute/manager.py   | 4 +---
 nova/virt/xenapi/vmops.py | 8 +++++++-
 nova/virt/xenapi_conn.py  | 9 +++++++--
 3 files changed, 15 insertions(+), 6 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index b3e864154..b35216dd3 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -510,9 +510,7 @@ class ComputeManager(manager.Manager):
         instance_ref = self.db.instance_get(context,
                 migration_ref['instance_id'])
 
-        # this may get passed into the following spawn instead
-        new_disk_info = self.driver.attach_disk(instance_ref, disk_info)
-        self.driver.spawn(instance_ref, disk=new_disk_info)
+        self.driver.finish_resize(instance_ref, disk_info)
 
         self.db.migration_update(context, migration_id,
                 {'status': 'finished', })
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 ede88283729663f11d913cc54bcf8ee08028d98f Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Mon, 7 Mar 2011 14:42:36 -0800
Subject: A few formatting niceties

---
 nova/service.py | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

(limited to 'nova')

diff --git a/nova/service.py b/nova/service.py
index 8fdaca0a5..389a6b2df 100644
--- a/nova/service.py
+++ b/nova/service.py
@@ -42,6 +42,7 @@ from nova import utils
 from nova import version
 from nova import wsgi
 
+
 FLAGS = flags.FLAGS
 flags.DEFINE_integer('report_interval', 10,
                      'seconds between nodes reporting state to datastore',
@@ -271,6 +272,11 @@ def serve(*services):
         x.start()
 
 
+def wait():
+    while True:
+        greenthread.sleep(5)
+
+
 def serve_wsgi(cls, conf):
     try:
         service = cls.create(conf)
@@ -290,11 +296,6 @@ def serve_wsgi(cls, conf):
     return service
 
 
-def wait():
-    while True:
-        greenthread.sleep(5)
-
-
 def _run_wsgi(paste_config_file, apis):
     logging.debug(_("Using paste.deploy config at: %s"), paste_config_file)
     apps = []
-- 
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/tests/test_xenapi.py  | 5 +++++
 nova/tests/xenapi/stubs.py | 4 ++++
 nova/virt/xenapi_conn.py   | 2 +-
 3 files changed, 10 insertions(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index 7f437c2b8..6e458558d 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -383,6 +383,11 @@ class XenAPIMigrateInstance(test.TestCase):
         conn = xenapi_conn.get_connection(False)
         conn.attach_disk(instance, {'base_copy': 'hurr', 'cow': 'durr'})
 
+    def test_finish_resize(self):
+        instance = db.instance_create(self.values)
+        stubs.stubout_session(self.stubs, stubs.FakeSessionForMigrationTests)
+        conn = xenapi_conn.get_connection(False)
+        conn.finish_resize(instance, dict(base_copy='hurr', cow='durr'))
 
 class XenAPIDetermineDiskImageTestCase(test.TestCase):
     """
diff --git a/nova/tests/xenapi/stubs.py b/nova/tests/xenapi/stubs.py
index 11e89c9b4..28037c2ba 100644
--- a/nova/tests/xenapi/stubs.py
+++ b/nova/tests/xenapi/stubs.py
@@ -251,6 +251,9 @@ def stub_out_migration_methods(stubs):
     def fake_destroy(*args, **kwargs):
         pass
 
+    def fake_spawn_with_disk(*args, **kwargs):
+        pass
+
     stubs.Set(vmops.VMOps, '_destroy', fake_destroy)
     stubs.Set(vm_utils.VMHelper, 'scan_default_sr', fake_sr)
     stubs.Set(vm_utils.VMHelper, 'scan_sr', fake_sr)
@@ -259,3 +262,4 @@ def stub_out_migration_methods(stubs):
     stubs.Set(xenapi_conn.XenAPISession, 'wait_for_task', lambda x, y, z: None)
     stubs.Set(vm_utils.VMHelper, 'get_sr_path', fake_get_sr_path)
     stubs.Set(vmops.VMOps, '_shutdown', fake_shutdown)
+    stubs.Set(vmops.VMOps, 'spawn_with_disk', fake_spawn_with_disk)
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/tests/test_xenapi.py |  6 ------
 nova/virt/xenapi/vmops.py | 10 +++++-----
 nova/virt/xenapi_conn.py  |  9 +++------
 3 files changed, 8 insertions(+), 17 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index 6e458558d..f5b154a51 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -377,12 +377,6 @@ class XenAPIMigrateInstance(test.TestCase):
         conn = xenapi_conn.get_connection(False)
         conn.migrate_disk_and_power_off(instance, '127.0.0.1')
 
-    def test_attach_disk(self):
-        instance = db.instance_create(self.values)
-        stubs.stubout_session(self.stubs, stubs.FakeSessionForMigrationTests)
-        conn = xenapi_conn.get_connection(False)
-        conn.attach_disk(instance, {'base_copy': 'hurr', 'cow': 'durr'})
-
     def test_finish_resize(self):
         instance = db.instance_create(self.values)
         stubs.stubout_session(self.stubs, stubs.FakeSessionForMigrationTests)
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 e69c802aaf40f3b90789aeef8bf3ef5dcbbcb2f3 Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Mon, 7 Mar 2011 15:36:04 -0800
Subject: Moved FLAGS.paste_config to its re-usable location

---
 nova/service.py | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/service.py b/nova/service.py
index 389a6b2df..5a8d58695 100644
--- a/nova/service.py
+++ b/nova/service.py
@@ -56,6 +56,8 @@ flags.DEFINE_integer('ec2_listen_port', 8773, 'port for ec2 api to listen')
 flags.DEFINE_string('osapi_listen', "0.0.0.0",
                     'IP address for OpenStack API to listen')
 flags.DEFINE_integer('osapi_listen_port', 8774, 'port for os api to listen')
+flags.DEFINE_string('paste_config', "api-paste.ini",
+                    'File name for the paste.deploy config for nova-api')
 
 
 class Service(object):
@@ -238,9 +240,11 @@ class ApiService(WsgiService):
     @classmethod
     def create(cls, conf=None):
         if not conf:
-            conf = wsgi.paste_config_file('nova-api.conf')
+            conf = wsgi.paste_config_file(FLAGS.paste_config)
             if not conf:
-                raise exception.Error(_("Cannot load nova-api.conf"))
+                message = (_("No paste configuration found for: %s"),
+                       FLAGS.paste_config)
+                raise exception.Error(message)
         api_endpoints = ['ec2', 'osapi']
         service = cls(conf, api_endpoints)
         return service
@@ -277,7 +281,7 @@ def wait():
         greenthread.sleep(5)
 
 
-def serve_wsgi(cls, conf):
+def serve_wsgi(cls, conf=None):
     try:
         service = cls.create(conf)
     except Exception:
-- 
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/tests/test_xenapi.py  | 14 ++++++++++----
 nova/tests/xenapi/stubs.py | 15 +++++++++++++--
 nova/virt/xenapi/vmops.py  | 30 ++++++++++++++----------------
 nova/virt/xenapi_conn.py   |  4 ++--
 4 files changed, 39 insertions(+), 24 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index f5b154a51..919a38c06 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -360,16 +360,22 @@ class XenAPIMigrateInstance(test.TestCase):
         db_fakes.stub_out_db_instance_api(self.stubs)
         stubs.stub_out_get_target(self.stubs)
         xenapi_fake.reset()
+        self.manager = manager.AuthManager()
+        self.user = self.manager.create_user('fake', 'fake', 'fake',
+                                             admin=True)
+        self.project = self.manager.create_project('fake', 'fake', 'fake')
         self.values = {'name': 1, 'id': 1,
-                  'project_id': 'fake',
-                  'user_id': 'fake',
+                  'project_id': self.project.id,
+                  'user_id': self.user.id,
                   'image_id': 1,
-                  'kernel_id': 2,
-                  'ramdisk_id': 3,
+                  'kernel_id': None,
+                  'ramdisk_id': None,
                   'instance_type': 'm1.large',
                   'mac_address': 'aa:bb:cc:dd:ee:ff',
                   }
         stubs.stub_out_migration_methods(self.stubs)
+        glance_stubs.stubout_glance_client(self.stubs,
+                                           glance_stubs.FakeGlance)
 
     def test_migrate_disk_and_power_off(self):
         instance = db.instance_create(self.values)
diff --git a/nova/tests/xenapi/stubs.py b/nova/tests/xenapi/stubs.py
index 28037c2ba..d8e358611 100644
--- a/nova/tests/xenapi/stubs.py
+++ b/nova/tests/xenapi/stubs.py
@@ -225,6 +225,17 @@ class FakeSessionForMigrationTests(fake.SessionBase):
     def __init__(self, uri):
         super(FakeSessionForMigrationTests, self).__init__(uri)
 
+    def VDI_get_by_uuid(*args):
+        return 'hurr'
+
+    def VM_start(self, _1, ref, _2, _3):
+        vm = fake.get_record('VM', ref)
+        if vm['power_state'] != 'Halted':
+            raise fake.Failure(['VM_BAD_POWER_STATE', ref, 'Halted',
+                                  vm['power_state']])
+        vm['power_state'] = 'Running'
+        vm['is_a_template'] = False
+        vm['is_control_domain'] = False
 
 def stub_out_migration_methods(stubs):
     def fake_get_snapshot(self, instance):
@@ -251,7 +262,7 @@ def stub_out_migration_methods(stubs):
     def fake_destroy(*args, **kwargs):
         pass
 
-    def fake_spawn_with_disk(*args, **kwargs):
+    def fake_reset_network(*args, **kwargs):
         pass
 
     stubs.Set(vmops.VMOps, '_destroy', fake_destroy)
@@ -261,5 +272,5 @@ def stub_out_migration_methods(stubs):
     stubs.Set(vm_utils.VMHelper, 'get_vdi_for_vm_safely', fake_get_vdi)
     stubs.Set(xenapi_conn.XenAPISession, 'wait_for_task', lambda x, y, z: None)
     stubs.Set(vm_utils.VMHelper, 'get_sr_path', fake_get_sr_path)
+    stubs.Set(vmops.VMOps, 'reset_network', fake_reset_network)
     stubs.Set(vmops.VMOps, '_shutdown', fake_shutdown)
-    stubs.Set(vmops.VMOps, 'spawn_with_disk', fake_spawn_with_disk)
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 <trey.morris@rackspace.com>
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')

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 <trey.morris@rackspace.com>
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')

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 <eric@cloudscaling.com>
Date: Tue, 8 Mar 2011 01:01:41 -0500
Subject: execvp

---
 nova/crypto.py               |  32 ++++---
 nova/network/linux_net.py    | 222 ++++++++++++++++++++++---------------------
 nova/tests/test_network.py   |  16 ++--
 nova/utils.py                |  16 ++--
 nova/virt/disk.py            |  44 +++++----
 nova/virt/images.py          |   5 +-
 nova/virt/libvirt_conn.py    |  36 ++++---
 nova/virt/xenapi/vm_utils.py |  11 ++-
 nova/volume/driver.py        |  71 +++++++-------
 9 files changed, 238 insertions(+), 215 deletions(-)

(limited to 'nova')

diff --git a/nova/crypto.py b/nova/crypto.py
index b240a3958..dd24723b8 100644
--- a/nova/crypto.py
+++ b/nova/crypto.py
@@ -105,8 +105,10 @@ def generate_key_pair(bits=1024):
 
     tmpdir = tempfile.mkdtemp()
     keyfile = os.path.join(tmpdir, 'temp')
-    utils.execute('ssh-keygen','-q','-b',"%d" % bits,'-N','""','-f',keyfile)
-    (out, err) = utils.execute('ssh-keygen','-q','-l','-f',"%s.pub" % (keyfile))
+    utils.execute('ssh-keygen', '-q', '-b', '%d' % bits, '-N', '',
+                  '-f', keyfile)
+    (out, err) = utils.execute('ssh-keygen', '-q', '-l', '-f',
+                               '%s.pub' % (keyfile))
     fingerprint = out.split(' ')[1]
     private_key = open(keyfile).read()
     public_key = open(keyfile + '.pub').read()
@@ -118,7 +120,7 @@ def generate_key_pair(bits=1024):
     # bio = M2Crypto.BIO.MemoryBuffer()
     # key.save_pub_key_bio(bio)
     # public_key = bio.read()
-    # public_key, err = execute('ssh-keygen','-y','-f','/dev/stdin', private_key)
+    # public_key, err = execute('ssh-keygen', '-y', '-f', '/dev/stdin', private_key)
 
     return (private_key, public_key, fingerprint)
 
@@ -143,9 +145,10 @@ def revoke_cert(project_id, file_name):
     start = os.getcwd()
     os.chdir(ca_folder(project_id))
     # NOTE(vish): potential race condition here
-    utils.execute('openssl','ca','-config','./openssl.cnf','-revoke',"'%s'" % file_name)
-    utils.execute('openssl','ca','-gencrl','-config','./openssl.cnf','-out',"'%s'" %
-                  FLAGS.crl_file)
+    utils.execute('openssl', 'ca', '-config', './openssl.cnf', '-revoke',
+                  '%s' % file_name)
+    utils.execute('openssl', 'ca', '-gencrl', '-config', './openssl.cnf',
+                  '-out', '%s' % FLAGS.crl_file)
     os.chdir(start)
 
 
@@ -193,8 +196,9 @@ def generate_x509_cert(user_id, project_id, bits=1024):
     tmpdir = tempfile.mkdtemp()
     keyfile = os.path.abspath(os.path.join(tmpdir, 'temp.key'))
     csrfile = os.path.join(tmpdir, 'temp.csr')
-    utils.execute('openssl','genrsa','-out',keyfile,bits)
-    utils.execute('openssl','req','-new','-key',keyfile,'-out',csrfile,'-batch','-subj',subject)
+    utils.execute('openssl', 'genrsa', '-out', keyfile, bits)
+    utils.execute('openssl', 'req', '-new', '-key', keyfile, '-out', csrfile,
+                  '-batch', '-subj', subject)
     private_key = open(keyfile).read()
     csr = open(csrfile).read()
     shutil.rmtree(tmpdir)
@@ -211,7 +215,8 @@ def _ensure_project_folder(project_id):
     if not os.path.exists(ca_path(project_id)):
         start = os.getcwd()
         os.chdir(ca_folder())
-        utils.execute('sh','geninter.sh',project_id, _project_cert_subject(project_id))
+        utils.execute('sh', 'geninter.sh', project_id,
+                      _project_cert_subject(project_id))
         os.chdir(start)
 
 
@@ -226,7 +231,7 @@ def generate_vpn_files(project_id):
     start = os.getcwd()
     os.chdir(ca_folder())
     # TODO(vish): the shell scripts could all be done in python
-    utils.execute('sh','genvpn.sh',
+    utils.execute('sh', 'genvpn.sh',
                   project_id, _vpn_cert_subject(project_id))
     with open(csr_fn, "r") as csrfile:
         csr_text = csrfile.read()
@@ -257,9 +262,10 @@ def _sign_csr(csr_text, ca_folder):
     start = os.getcwd()
     # Change working dir to CA
     os.chdir(ca_folder)
-    utils.execute('openssl','ca','-batch','-out',outbound,'-config'
-                  './openssl.cnf','-infiles',inbound)
-    out, _err = utils.execute('openssl','x509','-in',outbound','-serial','-noout')
+    utils.execute('openssl', 'ca', '-batch', '-out', outbound, '-config',
+                  './openssl.cnf', '-infiles', inbound)
+    out, _err = utils.execute('openssl', 'x509', '-in', outbound,
+                              '-serial', '-noout')
     serial = out.rpartition("=")[2]
     os.chdir(start)
     with open(outbound, "r") as crtfile:
diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index 535ce87bc..ad019a8c0 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -65,113 +65,117 @@ flags.DEFINE_string('dmz_cidr', '10.128.0.0/24',
 
 def metadata_forward():
     """Create forwarding rule for metadata"""
-    _confirm_rule("PREROUTING", "-t nat -s 0.0.0.0/0 "
-             "-d 169.254.169.254/32 -p tcp -m tcp --dport 80 -j DNAT "
-             "--to-destination %s:%s" % (FLAGS.ec2_dmz_host, FLAGS.ec2_port))
+    _confirm_rule("PREROUTING", '-t', 'nat', '-s', '0.0.0.0/0',
+             '-d', '169.254.169.254/32', '-p', 'tcp', '-m', 'tcp',
+             '--dport', '80', '-j', 'DNAT',
+             '--to-destination', '%s:%s' % (FLAGS.ec2_dmz_host, FLAGS.ec2_port))
 
 
 def init_host():
     """Basic networking setup goes here"""
 
     if FLAGS.use_nova_chains:
-        _execute("sudo iptables -N nova_input", check_exit_code=False)
-        _execute("sudo iptables -D %s -j nova_input" % FLAGS.input_chain,
+        _execute('sudo', 'iptables', '-N', 'nova_input', check_exit_code=False)
+        _execute('sudo', 'iptables', '-D', FLAGS.input_chain,
+                 '-j', 'nova_input',
                  check_exit_code=False)
-        _execute("sudo iptables -A %s -j nova_input" % FLAGS.input_chain)
-
-        _execute("sudo iptables -N nova_forward", check_exit_code=False)
-        _execute("sudo iptables -D FORWARD -j nova_forward",
+        _execute('sudo', 'iptables', '-A', FLAGS.input_chain,
+                 '-j', 'nova_input')
+        _execute('sudo', 'iptables', '-N', 'nova_forward',
                  check_exit_code=False)
-        _execute("sudo iptables -A FORWARD -j nova_forward")
-
-        _execute("sudo iptables -N nova_output", check_exit_code=False)
-        _execute("sudo iptables -D OUTPUT -j nova_output",
+        _execute('sudo', 'iptables', '-D', 'FORWARD', '-j', 'nova_forward',
                  check_exit_code=False)
-        _execute("sudo iptables -A OUTPUT -j nova_output")
-
-        _execute("sudo iptables -t nat -N nova_prerouting",
+        _execute('sudo', 'iptables', '-A', 'FORWARD', '-j', 'nova_forward')
+        _execute('sudo', 'iptables', '-N', 'nova_output', check_exit_code=False)
+        _execute('sudo', 'iptables', '-D', 'OUTPUT', '-j', 'nova_output',
                  check_exit_code=False)
-        _execute("sudo iptables -t nat -D PREROUTING -j nova_prerouting",
+        _execute('sudo', 'iptables', '-A', 'OUTPUT', '-j', 'nova_output')
+        _execute('sudo', 'iptables', '-t', 'nat', '-N', 'nova_prerouting',
                  check_exit_code=False)
-        _execute("sudo iptables -t nat -A PREROUTING -j nova_prerouting")
-
-        _execute("sudo iptables -t nat -N nova_postrouting",
+        _execute('sudo', 'iptables', '-t', 'nat', '-D', 'PREROUTING',
+                 '-j', 'nova_prerouting', check_exit_code=False)
+        _execute('sudo', 'iptables', '-t', 'nat', '-A', 'PREROUTING',
+                 '-j', 'nova_prerouting')
+        _execute('sudo', 'iptables', '-t', 'nat', '-N', 'nova_postrouting',
                  check_exit_code=False)
-        _execute("sudo iptables -t nat -D POSTROUTING -j nova_postrouting",
+        _execute('sudo', 'iptables', '-t', 'nat', '-D', 'POSTROUTING',
+                 '-j', 'nova_postrouting', check_exit_code=False)
+        _execute('sudo', 'iptables', '-t', 'nat', '-A', 'POSTROUTING',
+                 '-j', 'nova_postrouting')
+        _execute('sudo', 'iptables', '-t', 'nat', '-N', 'nova_snatting',
                  check_exit_code=False)
-        _execute("sudo iptables -t nat -A POSTROUTING -j nova_postrouting")
-
-        _execute("sudo iptables -t nat -N nova_snatting",
+        _execute('sudo', 'iptables', '-t', 'nat', '-D', 'POSTROUTING',
+                 '-j nova_snatting', check_exit_code=False)
+        _execute('sudo', 'iptables', '-t', 'nat', '-A', 'POSTROUTING',
+                 '-j', 'nova_snatting')
+        _execute('sudo', 'iptables', '-t', 'nat', '-N', 'nova_output',
                  check_exit_code=False)
-        _execute("sudo iptables -t nat -D POSTROUTING -j nova_snatting",
-                 check_exit_code=False)
-        _execute("sudo iptables -t nat -A POSTROUTING -j nova_snatting")
-
-        _execute("sudo iptables -t nat -N nova_output", check_exit_code=False)
-        _execute("sudo iptables -t nat -D OUTPUT -j nova_output",
-                 check_exit_code=False)
-        _execute("sudo iptables -t nat -A OUTPUT -j nova_output")
+        _execute('sudo', 'iptables', '-t', 'nat', '-D', 'OUTPUT',
+                 '-j nova_output', check_exit_code=False)
+        _execute('sudo', 'iptables', '-t', 'nat', '-A', 'OUTPUT',
+                 '-j', 'nova_output')
     else:
         # NOTE(vish): This makes it easy to ensure snatting rules always
         #             come after the accept rules in the postrouting chain
-        _execute("sudo iptables -t nat -N SNATTING",
-                 check_exit_code=False)
-        _execute("sudo iptables -t nat -D POSTROUTING -j SNATTING",
+        _execute('sudo', 'iptables', '-t', 'nat', '-N', 'SNATTING',
                  check_exit_code=False)
-        _execute("sudo iptables -t nat -A POSTROUTING -j SNATTING")
+        _execute('sudo', 'iptables', '-t', 'nat', '-D', 'POSTROUTING',
+                 '-j', 'SNATTING', check_exit_code=False)
+        _execute('sudo', 'iptables', '-t', 'nat', '-A', 'POSTROUTING',
+                 '-j', 'SNATTING')
 
     # NOTE(devcamcar): Cloud public SNAT entries and the default
     # SNAT rule for outbound traffic.
-    _confirm_rule("SNATTING", "-t nat -s %s "
-             "-j SNAT --to-source %s"
-             % (FLAGS.fixed_range, FLAGS.routing_source_ip), append=True)
+    _confirm_rule("SNATTING", '-t', 'nat', '-s', FLAGS.fixed_range,
+             '-j', 'SNAT', '--to-source', FLAGS.routing_source_ip,
+             append=True)
 
-    _confirm_rule("POSTROUTING", "-t nat -s %s -d %s -j ACCEPT" %
-                  (FLAGS.fixed_range, FLAGS.dmz_cidr))
-    _confirm_rule("POSTROUTING", "-t nat -s %(range)s -d %(range)s -j ACCEPT" %
-                  {'range': FLAGS.fixed_range})
+    _confirm_rule("POSTROUTING", '-t', 'nat', '-s', FLAGS.fixed_range,
+                  '-d', FLAGS.dmz_cidr, '-j', 'ACCEPT')
+    _confirm_rule("POSTROUTING", '-t', 'nat', '-s', FLAGS.fixed_range,
+                  '-d', FLAGS.fixed_range, '-j', 'ACCEPT')
 
 
 def bind_floating_ip(floating_ip, check_exit_code=True):
     """Bind ip to public interface"""
-    _execute("sudo ip addr add %s dev %s" % (floating_ip,
-                                             FLAGS.public_interface),
+    _execute('sudo', 'ip', 'addr', 'add', floating_ip,
+             'dev', FLAGS.public_interface),
              check_exit_code=check_exit_code)
 
 
 def unbind_floating_ip(floating_ip):
     """Unbind a public ip from public interface"""
-    _execute("sudo ip addr del %s dev %s" % (floating_ip,
-                                             FLAGS.public_interface))
+    _execute('sudo', 'ip', 'addr', 'del', floating_ip,
+             'dev', FLAGS.public_interface))
 
 
 def ensure_vlan_forward(public_ip, port, private_ip):
     """Sets up forwarding rules for vlan"""
-    _confirm_rule("FORWARD", "-d %s -p udp --dport 1194 -j ACCEPT" %
-                  private_ip)
-    _confirm_rule("PREROUTING",
-                  "-t nat -d %s -p udp --dport %s -j DNAT --to %s:1194"
-            % (public_ip, port, private_ip))
+    _confirm_rule("FORWARD", '-d', private_ip, '-p', 'udp',
+                  '--dport', '1194', '-j', 'ACCEPT')
+    _confirm_rule("PREROUTING", '-t', 'nat', '-d', public_ip, '-p', 'udp',
+                  '--dport', port, '-j', 'DNAT', '--to', '%s:1194'
+                  % private_ip)
 
 
 def ensure_floating_forward(floating_ip, fixed_ip):
     """Ensure floating ip forwarding rule"""
-    _confirm_rule("PREROUTING", "-t nat -d %s -j DNAT --to %s"
-                           % (floating_ip, fixed_ip))
-    _confirm_rule("OUTPUT", "-t nat -d %s -j DNAT --to %s"
-                           % (floating_ip, fixed_ip))
-    _confirm_rule("SNATTING", "-t nat -s %s -j SNAT --to %s"
-                           % (fixed_ip, floating_ip))
+    _confirm_rule("PREROUTING", '-t', 'nat', '-d', floating_ip, '-j', 'DNAT',
+                  '--to', fixed_ip)
+    _confirm_rule("OUTPUT", '-t', 'nat', '-d', floating_ip, '-j', 'DNAT',
+                  '--to', fixed_ip)
+    _confirm_rule("SNATTING", '-t', 'nat', '-s', fixed_ip, '-j', 'SNAT',
+                  '--to', floating_ip)
 
 
 def remove_floating_forward(floating_ip, fixed_ip):
     """Remove forwarding for floating ip"""
-    _remove_rule("PREROUTING", "-t nat -d %s -j DNAT --to %s"
-                          % (floating_ip, fixed_ip))
-    _remove_rule("OUTPUT", "-t nat -d %s -j DNAT --to %s"
-                          % (floating_ip, fixed_ip))
-    _remove_rule("SNATTING", "-t nat -s %s -j SNAT --to %s"
-                          % (fixed_ip, floating_ip))
+    _remove_rule("PREROUTING", '-t', 'nat', '-d', floating_ip, '-j', 'DNAT',
+                 '--to', fixed_ip)
+    _remove_rule("OUTPUT", '-t', 'nat', '-d', floating_ip, '-j', 'DNAT',
+                 '--to', fixed_ip)
+    _remove_rule("SNATTING", '-t', 'nat', '-s', fixed_ip, '-j', 'SNAT',
+                 '--to', floating_ip)
 
 
 def ensure_vlan_bridge(vlan_num, bridge, net_attrs=None):
@@ -185,9 +189,9 @@ def ensure_vlan(vlan_num):
     interface = "vlan%s" % vlan_num
     if not _device_exists(interface):
         LOG.debug(_("Starting VLAN inteface %s"), interface)
-        _execute("sudo vconfig set_name_type VLAN_PLUS_VID_NO_PAD")
-        _execute("sudo vconfig add %s %s" % (FLAGS.vlan_interface, vlan_num))
-        _execute("sudo ip link set %s up" % interface)
+        _execute('sudo', 'vconfig', 'set_name_type', 'VLAN_PLUS_VID_NO_PAD')
+        _execute('sudo', 'vconfig', 'add', FLAGS.vlan_interface, vlan_num)
+        _execute('sudo', 'ip', 'link', 'set', interface, 'up')
     return interface
 
 
@@ -206,52 +210,54 @@ def ensure_bridge(bridge, interface, net_attrs=None):
     """
     if not _device_exists(bridge):
         LOG.debug(_("Starting Bridge interface for %s"), interface)
-        _execute("sudo brctl addbr %s" % bridge)
-        _execute("sudo brctl setfd %s 0" % bridge)
+        _execute('sudo', 'brctl', 'addbr', bridge)
+        _execute('sudo', 'brctl', 'setfd', bridge, 0)
         # _execute("sudo brctl setageing %s 10" % bridge)
-        _execute("sudo brctl stp %s off" % bridge)
-        _execute("sudo ip link set %s up" % bridge)
+        _execute('sudo', 'brctl', 'stp', bridge', 'off')
+        _execute('sudo', 'ip', 'link', 'set', bridge, up)
     if net_attrs:
         # NOTE(vish): The ip for dnsmasq has to be the first address on the
         #             bridge for it to respond to reqests properly
         suffix = net_attrs['cidr'].rpartition('/')[2]
-        out, err = _execute("sudo ip addr add %s/%s brd %s dev %s" %
-                            (net_attrs['gateway'],
-                             suffix,
-                             net_attrs['broadcast'],
-                             bridge),
+        out, err = _execute('sudo', 'ip', 'addr', 'add',
+                            "%s/%s" % 
+                            (net_attrs['gateway'], suffix),
+                            'brd',
+                            net-attrs['broadcast'],
+                            'dev',
+                            bridge,
                             check_exit_code=False)
         if err and err != "RTNETLINK answers: File exists\n":
             raise exception.Error("Failed to add ip: %s" % err)
         if(FLAGS.use_ipv6):
-            _execute("sudo ip -f inet6 addr change %s dev %s" %
-                     (net_attrs['cidr_v6'], bridge))
+            _execute('sudo', 'ip', '-f', 'inet6', 'addr',
+                     'change', net_attrs['cidr_v6'],
+                     'dev', bridge)
         # NOTE(vish): If the public interface is the same as the
         #             bridge, then the bridge has to be in promiscuous
         #             to forward packets properly.
         if(FLAGS.public_interface == bridge):
-            _execute("sudo ip link set dev %s promisc on" % bridge)
+            _execute('sudo', 'ip', 'link', 'set', 'dev', bridge, 'promisc', 'on')
     if interface:
         # NOTE(vish): This will break if there is already an ip on the
         #             interface, so we move any ips to the bridge
         gateway = None
-        out, err = _execute("sudo route -n")
+        out, err = _execute('sudo', 'route', '-n')
         for line in out.split("\n"):
             fields = line.split()
             if fields and fields[0] == "0.0.0.0" and fields[-1] == interface:
                 gateway = fields[1]
-        out, err = _execute("sudo ip addr show dev %s scope global" %
-                            interface)
+        out, err = _execute('sudo', 'ip', 'addr', 'show', 'dev', interface,
+                            'scope', 'global')
         for line in out.split("\n"):
             fields = line.split()
             if fields and fields[0] == "inet":
                 params = ' '.join(fields[1:-1])
-                _execute("sudo ip addr del %s dev %s" % (params, fields[-1]))
-                _execute("sudo ip addr add %s dev %s" % (params, bridge))
+                _execute('sudo', 'ip', 'addr', 'del', params, 'dev', fields[-1])
+                _execute('sudo', 'ip', 'addr', 'add', params, 'dev', bridge)
         if gateway:
-            _execute("sudo route add 0.0.0.0 gw %s" % gateway)
-        out, err = _execute("sudo brctl addif %s %s" %
-                            (bridge, interface),
+            _execute('sudo', 'route', 'add', '0.0.0.0', 'gw', gateway)
+        out, err = _execute('sudo', 'brctl', 'addif, bridge, interface,
                             check_exit_code=False)
 
         if (err and err != "device %s is already a member of a bridge; can't "
@@ -259,18 +265,18 @@ def ensure_bridge(bridge, interface, net_attrs=None):
             raise exception.Error("Failed to add interface: %s" % err)
 
     if FLAGS.use_nova_chains:
-        (out, err) = _execute("sudo iptables -N nova_forward",
+        (out, err) = _execute('sudo', 'iptables', '-N', 'nova_forward,
                               check_exit_code=False)
         if err != 'iptables: Chain already exists.\n':
             # NOTE(vish): chain didn't exist link chain
-            _execute("sudo iptables -D FORWARD -j nova_forward",
+            _execute('sudo', 'iptables, '-D', 'FORWARD', '-j', 'nova_forward',
                      check_exit_code=False)
-            _execute("sudo iptables -A FORWARD -j nova_forward")
+            _execute('sudo', 'iptables', '-A', 'FORWARD', '-j', 'nova_forward')
 
-    _confirm_rule("FORWARD", "--in-interface %s -j ACCEPT" % bridge)
-    _confirm_rule("FORWARD", "--out-interface %s -j ACCEPT" % bridge)
-    _execute("sudo iptables -N nova-local", check_exit_code=False)
-    _confirm_rule("FORWARD", "-j nova-local")
+    _confirm_rule("FORWARD", '--in-interface', bridge, '-j', 'ACCEPT')
+    _confirm_rule("FORWARD", '--out-interface', bridge, '-j', 'ACCEPT')
+    _execute('sudo', 'iptables', '-N', 'nova-local', check_exit_code=False)
+    _confirm_rule("FORWARD", '-j', 'nova-local')
 
 
 def get_dhcp_hosts(context, network_id):
@@ -304,11 +310,11 @@ def update_dhcp(context, network_id):
 
     # if dnsmasq is already running, then tell it to reload
     if pid:
-        out, _err = _execute('cat /proc/%d/cmdline' % pid,
+        out, _err = _execute('cat', "/proc/%d/cmdline" % pid,
                              check_exit_code=False)
         if conffile in out:
             try:
-                _execute('sudo kill -HUP %d' % pid)
+                _execute('sudo', 'kill', '-HUP', pid)
                 return
             except Exception as exc:  # pylint: disable-msg=W0703
                 LOG.debug(_("Hupping dnsmasq threw %s"), exc)
@@ -349,11 +355,11 @@ interface %s
 
     # if radvd is already running, then tell it to reload
     if pid:
-        out, _err = _execute('cat /proc/%d/cmdline'
+        out, _err = _execute('cat', "/proc/%d/cmdline'
                              % pid, check_exit_code=False)
         if conffile in out:
             try:
-                _execute('sudo kill %d' % pid)
+                _execute('sudo', 'kill', pid)
             except Exception as exc:  # pylint: disable-msg=W0703
                 LOG.debug(_("killing radvd threw %s"), exc)
         else:
@@ -374,23 +380,23 @@ def _host_dhcp(fixed_ip_ref):
                                    fixed_ip_ref['address'])
 
 
-def _execute(cmd, *args, **kwargs):
+def _execute(*cmd, **kwargs):
     """Wrapper around utils._execute for fake_network"""
     if FLAGS.fake_network:
-        LOG.debug("FAKE NET: %s", cmd)
+        LOG.debug("FAKE NET: %s", ' '.join(cmd))
         return "fake", 0
     else:
-        return utils.execute(cmd, *args, **kwargs)
+        return utils.execute(*cmd, **kwargs)
 
 
 def _device_exists(device):
     """Check if ethernet device exists"""
-    (_out, err) = _execute("ip link show dev %s" % device,
+    (_out, err) = _execute('ip', 'link', 'show', 'dev', device,
                            check_exit_code=False)
     return not err
 
 
-def _confirm_rule(chain, cmd, append=False):
+def _confirm_rule(chain, *cmd, append=False):
     """Delete and re-add iptables rule"""
     if FLAGS.use_nova_chains:
         chain = "nova_%s" % chain.lower()
@@ -398,16 +404,16 @@ def _confirm_rule(chain, cmd, append=False):
         loc = "-A"
     else:
         loc = "-I"
-    _execute("sudo iptables --delete %s %s" % (chain, cmd),
+    _execute('sudo', 'iptables', '--delete', chain, *cmd,
              check_exit_code=False)
-    _execute("sudo iptables %s %s %s" % (loc, chain, cmd))
+    _execute('sudo', 'iptables', loc, chain, *cmd)
 
 
-def _remove_rule(chain, cmd):
+def _remove_rule(chain, *cmd):
     """Remove iptables rule"""
     if FLAGS.use_nova_chains:
         chain = "%s" % chain.lower()
-    _execute("sudo iptables --delete %s %s" % (chain, cmd))
+    _execute('sudo', 'iptables', '--delete', chain, *cmd)
 
 
 def _dnsmasq_cmd(net):
@@ -444,7 +450,7 @@ def _stop_dnsmasq(network):
 
     if pid:
         try:
-            _execute('sudo kill -TERM %d' % pid)
+            _execute('sudo', 'kill', '-TERM', pid)
         except Exception as exc:  # pylint: disable-msg=W0703
             LOG.debug(_("Killing dnsmasq threw %s"), exc)
 
diff --git a/nova/tests/test_network.py b/nova/tests/test_network.py
index ce1c77210..6d2d8b771 100644
--- a/nova/tests/test_network.py
+++ b/nova/tests/test_network.py
@@ -343,13 +343,13 @@ def lease_ip(private_ip):
                                           private_ip)
     instance_ref = db.fixed_ip_get_instance(context.get_admin_context(),
                                             private_ip)
-    cmd = "%s add %s %s fake" % (binpath('nova-dhcpbridge'),
-                                 instance_ref['mac_address'],
-                                 private_ip)
+    cmd = (binpath('nova-dhcpbridge'), 'add'
+           instance_ref['mac_address'],
+           private_ip, 'fake')
     env = {'DNSMASQ_INTERFACE': network_ref['bridge'],
            'TESTING': '1',
            'FLAGFILE': FLAGS.dhcpbridge_flagfile}
-    (out, err) = utils.execute(cmd, addl_env=env)
+    (out, err) = utils.execute(*cmd, addl_env=env)
     LOG.debug("ISSUE_IP: %s, %s ", out, err)
 
 
@@ -359,11 +359,11 @@ def release_ip(private_ip):
                                           private_ip)
     instance_ref = db.fixed_ip_get_instance(context.get_admin_context(),
                                             private_ip)
-    cmd = "%s del %s %s fake" % (binpath('nova-dhcpbridge'),
-                                 instance_ref['mac_address'],
-                                 private_ip)
+    cmd = (binpath('nova-dhcpbridge'), 'del',
+           instance_ref['mac_address'],
+           private_ip, 'fake')
     env = {'DNSMASQ_INTERFACE': network_ref['bridge'],
            'TESTING': '1',
            'FLAGFILE': FLAGS.dhcpbridge_flagfile}
-    (out, err) = utils.execute(cmd, addl_env=env)
+    (out, err) = utils.execute(*cmd, addl_env=env)
     LOG.debug("RELEASE_IP: %s, %s ", out, err)
diff --git a/nova/utils.py b/nova/utils.py
index 40a8d8d8c..c96b85294 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -125,15 +125,15 @@ def fetchfile(url, target):
 #    c.perform()
 #    c.close()
 #    fp.close()
-    execute("curl","--fail",url,"-o",target)
+    execute("curl", "--fail", url, "-o", target)
 
 
-def execute(cmd, process_input=None, addl_env=None, check_exit_code=True):
-    LOG.debug(_("Running cmd (subprocess): %s"), cmd)
+def execute(*cmd, process_input=None, addl_env=None, check_exit_code=True):
+    LOG.debug(_("Running cmd (subprocess): %s"), ' '.join(cmd))
     env = os.environ.copy()
     if addl_env:
         env.update(addl_env)
-    obj = subprocess.Popen(cmd, stdin=subprocess.PIPE,
+    obj = subprocess.Popen(*cmd, stdin=subprocess.PIPE,
         stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env)
     result = None
     if process_input != None:
@@ -148,7 +148,7 @@ def execute(cmd, process_input=None, addl_env=None, check_exit_code=True):
             raise ProcessExecutionError(exit_code=obj.returncode,
                                         stdout=stdout,
                                         stderr=stderr,
-                                        cmd=cmd)
+                                        cmd=' '.join(cmd))
     # NOTE(termie): this appears to be necessary to let the subprocess call
     #               clean something up in between calls, without it two
     #               execute calls in a row hangs the second one
@@ -158,7 +158,7 @@ def execute(cmd, process_input=None, addl_env=None, check_exit_code=True):
 
 def ssh_execute(ssh, cmd, process_input=None,
                 addl_env=None, check_exit_code=True):
-    LOG.debug(_("Running cmd (SSH): %s"), cmd)
+    LOG.debug(_("Running cmd (SSH): %s"), ' '.join(cmd))
     if addl_env:
         raise exception.Error("Environment not supported over SSH")
 
@@ -187,7 +187,7 @@ def ssh_execute(ssh, cmd, process_input=None,
             raise exception.ProcessExecutionError(exit_code=exit_status,
                                                   stdout=stdout,
                                                   stderr=stderr,
-                                                  cmd=cmd)
+                                                  cmd=' '.join(cmd))
 
     return (stdout, stderr)
 
@@ -254,7 +254,7 @@ def last_octet(address):
 
 def  get_my_linklocal(interface):
     try:
-        if_str = execute("ip","-f","inet6","-o","addr","show", interface)
+        if_str = execute("ip", "-f", "inet6", "-o", "addr", "show", interface)
         condition = "\s+inet6\s+([0-9a-f:]+)/\d+\s+scope\s+link"
         links = [re.search(condition, x) for x in if_str[0].split('\n')]
         address = [w.group(1) for w in links if w is not None]
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 </dev/null || echo free' % (port)
+
+                # TODO:ewindisch: subprocess lets us do this...
+                # but utils.execute abstracts it away from us
+                cmd = 'netcat', '0.0.0.0', port, '-w', '1', '</dev/null || echo free' % (port)
                 stdout, stderr = utils.execute(cmd)
                 if stdout.strip() == 'free':
                     return port
@@ -533,11 +538,11 @@ 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 %s'
-                              % (base, target))
+                utils.execute('qemu-img', 'create', '-f', 'qcow2', "'-o'',
+                              "cluster_size=2M,backing_file=%s" % base,
+                              target)
             else:
-                utils.execute('cp %s %s' % (base, target))
+                utils.execute('cp', base, target)
 
     def _fetch_image(self, target, image_id, user, project, size=None):
         """Grab image and optionally attempt to resize it"""
@@ -547,7 +552,7 @@ class LibvirtConnection(object):
 
     def _create_local(self, target, local_gb):
         """Create a blank image of specified size"""
-        utils.execute('truncate %s -s %dG' % (target, 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):
@@ -558,7 +563,7 @@ class LibvirtConnection(object):
                                 fname + suffix)
 
         # ensure directories exist and are writable
-        utils.execute('mkdir -p %s' % basepath(suffix=''))
+        utils.execute('mkdir', '-p', basepath(suffix='')
 
         LOG.info(_('instance %s: Creating image'), inst['name'])
         f = open(basepath('libvirt.xml'), 'w')
@@ -658,7 +663,7 @@ class LibvirtConnection(object):
                         ' data into image %(img_id)s (%(e)s)') % locals())
 
         if FLAGS.libvirt_type == 'uml':
-            utils.execute('sudo chown root %s' % basepath('disk'))
+            utils.execute('sudo', 'chown', 'root', basepath('disk'))
 
     def to_xml(self, instance, rescue=False):
         # TODO(termie): cache?
@@ -1240,13 +1245,14 @@ class IptablesFirewallDriver(FirewallDriver):
         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',
+        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_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',
+            self.execute('sudo', 'ip6tables-restore',
                          process_input='\n'.join(new_filter))
 
     def modify_rules(self, current_lines, ip_version=4):
diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py
index 564a25057..873dfce5e 100644
--- a/nova/virt/xenapi/vm_utils.py
+++ b/nova/virt/xenapi/vm_utils.py
@@ -736,13 +736,14 @@ 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=cmd,
+    def execute(*cmd, process_input=None, check_exit_code=True):
+        return utils.execute(*cmd,
                              process_input=process_input,
                              check_exit_code=check_exit_code)
 
-    execute('parted --script %s mklabel msdos' % dest)
-    execute('parted --script %s mkpart primary %ds %ds' %
-            (dest, primary_first, primary_last))
+    execute('parted', '--script', dest, 'mklabel', 'msdos')
+    execute('parted', '--script', dest, 'mkpart', 'primary',
+            '%ds' % primary_first,
+            '%ds' % primary_last)
 
     LOG.debug(_('Writing partition table %s done.'), dest)
diff --git a/nova/volume/driver.py b/nova/volume/driver.py
index e73202b73..220c9ef9d 100644
--- a/nova/volume/driver.py
+++ b/nova/volume/driver.py
@@ -65,14 +65,14 @@ class VolumeDriver(object):
         self._execute = execute
         self._sync_exec = sync_exec
 
-    def _try_execute(self, command):
+    def _try_execute(self, *command):
         # NOTE(vish): Volume commands can partially fail due to timing, but
         #             running them a second time on failure will usually
         #             recover nicely.
         tries = 0
         while True:
             try:
-                self._execute(command)
+                self._execute(*command)
                 return True
             except exception.ProcessExecutionError:
                 tries = tries + 1
@@ -84,7 +84,7 @@ class VolumeDriver(object):
 
     def check_for_setup_error(self):
         """Returns an error if prerequisites aren't met"""
-        out, err = self._execute("sudo vgs --noheadings -o name")
+        out, err = self._execute('sudo', 'vgs', '--noheadings', '-o', 'name')
         volume_groups = out.split()
         if not FLAGS.volume_group in volume_groups:
             raise exception.Error(_("volume group %s doesn't exist")
@@ -97,21 +97,21 @@ class VolumeDriver(object):
             sizestr = '100M'
         else:
             sizestr = '%sG' % volume['size']
-        self._try_execute('sudo','lvcreate','-L',sizestr,'-n',
+        self._try_execute('sudo', 'lvcreate', '-L', sizestr, '-n',
                            volume['name'],
                            FLAGS.volume_group)
 
     def delete_volume(self, volume):
         """Deletes a logical volume."""
         try:
-            self._try_execute('sudo','lvdisplay','%s/%s" %
+            self._try_execute('sudo', 'lvdisplay', '%s/%s" %
                               (FLAGS.volume_group,
                                volume['name']))
         except Exception as e:
             # If the volume isn't present, then don't attempt to delete
             return True
 
-        self._try_execute('sudo','lvremove','-f',"%s/%s" %
+        self._try_execute('sudo', 'lvremove', '-f',"%s/%s" %
                           (FLAGS.volume_group,
                            volume['name']))
 
@@ -167,7 +167,7 @@ class AOEDriver(VolumeDriver):
          blade_id) = self.db.volume_allocate_shelf_and_blade(context,
                                                              volume['id'])
         self._try_execute(
-                'sudo','vblade-persist','setup',
+                'sudo', 'vblade-persist', 'setup',
                  shelf_id,
                  blade_id,
                  FLAGS.aoe_eth_dev,
@@ -182,9 +182,9 @@ class AOEDriver(VolumeDriver):
         #             just wait a bit for the current volume to
         #             be ready and ignore any errors.
         time.sleep(2)
-        self._execute('sudo','vblade-persist','auto','all',
+        self._execute('sudo', 'vblade-persist', 'auto', 'all',
                       check_exit_code=False)
-        self._execute('sudo','vblade-persist','start','all',
+        self._execute('sudo', 'vblade-persist', 'start', 'all',
                       check_exit_code=False)
 
     def remove_export(self, context, volume):
@@ -192,15 +192,15 @@ class AOEDriver(VolumeDriver):
         (shelf_id,
          blade_id) = self.db.volume_get_shelf_and_blade(context,
                                                         volume['id'])
-        self._try_execute('sudo','vblade-persist','stop',
+        self._try_execute('sudo', 'vblade-persist', 'stop',
                           shelf_id, blade_id)
-        self._try_execute('sudo','vblade-persist','destroy',
+        self._try_execute('sudo', 'vblade-persist', 'destroy',
                           shelf_id, blade_id)
 
     def discover_volume(self, _volume):
         """Discover volume on a remote host."""
-        self._execute('sudo','aoe-discover')
-        self._execute('sudo','aoe-stat', check_exit_code=False)
+        self._execute('sudo', 'aoe-discover')
+        self._execute('sudo', 'aoe-stat', check_exit_code=False)
 
     def undiscover_volume(self, _volume):
         """Undiscover volume on a remote host."""
@@ -252,12 +252,12 @@ class ISCSIDriver(VolumeDriver):
 
         iscsi_name = "%s%s" % (FLAGS.iscsi_target_prefix, volume['name'])
         volume_path = "/dev/%s/%s" % (FLAGS.volume_group, volume['name'])
-        self._sync_exec('sudo','ietadm','--op','new',
+        self._sync_exec('sudo', 'ietadm', '--op', 'new',
                         "--tid=%s" % iscsi_target,
                         '--params',
                         "Name=%s" % iscsi-name,
                         check_exit_code=False)
-        self._sync_exec('sudo','ietadm','--op','new',
+        self._sync_exec('sudo', 'ietadm', '--op', 'new',
                         "--tid=%s" % iscsi_target,
                         '--lun=0',
                         '--params',
@@ -282,12 +282,13 @@ class ISCSIDriver(VolumeDriver):
                                                       volume['host'])
         iscsi_name = "%s%s" % (FLAGS.iscsi_target_prefix, volume['name'])
         volume_path = "/dev/%s/%s" % (FLAGS.volume_group, volume['name'])
-        self._execute("sudo ietadm --op new "
-                      "--tid=%s --params Name=%s" %
+        self._execute('sudo', 'ietadm', '--op', 'new',
+                      '--tid=%s --params Name=%s' %
                       (iscsi_target, iscsi_name))
-        self._execute("sudo ietadm --op new --tid=%s "
-                      "--lun=0 --params Path=%s,Type=fileio" %
-                      (iscsi_target, volume_path))
+        self._execute('sudo', 'ietadm', '--op', 'new',
+                      '--tid=%s' % iscsi_target,
+                      '--lun=0', '--params',
+                      'Path=%s,Type=fileio' % volume_path)
 
     def remove_export(self, context, volume):
         """Removes an export for a logical volume."""
@@ -302,16 +303,18 @@ class ISCSIDriver(VolumeDriver):
         try:
             # ietadm show will exit with an error
             # this export has already been removed
-            self._execute("sudo ietadm --op show --tid=%s " % iscsi_target)
+            self._execute('sudo', 'ietadm', '--op', 'show',
+                          '--tid=%s' % iscsi_target)
         except Exception as e:
             LOG.info(_("Skipping remove_export. No iscsi_target " +
                        "is presently exported for volume: %d"), volume['id'])
             return
 
-        self._execute("sudo ietadm --op delete --tid=%s "
-                      "--lun=0" % iscsi_target)
-        self._execute("sudo ietadm --op delete --tid=%s" %
-                      iscsi_target)
+        self._execute('sudo', 'ietadm', '--op', 'delete',
+                      '--tid=%s' % iscsi_target,
+                      '--lun=0')
+        self._execute('sudo', 'ietadm', '--op', 'delete',
+                      '--tid=%s' % iscsi_target)
 
     def _do_iscsi_discovery(self, volume):
         #TODO(justinsb): Deprecate discovery and use stored info
@@ -320,8 +323,8 @@ class ISCSIDriver(VolumeDriver):
 
         volume_name = volume['name']
 
-        (out, _err) = self._execute("sudo iscsiadm -m discovery -t "
-                                    "sendtargets -p %s" % (volume['host']))
+        (out, _err) = self._execute('sudo', 'iscsiadm', '-m', 'discovery',
+                                    '-t', 'sendtargets', '-p', volume['host'])
         for target in out.splitlines():
             if FLAGS.iscsi_ip_prefix in target and volume_name in target:
                 return target
@@ -481,7 +484,7 @@ class RBDDriver(VolumeDriver):
 
     def check_for_setup_error(self):
         """Returns an error if prerequisites aren't met"""
-        (stdout, stderr) = self._execute("rados lspools")
+        (stdout, stderr) = self._execute('rados', 'lspools')
         pools = stdout.split("\n")
         if not FLAGS.rbd_pool in pools:
             raise exception.Error(_("rbd has no pool %s") %
@@ -493,12 +496,12 @@ class RBDDriver(VolumeDriver):
             size = 100
         else:
             size = int(volume['size']) * 1024
-        self._try_execute('rbd','--pool',FLAGS.rbd_pool,
-                          '--size', size,'create', volume['name'])
+        self._try_execute('rbd', '--pool', FLAGS.rbd_pool,
+                          '--size', size, 'create', volume['name'])
 
     def delete_volume(self, volume):
         """Deletes a logical volume."""
-        self._try_execute('rbd','--pool',FLAGS.rbd_pool,
+        self._try_execute('rbd', '--pool', FLAGS.rbd_pool,
                           'rm', voluname['name'])
 
     def local_path(self, volume):
@@ -534,7 +537,7 @@ class SheepdogDriver(VolumeDriver):
     def check_for_setup_error(self):
         """Returns an error if prerequisites aren't met"""
         try:
-            (out, err) = self._execute('collie','cluster','info')
+            (out, err) = self._execute('collie', 'cluster', 'info')
             if not out.startswith('running'):
                 raise exception.Error(_("Sheepdog is not working: %s") % out)
         except exception.ProcessExecutionError:
@@ -546,13 +549,13 @@ class SheepdogDriver(VolumeDriver):
             sizestr = '100M'
         else:
             sizestr = '%sG' % volume['size']
-        self._try_execute('qemu-img','create',
+        self._try_execute('qemu-img', 'create',
                           "sheepdog:%s" %s" % volume['name'],
                           sizestr)
 
     def delete_volume(self, volume):
         """Deletes a logical volume"""
-        self._try_execute('collie','vdi','delete',volume['name'])
+        self._try_execute('collie', 'vdi', 'delete', volume['name'])
 
     def local_path(self, volume):
         return "sheepdog:%s" % volume['name']
-- 
cgit 


From 5fcf84f19c94f96d8f23d8b673ed3f4977f9189d Mon Sep 17 00:00:00 2001
From: Eric Windisch <eric@cloudscaling.com>
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')

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', '</dev/null || echo free' % (port)
                 stdout, stderr = utils.execute(cmd)
                 if stdout.strip() == 'free':
-- 
cgit 


From f53357d32304cd721185704fa0d48454b5627199 Mon Sep 17 00:00:00 2001
From: sateesh <sateesh.chodapuneedi@citrix.com>
Date: Tue, 8 Mar 2011 16:33:49 +0530
Subject: Removed stale references to XenAPI.

---
 nova/tests/test_vmwareapi.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/test_vmwareapi.py b/nova/tests/test_vmwareapi.py
index 5e8896b5a..65cdd5fcf 100644
--- a/nova/tests/test_vmwareapi.py
+++ b/nova/tests/test_vmwareapi.py
@@ -86,7 +86,7 @@ class VMWareAPIVMTestCase(test.TestCase):
         # Get Nova record for VM
         vm_info = self.conn.get_info(1)
 
-        # Get XenAPI record for VM
+        # Get record for VMs
         vms = vmwareapi_fake._get_objects("VirtualMachine")
         vm = vms[0]
 
@@ -102,7 +102,7 @@ class VMWareAPIVMTestCase(test.TestCase):
         # Check that the VM is running according to Nova
         self.assertEquals(vm_info['state'], power_state.RUNNING)
 
-        # Check that the VM is running according to XenAPI.
+        # Check that the VM is running according to vSphere API.
         self.assertEquals(vm.get("runtime.powerState"), 'poweredOn')
 
     def _check_vm_info(self, info, pwr_state=power_state.RUNNING):
-- 
cgit 


From b8a0fdca4df454a4d60df40d06ebd82bcc2ba3da Mon Sep 17 00:00:00 2001
From: Cory Wright <cory.wright@rackspace.com>
Date: Tue, 8 Mar 2011 14:35:53 +0000
Subject:  * pep8 cleanups in migrations  * a few bugfixes

---
 .../sqlalchemy/migrate_repo/versions/009_add_os_type_to_instances.py | 5 +----
 nova/tests/test_xenapi.py                                            | 4 ++--
 nova/virt/xenapi/vm_utils.py                                         | 2 +-
 3 files changed, 4 insertions(+), 7 deletions(-)

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/migrate_repo/versions/009_add_os_type_to_instances.py b/nova/db/sqlalchemy/migrate_repo/versions/009_add_os_type_to_instances.py
index a50f31e16..514b92b81 100644
--- a/nova/db/sqlalchemy/migrate_repo/versions/009_add_os_type_to_instances.py
+++ b/nova/db/sqlalchemy/migrate_repo/versions/009_add_os_type_to_instances.py
@@ -29,8 +29,6 @@ instances = Table('instances', meta,
         Column('id', Integer(),  primary_key=True, nullable=False),
         )
 
-# FIXME(dubs) should this be not null?  Maybe create as nullable, then
-#   populate all existing rows with 'linux', then adding not null constraint.
 instances_os_type = Column('os_type',
                            String(length=255, convert_unicode=False,
                                   assert_unicode=None, unicode_error=None,
@@ -45,7 +43,7 @@ def upgrade(migrate_engine):
 
     instances.create_column(instances_os_type)
     migrate_engine.execute(instances.update()\
-                           .where(instances.c.os_type==None)\
+                           .where(instances.c.os_type == None)\
                            .values(os_type='linux'))
 
 
@@ -53,4 +51,3 @@ def downgrade(migrate_engine):
     meta.bind = migrate_engine
 
     instances.drop_column('os_type')
-
diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index 27f0e5dd7..25070e108 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -251,7 +251,7 @@ class XenAPIVMTestCase(test.TestCase):
         self.vm_info = vm_info
         self.vm = vm
 
-    def check_vm_record(self):
+    def check_vm_record(self, conn):
         # Check that m1.large above turned into the right thing.
         instance_type = db.instance_type_get_by_name(conn, 'm1.large')
         mem_kib = long(instance_type['memory_mb']) << 10
@@ -321,7 +321,7 @@ class XenAPIVMTestCase(test.TestCase):
         instance = db.instance_create(values)
         conn.spawn(instance)
         self.create_vm_record(conn, os_type)
-        self.check_vm_record()
+        self.check_vm_record(conn)
 
     def test_spawn_not_enough_memory(self):
         FLAGS.xenapi_image_service = 'glance'
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 cbc2956a4e863c1bc952c7cef6045c39d293818d Mon Sep 17 00:00:00 2001
From: Monsyne Dragon <mdragon@rackspace.com>
Date: Tue, 8 Mar 2011 17:18:13 +0000
Subject: Remove addition of account to service url.

---
 nova/api/openstack/__init__.py            | 24 +++-------------
 nova/api/openstack/auth.py                | 46 ++++++-----------------------
 nova/auth/novarc.template                 |  2 +-
 nova/tests/api/openstack/test_accounts.py |  8 +++---
 nova/tests/api/openstack/test_adminapi.py |  4 +--
 nova/tests/api/openstack/test_auth.py     |  2 +-
 nova/tests/api/openstack/test_flavors.py  |  4 +--
 nova/tests/api/openstack/test_images.py   |  4 +--
 nova/tests/api/openstack/test_servers.py  | 48 +++++++++++++++----------------
 nova/tests/api/openstack/test_users.py    | 10 +++----
 nova/tests/api/openstack/test_zones.py    | 10 +++----
 11 files changed, 59 insertions(+), 103 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/__init__.py b/nova/api/openstack/__init__.py
index 005d330a6..a655b1c85 100644
--- a/nova/api/openstack/__init__.py
+++ b/nova/api/openstack/__init__.py
@@ -73,18 +73,6 @@ class APIRouter(wsgi.Router):
     def __init__(self):
         mapper = routes.Mapper()
 
-        accounts_controller = accounts.Controller()
-        mapper.connect("account", "/{id}",
-            controller=accounts_controller, action="show",
-                conditions=dict(method=["GET"]))
-        if FLAGS.allow_admin_api:
-            mapper.connect("/{id}",
-                controller=accounts_controller, action="update",
-                    conditions=dict(method=["PUT"]))
-            mapper.connect("/{id}",
-                controller=accounts_controller, action="delete",
-                    conditions=dict(method=["DELETE"]))
-
         server_members = {'action': 'POST'}
         if FLAGS.allow_admin_api:
             LOG.debug(_("Including admin operations in API."))
@@ -101,38 +89,34 @@ class APIRouter(wsgi.Router):
             server_members['inject_network_info'] = 'POST'
 
             mapper.resource("zone", "zones", controller=zones.Controller(),
-                        path_prefix="{account_id}/",
                         collection={'detail': 'GET'})
 
             mapper.resource("user", "users", controller=users.Controller(),
-                        path_prefix="{account_id}/",
                         collection={'detail': 'GET'})
 
+            mapper.resource("account", "accounts",
+                            controller=accounts.Controller(),
+                            collection={'detail': 'GET'})
+
         mapper.resource("server", "servers", controller=servers.Controller(),
                         collection={'detail': 'GET'},
-                        path_prefix="{account_id}/",
                         member=server_members)
 
         mapper.resource("backup_schedule", "backup_schedule",
                         controller=backup_schedules.Controller(),
-                        path_prefix="{account_id}/servers/{server_id}/",
                         parent_resource=dict(member_name='server',
                         collection_name='servers'))
 
         mapper.resource("console", "consoles",
                         controller=consoles.Controller(),
-                        path_prefix="{account_id}/servers/{server_id}/",
                         parent_resource=dict(member_name='server',
                         collection_name='servers'))
 
         mapper.resource("image", "images", controller=images.Controller(),
-                        path_prefix="{account_id}/",
                         collection={'detail': 'GET'})
         mapper.resource("flavor", "flavors", controller=flavors.Controller(),
-                        path_prefix="{account_id}/",
                         collection={'detail': 'GET'})
         mapper.resource("shared_ip_group", "shared_ip_groups",
-                        path_prefix="{account_id}/",
                         collection={'detail': 'GET'},
                         controller=shared_ip_groups.Controller())
 
diff --git a/nova/api/openstack/auth.py b/nova/api/openstack/auth.py
index e77910fed..e71fc69e3 100644
--- a/nova/api/openstack/auth.py
+++ b/nova/api/openstack/auth.py
@@ -53,19 +53,15 @@ class AuthMiddleware(wsgi.Middleware):
         if not self.has_authentication(req):
             return self.authenticate(req)
         user = self.get_user_by_authentication(req)
-        account_name = req.path_info_peek()
-
+        accounts = self.auth.get_projects(user=user)
         if not user:
             return faults.Fault(webob.exc.HTTPUnauthorized())
 
-        if not account_name:
-            if self.auth.is_admin(user):
-                account_name = FLAGS.default_project
-            else:
-                return faults.Fault(webob.exc.HTTPUnauthorized())
-        try:
-            account = self.auth.get_project(account_name)
-        except exception.NotFound:
+        if accounts:
+            #we are punting on this til auth is settled,
+            #and possibly til api v1.1 (mdragon)
+            account = accounts[0]
+        else:
             return faults.Fault(webob.exc.HTTPUnauthorized())
 
         if not self.auth.is_admin(user) and \
@@ -85,7 +81,6 @@ class AuthMiddleware(wsgi.Middleware):
         # Unless the request is explicitly made against /<version>/ don't
         # honor it
         path_info = req.path_info
-        account_name = None
         if len(path_info) > 1:
             return faults.Fault(webob.exc.HTTPUnauthorized())
 
@@ -95,10 +90,7 @@ class AuthMiddleware(wsgi.Middleware):
         except KeyError:
             return faults.Fault(webob.exc.HTTPUnauthorized())
 
-        if ':' in username:
-            account_name, username = username.rsplit(':', 1)
-
-        token, user = self._authorize_user(username, account_name, key, req)
+        token, user = self._authorize_user(username, key, req)
         if user and token:
             res = webob.Response()
             res.headers['X-Auth-Token'] = token.token_hash
@@ -135,31 +127,15 @@ class AuthMiddleware(wsgi.Middleware):
                 return self.auth.get_user(token.user_id)
         return None
 
-    def _authorize_user(self, username, account_name, key, req):
+    def _authorize_user(self, username, key, req):
         """Generates a new token and assigns it to a user.
 
         username - string
-        account_name - string
         key - string API key
         req - webob.Request object
         """
         ctxt = context.get_admin_context()
         user = self.auth.get_user_from_access_key(key)
-        if account_name:
-            try:
-                account = self.auth.get_project(account_name)
-            except exception.NotFound:
-                return None, None
-        else:
-            # (dragondm) punt and try to determine account.
-            # this is something of a hack, but a user on 1 account is a
-            # common case, and is the way the current RS code works.
-            accounts = self.auth.get_projects(user=user)
-            if len(accounts) == 1:
-                account = accounts[0]
-            else:
-                #we can't tell what account they are logging in for.
-                return None, None
 
         if user and user.name == username:
             token_hash = hashlib.sha1('%s%s%f' % (username, key,
@@ -167,11 +143,7 @@ class AuthMiddleware(wsgi.Middleware):
             token_dict = {}
             token_dict['token_hash'] = token_hash
             token_dict['cdn_management_url'] = ''
-            # auth url + project (account) id, e.g.
-            # http://foo.org:8774/baz/v1.0/myacct/
-            os_url = '%s%s%s/' % (req.url,
-                                  '' if req.url.endswith('/') else '/',
-                                  account.id)
+            os_url = req.url
             token_dict['server_management_url'] = os_url
             token_dict['storage_url'] = ''
             token_dict['user_id'] = user.id
diff --git a/nova/auth/novarc.template b/nova/auth/novarc.template
index 1c917ad44..cda2ecc28 100644
--- a/nova/auth/novarc.template
+++ b/nova/auth/novarc.template
@@ -11,5 +11,5 @@ export EUCALYPTUS_CERT=${NOVA_CERT} # euca-bundle-image seems to require this se
 alias ec2-bundle-image="ec2-bundle-image --cert ${EC2_CERT} --privatekey ${EC2_PRIVATE_KEY} --user 42 --ec2cert ${NOVA_CERT}"
 alias ec2-upload-bundle="ec2-upload-bundle -a ${EC2_ACCESS_KEY} -s ${EC2_SECRET_KEY} --url ${S3_URL} --ec2cert ${NOVA_CERT}"
 export NOVA_API_KEY="%(access)s"
-export NOVA_USERNAME="%(project)s:%(user)s"
+export NOVA_USERNAME="%(user)s"
 export NOVA_URL="%(os)s"
diff --git a/nova/tests/api/openstack/test_accounts.py b/nova/tests/api/openstack/test_accounts.py
index b2e89824a..746f02f57 100644
--- a/nova/tests/api/openstack/test_accounts.py
+++ b/nova/tests/api/openstack/test_accounts.py
@@ -70,7 +70,7 @@ class AccountsTest(test.TestCase):
         super(AccountsTest, self).tearDown()
 
     def test_get_account(self):
-        req = webob.Request.blank('/v1.0/test1')
+        req = webob.Request.blank('/v1.0/accounts/test1')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
 
@@ -80,7 +80,7 @@ class AccountsTest(test.TestCase):
         self.assertEqual(res.status_int, 200)
 
     def test_account_delete(self):
-        req = webob.Request.blank('/v1.0/test1')
+        req = webob.Request.blank('/v1.0/accounts/test1')
         req.method = 'DELETE'
         res = req.get_response(fakes.wsgi_app())
         self.assertTrue('test1' not in fakes.FakeAuthManager.projects)
@@ -89,7 +89,7 @@ class AccountsTest(test.TestCase):
     def test_account_create(self):
         body = dict(account=dict(description='test account',
                               manager='guy1'))
-        req = webob.Request.blank('/v1.0/newacct')
+        req = webob.Request.blank('/v1.0/accounts/newacct')
         req.method = 'PUT'
         req.body = json.dumps(body)
 
@@ -108,7 +108,7 @@ class AccountsTest(test.TestCase):
     def test_account_update(self):
         body = dict(account=dict(description='test account',
                               manager='guy2'))
-        req = webob.Request.blank('/v1.0/test1')
+        req = webob.Request.blank('/v1.0/accounts/test1')
         req.method = 'PUT'
         req.body = json.dumps(body)
 
diff --git a/nova/tests/api/openstack/test_adminapi.py b/nova/tests/api/openstack/test_adminapi.py
index 7cb9e8450..4568cb9f5 100644
--- a/nova/tests/api/openstack/test_adminapi.py
+++ b/nova/tests/api/openstack/test_adminapi.py
@@ -50,7 +50,7 @@ class AdminAPITest(test.TestCase):
     def test_admin_enabled(self):
         FLAGS.allow_admin_api = True
         # We should still be able to access public operations.
-        req = webob.Request.blank('/v1.0/testacct/flavors')
+        req = webob.Request.blank('/v1.0/flavors')
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 200)
         # TODO: Confirm admin operations are available.
@@ -58,7 +58,7 @@ class AdminAPITest(test.TestCase):
     def test_admin_disabled(self):
         FLAGS.allow_admin_api = False
         # We should still be able to access public operations.
-        req = webob.Request.blank('/v1.0/testacct/flavors')
+        req = webob.Request.blank('/v1.0/flavors')
         res = req.get_response(fakes.wsgi_app())
         # TODO: Confirm admin operations are unavailable.
         self.assertEqual(res.status_int, 200)
diff --git a/nova/tests/api/openstack/test_auth.py b/nova/tests/api/openstack/test_auth.py
index 8268a6fb9..49f90879d 100644
--- a/nova/tests/api/openstack/test_auth.py
+++ b/nova/tests/api/openstack/test_auth.py
@@ -78,7 +78,7 @@ class Test(test.TestCase):
         self.assertEqual(result.status, '204 No Content')
         self.assertEqual(len(result.headers['X-Auth-Token']), 40)
         self.assertEqual(result.headers['X-Server-Management-Url'],
-            "http://foo/v1.0/test/")
+            "http://foo/v1.0/")
         self.assertEqual(result.headers['X-CDN-Management-Url'],
             "")
         self.assertEqual(result.headers['X-Storage-Url'], "")
diff --git a/nova/tests/api/openstack/test_flavors.py b/nova/tests/api/openstack/test_flavors.py
index ba0785b0e..8280a505f 100644
--- a/nova/tests/api/openstack/test_flavors.py
+++ b/nova/tests/api/openstack/test_flavors.py
@@ -42,11 +42,11 @@ class FlavorsTest(test.TestCase):
         super(FlavorsTest, self).tearDown()
 
     def test_get_flavor_list(self):
-        req = webob.Request.blank('/v1.0/testacct/flavors')
+        req = webob.Request.blank('/v1.0/flavors')
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 200)
 
     def test_get_flavor_by_id(self):
-        req = webob.Request.blank('/v1.0/testacct/flavors/1')
+        req = webob.Request.blank('/v1.0/flavors/1')
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 200)
diff --git a/nova/tests/api/openstack/test_images.py b/nova/tests/api/openstack/test_images.py
index 819ca001e..dbe507f7d 100644
--- a/nova/tests/api/openstack/test_images.py
+++ b/nova/tests/api/openstack/test_images.py
@@ -216,7 +216,7 @@ class ImageControllerWithGlanceServiceTest(test.TestCase):
         super(ImageControllerWithGlanceServiceTest, self).tearDown()
 
     def test_get_image_index(self):
-        req = webob.Request.blank('/v1.0/testacct/images')
+        req = webob.Request.blank('/v1.0/images')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
 
@@ -228,7 +228,7 @@ class ImageControllerWithGlanceServiceTest(test.TestCase):
                               "image %s not in fixture index!" % str(image))
 
     def test_get_image_details(self):
-        req = webob.Request.blank('/v1.0/testacct/images/detail')
+        req = webob.Request.blank('/v1.0/images/detail')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
 
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index d592e06b0..705a2f800 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -150,7 +150,7 @@ class ServersTest(test.TestCase):
         super(ServersTest, self).tearDown()
 
     def test_get_server_by_id(self):
-        req = webob.Request.blank('/v1.0/testacct/servers/1')
+        req = webob.Request.blank('/v1.0/servers/1')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
         self.assertEqual(res_dict['server']['id'], '1')
@@ -161,7 +161,7 @@ class ServersTest(test.TestCase):
         public = ["1.2.3.4"]
         new_return_server = return_server_with_addresses(private, public)
         self.stubs.Set(nova.db.api, 'instance_get', new_return_server)
-        req = webob.Request.blank('/v1.0/testacct/servers/1')
+        req = webob.Request.blank('/v1.0/servers/1')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
         self.assertEqual(res_dict['server']['id'], '1')
@@ -173,7 +173,7 @@ class ServersTest(test.TestCase):
         self.assertEqual(addresses["private"][0], private)
 
     def test_get_server_list(self):
-        req = webob.Request.blank('/v1.0/testacct/servers')
+        req = webob.Request.blank('/v1.0/servers')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
 
@@ -224,7 +224,7 @@ class ServersTest(test.TestCase):
             name='server_test', imageId=2, flavorId=2,
             metadata={'hello': 'world', 'open': 'stack'},
             personality={}))
-        req = webob.Request.blank('/v1.0/testacct/servers')
+        req = webob.Request.blank('/v1.0/servers')
         req.method = 'POST'
         req.body = json.dumps(body)
 
@@ -233,7 +233,7 @@ class ServersTest(test.TestCase):
         self.assertEqual(res.status_int, 200)
 
     def test_update_no_body(self):
-        req = webob.Request.blank('/v1.0/testacct/servers/1')
+        req = webob.Request.blank('/v1.0/servers/1')
         req.method = 'PUT'
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 422)
@@ -251,7 +251,7 @@ class ServersTest(test.TestCase):
         self.stubs.Set(nova.db.api, 'instance_update',
             server_update)
 
-        req = webob.Request.blank('/v1.0/testacct/servers/1')
+        req = webob.Request.blank('/v1.0/servers/1')
         req.method = 'PUT'
         req.body = self.body
         req.get_response(fakes.wsgi_app())
@@ -267,30 +267,30 @@ class ServersTest(test.TestCase):
         self.stubs.Set(nova.db.api, 'instance_update',
             server_update)
 
-        req = webob.Request.blank('/v1.0/testacct/servers/1')
+        req = webob.Request.blank('/v1.0/servers/1')
         req.method = 'PUT'
         req.body = self.body
         req.get_response(fakes.wsgi_app())
 
     def test_create_backup_schedules(self):
-        req = webob.Request.blank('/v1.0/testacct/servers/1/backup_schedules')
+        req = webob.Request.blank('/v1.0/servers/1/backup_schedules')
         req.method = 'POST'
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status, '404 Not Found')
 
     def test_delete_backup_schedules(self):
-        req = webob.Request.blank('/v1.0/testacct/servers/1/backup_schedules')
+        req = webob.Request.blank('/v1.0/servers/1/backup_schedules')
         req.method = 'DELETE'
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status, '404 Not Found')
 
     def test_get_server_backup_schedules(self):
-        req = webob.Request.blank('/v1.0/testacct/servers/1/backup_schedules')
+        req = webob.Request.blank('/v1.0/servers/1/backup_schedules')
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status, '404 Not Found')
 
     def test_get_all_server_details(self):
-        req = webob.Request.blank('/v1.0/testacct/servers/detail')
+        req = webob.Request.blank('/v1.0/servers/detail')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
 
@@ -321,7 +321,7 @@ class ServersTest(test.TestCase):
         self.stubs.Set(nova.db.api, 'instance_get_all_by_user',
             return_servers_with_host)
 
-        req = webob.Request.blank('/v1.0/testacct/servers/detail')
+        req = webob.Request.blank('/v1.0/servers/detail')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
 
@@ -341,7 +341,7 @@ class ServersTest(test.TestCase):
         body = dict(server=dict(
             name='server_test', imageId=2, flavorId=2, metadata={},
             personality={}))
-        req = webob.Request.blank('/v1.0/testacct/servers/1/pause')
+        req = webob.Request.blank('/v1.0/servers/1/pause')
         req.method = 'POST'
         req.content_type = 'application/json'
         req.body = json.dumps(body)
@@ -353,7 +353,7 @@ class ServersTest(test.TestCase):
         body = dict(server=dict(
             name='server_test', imageId=2, flavorId=2, metadata={},
             personality={}))
-        req = webob.Request.blank('/v1.0/testacct/servers/1/unpause')
+        req = webob.Request.blank('/v1.0/servers/1/unpause')
         req.method = 'POST'
         req.content_type = 'application/json'
         req.body = json.dumps(body)
@@ -365,7 +365,7 @@ class ServersTest(test.TestCase):
         body = dict(server=dict(
             name='server_test', imageId=2, flavorId=2, metadata={},
             personality={}))
-        req = webob.Request.blank('/v1.0/testacct/servers/1/suspend')
+        req = webob.Request.blank('/v1.0/servers/1/suspend')
         req.method = 'POST'
         req.content_type = 'application/json'
         req.body = json.dumps(body)
@@ -377,7 +377,7 @@ class ServersTest(test.TestCase):
         body = dict(server=dict(
             name='server_test', imageId=2, flavorId=2, metadata={},
             personality={}))
-        req = webob.Request.blank('/v1.0/testacct/servers/1/resume')
+        req = webob.Request.blank('/v1.0/servers/1/resume')
         req.method = 'POST'
         req.content_type = 'application/json'
         req.body = json.dumps(body)
@@ -389,7 +389,7 @@ class ServersTest(test.TestCase):
         body = dict(server=dict(
             name='server_test', imageId=2, flavorId=2, metadata={},
             personality={}))
-        req = webob.Request.blank('/v1.0/testacct/servers/1/reset_network')
+        req = webob.Request.blank('/v1.0/servers/1/reset_network')
         req.method = 'POST'
         req.content_type = 'application/json'
         req.body = json.dumps(body)
@@ -402,7 +402,7 @@ class ServersTest(test.TestCase):
             name='server_test', imageId=2, flavorId=2, metadata={},
             personality={}))
         req = webob.Request.blank(
-              '/v1.0/testacct/servers/1/inject_network_info')
+              '/v1.0/servers/1/inject_network_info')
         req.method = 'POST'
         req.content_type = 'application/json'
         req.body = json.dumps(body)
@@ -410,13 +410,13 @@ class ServersTest(test.TestCase):
         self.assertEqual(res.status_int, 202)
 
     def test_server_diagnostics(self):
-        req = webob.Request.blank("/v1.0/testacct/servers/1/diagnostics")
+        req = webob.Request.blank("/v1.0/servers/1/diagnostics")
         req.method = "GET"
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 404)
 
     def test_server_actions(self):
-        req = webob.Request.blank("/v1.0/testacct/servers/1/actions")
+        req = webob.Request.blank("/v1.0/servers/1/actions")
         req.method = "GET"
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 404)
@@ -425,7 +425,7 @@ class ServersTest(test.TestCase):
         body = dict(server=dict(
             name='server_test', imageId=2, flavorId=2, metadata={},
             personality={}))
-        req = webob.Request.blank('/v1.0/testacct/servers/1/action')
+        req = webob.Request.blank('/v1.0/servers/1/action')
         req.method = 'POST'
         req.content_type = 'application/json'
         req.body = json.dumps(body)
@@ -435,7 +435,7 @@ class ServersTest(test.TestCase):
         body = dict(server=dict(
             name='server_test', imageId=2, flavorId=2, metadata={},
             personality={}))
-        req = webob.Request.blank('/v1.0/testacct/servers/1/action')
+        req = webob.Request.blank('/v1.0/servers/1/action')
         req.method = 'POST'
         req.content_type = 'application/json'
         req.body = json.dumps(body)
@@ -445,14 +445,14 @@ class ServersTest(test.TestCase):
         body = dict(server=dict(
             name='server_test', imageId=2, flavorId=2, metadata={},
             personality={}))
-        req = webob.Request.blank('/v1.0/testacct/servers/1/action')
+        req = webob.Request.blank('/v1.0/servers/1/action')
         req.method = 'POST'
         req.content_type = 'application/json'
         req.body = json.dumps(body)
         res = req.get_response(fakes.wsgi_app())
 
     def test_delete_server_instance(self):
-        req = webob.Request.blank('/v1.0/testacct/servers/1')
+        req = webob.Request.blank('/v1.0/servers/1')
         req.method = 'DELETE'
 
         self.server_delete_called = False
diff --git a/nova/tests/api/openstack/test_users.py b/nova/tests/api/openstack/test_users.py
index bd32254cd..14c7897f0 100644
--- a/nova/tests/api/openstack/test_users.py
+++ b/nova/tests/api/openstack/test_users.py
@@ -72,7 +72,7 @@ class UsersTest(test.TestCase):
         super(UsersTest, self).tearDown()
 
     def test_get_user_list(self):
-        req = webob.Request.blank('/v1.0/testacct/users')
+        req = webob.Request.blank('/v1.0/users')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
 
@@ -80,7 +80,7 @@ class UsersTest(test.TestCase):
         self.assertEqual(len(res_dict['users']), 2)
 
     def test_get_user_by_id(self):
-        req = webob.Request.blank('/v1.0/testacct/users/guy2')
+        req = webob.Request.blank('/v1.0/users/guy2')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
 
@@ -91,7 +91,7 @@ class UsersTest(test.TestCase):
         self.assertEqual(res.status_int, 200)
 
     def test_user_delete(self):
-        req = webob.Request.blank('/v1.0/testacct/users/guy1')
+        req = webob.Request.blank('/v1.0/users/guy1')
         req.method = 'DELETE'
         res = req.get_response(fakes.wsgi_app())
         self.assertTrue('guy1' not in [u.id for u in
@@ -103,7 +103,7 @@ class UsersTest(test.TestCase):
                               access='acc3',
                               secret='invasionIsInNormandy',
                               admin=True))
-        req = webob.Request.blank('/v1.0/testacct/users')
+        req = webob.Request.blank('/v1.0/users')
         req.method = 'POST'
         req.body = json.dumps(body)
 
@@ -124,7 +124,7 @@ class UsersTest(test.TestCase):
         body = dict(user=dict(name='guy2',
                               access='acc2',
                               secret='invasionIsInNormandy'))
-        req = webob.Request.blank('/v1.0/testacct/users/guy2')
+        req = webob.Request.blank('/v1.0/users/guy2')
         req.method = 'PUT'
         req.body = json.dumps(body)
 
diff --git a/nova/tests/api/openstack/test_zones.py b/nova/tests/api/openstack/test_zones.py
index 51f13af48..6d869dc15 100644
--- a/nova/tests/api/openstack/test_zones.py
+++ b/nova/tests/api/openstack/test_zones.py
@@ -85,7 +85,7 @@ class ZonesTest(test.TestCase):
         super(ZonesTest, self).tearDown()
 
     def test_get_zone_list(self):
-        req = webob.Request.blank('/v1.0/testacct/zones')
+        req = webob.Request.blank('/v1.0/zones')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
 
@@ -93,7 +93,7 @@ class ZonesTest(test.TestCase):
         self.assertEqual(len(res_dict['zones']), 2)
 
     def test_get_zone_by_id(self):
-        req = webob.Request.blank('/v1.0/testacct/zones/1')
+        req = webob.Request.blank('/v1.0/zones/1')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
 
@@ -103,7 +103,7 @@ class ZonesTest(test.TestCase):
         self.assertEqual(res.status_int, 200)
 
     def test_zone_delete(self):
-        req = webob.Request.blank('/v1.0/testacct/zones/1')
+        req = webob.Request.blank('/v1.0/zones/1')
         res = req.get_response(fakes.wsgi_app())
 
         self.assertEqual(res.status_int, 200)
@@ -111,7 +111,7 @@ class ZonesTest(test.TestCase):
     def test_zone_create(self):
         body = dict(zone=dict(api_url='http://blah.zoo', username='fred',
                         password='fubar'))
-        req = webob.Request.blank('/v1.0/testacct/zones')
+        req = webob.Request.blank('/v1.0/zones')
         req.method = 'POST'
         req.body = json.dumps(body)
 
@@ -125,7 +125,7 @@ class ZonesTest(test.TestCase):
 
     def test_zone_update(self):
         body = dict(zone=dict(username='zeb', password='sneaky'))
-        req = webob.Request.blank('/v1.0/testacct/zones/1')
+        req = webob.Request.blank('/v1.0/zones/1')
         req.method = 'PUT'
         req.body = json.dumps(body)
 
-- 
cgit 


From e81294b94e3bc8708bd4777b685a7d302594557e Mon Sep 17 00:00:00 2001
From: Ricardo Carrillo Cruz <emaildericky@gmail.com>
Date: Tue, 8 Mar 2011 18:53:20 +0100
Subject: Added ability to remove networks on nova-manage command

---
 nova/db/api.py            | 7 +++++++
 nova/db/sqlalchemy/api.py | 7 +++++++
 2 files changed, 14 insertions(+)

(limited to 'nova')

diff --git a/nova/db/api.py b/nova/db/api.py
index 04f5fd72f..7ad99c1f4 100644
--- a/nova/db/api.py
+++ b/nova/db/api.py
@@ -488,6 +488,13 @@ def network_create_safe(context, values):
     """
     return IMPL.network_create_safe(context, values)
 
+def network_delete_safe(context, network_id):
+    """Delete network with key network_id
+     
+    This method assumes that the network is not associated with any project
+    """
+    return IMPL.network_delete_safe(context, network_id)
+
 
 def network_create_fixed_ips(context, network_id, num_vpn_clients):
     """Create the ips for the network, reserving sepecified ips."""
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index c8f42425d..90730d325 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -1042,6 +1042,13 @@ def network_create_safe(context, values):
     except IntegrityError:
         return None
 
+@require_admin_context
+def network_delete_safe(context, network_id):
+    session = get_session()
+    with session.begin():
+        network_ref = network_get(context, network_id=network_id, session=session)
+        session.delete(network_ref)        
+
 
 @require_admin_context
 def network_disassociate(context, network_id):
-- 
cgit 


From a74bf3381ada34f35c43d6f307fbae9abecfb255 Mon Sep 17 00:00:00 2001
From: Tushar Patil <tushar.vitthal.patil@gmail.com>
Date: Tue, 8 Mar 2011 10:30:48 -0800
Subject: abstracted network code in the base class for flat and vlan

---
 nova/network/manager.py         |   8 +-
 nova/tests/network/__init__.py  |  47 +++++++++
 nova/tests/network/base.py      | 154 ++++++++++++++++++++++++++++++
 nova/tests/test_flat_network.py | 147 ++++------------------------
 nova/tests/test_vlan_network.py | 205 ++++++++--------------------------------
 5 files changed, 259 insertions(+), 302 deletions(-)
 create mode 100644 nova/tests/network/__init__.py
 create mode 100644 nova/tests/network/base.py

(limited to 'nova')

diff --git a/nova/network/manager.py b/nova/network/manager.py
index 686ab9732..670ff55fd 100644
--- a/nova/network/manager.py
+++ b/nova/network/manager.py
@@ -404,9 +404,11 @@ class FlatManager(NetworkManager):
         net = {}
         net['injected'] = FLAGS.flat_injected
         net['dns'] = FLAGS.flat_network_dns
-        if(FLAGS.use_ipv6):
-            net['gateway_v6'] = \
-                             utils.get_my_linklocal(FLAGS.flat_network_bridge)
+        if not FLAGS.fake_network:
+            if(FLAGS.use_ipv6):
+                net['gateway_v6'] = \
+                                 utils.get_my_linklocal(
+                                         FLAGS.flat_network_bridge)
         self.db.network_update(context, network_id, net)
 
     def allocate_floating_ip(self, context, project_id):
diff --git a/nova/tests/network/__init__.py b/nova/tests/network/__init__.py
new file mode 100644
index 000000000..e51065983
--- /dev/null
+++ b/nova/tests/network/__init__.py
@@ -0,0 +1,47 @@
+import os
+
+from nova import context
+from nova import db
+from nova import flags
+from nova import log as logging
+from nova import utils
+
+FLAGS = flags.FLAGS
+LOG = logging.getLogger('nova.tests.network')
+
+
+def binpath(script):
+    """Returns the absolute path to a script in bin"""
+    return os.path.abspath(os.path.join(__file__, "../../../../bin", script))
+
+
+def lease_ip(private_ip):
+    """Run add command on dhcpbridge"""
+    network_ref = db.fixed_ip_get_network(context.get_admin_context(),
+                                          private_ip)
+    instance_ref = db.fixed_ip_get_instance(context.get_admin_context(),
+                                            private_ip)
+    cmd = "%s add %s %s fake" % (binpath('nova-dhcpbridge'),
+                                 instance_ref['mac_address'],
+                                 private_ip)
+    env = {'DNSMASQ_INTERFACE': network_ref['bridge'],
+           'TESTING': '1',
+           'FLAGFILE': FLAGS.dhcpbridge_flagfile}
+    (out, err) = utils.execute(cmd, addl_env=env)
+    LOG.debug("ISSUE_IP: %s, %s ", out, err)
+
+
+def release_ip(private_ip):
+    """Run del command on dhcpbridge"""
+    network_ref = db.fixed_ip_get_network(context.get_admin_context(),
+                                          private_ip)
+    instance_ref = db.fixed_ip_get_instance(context.get_admin_context(),
+                                            private_ip)
+    cmd = "%s del %s %s fake" % (binpath('nova-dhcpbridge'),
+                                 instance_ref['mac_address'],
+                                 private_ip)
+    env = {'DNSMASQ_INTERFACE': network_ref['bridge'],
+           'TESTING': '1',
+           'FLAGFILE': FLAGS.dhcpbridge_flagfile}
+    (out, err) = utils.execute(cmd, addl_env=env)
+    LOG.debug("RELEASE_IP: %s, %s ", out, err)
diff --git a/nova/tests/network/base.py b/nova/tests/network/base.py
new file mode 100644
index 000000000..2dd8178ff
--- /dev/null
+++ b/nova/tests/network/base.py
@@ -0,0 +1,154 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# 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.
+"""
+Base class of Unit Tests for all network models
+"""
+import IPy
+import os
+
+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 test
+from nova import utils
+from nova.auth import manager
+
+FLAGS = flags.FLAGS
+LOG = logging.getLogger('nova.tests.network')
+
+
+class NetworkTestCase(test.TestCase):
+    """Test cases for network code"""
+    def setUp(self):
+        super(NetworkTestCase, self).setUp()
+        # NOTE(vish): if you change these flags, make sure to change the
+        #             flags in the corresponding section in nova-dhcpbridge
+        self.flags(connection_type='fake',
+                   fake_call=True,
+                   fake_network=True)
+        self.manager = manager.AuthManager()
+        self.user = self.manager.create_user('netuser', 'netuser', 'netuser')
+        self.projects = []
+        self.network = utils.import_object(FLAGS.network_manager)
+        self.context = context.RequestContext(project=None, user=self.user)
+        for i in range(FLAGS.num_networks):
+            name = 'project%s' % i
+            project = self.manager.create_project(name, 'netuser', name)
+            self.projects.append(project)
+            # create the necessary network data for the project
+            user_context = context.RequestContext(project=self.projects[i],
+                                                     user=self.user)
+            host = self.network.get_network_host(user_context.elevated())
+        instance_ref = self._create_instance(0)
+        self.instance_id = instance_ref['id']
+        instance_ref = self._create_instance(1)
+        self.instance2_id = instance_ref['id']
+
+    def tearDown(self):
+        # TODO(termie): this should really be instantiating clean datastores
+        #               in between runs, one failure kills all the tests
+        db.instance_destroy(context.get_admin_context(), self.instance_id)
+        db.instance_destroy(context.get_admin_context(), self.instance2_id)
+        for project in self.projects:
+            self.manager.delete_project(project)
+        self.manager.delete_user(self.user)
+        super(NetworkTestCase, self).tearDown()
+
+    def _create_instance(self, project_num, mac=None):
+        if not mac:
+            mac = utils.generate_mac()
+        project = self.projects[project_num]
+        self.context._project = project
+        self.context.project_id = project.id
+        return db.instance_create(self.context,
+                                  {'project_id': project.id,
+                                   'mac_address': mac})
+
+    def _create_address(self, project_num, instance_id=None):
+        """Create an address in given project num"""
+        if instance_id is None:
+            instance_id = self.instance_id
+        self.context._project = self.projects[project_num]
+        self.context.project_id = self.projects[project_num].id
+        return self.network.allocate_fixed_ip(self.context, instance_id)
+
+    def _deallocate_address(self, project_num, address):
+        self.context._project = self.projects[project_num]
+        self.context.project_id = self.projects[project_num].id
+        self.network.deallocate_fixed_ip(self.context, address)
+
+    def _is_allocated_in_project(self, address, project_id):
+        """Returns true if address is in specified project"""
+        project_net = db.network_get_by_bridge(context.get_admin_context(),
+                                           FLAGS.flat_network_bridge)
+        network = db.fixed_ip_get_network(context.get_admin_context(),
+                                          address)
+        instance = db.fixed_ip_get_instance(context.get_admin_context(),
+                                            address)
+        # instance exists until release
+        return instance is not None and network['id'] == project_net['id']
+
+    def test_private_ipv6(self):
+        """Make sure ipv6 is OK"""
+        if FLAGS.use_ipv6:
+            instance_ref = self._create_instance(0)
+            address = self._create_address(0, instance_ref['id'])
+            network_ref = db.project_get_network(
+                                                 context.get_admin_context(),
+                                                 self.context.project_id)
+            address_v6 = db.instance_get_fixed_address_v6(
+                                                 context.get_admin_context(),
+                                                 instance_ref['id'])
+            self.assertEqual(instance_ref['mac_address'],
+                             utils.to_mac(address_v6))
+            instance_ref2 = db.fixed_ip_get_instance_v6(
+                                                 context.get_admin_context(),
+                                                 address_v6)
+            self.assertEqual(instance_ref['id'], instance_ref2['id'])
+            self.assertEqual(address_v6,
+                             utils.to_global_ipv6(
+                                                 network_ref['cidr_v6'],
+                                                 instance_ref['mac_address']))
+            self._deallocate_address(0, address)
+            db.instance_destroy(context.get_admin_context(),
+                                instance_ref['id'])
+
+    def test_available_ips(self):
+        """Make sure the number of available ips for the network is correct
+
+        The number of available IP addresses depends on the test
+        environment's setup.
+
+        Network size is set in test fixture's setUp method.
+
+        There are ips reserved at the bottom and top of the range.
+        services (network, gateway, CloudPipe, broadcast)
+        """
+        network = db.project_get_network(context.get_admin_context(),
+                                         self.projects[0].id)
+        net_size = flags.FLAGS.network_size
+        admin_context = context.get_admin_context()
+        total_ips = (db.network_count_available_ips(admin_context,
+                                                    network['id']) +
+                     db.network_count_reserved_ips(admin_context,
+                                                   network['id']) +
+                     db.network_count_allocated_ips(admin_context,
+                                                    network['id']))
+        self.assertEqual(total_ips, net_size)
diff --git a/nova/tests/test_flat_network.py b/nova/tests/test_flat_network.py
index 91a49920d..a9a934158 100644
--- a/nova/tests/test_flat_network.py
+++ b/nova/tests/test_flat_network.py
@@ -30,96 +30,15 @@ from nova import log as logging
 from nova import test
 from nova import utils
 from nova.auth import manager
+from nova.tests.network import base
+
 
 FLAGS = flags.FLAGS
 LOG = logging.getLogger('nova.tests.network')
 
 
-class FlatNetworkTestCase(test.TestCase):
+class FlatNetworkTestCase(base.NetworkTestCase):
     """Test cases for network code"""
-    def setUp(self):
-        super(FlatNetworkTestCase, self).setUp()
-        # NOTE(vish): if you change these flags, make sure to change the
-        #             flags in the corresponding section in nova-dhcpbridge
-        self.flags(connection_type='fake',
-                   fake_call=True,
-                   fake_network=True)
-        self.manager = manager.AuthManager()
-        self.user = self.manager.create_user('netuser', 'netuser', 'netuser')
-        self.projects = []
-        self.network = utils.import_object(FLAGS.network_manager)
-        self.context = context.RequestContext(project=None, user=self.user)
-        for i in range(5):
-            name = 'project%s' % i
-            project = self.manager.create_project(name, 'netuser', name)
-            self.projects.append(project)
-            # create the necessary network data for the project
-            user_context = context.RequestContext(project=self.projects[i],
-                                                     user=self.user)
-            host = self.network.get_network_host(user_context.elevated())
-        instance_ref = self._create_instance(0)
-        self.instance_id = instance_ref['id']
-        instance_ref = self._create_instance(1)
-        self.instance2_id = instance_ref['id']
-
-    def tearDown(self):
-        # TODO(termie): this should really be instantiating clean datastores
-        #               in between runs, one failure kills all the tests
-        db.instance_destroy(context.get_admin_context(), self.instance_id)
-        db.instance_destroy(context.get_admin_context(), self.instance2_id)
-        for project in self.projects:
-            self.manager.delete_project(project)
-        self.manager.delete_user(self.user)
-        super(FlatNetworkTestCase, self).tearDown()
-
-    def _create_instance(self, project_num, mac=None):
-        if not mac:
-            mac = utils.generate_mac()
-        project = self.projects[project_num]
-        self.context._project = project
-        self.context.project_id = project.id
-        return db.instance_create(self.context,
-                                  {'project_id': project.id,
-                                   'mac_address': mac})
-
-    def _create_address(self, project_num, instance_id=None):
-        """Create an address in given project num"""
-        if instance_id is None:
-            instance_id = self.instance_id
-        self.context._project = self.projects[project_num]
-        self.context.project_id = self.projects[project_num].id
-        return self.network.allocate_fixed_ip(self.context, instance_id)
-
-    def _deallocate_address(self, project_num, address):
-        self.context._project = self.projects[project_num]
-        self.context.project_id = self.projects[project_num].id
-        self.network.deallocate_fixed_ip(self.context, address)
-
-    def test_private_ipv6(self):
-        """Make sure ipv6 is OK"""
-        if FLAGS.use_ipv6:
-            instance_ref = self._create_instance(0)
-            address = self._create_address(0, instance_ref['id'])
-            network_ref = db.project_get_network(
-                                                 context.get_admin_context(),
-                                                 self.context.project_id)
-            address_v6 = db.instance_get_fixed_address_v6(
-                                                 context.get_admin_context(),
-                                                 instance_ref['id'])
-            self.assertEqual(instance_ref['mac_address'],
-                             utils.to_mac(address_v6))
-            instance_ref2 = db.fixed_ip_get_instance_v6(
-                                                 context.get_admin_context(),
-                                                 address_v6)
-            self.assertEqual(instance_ref['id'], instance_ref2['id'])
-            self.assertEqual(address_v6,
-                             utils.to_global_ipv6(
-                                                 network_ref['cidr_v6'],
-                                                 instance_ref['mac_address']))
-            self._deallocate_address(0, address)
-            db.instance_destroy(context.get_admin_context(),
-                                instance_ref['id'])
-
     def test_public_network_association(self):
         """Makes sure that we can allocate a public ip"""
         # TODO(vish): better way of adding floating ips
@@ -167,28 +86,34 @@ class FlatNetworkTestCase(test.TestCase):
     def test_allocate_deallocate_fixed_ip(self):
         """Makes sure that we can allocate and deallocate a fixed ip"""
         address = self._create_address(0)
-        self.assertTrue(is_allocated_in_project(address, self.projects[0].id))
+        self.assertTrue(self._is_allocated_in_project(address,
+                                                      self.projects[0].id))
         self._deallocate_address(0, address)
 
         # check if the fixed ip address is really deallocated
-        self.assertFalse(is_allocated_in_project(address, self.projects[0].id))
+        self.assertFalse(self._is_allocated_in_project(address,
+                                                       self.projects[0].id))
 
     def test_side_effects(self):
         """Ensures allocating and releasing has no side effects"""
         address = self._create_address(0)
         address2 = self._create_address(1, self.instance2_id)
 
-        self.assertTrue(is_allocated_in_project(address, self.projects[0].id))
-        self.assertTrue(is_allocated_in_project(address2, self.projects[1].id))
+        self.assertTrue(self._is_allocated_in_project(address,
+                                                      self.projects[0].id))
+        self.assertTrue(self._is_allocated_in_project(address2,
+                                                      self.projects[1].id))
 
         self._deallocate_address(0, address)
-        self.assertFalse(is_allocated_in_project(address, self.projects[0].id))
+        self.assertFalse(self._is_allocated_in_project(address,
+                                                       self.projects[0].id))
 
         # First address release shouldn't affect the second
-        self.assertTrue(is_allocated_in_project(address2, self.projects[0].id))
+        self.assertTrue(self._is_allocated_in_project(address2,
+                                                      self.projects[0].id))
 
         self._deallocate_address(1, address2)
-        self.assertFalse(is_allocated_in_project(address2,
+        self.assertFalse(self._is_allocated_in_project(address2,
                                                  self.projects[1].id))
 
     def test_ips_are_reused(self):
@@ -201,29 +126,6 @@ class FlatNetworkTestCase(test.TestCase):
 
         self.network.deallocate_fixed_ip(self.context, address2)
 
-    def test_available_ips(self):
-        """Make sure the number of available ips for the network is correct
-
-        The number of available IP addresses depends on the test
-        environment's setup.
-
-        Network size is set in test fixture's setUp method.
-
-        There are ips reserved at the bottom and top of the range.
-        services (network, gateway, CloudPipe, broadcast)
-        """
-        network = db.project_get_network(context.get_admin_context(),
-                                         self.projects[0].id)
-        net_size = flags.FLAGS.network_size
-        admin_context = context.get_admin_context()
-        total_ips = (db.network_count_available_ips(admin_context,
-                                                    network['id']) +
-                     db.network_count_reserved_ips(admin_context,
-                                                   network['id']) +
-                     db.network_count_allocated_ips(admin_context,
-                                                    network['id']))
-        self.assertEqual(total_ips, net_size)
-
     def test_too_many_addresses(self):
         """Test for a NoMoreAddresses exception when all fixed ips are used.
         """
@@ -257,20 +159,3 @@ class FlatNetworkTestCase(test.TestCase):
     def run(self, result=None):
         if(FLAGS.network_manager == 'nova.network.manager.FlatManager'):
             super(FlatNetworkTestCase, self).run(result)
-
-
-def is_allocated_in_project(address, project_id):
-    """Returns true if address is in specified project"""
-    #project_net = db.project_get_network(context.get_admin_context(),
-    #                                     project_id)
-    project_net = db.network_get_by_bridge(context.get_admin_context(),
-                                           FLAGS.flat_network_bridge)
-    network = db.fixed_ip_get_network(context.get_admin_context(), address)
-    instance = db.fixed_ip_get_instance(context.get_admin_context(), address)
-    # instance exists until release
-    return instance is not None and network['id'] == project_net['id']
-
-
-def binpath(script):
-    """Returns the absolute path to a script in bin"""
-    return os.path.abspath(os.path.join(__file__, "../../../bin", script))
diff --git a/nova/tests/test_vlan_network.py b/nova/tests/test_vlan_network.py
index be39313bb..f3478320b 100644
--- a/nova/tests/test_vlan_network.py
+++ b/nova/tests/test_vlan_network.py
@@ -29,100 +29,16 @@ from nova import log as logging
 from nova import test
 from nova import utils
 from nova.auth import manager
+from nova.tests.network import base
+from nova.tests.network import binpath,\
+    lease_ip, release_ip
 
 FLAGS = flags.FLAGS
 LOG = logging.getLogger('nova.tests.network')
 
 
-class VlanNetworkTestCase(test.TestCase):
+class VlanNetworkTestCase(base.NetworkTestCase):
     """Test cases for network code"""
-    def setUp(self):
-        super(VlanNetworkTestCase, self).setUp()
-        # NOTE(vish): if you change these flags, make sure to change the
-        #             flags in the corresponding section in nova-dhcpbridge
-        self.flags(connection_type='fake',
-                   fake_call=True,
-                   fake_network=True)
-        self.manager = manager.AuthManager()
-        self.user = self.manager.create_user('netuser', 'netuser', 'netuser')
-        self.projects = []
-        self.network = utils.import_object(FLAGS.network_manager)
-        self.context = context.RequestContext(project=None, user=self.user)
-        for i in range(FLAGS.num_networks):
-            name = 'project%s' % i
-            project = self.manager.create_project(name, 'netuser', name)
-            self.projects.append(project)
-            # create the necessary network data for the project
-            user_context = context.RequestContext(project=self.projects[i],
-                                                     user=self.user)
-            host = self.network.get_network_host(user_context.elevated())
-        instance_ref = self._create_instance(0)
-        self.instance_id = instance_ref['id']
-        instance_ref = self._create_instance(1)
-        self.instance2_id = instance_ref['id']
-
-    def tearDown(self):
-        # TODO(termie): this should really be instantiating clean datastores
-        #               in between runs, one failure kills all the tests
-        db.instance_destroy(context.get_admin_context(), self.instance_id)
-        db.instance_destroy(context.get_admin_context(), self.instance2_id)
-        for project in self.projects:
-            self.manager.delete_project(project)
-        self.manager.delete_user(self.user)
-        super(VlanNetworkTestCase, self).tearDown()
-
-    def run(self, result=None):
-        if(FLAGS.network_manager == 'nova.network.manager.VlanManager'):
-            super(VlanNetworkTestCase, self).run(result)
-
-    def _create_instance(self, project_num, mac=None):
-        if not mac:
-            mac = utils.generate_mac()
-        project = self.projects[project_num]
-        self.context._project = project
-        self.context.project_id = project.id
-        return db.instance_create(self.context,
-                                  {'project_id': project.id,
-                                   'mac_address': mac})
-
-    def _create_address(self, project_num, instance_id=None):
-        """Create an address in given project num"""
-        if instance_id is None:
-            instance_id = self.instance_id
-        self.context._project = self.projects[project_num]
-        self.context.project_id = self.projects[project_num].id
-        return self.network.allocate_fixed_ip(self.context, instance_id)
-
-    def _deallocate_address(self, project_num, address):
-        self.context._project = self.projects[project_num]
-        self.context.project_id = self.projects[project_num].id
-        self.network.deallocate_fixed_ip(self.context, address)
-
-    def test_private_ipv6(self):
-        """Make sure ipv6 is OK"""
-        if FLAGS.use_ipv6:
-            instance_ref = self._create_instance(0)
-            address = self._create_address(0, instance_ref['id'])
-            network_ref = db.project_get_network(
-                                                 context.get_admin_context(),
-                                                 self.context.project_id)
-            address_v6 = db.instance_get_fixed_address_v6(
-                                                 context.get_admin_context(),
-                                                 instance_ref['id'])
-            self.assertEqual(instance_ref['mac_address'],
-                             utils.to_mac(address_v6))
-            instance_ref2 = db.fixed_ip_get_instance_v6(
-                                                 context.get_admin_context(),
-                                                 address_v6)
-            self.assertEqual(instance_ref['id'], instance_ref2['id'])
-            self.assertEqual(address_v6,
-                             utils.to_global_ipv6(
-                                                 network_ref['cidr_v6'],
-                                                 instance_ref['mac_address']))
-            self._deallocate_address(0, address)
-            db.instance_destroy(context.get_admin_context(),
-                                instance_ref['id'])
-
     def test_public_network_association(self):
         """Makes sure that we can allocaate a public ip"""
         # TODO(vish): better way of adding floating ips
@@ -157,24 +73,30 @@ class VlanNetworkTestCase(test.TestCase):
     def test_allocate_deallocate_fixed_ip(self):
         """Makes sure that we can allocate and deallocate a fixed ip"""
         address = self._create_address(0)
-        self.assertTrue(is_allocated_in_project(address, self.projects[0].id))
+        self.assertTrue(self._is_allocated_in_project(address,
+                                                      self.projects[0].id))
         lease_ip(address)
         self._deallocate_address(0, address)
 
         # Doesn't go away until it's dhcp released
-        self.assertTrue(is_allocated_in_project(address, self.projects[0].id))
+        self.assertTrue(self._is_allocated_in_project(address,
+                                                      self.projects[0].id))
 
         release_ip(address)
-        self.assertFalse(is_allocated_in_project(address, self.projects[0].id))
+        self.assertFalse(self._is_allocated_in_project(address,
+                                                       self.projects[0].id))
 
     def test_side_effects(self):
         """Ensures allocating and releasing has no side effects"""
         address = self._create_address(0)
         address2 = self._create_address(1, self.instance2_id)
 
-        self.assertTrue(is_allocated_in_project(address, self.projects[0].id))
-        self.assertTrue(is_allocated_in_project(address2, self.projects[1].id))
-        self.assertFalse(is_allocated_in_project(address, self.projects[1].id))
+        self.assertTrue(self._is_allocated_in_project(address,
+                                                      self.projects[0].id))
+        self.assertTrue(self._is_allocated_in_project(address2,
+                                                      self.projects[1].id))
+        self.assertFalse(self._is_allocated_in_project(address,
+                                                       self.projects[1].id))
 
         # Addresses are allocated before they're issued
         lease_ip(address)
@@ -182,14 +104,16 @@ class VlanNetworkTestCase(test.TestCase):
 
         self._deallocate_address(0, address)
         release_ip(address)
-        self.assertFalse(is_allocated_in_project(address, self.projects[0].id))
+        self.assertFalse(self._is_allocated_in_project(address,
+                                                       self.projects[0].id))
 
         # First address release shouldn't affect the second
-        self.assertTrue(is_allocated_in_project(address2, self.projects[1].id))
+        self.assertTrue(self._is_allocated_in_project(address2,
+                                                      self.projects[1].id))
 
         self._deallocate_address(1, address2)
         release_ip(address2)
-        self.assertFalse(is_allocated_in_project(address2,
+        self.assertFalse(self._is_allocated_in_project(address2,
                                                  self.projects[1].id))
 
     def test_subnet_edge(self):
@@ -212,11 +136,11 @@ class VlanNetworkTestCase(test.TestCase):
             lease_ip(address3)
             self.context._project = self.projects[i]
             self.context.project_id = self.projects[i].id
-            self.assertFalse(is_allocated_in_project(address,
+            self.assertFalse(self._is_allocated_in_project(address,
                                                      self.projects[0].id))
-            self.assertFalse(is_allocated_in_project(address2,
+            self.assertFalse(self._is_allocated_in_project(address2,
                                                      self.projects[0].id))
-            self.assertFalse(is_allocated_in_project(address3,
+            self.assertFalse(self._is_allocated_in_project(address3,
                                                      self.projects[0].id))
             self.network.deallocate_fixed_ip(self.context, address)
             self.network.deallocate_fixed_ip(self.context, address2)
@@ -270,29 +194,6 @@ class VlanNetworkTestCase(test.TestCase):
         self.network.deallocate_fixed_ip(self.context, address2)
         release_ip(address)
 
-    def test_available_ips(self):
-        """Make sure the number of available ips for the network is correct
-
-        The number of available IP addresses depends on the test
-        environment's setup.
-
-        Network size is set in test fixture's setUp method.
-
-        There are ips reserved at the bottom and top of the range.
-        services (network, gateway, CloudPipe, broadcast)
-        """
-        network = db.project_get_network(context.get_admin_context(),
-                                         self.projects[0].id)
-        net_size = flags.FLAGS.network_size
-        admin_context = context.get_admin_context()
-        total_ips = (db.network_count_available_ips(admin_context,
-                                                    network['id']) +
-                     db.network_count_reserved_ips(admin_context,
-                                                   network['id']) +
-                     db.network_count_allocated_ips(admin_context,
-                                                    network['id']))
-        self.assertEqual(total_ips, net_size)
-
     def test_too_many_addresses(self):
         """Test for a NoMoreAddresses exception when all fixed ips are used.
         """
@@ -325,49 +226,17 @@ class VlanNetworkTestCase(test.TestCase):
                                                   network['id'])
         self.assertEqual(ip_count, num_available_ips)
 
+    def _is_allocated_in_project(self, address, project_id):
+        """Returns true if address is in specified project"""
+        project_net = db.project_get_network(context.get_admin_context(),
+                                             project_id)
+        network = db.fixed_ip_get_network(context.get_admin_context(),
+                                          address)
+        instance = db.fixed_ip_get_instance(context.get_admin_context(),
+                                            address)
+        # instance exists until release
+        return instance is not None and network['id'] == project_net['id']
 
-def is_allocated_in_project(address, project_id):
-    """Returns true if address is in specified project"""
-    project_net = db.project_get_network(context.get_admin_context(),
-                                         project_id)
-    network = db.fixed_ip_get_network(context.get_admin_context(), address)
-    instance = db.fixed_ip_get_instance(context.get_admin_context(), address)
-    # instance exists until release
-    return instance is not None and network['id'] == project_net['id']
-
-
-def binpath(script):
-    """Returns the absolute path to a script in bin"""
-    return os.path.abspath(os.path.join(__file__, "../../../bin", script))
-
-
-def lease_ip(private_ip):
-    """Run add command on dhcpbridge"""
-    network_ref = db.fixed_ip_get_network(context.get_admin_context(),
-                                          private_ip)
-    instance_ref = db.fixed_ip_get_instance(context.get_admin_context(),
-                                            private_ip)
-    cmd = "%s add %s %s fake" % (binpath('nova-dhcpbridge'),
-                                 instance_ref['mac_address'],
-                                 private_ip)
-    env = {'DNSMASQ_INTERFACE': network_ref['bridge'],
-           'TESTING': '1',
-           'FLAGFILE': FLAGS.dhcpbridge_flagfile}
-    (out, err) = utils.execute(cmd, addl_env=env)
-    LOG.debug("ISSUE_IP: %s, %s ", out, err)
-
-
-def release_ip(private_ip):
-    """Run del command on dhcpbridge"""
-    network_ref = db.fixed_ip_get_network(context.get_admin_context(),
-                                          private_ip)
-    instance_ref = db.fixed_ip_get_instance(context.get_admin_context(),
-                                            private_ip)
-    cmd = "%s del %s %s fake" % (binpath('nova-dhcpbridge'),
-                                 instance_ref['mac_address'],
-                                 private_ip)
-    env = {'DNSMASQ_INTERFACE': network_ref['bridge'],
-           'TESTING': '1',
-           'FLAGFILE': FLAGS.dhcpbridge_flagfile}
-    (out, err) = utils.execute(cmd, addl_env=env)
-    LOG.debug("RELEASE_IP: %s, %s ", out, err)
+    def run(self, result=None):
+        if(FLAGS.network_manager == 'nova.network.manager.VlanManager'):
+            super(VlanNetworkTestCase, self).run(result)
-- 
cgit 


From 1caceddf431a1ad1ef22235c2206bccf39fde5c5 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
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')

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 23d3be4b6f28359211e29212867157daeac9e142 Mon Sep 17 00:00:00 2001
From: Vishvananda Ishaya <vishvananda@gmail.com>
Date: Tue, 8 Mar 2011 20:25:05 +0000
Subject: update code to work with new container and disk formats from glance

---
 nova/api/ec2/cloud.py | 9 ++++++---
 nova/image/s3.py      | 7 ++++++-
 2 files changed, 12 insertions(+), 4 deletions(-)

(limited to 'nova')

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 6479c9445..6b79f7f53 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -867,7 +867,8 @@ class CloudController(object):
     def _format_image(self, image):
         """Convert from format defined by BaseImageService to S3 format."""
         i = {}
-        ec2_id = self._image_ec2_id(image.get('id'), image.get('type'))
+        image_type = image['properties'].get('type')
+        ec2_id = self._image_ec2_id(image.get('id'), image_type)
         name = image.get('name')
         if name:
             i['imageId'] = "%s (%s)" % (ec2_id, name)
@@ -882,7 +883,7 @@ class CloudController(object):
         i['imageOwnerId'] = image['properties'].get('owner_id')
         i['imageLocation'] = image['properties'].get('image_location')
         i['imageState'] = image['properties'].get('image_state')
-        i['type'] = image.get('type')
+        i['type'] = image_type
         i['isPublic'] = str(image['properties'].get('is_public', '')) == 'True'
         i['architecture'] = image['properties'].get('architecture')
         return i
@@ -915,7 +916,8 @@ class CloudController(object):
             image_location = kwargs['name']
         metadata = {'properties': {'image_location': image_location}}
         image = self.image_service.create(context, metadata)
-        image_id = self._image_ec2_id(image['id'], image['type'])
+        image_id = self._image_ec2_id(image['id'],
+                                      image['properties']['type'])
         msg = _("Registered image %(image_location)s with"
                 " id %(image_id)s") % locals()
         LOG.audit(msg, context=context)
@@ -954,6 +956,7 @@ class CloudController(object):
             raise exception.NotFound(_('Image %s not found') % image_id)
         internal_id = image['id']
         del(image['id'])
+        raise Exception(image)
         image['properties']['is_public'] = (operation_type == 'add')
         return self.image_service.update(context, internal_id, image)
 
diff --git a/nova/image/s3.py b/nova/image/s3.py
index ab6eea8cf..bf104c29a 100644
--- a/nova/image/s3.py
+++ b/nova/image/s3.py
@@ -139,11 +139,13 @@ class S3ImageService(service.BaseImageService):
         manifest = key.get_contents_as_string()
 
         manifest = ElementTree.fromstring(manifest)
+        image_format = 'ami'
         image_type = 'machine'
 
         try:
             kernel_id = manifest.find("machine_configuration/kernel_id").text
             if kernel_id == 'true':
+                image_format = 'aki'
                 image_type = 'kernel'
                 kernel_id = None
         except:
@@ -152,6 +154,7 @@ class S3ImageService(service.BaseImageService):
         try:
             ramdisk_id = manifest.find("machine_configuration/ramdisk_id").text
             if ramdisk_id == 'true':
+                image_format = 'ari'
                 image_type = 'ramdisk'
                 ramdisk_id = None
         except:
@@ -173,7 +176,9 @@ class S3ImageService(service.BaseImageService):
             properties['ramdisk_id'] = ec2utils.ec2_id_to_id(ramdisk_id)
 
         properties['is_public'] = False
-        metadata.update({'type': image_type,
+        properties['type'] = image_type
+        metadata.update({'disk_format': image_format,
+                         'container_format': image_format,
                          'status': 'queued',
                          'is_public': True,
                          'properties': properties})
-- 
cgit 


From dd2f0019297d01fe5d6b3dae4efc72946191be75 Mon Sep 17 00:00:00 2001
From: Rick Harris <rick.harris@rackspace.com>
Date: Tue, 8 Mar 2011 22:14:25 +0000
Subject: Use disk_format and container_format instead of image type

---
 nova/api/openstack/servers.py |  2 +-
 nova/virt/xenapi/vm_utils.py  | 18 ++++++++++--------
 2 files changed, 11 insertions(+), 9 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index c2bf42b72..85999764f 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -450,7 +450,7 @@ class Controller(wsgi.Controller):
                 _("Cannot build from image %(image_id)s, status not active") %
                   locals())
 
-        if image['type'] != 'machine':
+        if image['disk_format'] != 'ami':
             return None, None
 
         try:
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 7a6833c883a04fd7920bff7367c9e28a35858d8d Mon Sep 17 00:00:00 2001
From: "matt.dietz@rackspace.com" <>
Date: Tue, 8 Mar 2011 23:17:50 +0000
Subject: Accidentally left some bad data around

---
 nova/tests/test_xenapi.py | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'nova')

diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index 919a38c06..916555af3 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -376,6 +376,11 @@ class XenAPIMigrateInstance(test.TestCase):
         stubs.stub_out_migration_methods(self.stubs)
         glance_stubs.stubout_glance_client(self.stubs,
                                            glance_stubs.FakeGlance)
+    def tearDown(self):
+        super(XenAPIMigrateInstance, self).tearDown()
+        self.manager.delete_project(self.project)
+        self.manager.delete_user(self.user)
+        self.stubs.UnsetAll()
 
     def test_migrate_disk_and_power_off(self):
         instance = db.instance_create(self.values)
-- 
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/tests/test_xenapi.py  | 2 ++
 nova/tests/xenapi/stubs.py | 1 +
 nova/virt/xenapi/vmops.py  | 2 +-
 3 files changed, 4 insertions(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index 916555af3..c26dc8639 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -376,6 +376,7 @@ class XenAPIMigrateInstance(test.TestCase):
         stubs.stub_out_migration_methods(self.stubs)
         glance_stubs.stubout_glance_client(self.stubs,
                                            glance_stubs.FakeGlance)
+
     def tearDown(self):
         super(XenAPIMigrateInstance, self).tearDown()
         self.manager.delete_project(self.project)
@@ -394,6 +395,7 @@ class XenAPIMigrateInstance(test.TestCase):
         conn = xenapi_conn.get_connection(False)
         conn.finish_resize(instance, dict(base_copy='hurr', cow='durr'))
 
+
 class XenAPIDetermineDiskImageTestCase(test.TestCase):
     """
     Unit tests for code that detects the ImageType
diff --git a/nova/tests/xenapi/stubs.py b/nova/tests/xenapi/stubs.py
index d8e358611..70d46a1fb 100644
--- a/nova/tests/xenapi/stubs.py
+++ b/nova/tests/xenapi/stubs.py
@@ -237,6 +237,7 @@ class FakeSessionForMigrationTests(fake.SessionBase):
         vm['is_a_template'] = False
         vm['is_control_domain'] = False
 
+
 def stub_out_migration_methods(stubs):
     def fake_get_snapshot(self, instance):
         return 'foo', 'bar'
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 6207abe3068964c586d06bb0e3740b8bad922dca Mon Sep 17 00:00:00 2001
From: Rick Harris <rick.harris@rackspace.com>
Date: Tue, 8 Mar 2011 23:26:33 +0000
Subject: Fixing tests

---
 nova/tests/glance/stubs.py | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/glance/stubs.py b/nova/tests/glance/stubs.py
index 3ff8d7ce5..5872552ec 100644
--- a/nova/tests/glance/stubs.py
+++ b/nova/tests/glance/stubs.py
@@ -35,23 +35,28 @@ class FakeGlance(object):
     IMAGE_FIXTURES = {
         IMAGE_MACHINE: {
             'image_meta': {'name': 'fakemachine', 'size': 0,
-                           'type': 'machine'},
+                           'disk_format': 'ami',
+                           'container_format': 'ami'},
             'image_data': StringIO.StringIO('')},
         IMAGE_KERNEL: {
             'image_meta': {'name': 'fakekernel', 'size': 0,
-                           'type': 'kernel'},
+                           'disk_format': 'aki',
+                           'container_format': 'aki'},
             'image_data': StringIO.StringIO('')},
         IMAGE_RAMDISK: {
             'image_meta': {'name': 'fakeramdisk', 'size': 0,
-                           'type': 'ramdisk'},
+                           'disk_format': 'ari',
+                           'container_format': 'ari'},
             'image_data': StringIO.StringIO('')},
         IMAGE_RAW: {
             'image_meta': {'name': 'fakeraw', 'size': 0,
-                           'type': 'raw'},
+                           'disk_format': 'raw',
+                           'container_format': 'bare'},
             'image_data': StringIO.StringIO('')},
         IMAGE_VHD: {
             'image_meta': {'name': 'fakevhd', 'size': 0,
-                           'type': 'vhd'},
+                           'disk_format': 'vhd',
+                           'container_format': 'ovf'},
             'image_data': StringIO.StringIO('')}}
 
     def __init__(self, host, port=None, use_ssl=False):
-- 
cgit 


From e7626da8ade4a3d29d441fed1c21c50cbc9928de Mon Sep 17 00:00:00 2001
From: Salvatore Orlando <salvatore.orlando@eu.citrix.com>
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')

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 e8c8fd3f232371625f0924410c4c09c32339b113 Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Tue, 8 Mar 2011 16:47:43 -0800
Subject: Renamed FLAG.paste_config -> FLAG.api_paste_config

---
 nova/service.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'nova')

diff --git a/nova/service.py b/nova/service.py
index 5a8d58695..460f36f7a 100644
--- a/nova/service.py
+++ b/nova/service.py
@@ -56,7 +56,7 @@ flags.DEFINE_integer('ec2_listen_port', 8773, 'port for ec2 api to listen')
 flags.DEFINE_string('osapi_listen', "0.0.0.0",
                     'IP address for OpenStack API to listen')
 flags.DEFINE_integer('osapi_listen_port', 8774, 'port for os api to listen')
-flags.DEFINE_string('paste_config', "api-paste.ini",
+flags.DEFINE_string('api_paste_config', "api-paste.ini",
                     'File name for the paste.deploy config for nova-api')
 
 
@@ -240,10 +240,10 @@ class ApiService(WsgiService):
     @classmethod
     def create(cls, conf=None):
         if not conf:
-            conf = wsgi.paste_config_file(FLAGS.paste_config)
+            conf = wsgi.paste_config_file(FLAGS.api_paste_config)
             if not conf:
                 message = (_("No paste configuration found for: %s"),
-                       FLAGS.paste_config)
+                           FLAGS.api_paste_config)
                 raise exception.Error(message)
         api_endpoints = ['ec2', 'osapi']
         service = cls(conf, api_endpoints)
@@ -315,7 +315,7 @@ def _run_wsgi(paste_config_file, apis):
                      getattr(FLAGS, "%s_listen" % api)))
     if len(apps) == 0:
         logging.error(_("No known API applications configured in %s."),
-                  paste_config_file)
+                      paste_config_file)
         return
 
     server = wsgi.Server()
-- 
cgit 


From e4b176d41cca234082c28ba6d9188745f1d2b98a Mon Sep 17 00:00:00 2001
From: Cory Wright <cory.wright@rackspace.com>
Date: Wed, 9 Mar 2011 00:49:56 +0000
Subject: a few fixes for the tests

---
 .../versions/009_add_os_type_to_instances.py       | 53 ----------------------
 .../versions/010_add_os_type_to_instances.py       | 53 ++++++++++++++++++++++
 nova/tests/test_xenapi.py                          |  1 +
 nova/virt/xenapi/vmops.py                          |  2 +-
 4 files changed, 55 insertions(+), 54 deletions(-)
 delete mode 100644 nova/db/sqlalchemy/migrate_repo/versions/009_add_os_type_to_instances.py
 create mode 100644 nova/db/sqlalchemy/migrate_repo/versions/010_add_os_type_to_instances.py

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/migrate_repo/versions/009_add_os_type_to_instances.py b/nova/db/sqlalchemy/migrate_repo/versions/009_add_os_type_to_instances.py
deleted file mode 100644
index 514b92b81..000000000
--- a/nova/db/sqlalchemy/migrate_repo/versions/009_add_os_type_to_instances.py
+++ /dev/null
@@ -1,53 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 United States Government as represented by the
-# Administrator of the National Aeronautics and Space Administration.
-# 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.
-
-from sqlalchemy import *
-from sqlalchemy.sql import text
-from migrate import *
-
-from nova import log as logging
-
-
-meta = MetaData()
-
-instances = Table('instances', meta,
-        Column('id', Integer(),  primary_key=True, nullable=False),
-        )
-
-instances_os_type = Column('os_type',
-                           String(length=255, convert_unicode=False,
-                                  assert_unicode=None, unicode_error=None,
-                                  _warn_on_bytestring=False),
-                           nullable=True)
-
-
-def upgrade(migrate_engine):
-    # Upgrade operations go here. Don't create your own engine;
-    # bind migrate_engine to your metadata
-    meta.bind = migrate_engine
-
-    instances.create_column(instances_os_type)
-    migrate_engine.execute(instances.update()\
-                           .where(instances.c.os_type == None)\
-                           .values(os_type='linux'))
-
-
-def downgrade(migrate_engine):
-    meta.bind = migrate_engine
-
-    instances.drop_column('os_type')
diff --git a/nova/db/sqlalchemy/migrate_repo/versions/010_add_os_type_to_instances.py b/nova/db/sqlalchemy/migrate_repo/versions/010_add_os_type_to_instances.py
new file mode 100644
index 000000000..514b92b81
--- /dev/null
+++ b/nova/db/sqlalchemy/migrate_repo/versions/010_add_os_type_to_instances.py
@@ -0,0 +1,53 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# 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.
+
+from sqlalchemy import *
+from sqlalchemy.sql import text
+from migrate import *
+
+from nova import log as logging
+
+
+meta = MetaData()
+
+instances = Table('instances', meta,
+        Column('id', Integer(),  primary_key=True, nullable=False),
+        )
+
+instances_os_type = Column('os_type',
+                           String(length=255, convert_unicode=False,
+                                  assert_unicode=None, unicode_error=None,
+                                  _warn_on_bytestring=False),
+                           nullable=True)
+
+
+def upgrade(migrate_engine):
+    # Upgrade operations go here. Don't create your own engine;
+    # bind migrate_engine to your metadata
+    meta.bind = migrate_engine
+
+    instances.create_column(instances_os_type)
+    migrate_engine.execute(instances.update()\
+                           .where(instances.c.os_type == None)\
+                           .values(os_type='linux'))
+
+
+def downgrade(migrate_engine):
+    meta.bind = migrate_engine
+
+    instances.drop_column('os_type')
diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index 383819b00..cd125a301 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -440,6 +440,7 @@ class XenAPIMigrateInstance(test.TestCase):
                   'ramdisk_id': None,
                   'instance_type': 'm1.large',
                   'mac_address': 'aa:bb:cc:dd:ee:ff',
+                  'os_type': 'linux'
                   }
         stubs.stub_out_migration_methods(self.stubs)
         glance_stubs.stubout_glance_client(self.stubs,
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 59fa70102a06dce9f86b9b29825245bc54c01598 Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Tue, 8 Mar 2011 16:51:05 -0800
Subject: Added documentation about needed flags

---
 nova/service.py | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/service.py b/nova/service.py
index 460f36f7a..af20db01c 100644
--- a/nova/service.py
+++ b/nova/service.py
@@ -221,7 +221,12 @@ class Service(object):
 
 
 class WsgiService(object):
-    """Base class for WSGI based services."""
+    """Base class for WSGI based services.
+
+    For each api you define, you must also define these flags:
+    :<api>_listen:            The address on which to listen
+    :<api>_listen_port:       The port on which to listen
+    """
 
     def __init__(self, conf, apis):
         self.conf = conf
-- 
cgit 


From a320b5df9f916adf8422ed312306c77570d392c2 Mon Sep 17 00:00:00 2001
From: Eric Windisch <eric@cloudscaling.com>
Date: Wed, 9 Mar 2011 00:30:05 -0500
Subject: execvp: almost passes tests

---
 nova/api/ec2/cloud.py        |  2 +-
 nova/network/linux_net.py    | 21 +++++++++++----------
 nova/tests/test_network.py   |  2 +-
 nova/tests/test_virt.py      | 11 ++++++-----
 nova/utils.py                | 19 +++++++++++++------
 nova/virt/libvirt_conn.py    | 11 ++++++-----
 nova/virt/xenapi/vm_utils.py |  6 ++----
 nova/volume/driver.py        |  5 +++--
 8 files changed, 43 insertions(+), 34 deletions(-)

(limited to 'nova')

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 0d22a3f46..b7d72d1c1 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -115,7 +115,7 @@ class CloudController(object):
             start = os.getcwd()
             os.chdir(FLAGS.ca_path)
             # TODO(vish): Do this with M2Crypto instead
-            utils.runthis(_("Generating root CA: %s"), "sh genrootca.sh")
+            utils.runthis(_("Generating root CA: %s"), "sh", "genrootca.sh")
             os.chdir(start)
 
     def _get_mpi_data(self, context, project_id):
diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index ad019a8c0..b66a1adb7 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -139,14 +139,14 @@ def init_host():
 def bind_floating_ip(floating_ip, check_exit_code=True):
     """Bind ip to public interface"""
     _execute('sudo', 'ip', 'addr', 'add', floating_ip,
-             'dev', FLAGS.public_interface),
+             'dev', FLAGS.public_interface,
              check_exit_code=check_exit_code)
 
 
 def unbind_floating_ip(floating_ip):
     """Unbind a public ip from public interface"""
     _execute('sudo', 'ip', 'addr', 'del', floating_ip,
-             'dev', FLAGS.public_interface))
+             'dev', FLAGS.public_interface)
 
 
 def ensure_vlan_forward(public_ip, port, private_ip):
@@ -213,7 +213,7 @@ def ensure_bridge(bridge, interface, net_attrs=None):
         _execute('sudo', 'brctl', 'addbr', bridge)
         _execute('sudo', 'brctl', 'setfd', bridge, 0)
         # _execute("sudo brctl setageing %s 10" % bridge)
-        _execute('sudo', 'brctl', 'stp', bridge', 'off')
+        _execute('sudo', 'brctl', 'stp', bridge, 'off')
         _execute('sudo', 'ip', 'link', 'set', bridge, up)
     if net_attrs:
         # NOTE(vish): The ip for dnsmasq has to be the first address on the
@@ -223,7 +223,7 @@ def ensure_bridge(bridge, interface, net_attrs=None):
                             "%s/%s" % 
                             (net_attrs['gateway'], suffix),
                             'brd',
-                            net-attrs['broadcast'],
+                            net_attrs['broadcast'],
                             'dev',
                             bridge,
                             check_exit_code=False)
@@ -257,7 +257,7 @@ def ensure_bridge(bridge, interface, net_attrs=None):
                 _execute('sudo', 'ip', 'addr', 'add', params, 'dev', bridge)
         if gateway:
             _execute('sudo', 'route', 'add', '0.0.0.0', 'gw', gateway)
-        out, err = _execute('sudo', 'brctl', 'addif, bridge, interface,
+        out, err = _execute('sudo', 'brctl', 'addif', bridge, interface,
                             check_exit_code=False)
 
         if (err and err != "device %s is already a member of a bridge; can't "
@@ -265,11 +265,11 @@ def ensure_bridge(bridge, interface, net_attrs=None):
             raise exception.Error("Failed to add interface: %s" % err)
 
     if FLAGS.use_nova_chains:
-        (out, err) = _execute('sudo', 'iptables', '-N', 'nova_forward,
+        (out, err) = _execute('sudo', 'iptables', '-N', 'nova_forward',
                               check_exit_code=False)
         if err != 'iptables: Chain already exists.\n':
             # NOTE(vish): chain didn't exist link chain
-            _execute('sudo', 'iptables, '-D', 'FORWARD', '-j', 'nova_forward',
+            _execute('sudo', 'iptables', '-D', 'FORWARD', '-j', 'nova_forward',
                      check_exit_code=False)
             _execute('sudo', 'iptables', '-A', 'FORWARD', '-j', 'nova_forward')
 
@@ -355,7 +355,7 @@ interface %s
 
     # if radvd is already running, then tell it to reload
     if pid:
-        out, _err = _execute('cat', "/proc/%d/cmdline'
+        out, _err = _execute('cat', '/proc/%d/cmdline'
                              % pid, check_exit_code=False)
         if conffile in out:
             try:
@@ -383,7 +383,7 @@ def _host_dhcp(fixed_ip_ref):
 def _execute(*cmd, **kwargs):
     """Wrapper around utils._execute for fake_network"""
     if FLAGS.fake_network:
-        LOG.debug("FAKE NET: %s", ' '.join(cmd))
+        LOG.debug("FAKE NET: %s", " ".join(map(str, cmd)))
         return "fake", 0
     else:
         return utils.execute(*cmd, **kwargs)
@@ -396,7 +396,8 @@ def _device_exists(device):
     return not err
 
 
-def _confirm_rule(chain, *cmd, append=False):
+def _confirm_rule(chain, *cmd, **kwargs):
+    append=kwargs.get('append',False)
     """Delete and re-add iptables rule"""
     if FLAGS.use_nova_chains:
         chain = "nova_%s" % chain.lower()
diff --git a/nova/tests/test_network.py b/nova/tests/test_network.py
index 6d2d8b771..19099ff4c 100644
--- a/nova/tests/test_network.py
+++ b/nova/tests/test_network.py
@@ -343,7 +343,7 @@ def lease_ip(private_ip):
                                           private_ip)
     instance_ref = db.fixed_ip_get_instance(context.get_admin_context(),
                                             private_ip)
-    cmd = (binpath('nova-dhcpbridge'), 'add'
+    cmd = (binpath('nova-dhcpbridge'), 'add',
            instance_ref['mac_address'],
            private_ip, 'fake')
     env = {'DNSMASQ_INTERFACE': network_ref['bridge'],
diff --git a/nova/tests/test_virt.py b/nova/tests/test_virt.py
index f151ae911..7f1ad002e 100644
--- a/nova/tests/test_virt.py
+++ b/nova/tests/test_virt.py
@@ -315,15 +315,16 @@ class IptablesFirewallTestCase(test.TestCase):
         instance_ref = db.instance_get(admin_ctxt, instance_ref['id'])
 
 #        self.fw.add_instance(instance_ref)
-        def fake_iptables_execute(cmd, process_input=None):
-            if cmd == 'sudo ip6tables-save -t filter':
+        def fake_iptables_execute(*cmd, **kwargs):
+            process_input=kwargs.get('process_input', None)
+            if cmd == ('sudo', 'ip6tables-save', '-t', 'filter'):
                 return '\n'.join(self.in6_rules), None
-            if cmd == 'sudo iptables-save -t filter':
+            if cmd == ('sudo', 'iptables-save', '-t', 'filter'):
                 return '\n'.join(self.in_rules), None
-            if cmd == 'sudo iptables-restore':
+            if cmd == ('sudo', 'iptables-restore'):
                 self.out_rules = process_input.split('\n')
                 return '', ''
-            if cmd == 'sudo ip6tables-restore':
+            if cmd == ('sudo', 'ip6tables-restore'):
                 self.out6_rules = process_input.split('\n')
                 return '', ''
         self.fw.execute = fake_iptables_execute
diff --git a/nova/utils.py b/nova/utils.py
index c96b85294..9b51f8b40 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -128,13 +128,20 @@ def fetchfile(url, target):
     execute("curl", "--fail", url, "-o", target)
 
 
-def execute(*cmd, process_input=None, addl_env=None, check_exit_code=True):
+def execute(*cmd, **kwargs):
+    process_input=kwargs.get('process_input', None)
+    addl_env=kwargs.get('addl_env', None)
+    check_exit_code=kwargs.get('check_exit_code', True)
+    stdin=kwargs.get('stdin', subprocess.PIPE)
+    stdout=kwargs.get('stdout', subprocess.PIPE)
+    stderr=kwargs.get('stderr', subprocess.PIPE)
+
     LOG.debug(_("Running cmd (subprocess): %s"), ' '.join(cmd))
     env = os.environ.copy()
     if addl_env:
         env.update(addl_env)
-    obj = subprocess.Popen(*cmd, stdin=subprocess.PIPE,
-        stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env)
+    obj = subprocess.Popen(cmd, stdin=stdin,
+            stdout=stdout, stderr=stderr, env=env)
     result = None
     if process_input != None:
         result = obj.communicate(process_input)
@@ -220,9 +227,9 @@ def debug(arg):
     return arg
 
 
-def runthis(prompt, cmd, check_exit_code=True):
-    LOG.debug(_("Running %s"), (cmd))
-    rv, err = execute(cmd, check_exit_code=check_exit_code)
+def runthis(prompt, *cmd, **kwargs):
+    LOG.debug(_("Running %s"), (" ".join(cmd)))
+    rv, err = execute(*cmd, **kwargs)
 
 
 def generate_uid(topic, size=8):
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',
diff --git a/nova/volume/driver.py b/nova/volume/driver.py
index 220c9ef9d..e9bdf162f 100644
--- a/nova/volume/driver.py
+++ b/nova/volume/driver.py
@@ -104,7 +104,8 @@ class VolumeDriver(object):
     def delete_volume(self, volume):
         """Deletes a logical volume."""
         try:
-            self._try_execute('sudo', 'lvdisplay', '%s/%s" %
+            self._try_execute('sudo', 'lvdisplay',
+                              '%s/%s' %
                               (FLAGS.volume_group,
                                volume['name']))
         except Exception as e:
@@ -550,7 +551,7 @@ class SheepdogDriver(VolumeDriver):
         else:
             sizestr = '%sG' % volume['size']
         self._try_execute('qemu-img', 'create',
-                          "sheepdog:%s" %s" % volume['name'],
+                          "sheepdog:%s" % volume['name'],
                           sizestr)
 
     def delete_volume(self, volume):
-- 
cgit 


From 1d7358e70379607c9cce02307f4336efbd135a5d Mon Sep 17 00:00:00 2001
From: Eric Windisch <eric@cloudscaling.com>
Date: Wed, 9 Mar 2011 01:26:53 -0500
Subject: execvp: unit tests pass

---
 nova/crypto.py | 2 +-
 nova/utils.py  | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/crypto.py b/nova/crypto.py
index dd24723b8..20bb570a5 100644
--- a/nova/crypto.py
+++ b/nova/crypto.py
@@ -196,7 +196,7 @@ def generate_x509_cert(user_id, project_id, bits=1024):
     tmpdir = tempfile.mkdtemp()
     keyfile = os.path.abspath(os.path.join(tmpdir, 'temp.key'))
     csrfile = os.path.join(tmpdir, 'temp.csr')
-    utils.execute('openssl', 'genrsa', '-out', keyfile, bits)
+    utils.execute('openssl', 'genrsa', '-out', keyfile, str(bits))
     utils.execute('openssl', 'req', '-new', '-key', keyfile, '-out', csrfile,
                   '-batch', '-subj', subject)
     private_key = open(keyfile).read()
diff --git a/nova/utils.py b/nova/utils.py
index 9b51f8b40..7ddf056ea 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -135,6 +135,7 @@ def execute(*cmd, **kwargs):
     stdin=kwargs.get('stdin', subprocess.PIPE)
     stdout=kwargs.get('stdout', subprocess.PIPE)
     stderr=kwargs.get('stderr', subprocess.PIPE)
+    cmd=map(str,cmd)
 
     LOG.debug(_("Running cmd (subprocess): %s"), ' '.join(cmd))
     env = os.environ.copy()
-- 
cgit 


From 77da93886be61230dea5a4a4c4de036a57e62550 Mon Sep 17 00:00:00 2001
From: Vishvananda Ishaya <vishvananda@gmail.com>
Date: Wed, 9 Mar 2011 06:56:42 +0000
Subject: tests and semaphore fix for image caching

---
 nova/tests/test_virt.py   | 66 +++++++++++++++++++++++++++++++++++++++++++++++
 nova/virt/libvirt_conn.py | 14 +++++++---
 2 files changed, 76 insertions(+), 4 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/test_virt.py b/nova/tests/test_virt.py
index f151ae911..ec7498d72 100644
--- a/nova/tests/test_virt.py
+++ b/nova/tests/test_virt.py
@@ -14,12 +14,16 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+import os
+
+import eventlet
 from xml.etree.ElementTree import fromstring as xml_to_tree
 from xml.dom.minidom import parseString as xml_to_dom
 
 from nova import context
 from nova import db
 from nova import flags
+from nova import log as logging
 from nova import test
 from nova import utils
 from nova.api.ec2 import cloud
@@ -30,6 +34,68 @@ FLAGS = flags.FLAGS
 flags.DECLARE('instances_path', 'nova.compute.manager')
 
 
+def _concurrency(wait, done, target):
+    wait.wait()
+    done.send()
+
+
+class CacheConcurrencyTestCase(test.TestCase):
+    def setUp(self):
+        super(CacheConcurrencyTestCase, self).setUp()
+
+        def fake_exists(fname):
+            basedir = os.path.join(FLAGS.instances_path, '_base')
+            if fname == basedir:
+                return True
+            return False
+
+        def fake_execute(*args, **kwargs):
+            pass
+
+        self.stubs.Set(os.path, 'exists', fake_exists)
+        self.stubs.Set(utils, 'execute', fake_execute)
+
+    def test_same_fname_concurrency(self):
+        """Ensures that the same fname cache runs at a sequentially"""
+        conn = libvirt_conn.get_connection(False)
+        wait1 = eventlet.event.Event()
+        done1 = eventlet.event.Event()
+        eventlet.spawn(conn._cache_image, _concurrency,
+                       'target', 'fname', False, wait1, done1)
+        wait2 = eventlet.event.Event()
+        done2 = eventlet.event.Event()
+        eventlet.spawn(conn._cache_image, _concurrency,
+                       'target', 'fname', False, wait2, done2)
+        wait2.send()
+        eventlet.sleep(0)
+        try:
+            self.assertFalse(done2.ready())
+        finally:
+            wait1.send()
+        done1.wait()
+        eventlet.sleep(0)
+        self.assertTrue(done2.ready())
+
+    def test_different_fname_concurrency(self):
+        """Ensures that two different fname caches are concurrent"""
+        conn = libvirt_conn.get_connection(False)
+        wait1 = eventlet.event.Event()
+        done1 = eventlet.event.Event()
+        eventlet.spawn(conn._cache_image, _concurrency,
+                       'target', 'fname2', False, wait1, done1)
+        wait2 = eventlet.event.Event()
+        done2 = eventlet.event.Event()
+        eventlet.spawn(conn._cache_image, _concurrency,
+                       'target', 'fname1', False, wait2, done2)
+        wait2.send()
+        eventlet.sleep(0)
+        try:
+            self.assertTrue(done2.ready())
+        finally:
+            wait1.send()
+            eventlet.sleep(0)
+
+
 class LibvirtConnTestCase(test.TestCase):
     def setUp(self):
         super(LibvirtConnTestCase, self).setUp()
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 <vishvananda@gmail.com>
Date: Wed, 9 Mar 2011 07:35:58 +0000
Subject: make static method for testing without initializing libvirt

---
 nova/tests/test_virt.py   |  4 ++--
 nova/virt/libvirt_conn.py | 11 ++++++-----
 2 files changed, 8 insertions(+), 7 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/test_virt.py b/nova/tests/test_virt.py
index ec7498d72..113632a0c 100644
--- a/nova/tests/test_virt.py
+++ b/nova/tests/test_virt.py
@@ -57,7 +57,7 @@ class CacheConcurrencyTestCase(test.TestCase):
 
     def test_same_fname_concurrency(self):
         """Ensures that the same fname cache runs at a sequentially"""
-        conn = libvirt_conn.get_connection(False)
+        conn = libvirt_conn.LibvirtConnection
         wait1 = eventlet.event.Event()
         done1 = eventlet.event.Event()
         eventlet.spawn(conn._cache_image, _concurrency,
@@ -78,7 +78,7 @@ class CacheConcurrencyTestCase(test.TestCase):
 
     def test_different_fname_concurrency(self):
         """Ensures that two different fname caches are concurrent"""
-        conn = libvirt_conn.get_connection(False)
+        conn = libvirt_conn.LibvirtConnection
         wait1 = eventlet.event.Event()
         done1 = eventlet.event.Event()
         eventlet.spawn(conn._cache_image, _concurrency,
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 7d31fe9ef316f49379818259a55a84deb5b850cd Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Wed, 9 Mar 2011 10:30:18 +0100
Subject: Stop assuming anything about the order in which the two processes are
 scheduled.

---
 nova/tests/test_misc.py | 47 +++++++++++++++++++++++++----------------------
 1 file changed, 25 insertions(+), 22 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/test_misc.py b/nova/tests/test_misc.py
index 9f572b58e..a658e4978 100644
--- a/nova/tests/test_misc.py
+++ b/nova/tests/test_misc.py
@@ -71,30 +71,33 @@ class LockTestCase(test.TestCase):
                                                "got mangled")
 
     def test_synchronized(self):
-        rpipe, wpipe = os.pipe()
+        rpipe1, wpipe1 = os.pipe()
+        rpipe2, wpipe2 = os.pipe()
+
+        @synchronized('testlock')
+        def f(rpipe, wpipe):
+            try:
+                os.write(wpipe, "foo")
+            except OSError, e:
+                self.assertEquals(e.errno, errno.EPIPE)
+                return
+
+            rfds, _, __ = select.select([rpipe], [], [], 1)
+            self.assertEquals(len(rfds), 0, "The other process, which was"
+                                            " supposed to be locked, "
+                                            "wrote on its end of the "
+                                            "pipe")
+            os.close(rpipe)
+
         pid = os.fork()
         if pid > 0:
-            os.close(wpipe)
-
-            @synchronized('testlock')
-            def f():
-                rfds, _, __ = select.select([rpipe], [], [], 1)
-                self.assertEquals(len(rfds), 0, "The other process, which was"
-                                                " supposed to be locked, "
-                                                "wrote on its end of the "
-                                                "pipe")
-                os.close(rpipe)
-
-            f()
+            os.close(wpipe1)
+            os.close(rpipe2)
+
+            f(rpipe1, wpipe2)
         else:
-            os.close(rpipe)
+            os.close(rpipe1)
+            os.close(wpipe2)
 
-            @synchronized('testlock')
-            def g():
-                try:
-                    os.write(wpipe, "foo")
-                except OSError, e:
-                    self.assertEquals(e.errno, errno.EPIPE)
-                    return
-            g()
+            f(rpipe2, wpipe1)
             os._exit(0)
-- 
cgit 


From 0f45b59ca6f9502a3ae6578e2fca5a7d9575ae5e Mon Sep 17 00:00:00 2001
From: Dan Prince <dan.prince@rackspace.com>
Date: Wed, 9 Mar 2011 10:37:21 -0500
Subject: Added 'adminPass' to the serialization_metadata.

---
 nova/api/openstack/servers.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 9581b8477..bbedd7c63 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -96,7 +96,7 @@ class Controller(wsgi.Controller):
         'application/xml': {
             "attributes": {
                 "server": ["id", "imageId", "name", "flavorId", "hostId",
-                           "status", "progress"]}}}
+                           "status", "progress", "adminPass"]}}}
 
     def __init__(self):
         self.compute_api = compute.API()
-- 
cgit 


From f1dea606a64c9144fb723be0e5b86806891380f8 Mon Sep 17 00:00:00 2001
From: Mark Washenberger <mark.washenberger@rackspace.com>
Date: Wed, 9 Mar 2011 11:54:21 -0500
Subject: add override to handle xml deserialization for server instance
 creation

---
 nova/api/openstack/servers.py            |  68 +++++++-
 nova/tests/api/openstack/fakes.py        |   2 -
 nova/tests/api/openstack/test_servers.py | 277 +++++++++++++++++++++++++++++++
 3 files changed, 344 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 93f504f91..4a6282204 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -17,6 +17,7 @@ import base64
 import hashlib
 import json
 import traceback
+from xml.dom import minidom
 
 from webob import exc
 
@@ -166,9 +167,16 @@ class Controller(wsgi.Controller):
             personality_files.append((path, contents))
         return personality_files
 
+    def _deserialize_create(self, request):
+        if request.content_type == "application/xml":
+            deserializer = ServerCreateRequestXMLDeserializer()
+            return deserializer.deserialize(request.body)
+        else:
+            return self._deserialize(request.body, request)
+
     def create(self, req):
         """ Creates a new server for a given user """
-        env = self._deserialize(req.body, req)
+        env = self._deserialize_create(req)
         if not env:
             return faults.Fault(exc.HTTPUnprocessableEntity())
 
@@ -448,3 +456,61 @@ class Controller(wsgi.Controller):
                 _("Ramdisk not found for image %(image_id)s") % locals())
 
         return kernel_id, ramdisk_id
+
+
+class ServerCreateRequestXMLDeserializer(object):
+
+    def deserialize(self, string):
+        dom = minidom.parseString(string)
+        server = self._extract_server(dom)
+        return {'server': server}
+
+    def _extract_server(self, node):
+        server = {}
+        server_node = self._find_first_child_named(node, 'server')
+        for attr in ["name", "imageId", "flavorId"]:
+            server[attr] = server_node.getAttribute(attr)
+        metadata = self._extract_metadata(server_node)
+        if metadata is not None:
+            server["metadata"] = metadata
+        personality = self._extract_personality(server_node)
+        if personality is not None:
+            server["personality"] = personality
+        return server
+
+    def _extract_metadata(self, server_node):
+        metadata_node = self._find_first_child_named(server_node, "metadata")
+        if metadata_node is None:
+            return None
+        metadata = {}
+        for meta_node in metadata_node.childNodes:
+            key = meta_node.getAttribute("key")
+            metadata[key] = self._extract_text(meta_node)
+        return metadata
+
+    def _extract_personality(self, server_node):
+        personality_node = \
+                self._find_first_child_named(server_node, "personality")
+        if personality_node is None:
+            return None
+        personality = []
+        for file_node in personality_node.childNodes:
+            item = {}
+            if file_node.hasAttribute("path"):
+                item["path"] = file_node.getAttribute("path")
+            item["contents"] = self._extract_text(file_node)
+            personality.append(item)
+        return personality
+
+    def _find_first_child_named(self, parent, name):
+        for node in parent.childNodes:
+            if node.nodeName == name:
+                return node
+        return None
+
+    def _extract_text(self, node):
+        if len(node.childNodes) == 1:
+            child = node.childNodes[0]
+            if child.nodeType == child.TEXT_NODE:
+                return child.nodeValue
+        return ""
diff --git a/nova/tests/api/openstack/fakes.py b/nova/tests/api/openstack/fakes.py
index 49ce8c1b5..1d8692528 100644
--- a/nova/tests/api/openstack/fakes.py
+++ b/nova/tests/api/openstack/fakes.py
@@ -68,8 +68,6 @@ def fake_auth_init(self, application):
 @webob.dec.wsgify
 def fake_wsgi(self, req):
     req.environ['nova.context'] = context.RequestContext(1, 1)
-    if req.body:
-        req.environ['inst_dict'] = json.loads(req.body)
     return self.application
 
 
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 8fb5a9aec..5132d1ad3 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -18,6 +18,7 @@
 import base64
 import datetime
 import json
+import unittest
 
 import stubout
 import webob
@@ -284,6 +285,37 @@ class ServersTest(test.TestCase):
         response = request.get_response(fakes.wsgi_app())
         return compute_api, response
 
+    def _format_xml_request_body(self, body_dict):
+        server = body_dict['server']
+        body_parts = []
+        body_parts.extend([
+            '<?xml version="1.0" encoding="UTF-8"?>',
+            '<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"',
+            ' name="%s" imageId="%s" flavorId="%s">' % (
+                    server['name'], server['imageId'], server['flavorId'])])
+        if 'metadata' in server:
+            metadata = server['metadata']
+            body_parts.append('<metadata>')
+            for item in metadata.iteritems():
+                body_parts.append('<meta key="%s">%s</meta>' % item)
+            body_parts.append('</metadata>')
+        if 'personality' in server:
+            personalities = server['personality']
+            body_parts.append('<personality>')
+            for file in personalities:
+                item = (file['path'], file['contents'])
+                body_parts.append('<file path="%s">%s</file>' % item)
+            body_parts.append('</personality>')
+        body_parts.append('</server>')
+        return ''.join(body_parts)
+
+    def _get_create_request_xml(self, body_dict):
+        req = webob.Request.blank('/v1.0/servers')
+        req.content_type = 'application/xml'
+        req.method = 'POST'
+        req.body = self._format_xml_request_body(body_dict)
+        return req
+
     def _create_instance_with_personality_json(self, personality):
         body_dict = self._create_personality_request_dict(personality)
         request = self._get_create_request_json(body_dict)
@@ -291,12 +323,25 @@ class ServersTest(test.TestCase):
             self._run_create_instance_with_mock_compute_api(request)
         return request, response, compute_api.personality_files
 
+    def _create_instance_with_personality_xml(self, personality):
+        body_dict = self._create_personality_request_dict(personality)
+        request = self._get_create_request_xml(body_dict)
+        compute_api, response = \
+            self._run_create_instance_with_mock_compute_api(request)
+        return request, response, compute_api.personality_files
+
     def test_create_instance_with_no_personality(self):
         request, response, personality_files = \
                 self._create_instance_with_personality_json(personality=None)
         self.assertEquals(response.status_int, 200)
         self.assertEquals(personality_files, [])
 
+    def test_create_instance_with_no_personality_xml(self):
+        request, response, personality_files = \
+                self._create_instance_with_personality_xml(personality=None)
+        self.assertEquals(response.status_int, 200)
+        self.assertEquals(personality_files, [])
+
     def test_create_instance_with_personality(self):
         path = '/my/file/path'
         contents = '#!/bin/bash\necho "Hello, World!"\n'
@@ -307,6 +352,16 @@ class ServersTest(test.TestCase):
         self.assertEquals(response.status_int, 200)
         self.assertEquals(personality_files, [(path, contents)])
 
+    def test_create_instance_with_personality_xml(self):
+        path = '/my/file/path'
+        contents = '#!/bin/bash\necho "Hello, World!"\n'
+        b64contents = base64.b64encode(contents)
+        personality = [(path, b64contents)]
+        request, response, personality_files = \
+            self._create_instance_with_personality_xml(personality)
+        self.assertEquals(response.status_int, 200)
+        self.assertEquals(personality_files, [(path, contents)])
+
     def test_create_instance_with_personality_no_path(self):
         personality = [('/remove/this/path',
             base64.b64encode('my\n\file\ncontents'))]
@@ -318,6 +373,17 @@ class ServersTest(test.TestCase):
         self.assertEquals(response.status_int, 400)
         self.assertEquals(compute_api.personality_files, None)
 
+    def _test_create_instance_with_personality_no_path_xml(self):
+        personality = [('/remove/this/path',
+            base64.b64encode('my\n\file\ncontents'))]
+        body_dict = self._create_personality_request_dict(personality)
+        request = self._get_create_request_xml(body_dict)
+        request.body = request.body.replace(' path="/remove/this/path"', '')
+        compute_api, response = \
+            self._run_create_instance_with_mock_compute_api(request)
+        self.assertEquals(response.status_int, 400)
+        self.assertEquals(compute_api.personality_files, None)
+
     def test_create_instance_with_personality_no_contents(self):
         personality = [('/test/path',
             base64.b64encode('remove\nthese\ncontents'))]
@@ -605,3 +671,214 @@ class ServersTest(test.TestCase):
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status, '202 Accepted')
         self.assertEqual(self.server_delete_called, True)
+
+
+class TestServerCreateRequestXMLDeserializer(unittest.TestCase):
+
+    def setUp(self):
+        self.deserializer = servers.ServerCreateRequestXMLDeserializer()
+
+    def test_minimal_request(self):
+        serial_request = """
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"\
+ name="new-server-test" imageId="1" flavorId="1"/>"""
+        request = self.deserializer.deserialize(serial_request)
+        expected = {"server": {
+                "name": "new-server-test",
+                "imageId": "1",
+                "flavorId": "1",
+                }}
+        self.assertEquals(request, expected)
+
+    def test_request_with_empty_metadata(self):
+        serial_request = """
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"\
+ name="new-server-test" imageId="1" flavorId="1"><metadata/></server>"""
+        request = self.deserializer.deserialize(serial_request)
+        expected = {"server": {
+                "name": "new-server-test",
+                "imageId": "1",
+                "flavorId": "1",
+                "metadata": {},
+                }}
+        self.assertEquals(request, expected)
+
+    def test_request_with_empty_personality(self):
+        serial_request = """
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"\
+ name="new-server-test" imageId="1" flavorId="1"><personality/></server>"""
+        request = self.deserializer.deserialize(serial_request)
+        expected = {"server": {
+                "name": "new-server-test",
+                "imageId": "1",
+                "flavorId": "1",
+                "personality": [],
+                }}
+        self.assertEquals(request, expected)
+
+    def test_request_with_empty_metadata_and_personality(self):
+        serial_request = """
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"\
+ name="new-server-test" imageId="1" flavorId="1">\
+<metadata/><personality/></server>"""
+        request = self.deserializer.deserialize(serial_request)
+        expected = {"server": {
+                "name": "new-server-test",
+                "imageId": "1",
+                "flavorId": "1",
+                "metadata": {},
+                "personality": [],
+                }}
+        self.assertEquals(request, expected)
+
+    def test_request_with_empty_metadata_and_personality_reversed(self):
+        serial_request = """
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"\
+ name="new-server-test" imageId="1" flavorId="1">\
+<personality/><metadata/></server>"""
+        request = self.deserializer.deserialize(serial_request)
+        expected = {"server": {
+                "name": "new-server-test",
+                "imageId": "1",
+                "flavorId": "1",
+                "metadata": {},
+                "personality": [],
+                }}
+        self.assertEquals(request, expected)
+
+    def test_request_with_one_personality(self):
+        serial_request = """
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"\
+ name="new-server-test" imageId="1" flavorId="1">\
+<personality><file path="/etc/conf">aabbccdd</file></personality></server>"""
+        request = self.deserializer.deserialize(serial_request)
+        expected = [{"path": "/etc/conf", "contents": "aabbccdd"}]
+        self.assertEquals(request["server"]["personality"], expected)
+
+    def test_request_with_two_personalities(self):
+        serial_request = """
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"\
+ name="new-server-test" imageId="1" flavorId="1">\
+<personality><file path="/etc/conf">aabbccdd</file>\
+<file path="/etc/sudoers">abcd</file></personality></server>"""
+        request = self.deserializer.deserialize(serial_request)
+        expected = [{"path": "/etc/conf", "contents": "aabbccdd"},
+                    {"path": "/etc/sudoers", "contents": "abcd"}]
+        self.assertEquals(request["server"]["personality"], expected)
+
+    def test_request_with_one_personality_missing_path(self):
+        serial_request = """
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"\
+ name="new-server-test" imageId="1" flavorId="1">\
+<personality><file>aabbccdd</file></personality></server>"""
+        request = self.deserializer.deserialize(serial_request)
+        expected = [{"contents": "aabbccdd"}]
+        self.assertEquals(request["server"]["personality"], expected)
+
+    def test_request_with_one_personality_empty_contents(self):
+        serial_request = """
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"\
+ name="new-server-test" imageId="1" flavorId="1">\
+<personality><file path="/etc/conf"></file></personality></server>"""
+        request = self.deserializer.deserialize(serial_request)
+        expected = [{"path": "/etc/conf", "contents": ""}]
+        self.assertEquals(request["server"]["personality"], expected)
+
+    def test_request_with_one_personality_empty_contents_variation(self):
+        serial_request = """
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"\
+ name="new-server-test" imageId="1" flavorId="1">\
+<personality><file path="/etc/conf"/></personality></server>"""
+        request = self.deserializer.deserialize(serial_request)
+        expected = [{"path": "/etc/conf", "contents": ""}]
+        self.assertEquals(request["server"]["personality"], expected)
+
+    def test_request_with_one_metadata(self):
+        serial_request = """
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"\
+ name="new-server-test" imageId="1" flavorId="1">\
+<metadata><meta key="alpha">beta</meta></metadata></server>"""
+        request = self.deserializer.deserialize(serial_request)
+        expected = {"alpha": "beta"}
+        self.assertEquals(request["server"]["metadata"], expected)
+
+    def test_request_with_two_metadata(self):
+        serial_request = """
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"\
+ name="new-server-test" imageId="1" flavorId="1">\
+<metadata><meta key="alpha">beta</meta><meta key="foo">bar</meta>\
+</metadata></server>"""
+        request = self.deserializer.deserialize(serial_request)
+        expected = {"alpha": "beta", "foo": "bar"}
+        self.assertEquals(request["server"]["metadata"], expected)
+
+    def test_request_with_metadata_missing_value(self):
+        serial_request = """
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"\
+ name="new-server-test" imageId="1" flavorId="1">\
+<metadata><meta key="alpha"></meta></metadata></server>"""
+        request = self.deserializer.deserialize(serial_request)
+        expected = {"alpha": ""}
+        self.assertEquals(request["server"]["metadata"], expected)
+
+    def test_request_with_metadata_missing_key(self):
+        serial_request = """
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"\
+ name="new-server-test" imageId="1" flavorId="1">\
+<metadata><meta>beta</meta></metadata></server>"""
+        request = self.deserializer.deserialize(serial_request)
+        expected = {"": "beta"}
+        self.assertEquals(request["server"]["metadata"], expected)
+
+    def test_request_with_metadata_duplicate_key(self):
+        serial_request = """
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"\
+ name="new-server-test" imageId="1" flavorId="1">\
+<metadata><meta key="foo">bar</meta><meta key="foo">baz</meta>\
+</metadata></server>"""
+        request = self.deserializer.deserialize(serial_request)
+        expected = {"foo": "baz"}
+        self.assertEquals(request["server"]["metadata"], expected)
+
+    def test_canonical_request_from_docs(self):
+        serial_request = """
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"\
+ name="new-server-test" imageId="1" flavorId="1">\
+<metadata><meta key="My Server Name">Apache1</meta></metadata>\
+<personality><file path="/etc/banner.txt">\
+ICAgICAgDQoiQSBjbG91ZCBkb2VzIG5vdCBrbm93IHdoeSBp\
+dCBtb3ZlcyBpbiBqdXN0IHN1Y2ggYSBkaXJlY3Rpb24gYW5k\
+IGF0IHN1Y2ggYSBzcGVlZC4uLkl0IGZlZWxzIGFuIGltcHVs\
+c2lvbi4uLnRoaXMgaXMgdGhlIHBsYWNlIHRvIGdvIG5vdy4g\
+QnV0IHRoZSBza3kga25vd3MgdGhlIHJlYXNvbnMgYW5kIHRo\
+ZSBwYXR0ZXJucyBiZWhpbmQgYWxsIGNsb3VkcywgYW5kIHlv\
+dSB3aWxsIGtub3csIHRvbywgd2hlbiB5b3UgbGlmdCB5b3Vy\
+c2VsZiBoaWdoIGVub3VnaCB0byBzZWUgYmV5b25kIGhvcml6\
+b25zLiINCg0KLVJpY2hhcmQgQmFjaA==\
+</file></personality></server>"""
+        expected = {"server": {
+            "name": "new-server-test",
+            "imageId": "1",
+            "flavorId": "1",
+            "metadata": {
+                "My Server Name": "Apache1",
+            },
+            "personality": [
+                {
+                    "path": "/etc/banner.txt",
+                    "contents": """\
+ICAgICAgDQoiQSBjbG91ZCBkb2VzIG5vdCBrbm93IHdoeSBp\
+dCBtb3ZlcyBpbiBqdXN0IHN1Y2ggYSBkaXJlY3Rpb24gYW5k\
+IGF0IHN1Y2ggYSBzcGVlZC4uLkl0IGZlZWxzIGFuIGltcHVs\
+c2lvbi4uLnRoaXMgaXMgdGhlIHBsYWNlIHRvIGdvIG5vdy4g\
+QnV0IHRoZSBza3kga25vd3MgdGhlIHJlYXNvbnMgYW5kIHRo\
+ZSBwYXR0ZXJucyBiZWhpbmQgYWxsIGNsb3VkcywgYW5kIHlv\
+dSB3aWxsIGtub3csIHRvbywgd2hlbiB5b3UgbGlmdCB5b3Vy\
+c2VsZiBoaWdoIGVub3VnaCB0byBzZWUgYmV5b25kIGhvcml6\
+b25zLiINCg0KLVJpY2hhcmQgQmFjaA==""",
+                }
+            ],
+        }}
+        request = self.deserializer.deserialize(serial_request)
+        self.assertEqual(request, expected)
+
-- 
cgit 


From 1d74816bf705cb672d9d323398b03142297d8bec Mon Sep 17 00:00:00 2001
From: Mark Washenberger <mark.washenberger@rackspace.com>
Date: Wed, 9 Mar 2011 12:03:17 -0500
Subject: remove superfluous trailing blank line

---
 nova/tests/api/openstack/test_servers.py | 1 -
 1 file changed, 1 deletion(-)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 5132d1ad3..51fb09b18 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -881,4 +881,3 @@ b25zLiINCg0KLVJpY2hhcmQgQmFjaA==""",
         }}
         request = self.deserializer.deserialize(serial_request)
         self.assertEqual(request, expected)
-
-- 
cgit 


From eadce208c55513ddbab550898e641b8ee55a67ec Mon Sep 17 00:00:00 2001
From: Dan Prince <dan.prince@rackspace.com>
Date: Wed, 9 Mar 2011 12:32:15 -0500
Subject: Fix spacing.

---
 nova/api/openstack/servers.py | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index bbedd7c63..7222285e0 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -84,11 +84,13 @@ def _translate_detail_keys(inst):
 
     return dict(server=inst_dict)
 
+
 def _translate_keys(inst):
     """ Coerces into dictionary format, excluding all model attributes
     save for id and name """
     return dict(server=dict(id=inst['id'], name=inst['display_name']))
 
+
 class Controller(wsgi.Controller):
     """ The Server API controller for the OpenStack API """
 
-- 
cgit 


From e17876ec002f976572b6ac102dc113024669a45c Mon Sep 17 00:00:00 2001
From: Ricardo Carrillo Cruz <emaildericky@gmail.com>
Date: Wed, 9 Mar 2011 18:57:53 +0100
Subject: fixed lp715427

---
 nova/network/manager.py | 10 ++++++++++
 1 file changed, 10 insertions(+)

(limited to 'nova')

diff --git a/nova/network/manager.py b/nova/network/manager.py
index b36dd59cf..39da031eb 100644
--- a/nova/network/manager.py
+++ b/nova/network/manager.py
@@ -563,6 +563,16 @@ class VlanManager(NetworkManager):
             # NOTE(vish): This makes ports unique accross the cloud, a more
             #             robust solution would be to make them unique per ip
             net['vpn_public_port'] = vpn_start + index
+            network_ref = None
+            try:
+                network_ref = db.network_get_by_cidr(context, cidr)
+            except exception.NotFound:
+                pass
+            
+            if network_ref is not None:
+                raise ValueError(_('Network with cidr %s already exists' %
+                                   cidr))
+            
             network_ref = self.db.network_create_safe(context, net)
             if network_ref:
                 self._create_fixed_ips(context, network_ref['id'])
-- 
cgit 


From 429fdb1ee733a62052c67f4e42c62447fc716ec0 Mon Sep 17 00:00:00 2001
From: Monsyne Dragon <mdragon@rackspace.com>
Date: Wed, 9 Mar 2011 18:10:45 +0000
Subject: removed uneeded  **kw args leftover from removed account-in-url
 changes.

---
 nova/api/openstack/backup_schedules.py |  6 ++---
 nova/api/openstack/consoles.py         | 10 ++++----
 nova/api/openstack/flavors.py          |  6 ++---
 nova/api/openstack/images.py           | 12 +++++-----
 nova/api/openstack/servers.py          | 42 +++++++++++++++++-----------------
 nova/api/openstack/shared_ip_groups.py | 12 +++++-----
 nova/api/openstack/users.py            | 12 +++++-----
 nova/api/openstack/zones.py            | 12 +++++-----
 8 files changed, 56 insertions(+), 56 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/backup_schedules.py b/nova/api/openstack/backup_schedules.py
index a4d5939df..7abb5f884 100644
--- a/nova/api/openstack/backup_schedules.py
+++ b/nova/api/openstack/backup_schedules.py
@@ -40,15 +40,15 @@ class Controller(wsgi.Controller):
     def __init__(self):
         pass
 
-    def index(self, req, server_id, **kw):
+    def index(self, req, server_id):
         """ Returns the list of backup schedules for a given instance """
         return _translate_keys({})
 
-    def create(self, req, server_id, **kw):
+    def create(self, req, server_id):
         """ No actual update method required, since the existing API allows
         both create and update through a POST """
         return faults.Fault(exc.HTTPNotImplemented())
 
-    def delete(self, req, server_id, id, **kw):
+    def delete(self, req, server_id, id):
         """ Deletes an existing backup schedule """
         return faults.Fault(exc.HTTPNotImplemented())
diff --git a/nova/api/openstack/consoles.py b/nova/api/openstack/consoles.py
index 85b2a4140..9ebdbe710 100644
--- a/nova/api/openstack/consoles.py
+++ b/nova/api/openstack/consoles.py
@@ -55,7 +55,7 @@ class Controller(wsgi.Controller):
         self.console_api = console.API()
         super(Controller, self).__init__()
 
-    def index(self, req, server_id, **kw):
+    def index(self, req, server_id):
         """Returns a list of consoles for this instance"""
         consoles = self.console_api.get_consoles(
                                     req.environ['nova.context'],
@@ -63,14 +63,14 @@ class Controller(wsgi.Controller):
         return dict(consoles=[_translate_keys(console)
                               for console in consoles])
 
-    def create(self, req, server_id, **kw):
+    def create(self, req, server_id):
         """Creates a new console"""
         #info = self._deserialize(req.body, req)
         self.console_api.create_console(
                                 req.environ['nova.context'],
                                 int(server_id))
 
-    def show(self, req, server_id, id, **kw):
+    def show(self, req, server_id, id):
         """Shows in-depth information on a specific console"""
         try:
             console = self.console_api.get_console(
@@ -81,11 +81,11 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPNotFound())
         return _translate_detail_keys(console)
 
-    def update(self, req, server_id, id, **kw):
+    def update(self, req, server_id, id):
         """You can't update a console"""
         raise faults.Fault(exc.HTTPNotImplemented())
 
-    def delete(self, req, server_id, id, **kw):
+    def delete(self, req, server_id, id):
         """Deletes a console"""
         try:
             self.console_api.delete_console(req.environ['nova.context'],
diff --git a/nova/api/openstack/flavors.py b/nova/api/openstack/flavors.py
index 1de67328b..f3d040ba3 100644
--- a/nova/api/openstack/flavors.py
+++ b/nova/api/openstack/flavors.py
@@ -34,17 +34,17 @@ class Controller(wsgi.Controller):
             "attributes": {
                 "flavor": ["id", "name", "ram", "disk"]}}}
 
-    def index(self, req, **kw):
+    def index(self, req):
         """Return all flavors in brief."""
         return dict(flavors=[dict(id=flavor['id'], name=flavor['name'])
                              for flavor in self.detail(req)['flavors']])
 
-    def detail(self, req, **kw):
+    def detail(self, req):
         """Return all flavors in detail."""
         items = [self.show(req, id)['flavor'] for id in self._all_ids(req)]
         return dict(flavors=items)
 
-    def show(self, req, id, **kw):
+    def show(self, req, id):
         """Return data about the given flavor id."""
         ctxt = req.environ['nova.context']
         values = db.instance_type_get_by_flavor_id(ctxt, id)
diff --git a/nova/api/openstack/images.py b/nova/api/openstack/images.py
index 5bc5b9978..cf85a496f 100644
--- a/nova/api/openstack/images.py
+++ b/nova/api/openstack/images.py
@@ -115,14 +115,14 @@ class Controller(wsgi.Controller):
     def __init__(self):
         self._service = utils.import_object(FLAGS.image_service)
 
-    def index(self, req, **kw):
+    def index(self, req):
         """Return all public images in brief"""
         items = self._service.index(req.environ['nova.context'])
         items = common.limited(items, req)
         items = [_filter_keys(item, ('id', 'name')) for item in items]
         return dict(images=items)
 
-    def detail(self, req, **kw):
+    def detail(self, req):
         """Return all public images in detail"""
         try:
             items = self._service.detail(req.environ['nova.context'])
@@ -136,7 +136,7 @@ class Controller(wsgi.Controller):
         items = [_translate_status(item) for item in items]
         return dict(images=items)
 
-    def show(self, req, id, **kw):
+    def show(self, req, id):
         """Return data about the given image id"""
         image_id = common.get_image_id_from_image_hash(self._service,
                     req.environ['nova.context'], id)
@@ -145,11 +145,11 @@ class Controller(wsgi.Controller):
         _convert_image_id_to_hash(image)
         return dict(image=image)
 
-    def delete(self, req, id, **kw):
+    def delete(self, req, id):
         # Only public images are supported for now.
         raise faults.Fault(exc.HTTPNotFound())
 
-    def create(self, req, **kw):
+    def create(self, req):
         context = req.environ['nova.context']
         env = self._deserialize(req.body, req)
         instance_id = env["image"]["serverId"]
@@ -160,7 +160,7 @@ class Controller(wsgi.Controller):
 
         return dict(image=image_meta)
 
-    def update(self, req, id, **kw):
+    def update(self, req, id):
         # Users may not modify public images, and that's all that
         # we support for now.
         raise faults.Fault(exc.HTTPNotFound())
diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 54060c2bb..c2bf42b72 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -105,11 +105,11 @@ class Controller(wsgi.Controller):
         self._image_service = utils.import_object(FLAGS.image_service)
         super(Controller, self).__init__()
 
-    def index(self, req, **kw):
+    def index(self, req):
         """ Returns a list of server names and ids for a given user """
         return self._items(req, entity_maker=_translate_keys)
 
-    def detail(self, req, **kw):
+    def detail(self, req):
         """ Returns a list of server details for a given user """
         return self._items(req, entity_maker=_translate_detail_keys)
 
@@ -123,7 +123,7 @@ class Controller(wsgi.Controller):
         res = [entity_maker(inst)['server'] for inst in limited_list]
         return dict(servers=res)
 
-    def show(self, req, id, **kw):
+    def show(self, req, id):
         """ Returns server details by server id """
         try:
             instance = self.compute_api.get(req.environ['nova.context'], id)
@@ -131,7 +131,7 @@ class Controller(wsgi.Controller):
         except exception.NotFound:
             return faults.Fault(exc.HTTPNotFound())
 
-    def delete(self, req, id, **kw):
+    def delete(self, req, id):
         """ Destroys a server """
         try:
             self.compute_api.delete(req.environ['nova.context'], id)
@@ -139,7 +139,7 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPNotFound())
         return exc.HTTPAccepted()
 
-    def create(self, req, **kw):
+    def create(self, req):
         """ Creates a new server for a given user """
         env = self._deserialize(req.body, req)
         if not env:
@@ -180,7 +180,7 @@ class Controller(wsgi.Controller):
             onset_files=env.get('onset_files', []))
         return _translate_keys(instances[0])
 
-    def update(self, req, id, **kw):
+    def update(self, req, id):
         """ Updates the server name or password """
         inst_dict = self._deserialize(req.body, req)
         if not inst_dict:
@@ -202,7 +202,7 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPNotFound())
         return exc.HTTPNoContent()
 
-    def action(self, req, id, **kw):
+    def action(self, req, id):
         """Multi-purpose method used to reboot, rebuild, or
         resize a server"""
 
@@ -267,7 +267,7 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPUnprocessableEntity())
         return exc.HTTPAccepted()
 
-    def lock(self, req, id, **kw):
+    def lock(self, req, id):
         """
         lock the instance with id
         admin only operation
@@ -282,7 +282,7 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPUnprocessableEntity())
         return exc.HTTPAccepted()
 
-    def unlock(self, req, id, **kw):
+    def unlock(self, req, id):
         """
         unlock the instance with id
         admin only operation
@@ -297,7 +297,7 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPUnprocessableEntity())
         return exc.HTTPAccepted()
 
-    def get_lock(self, req, id, **kw):
+    def get_lock(self, req, id):
         """
         return the boolean state of (instance with id)'s lock
 
@@ -311,7 +311,7 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPUnprocessableEntity())
         return exc.HTTPAccepted()
 
-    def reset_network(self, req, id, **kw):
+    def reset_network(self, req, id):
         """
         Reset networking on an instance (admin only).
 
@@ -325,7 +325,7 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPUnprocessableEntity())
         return exc.HTTPAccepted()
 
-    def inject_network_info(self, req, id, **kw):
+    def inject_network_info(self, req, id):
         """
         Inject network info for an instance (admin only).
 
@@ -339,7 +339,7 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPUnprocessableEntity())
         return exc.HTTPAccepted()
 
-    def pause(self, req, id, **kw):
+    def pause(self, req, id):
         """ Permit Admins to Pause the server. """
         ctxt = req.environ['nova.context']
         try:
@@ -350,7 +350,7 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPUnprocessableEntity())
         return exc.HTTPAccepted()
 
-    def unpause(self, req, id, **kw):
+    def unpause(self, req, id):
         """ Permit Admins to Unpause the server. """
         ctxt = req.environ['nova.context']
         try:
@@ -361,7 +361,7 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPUnprocessableEntity())
         return exc.HTTPAccepted()
 
-    def suspend(self, req, id, **kw):
+    def suspend(self, req, id):
         """permit admins to suspend the server"""
         context = req.environ['nova.context']
         try:
@@ -372,7 +372,7 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPUnprocessableEntity())
         return exc.HTTPAccepted()
 
-    def resume(self, req, id, **kw):
+    def resume(self, req, id):
         """permit admins to resume the server from suspend"""
         context = req.environ['nova.context']
         try:
@@ -383,7 +383,7 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPUnprocessableEntity())
         return exc.HTTPAccepted()
 
-    def rescue(self, req, id, **kw):
+    def rescue(self, req, id):
         """Permit users to rescue the server."""
         context = req.environ["nova.context"]
         try:
@@ -394,7 +394,7 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPUnprocessableEntity())
         return exc.HTTPAccepted()
 
-    def unrescue(self, req, id, **kw):
+    def unrescue(self, req, id):
         """Permit users to unrescue the server."""
         context = req.environ["nova.context"]
         try:
@@ -405,7 +405,7 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPUnprocessableEntity())
         return exc.HTTPAccepted()
 
-    def get_ajax_console(self, req, id, **kw):
+    def get_ajax_console(self, req, id):
         """ Returns a url to an instance's ajaxterm console. """
         try:
             self.compute_api.get_ajax_console(req.environ['nova.context'],
@@ -414,12 +414,12 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPNotFound())
         return exc.HTTPAccepted()
 
-    def diagnostics(self, req, id, **kw):
+    def diagnostics(self, req, id):
         """Permit Admins to retrieve server diagnostics."""
         ctxt = req.environ["nova.context"]
         return self.compute_api.get_diagnostics(ctxt, id)
 
-    def actions(self, req, id, **kw):
+    def actions(self, req, id):
         """Permit Admins to retrieve server actions."""
         ctxt = req.environ["nova.context"]
         items = self.compute_api.get_actions(ctxt, id)
diff --git a/nova/api/openstack/shared_ip_groups.py b/nova/api/openstack/shared_ip_groups.py
index e3c917749..5d78f9377 100644
--- a/nova/api/openstack/shared_ip_groups.py
+++ b/nova/api/openstack/shared_ip_groups.py
@@ -40,26 +40,26 @@ class Controller(wsgi.Controller):
             'attributes': {
                 'sharedIpGroup': []}}}
 
-    def index(self, req, **kw):
+    def index(self, req):
         """ Returns a list of Shared IP Groups for the user """
         return dict(sharedIpGroups=[])
 
-    def show(self, req, id, **kw):
+    def show(self, req, id):
         """ Shows in-depth information on a specific Shared IP Group """
         return _translate_keys({})
 
-    def update(self, req, id, **kw):
+    def update(self, req, id):
         """ You can't update a Shared IP Group """
         raise faults.Fault(exc.HTTPNotImplemented())
 
-    def delete(self, req, id, **kw):
+    def delete(self, req, id):
         """ Deletes a Shared IP Group """
         raise faults.Fault(exc.HTTPNotImplemented())
 
-    def detail(self, req, **kw):
+    def detail(self, req):
         """ Returns a complete list of Shared IP Groups """
         return _translate_detail_keys({})
 
-    def create(self, req, **kw):
+    def create(self, req):
         """ Creates a new Shared IP group """
         raise faults.Fault(exc.HTTPNotImplemented())
diff --git a/nova/api/openstack/users.py b/nova/api/openstack/users.py
index ae3bf7791..83ebec964 100644
--- a/nova/api/openstack/users.py
+++ b/nova/api/openstack/users.py
@@ -50,28 +50,28 @@ class Controller(wsgi.Controller):
         if not context.is_admin:
             raise exception.NotAuthorized(_("Not admin user"))
 
-    def index(self, req, **kw):
+    def index(self, req):
         """Return all users in brief"""
         users = self.manager.get_users()
         users = common.limited(users, req)
         users = [_translate_keys(user) for user in users]
         return dict(users=users)
 
-    def detail(self, req, **kw):
+    def detail(self, req):
         """Return all users in detail"""
         return self.index(req)
 
-    def show(self, req, id, **kw):
+    def show(self, req, id):
         """Return data about the given user id"""
         user = self.manager.get_user(id)
         return dict(user=_translate_keys(user))
 
-    def delete(self, req, id, **kw):
+    def delete(self, req, id):
         self._check_admin(req.environ['nova.context'])
         self.manager.delete_user(id)
         return {}
 
-    def create(self, req, **kw):
+    def create(self, req):
         self._check_admin(req.environ['nova.context'])
         env = self._deserialize(req.body, req)
         is_admin = env['user'].get('admin') in ('T', 'True', True)
@@ -81,7 +81,7 @@ class Controller(wsgi.Controller):
         user = self.manager.create_user(name, access, secret, is_admin)
         return dict(user=_translate_keys(user))
 
-    def update(self, req, id, **kw):
+    def update(self, req, id):
         self._check_admin(req.environ['nova.context'])
         env = self._deserialize(req.body, req)
         is_admin = env['user'].get('admin')
diff --git a/nova/api/openstack/zones.py b/nova/api/openstack/zones.py
index 30bf2b67b..d5206da20 100644
--- a/nova/api/openstack/zones.py
+++ b/nova/api/openstack/zones.py
@@ -43,35 +43,35 @@ class Controller(wsgi.Controller):
             "attributes": {
                 "zone": ["id", "api_url"]}}}
 
-    def index(self, req, **kw):
+    def index(self, req):
         """Return all zones in brief"""
         items = db.zone_get_all(req.environ['nova.context'])
         items = common.limited(items, req)
         items = [_scrub_zone(item) for item in items]
         return dict(zones=items)
 
-    def detail(self, req, **kw):
+    def detail(self, req):
         """Return all zones in detail"""
         return self.index(req)
 
-    def show(self, req, id, **kw):
+    def show(self, req, id):
         """Return data about the given zone id"""
         zone_id = int(id)
         zone = db.zone_get(req.environ['nova.context'], zone_id)
         return dict(zone=_scrub_zone(zone))
 
-    def delete(self, req, id, **kw):
+    def delete(self, req, id):
         zone_id = int(id)
         db.zone_delete(req.environ['nova.context'], zone_id)
         return {}
 
-    def create(self, req, **kw):
+    def create(self, req):
         context = req.environ['nova.context']
         env = self._deserialize(req.body, req)
         zone = db.zone_create(context, env["zone"])
         return dict(zone=_scrub_zone(zone))
 
-    def update(self, req, id, **kw):
+    def update(self, req, id):
         context = req.environ['nova.context']
         env = self._deserialize(req.body, req)
         zone_id = int(id)
-- 
cgit 


From e44f085ed464a3397e3bf89a3e5355e538c71a65 Mon Sep 17 00:00:00 2001
From: Ricardo Carrillo Cruz <emaildericky@gmail.com>
Date: Wed, 9 Mar 2011 19:16:26 +0100
Subject: Fixed pep8 issues

---
 nova/db/api.py            | 7 +++++--
 nova/db/sqlalchemy/api.py | 7 +++++--
 nova/network/manager.py   | 4 ++--
 3 files changed, 12 insertions(+), 6 deletions(-)

(limited to 'nova')

diff --git a/nova/db/api.py b/nova/db/api.py
index 7ad99c1f4..5c34a02e4 100644
--- a/nova/db/api.py
+++ b/nova/db/api.py
@@ -459,6 +459,7 @@ def network_associate(context, project_id):
     """Associate a free network to a project."""
     return IMPL.network_associate(context, project_id)
 
+
 def network_count(context):
     """Return the number of networks."""
     return IMPL.network_count(context)
@@ -488,9 +489,9 @@ def network_create_safe(context, values):
     """
     return IMPL.network_create_safe(context, values)
 
+
 def network_delete_safe(context, network_id):
-    """Delete network with key network_id
-     
+    """Delete network with key network_id.
     This method assumes that the network is not associated with any project
     """
     return IMPL.network_delete_safe(context, network_id)
@@ -531,10 +532,12 @@ def network_get_by_bridge(context, bridge):
     """Get a network by bridge or raise if it does not exist."""
     return IMPL.network_get_by_bridge(context, bridge)
 
+
 def network_get_by_cidr(context, cidr):
     """Get a network by cidr or raise if it does not exist"""
     return IMPL.network_get_by_cidr(context, cidr)
 
+
 def network_get_by_instance(context, instance_id):
     """Get a network by instance id or raise if it does not exist."""
     return IMPL.network_get_by_instance(context, instance_id)
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 90730d325..3a1162a17 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -1042,12 +1042,14 @@ def network_create_safe(context, values):
     except IntegrityError:
         return None
 
+
 @require_admin_context
 def network_delete_safe(context, network_id):
     session = get_session()
     with session.begin():
-        network_ref = network_get(context, network_id=network_id, session=session)
-        session.delete(network_ref)        
+        network_ref = network_get(context, network_id=network_id, \
+                                  session=session)
+        session.delete(network_ref)
 
 
 @require_admin_context
@@ -1134,6 +1136,7 @@ def network_get_by_cidr(context, cidr):
                                   cidr)
     return result
 
+
 @require_admin_context
 def network_get_by_instance(_context, instance_id):
     session = get_session()
diff --git a/nova/network/manager.py b/nova/network/manager.py
index 39da031eb..3dfc48934 100644
--- a/nova/network/manager.py
+++ b/nova/network/manager.py
@@ -568,11 +568,11 @@ class VlanManager(NetworkManager):
                 network_ref = db.network_get_by_cidr(context, cidr)
             except exception.NotFound:
                 pass
-            
+
             if network_ref is not None:
                 raise ValueError(_('Network with cidr %s already exists' %
                                    cidr))
-            
+
             network_ref = self.db.network_create_safe(context, net)
             if network_ref:
                 self._create_fixed_ips(context, network_ref['id'])
-- 
cgit 


From 1166e16d08769222189e31e6de1c6019495fc743 Mon Sep 17 00:00:00 2001
From: Mark Washenberger <mark.washenberger@rackspace.com>
Date: Wed, 9 Mar 2011 13:54:30 -0500
Subject: move my tests into their own testcase

---
 nova/tests/api/openstack/test_servers.py | 447 +++++++++++++++++--------------
 1 file changed, 243 insertions(+), 204 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index f2fbb04af..b0f888766 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -238,210 +238,6 @@ class ServersTest(test.TestCase):
 
         self.assertEqual(res.status_int, 200)
 
-    def _setup_mock_compute_api_for_personality(self):
-
-        class MockComputeAPI(object):
-
-            def __init__(self):
-                self.personality_files = None
-
-            def create(self, *args, **kwargs):
-                if 'personality_files' in kwargs:
-                    self.personality_files = kwargs['personality_files']
-                else:
-                    self.personality_files = None
-                return [{'id': '1234', 'display_name': 'fakeinstance'}]
-
-        def make_stub_method(canned_return):
-            def stub_method(*args, **kwargs):
-                return canned_return
-            return stub_method
-
-        compute_api = MockComputeAPI()
-        self.stubs.Set(nova.compute, 'API', make_stub_method(compute_api))
-        self.stubs.Set(nova.api.openstack.servers.Controller,
-            '_get_kernel_ramdisk_from_image', make_stub_method((1, 1)))
-        self.stubs.Set(nova.api.openstack.common,
-            'get_image_id_from_image_hash', make_stub_method(2))
-        return compute_api
-
-    def _create_personality_request_dict(self, personality_files):
-        server = {}
-        server['name'] = 'new-server-test'
-        server['imageId'] = 1
-        server['flavorId'] = 1
-        if personality_files is not None:
-            personalities = []
-            for path, contents in personality_files:
-                personalities.append({'path': path, 'contents': contents})
-            server['personality'] = personalities
-        return {'server': server}
-
-    def _get_create_request_json(self, body_dict):
-        req = webob.Request.blank('/v1.0/servers')
-        req.content_type = 'application/json'
-        req.method = 'POST'
-        req.body = json.dumps(body_dict)
-        return req
-
-    def _run_create_instance_with_mock_compute_api(self, request):
-        compute_api = self._setup_mock_compute_api_for_personality()
-        response = request.get_response(fakes.wsgi_app())
-        return compute_api, response
-
-    def _format_xml_request_body(self, body_dict):
-        server = body_dict['server']
-        body_parts = []
-        body_parts.extend([
-            '<?xml version="1.0" encoding="UTF-8"?>',
-            '<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"',
-            ' name="%s" imageId="%s" flavorId="%s">' % (
-                    server['name'], server['imageId'], server['flavorId'])])
-        if 'metadata' in server:
-            metadata = server['metadata']
-            body_parts.append('<metadata>')
-            for item in metadata.iteritems():
-                body_parts.append('<meta key="%s">%s</meta>' % item)
-            body_parts.append('</metadata>')
-        if 'personality' in server:
-            personalities = server['personality']
-            body_parts.append('<personality>')
-            for file in personalities:
-                item = (file['path'], file['contents'])
-                body_parts.append('<file path="%s">%s</file>' % item)
-            body_parts.append('</personality>')
-        body_parts.append('</server>')
-        return ''.join(body_parts)
-
-    def _get_create_request_xml(self, body_dict):
-        req = webob.Request.blank('/v1.0/servers')
-        req.content_type = 'application/xml'
-        req.method = 'POST'
-        req.body = self._format_xml_request_body(body_dict)
-        return req
-
-    def _create_instance_with_personality_json(self, personality):
-        body_dict = self._create_personality_request_dict(personality)
-        request = self._get_create_request_json(body_dict)
-        compute_api, response = \
-            self._run_create_instance_with_mock_compute_api(request)
-        return request, response, compute_api.personality_files
-
-    def _create_instance_with_personality_xml(self, personality):
-        body_dict = self._create_personality_request_dict(personality)
-        request = self._get_create_request_xml(body_dict)
-        compute_api, response = \
-            self._run_create_instance_with_mock_compute_api(request)
-        return request, response, compute_api.personality_files
-
-    def test_create_instance_with_no_personality(self):
-        request, response, personality_files = \
-                self._create_instance_with_personality_json(personality=None)
-        self.assertEquals(response.status_int, 200)
-        self.assertEquals(personality_files, [])
-
-    def test_create_instance_with_no_personality_xml(self):
-        request, response, personality_files = \
-                self._create_instance_with_personality_xml(personality=None)
-        self.assertEquals(response.status_int, 200)
-        self.assertEquals(personality_files, [])
-
-    def test_create_instance_with_personality(self):
-        path = '/my/file/path'
-        contents = '#!/bin/bash\necho "Hello, World!"\n'
-        b64contents = base64.b64encode(contents)
-        personality = [(path, b64contents)]
-        request, response, personality_files = \
-            self._create_instance_with_personality_json(personality)
-        self.assertEquals(response.status_int, 200)
-        self.assertEquals(personality_files, [(path, contents)])
-
-    def test_create_instance_with_personality_xml(self):
-        path = '/my/file/path'
-        contents = '#!/bin/bash\necho "Hello, World!"\n'
-        b64contents = base64.b64encode(contents)
-        personality = [(path, b64contents)]
-        request, response, personality_files = \
-            self._create_instance_with_personality_xml(personality)
-        self.assertEquals(response.status_int, 200)
-        self.assertEquals(personality_files, [(path, contents)])
-
-    def test_create_instance_with_personality_no_path(self):
-        personality = [('/remove/this/path',
-            base64.b64encode('my\n\file\ncontents'))]
-        body_dict = self._create_personality_request_dict(personality)
-        del body_dict['server']['personality'][0]['path']
-        request = self._get_create_request_json(body_dict)
-        compute_api, response = \
-            self._run_create_instance_with_mock_compute_api(request)
-        self.assertEquals(response.status_int, 400)
-        self.assertEquals(compute_api.personality_files, None)
-
-    def _test_create_instance_with_personality_no_path_xml(self):
-        personality = [('/remove/this/path',
-            base64.b64encode('my\n\file\ncontents'))]
-        body_dict = self._create_personality_request_dict(personality)
-        request = self._get_create_request_xml(body_dict)
-        request.body = request.body.replace(' path="/remove/this/path"', '')
-        compute_api, response = \
-            self._run_create_instance_with_mock_compute_api(request)
-        self.assertEquals(response.status_int, 400)
-        self.assertEquals(compute_api.personality_files, None)
-
-    def test_create_instance_with_personality_no_contents(self):
-        personality = [('/test/path',
-            base64.b64encode('remove\nthese\ncontents'))]
-        body_dict = self._create_personality_request_dict(personality)
-        del body_dict['server']['personality'][0]['contents']
-        request = self._get_create_request_json(body_dict)
-        compute_api, response = \
-            self._run_create_instance_with_mock_compute_api(request)
-        self.assertEquals(response.status_int, 400)
-        self.assertEquals(compute_api.personality_files, None)
-
-    def test_create_instance_with_personality_not_a_list(self):
-        personality = [('/test/path', base64.b64encode('test\ncontents\n'))]
-        body_dict = self._create_personality_request_dict(personality)
-        body_dict['server']['personality'] = \
-            body_dict['server']['personality'][0]
-        request = self._get_create_request_json(body_dict)
-        compute_api, response = \
-            self._run_create_instance_with_mock_compute_api(request)
-        self.assertEquals(response.status_int, 400)
-        self.assertEquals(compute_api.personality_files, None)
-
-    def test_create_instance_with_personality_with_non_b64_content(self):
-        path = '/my/file/path'
-        contents = '#!/bin/bash\necho "Oh no!"\n'
-        personality = [(path, contents)]
-        request, response, personality_files = \
-            self._create_instance_with_personality_json(personality)
-        self.assertEquals(response.status_int, 400)
-        self.assertEquals(personality_files, None)
-
-    def test_create_instance_with_three_personalities(self):
-        files = [
-            ('/etc/sudoers', 'ALL ALL=NOPASSWD: ALL\n'),
-            ('/etc/motd', 'Enjoy your root access!\n'),
-            ('/etc/dovecot.conf', 'dovecot\nconfig\nstuff\n'),
-            ]
-        personality = []
-        for path, content in files:
-            personality.append((path, base64.b64encode(content)))
-        request, response, personality_files = \
-            self._create_instance_with_personality_json(personality)
-        self.assertEquals(response.status_int, 200)
-        self.assertEquals(personality_files, files)
-
-    def test_create_instance_personality_empty_content(self):
-        path = '/my/file/path'
-        contents = ''
-        personality = [(path, contents)]
-        request, response, personality_files = \
-            self._create_instance_with_personality_json(personality)
-        self.assertEquals(response.status_int, 200)
-        self.assertEquals(personality_files, [(path, contents)])
-
     def test_update_no_body(self):
         req = webob.Request.blank('/v1.0/servers/1')
         req.method = 'PUT'
@@ -980,5 +776,248 @@ b25zLiINCg0KLVJpY2hhcmQgQmFjaA==""",
         self.assertEqual(request, expected)
 
 
+class TestServerInstanceCreation(test.TestCase):
+
+    def setUp(self):
+        super(TestServerInstanceCreation, self).setUp()
+        self.stubs = stubout.StubOutForTesting()
+        fakes.FakeAuthManager.auth_data = {}
+        fakes.FakeAuthDatabase.data = {}
+        fakes.stub_out_networking(self.stubs)
+        fakes.stub_out_rate_limiting(self.stubs)
+        fakes.stub_out_auth(self.stubs)
+        fakes.stub_out_key_pair_funcs(self.stubs)
+        fakes.stub_out_image_service(self.stubs)
+        self.stubs.Set(nova.db.api, 'instance_get_all', return_servers)
+        self.stubs.Set(nova.db.api, 'instance_get', return_server)
+        self.stubs.Set(nova.db.api, 'instance_get_all_by_user',
+                       return_servers)
+        self.stubs.Set(nova.db.api, 'instance_add_security_group',
+                       return_security_group)
+        self.stubs.Set(nova.db.api, 'instance_update', instance_update)
+        self.stubs.Set(nova.db.api, 'instance_get_fixed_address',
+                       instance_address)
+        self.stubs.Set(nova.db.api, 'instance_get_floating_address',
+                       instance_address)
+        self.stubs.Set(nova.compute.API, 'pause', fake_compute_api)
+        self.stubs.Set(nova.compute.API, 'unpause', fake_compute_api)
+        self.stubs.Set(nova.compute.API, 'suspend', fake_compute_api)
+        self.stubs.Set(nova.compute.API, 'resume', fake_compute_api)
+        self.stubs.Set(nova.compute.API, "get_diagnostics", fake_compute_api)
+        self.stubs.Set(nova.compute.API, "get_actions", fake_compute_api)
+        self.allow_admin = FLAGS.allow_admin_api
+
+        self.webreq = common.webob_factory('/v1.0/servers')
+
+    def tearDown(self):
+        self.stubs.UnsetAll()
+        FLAGS.allow_admin_api = self.allow_admin
+        super(TestServerInstanceCreation, self).tearDown()
+
+    def _setup_mock_compute_api_for_personality(self):
+
+        class MockComputeAPI(object):
+
+            def __init__(self):
+                self.personality_files = None
+
+            def create(self, *args, **kwargs):
+                if 'personality_files' in kwargs:
+                    self.personality_files = kwargs['personality_files']
+                else:
+                    self.personality_files = None
+                return [{'id': '1234', 'display_name': 'fakeinstance'}]
+
+        def make_stub_method(canned_return):
+            def stub_method(*args, **kwargs):
+                return canned_return
+            return stub_method
+
+        compute_api = MockComputeAPI()
+        self.stubs.Set(nova.compute, 'API', make_stub_method(compute_api))
+        self.stubs.Set(nova.api.openstack.servers.Controller,
+            '_get_kernel_ramdisk_from_image', make_stub_method((1, 1)))
+        self.stubs.Set(nova.api.openstack.common,
+            'get_image_id_from_image_hash', make_stub_method(2))
+        return compute_api
+
+    def _create_personality_request_dict(self, personality_files):
+        server = {}
+        server['name'] = 'new-server-test'
+        server['imageId'] = 1
+        server['flavorId'] = 1
+        if personality_files is not None:
+            personalities = []
+            for path, contents in personality_files:
+                personalities.append({'path': path, 'contents': contents})
+            server['personality'] = personalities
+        return {'server': server}
+
+    def _get_create_request_json(self, body_dict):
+        req = webob.Request.blank('/v1.0/servers')
+        req.content_type = 'application/json'
+        req.method = 'POST'
+        req.body = json.dumps(body_dict)
+        return req
+
+    def _run_create_instance_with_mock_compute_api(self, request):
+        compute_api = self._setup_mock_compute_api_for_personality()
+        response = request.get_response(fakes.wsgi_app())
+        return compute_api, response
+
+    def _format_xml_request_body(self, body_dict):
+        server = body_dict['server']
+        body_parts = []
+        body_parts.extend([
+            '<?xml version="1.0" encoding="UTF-8"?>',
+            '<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"',
+            ' name="%s" imageId="%s" flavorId="%s">' % (
+                    server['name'], server['imageId'], server['flavorId'])])
+        if 'metadata' in server:
+            metadata = server['metadata']
+            body_parts.append('<metadata>')
+            for item in metadata.iteritems():
+                body_parts.append('<meta key="%s">%s</meta>' % item)
+            body_parts.append('</metadata>')
+        if 'personality' in server:
+            personalities = server['personality']
+            body_parts.append('<personality>')
+            for file in personalities:
+                item = (file['path'], file['contents'])
+                body_parts.append('<file path="%s">%s</file>' % item)
+            body_parts.append('</personality>')
+        body_parts.append('</server>')
+        return ''.join(body_parts)
+
+    def _get_create_request_xml(self, body_dict):
+        req = webob.Request.blank('/v1.0/servers')
+        req.content_type = 'application/xml'
+        req.method = 'POST'
+        req.body = self._format_xml_request_body(body_dict)
+        return req
+
+    def _create_instance_with_personality_json(self, personality):
+        body_dict = self._create_personality_request_dict(personality)
+        request = self._get_create_request_json(body_dict)
+        compute_api, response = \
+            self._run_create_instance_with_mock_compute_api(request)
+        return request, response, compute_api.personality_files
+
+    def _create_instance_with_personality_xml(self, personality):
+        body_dict = self._create_personality_request_dict(personality)
+        request = self._get_create_request_xml(body_dict)
+        compute_api, response = \
+            self._run_create_instance_with_mock_compute_api(request)
+        return request, response, compute_api.personality_files
+
+    def test_create_instance_with_no_personality(self):
+        request, response, personality_files = \
+                self._create_instance_with_personality_json(personality=None)
+        self.assertEquals(response.status_int, 200)
+        self.assertEquals(personality_files, [])
+
+    def test_create_instance_with_no_personality_xml(self):
+        request, response, personality_files = \
+                self._create_instance_with_personality_xml(personality=None)
+        self.assertEquals(response.status_int, 200)
+        self.assertEquals(personality_files, [])
+
+    def test_create_instance_with_personality(self):
+        path = '/my/file/path'
+        contents = '#!/bin/bash\necho "Hello, World!"\n'
+        b64contents = base64.b64encode(contents)
+        personality = [(path, b64contents)]
+        request, response, personality_files = \
+            self._create_instance_with_personality_json(personality)
+        self.assertEquals(response.status_int, 200)
+        self.assertEquals(personality_files, [(path, contents)])
+
+    def test_create_instance_with_personality_xml(self):
+        path = '/my/file/path'
+        contents = '#!/bin/bash\necho "Hello, World!"\n'
+        b64contents = base64.b64encode(contents)
+        personality = [(path, b64contents)]
+        request, response, personality_files = \
+            self._create_instance_with_personality_xml(personality)
+        self.assertEquals(response.status_int, 200)
+        self.assertEquals(personality_files, [(path, contents)])
+
+    def test_create_instance_with_personality_no_path(self):
+        personality = [('/remove/this/path',
+            base64.b64encode('my\n\file\ncontents'))]
+        body_dict = self._create_personality_request_dict(personality)
+        del body_dict['server']['personality'][0]['path']
+        request = self._get_create_request_json(body_dict)
+        compute_api, response = \
+            self._run_create_instance_with_mock_compute_api(request)
+        self.assertEquals(response.status_int, 400)
+        self.assertEquals(compute_api.personality_files, None)
+
+    def _test_create_instance_with_personality_no_path_xml(self):
+        personality = [('/remove/this/path',
+            base64.b64encode('my\n\file\ncontents'))]
+        body_dict = self._create_personality_request_dict(personality)
+        request = self._get_create_request_xml(body_dict)
+        request.body = request.body.replace(' path="/remove/this/path"', '')
+        compute_api, response = \
+            self._run_create_instance_with_mock_compute_api(request)
+        self.assertEquals(response.status_int, 400)
+        self.assertEquals(compute_api.personality_files, None)
+
+    def test_create_instance_with_personality_no_contents(self):
+        personality = [('/test/path',
+            base64.b64encode('remove\nthese\ncontents'))]
+        body_dict = self._create_personality_request_dict(personality)
+        del body_dict['server']['personality'][0]['contents']
+        request = self._get_create_request_json(body_dict)
+        compute_api, response = \
+            self._run_create_instance_with_mock_compute_api(request)
+        self.assertEquals(response.status_int, 400)
+        self.assertEquals(compute_api.personality_files, None)
+
+    def test_create_instance_with_personality_not_a_list(self):
+        personality = [('/test/path', base64.b64encode('test\ncontents\n'))]
+        body_dict = self._create_personality_request_dict(personality)
+        body_dict['server']['personality'] = \
+            body_dict['server']['personality'][0]
+        request = self._get_create_request_json(body_dict)
+        compute_api, response = \
+            self._run_create_instance_with_mock_compute_api(request)
+        self.assertEquals(response.status_int, 400)
+        self.assertEquals(compute_api.personality_files, None)
+
+    def test_create_instance_with_personality_with_non_b64_content(self):
+        path = '/my/file/path'
+        contents = '#!/bin/bash\necho "Oh no!"\n'
+        personality = [(path, contents)]
+        request, response, personality_files = \
+            self._create_instance_with_personality_json(personality)
+        self.assertEquals(response.status_int, 400)
+        self.assertEquals(personality_files, None)
+
+    def test_create_instance_with_three_personalities(self):
+        files = [
+            ('/etc/sudoers', 'ALL ALL=NOPASSWD: ALL\n'),
+            ('/etc/motd', 'Enjoy your root access!\n'),
+            ('/etc/dovecot.conf', 'dovecot\nconfig\nstuff\n'),
+            ]
+        personality = []
+        for path, content in files:
+            personality.append((path, base64.b64encode(content)))
+        request, response, personality_files = \
+            self._create_instance_with_personality_json(personality)
+        self.assertEquals(response.status_int, 200)
+        self.assertEquals(personality_files, files)
+
+    def test_create_instance_personality_empty_content(self):
+        path = '/my/file/path'
+        contents = ''
+        personality = [(path, contents)]
+        request, response, personality_files = \
+            self._create_instance_with_personality_json(personality)
+        self.assertEquals(response.status_int, 200)
+        self.assertEquals(personality_files, [(path, contents)])
+
+
 if __name__ == "__main__":
     unittest.main()
-- 
cgit 


From 3999bb363501c6587f75255333094c9e61bf1828 Mon Sep 17 00:00:00 2001
From: Mark Washenberger <mark.washenberger@rackspace.com>
Date: Wed, 9 Mar 2011 14:07:33 -0500
Subject: remove unneeded stubs

---
 nova/tests/api/openstack/test_servers.py | 22 ----------------------
 1 file changed, 22 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index b0f888766..c67ecdaae 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -783,32 +783,10 @@ class TestServerInstanceCreation(test.TestCase):
         self.stubs = stubout.StubOutForTesting()
         fakes.FakeAuthManager.auth_data = {}
         fakes.FakeAuthDatabase.data = {}
-        fakes.stub_out_networking(self.stubs)
-        fakes.stub_out_rate_limiting(self.stubs)
         fakes.stub_out_auth(self.stubs)
         fakes.stub_out_key_pair_funcs(self.stubs)
-        fakes.stub_out_image_service(self.stubs)
-        self.stubs.Set(nova.db.api, 'instance_get_all', return_servers)
-        self.stubs.Set(nova.db.api, 'instance_get', return_server)
-        self.stubs.Set(nova.db.api, 'instance_get_all_by_user',
-                       return_servers)
-        self.stubs.Set(nova.db.api, 'instance_add_security_group',
-                       return_security_group)
-        self.stubs.Set(nova.db.api, 'instance_update', instance_update)
-        self.stubs.Set(nova.db.api, 'instance_get_fixed_address',
-                       instance_address)
-        self.stubs.Set(nova.db.api, 'instance_get_floating_address',
-                       instance_address)
-        self.stubs.Set(nova.compute.API, 'pause', fake_compute_api)
-        self.stubs.Set(nova.compute.API, 'unpause', fake_compute_api)
-        self.stubs.Set(nova.compute.API, 'suspend', fake_compute_api)
-        self.stubs.Set(nova.compute.API, 'resume', fake_compute_api)
-        self.stubs.Set(nova.compute.API, "get_diagnostics", fake_compute_api)
-        self.stubs.Set(nova.compute.API, "get_actions", fake_compute_api)
         self.allow_admin = FLAGS.allow_admin_api
 
-        self.webreq = common.webob_factory('/v1.0/servers')
-
     def tearDown(self):
         self.stubs.UnsetAll()
         FLAGS.allow_admin_api = self.allow_admin
-- 
cgit 


From 23369a63f4b74fb64bf57554a3fd8b15e3e2b49c Mon Sep 17 00:00:00 2001
From: Eric Windisch <eric@cloudscaling.com>
Date: Wed, 9 Mar 2011 14:31:23 -0500
Subject: Fixes uses of process_input

---
 nova/utils.py             |  4 ++--
 nova/virt/disk.py         |  4 ++--
 nova/virt/libvirt_conn.py | 11 ++++-------
 3 files changed, 8 insertions(+), 11 deletions(-)

(limited to 'nova')

diff --git a/nova/utils.py b/nova/utils.py
index 7ddf056ea..0937522ec 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -131,7 +131,7 @@ def fetchfile(url, target):
 def execute(*cmd, **kwargs):
     process_input=kwargs.get('process_input', None)
     addl_env=kwargs.get('addl_env', None)
-    check_exit_code=kwargs.get('check_exit_code', True)
+    check_exit_code=kwargs.get('check_exit_code', 0)
     stdin=kwargs.get('stdin', subprocess.PIPE)
     stdout=kwargs.get('stdout', subprocess.PIPE)
     stderr=kwargs.get('stderr', subprocess.PIPE)
@@ -151,7 +151,7 @@ def execute(*cmd, **kwargs):
     obj.stdin.close()
     if obj.returncode:
         LOG.debug(_("Result was %s") % obj.returncode)
-        if check_exit_code and obj.returncode != 0:
+        if check_exit_code is not None and obj.returncode != check_exit_code:
             (stdout, stderr) = result
             raise ProcessExecutionError(exit_code=obj.returncode,
                                         stdout=stdout,
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', '</dev/null || echo free' % (port)
-                stdout, stderr = utils.execute(cmd)
-                if stdout.strip() == 'free':
+                cmd = 'netcat', '0.0.0.0', port, '-w', '1'
+                try:
+                    stdout, stderr = utils.execute(*cmd, process_input='')
+                except ProcessExecutionError:
                     return port
             raise Exception(_('Unable to find an open port'))
 
-- 
cgit 


From 2c733d5365b753989b506d82d376d980cd701547 Mon Sep 17 00:00:00 2001
From: Mark Washenberger <mark.washenberger@rackspace.com>
Date: Wed, 9 Mar 2011 14:38:34 -0500
Subject: rearrange functions and add docstrings

---
 nova/api/openstack/servers.py | 83 ++++++++++++++++++++++++++-----------------
 1 file changed, 50 insertions(+), 33 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 4a18d870c..419a001fb 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -141,39 +141,6 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPNotFound())
         return exc.HTTPAccepted()
 
-    def _get_personality_files(self, personality):
-        """
-        Create a list of personality files from the personality attribute
-
-        At this time, personality_files must be formatted as a list of
-        (file_path, file_content) pairs for compatibility with the
-        underlying compute service.
-        """
-        personality_files = []
-        for item in personality:
-            try:
-                path = item['path']
-                contents = item['contents']
-            except KeyError as key:
-                expl = 'Bad personality format: missing %s' % key
-                raise exc.HTTPBadRequest(explanation=expl)
-            except TypeError:
-                raise exc.HTTPBadRequest(explanation='Bad personality format')
-            try:
-                contents = base64.b64decode(contents)
-            except TypeError:
-                msg = 'Personality content for %s cannot be decoded' % path
-                raise exc.HTTPBadRequest(explanation=msg)
-            personality_files.append((path, contents))
-        return personality_files
-
-    def _deserialize_create(self, request):
-        if request.content_type == "application/xml":
-            deserializer = ServerCreateRequestXMLDeserializer()
-            return deserializer.deserialize(request.body)
-        else:
-            return self._deserialize(request.body, request)
-
     def create(self, req):
         """ Creates a new server for a given user """
         env = self._deserialize_create(req)
@@ -218,6 +185,44 @@ class Controller(wsgi.Controller):
             personality_files=personality_files)
         return _translate_keys(instances[0])
 
+    def _deserialize_create(self, request):
+        """
+        Deserialize a create request
+
+        Overrides normal behavior in the case of xml content
+        """
+        if request.content_type == "application/xml":
+            deserializer = ServerCreateRequestXMLDeserializer()
+            return deserializer.deserialize(request.body)
+        else:
+            return self._deserialize(request.body, request)
+
+    def _get_personality_files(self, personality):
+        """
+        Create a list of personality files from the personality attribute
+
+        At this time, personality_files must be formatted as a list of
+        (file_path, file_content) pairs for compatibility with the
+        underlying compute service.
+        """
+        personality_files = []
+        for item in personality:
+            try:
+                path = item['path']
+                contents = item['contents']
+            except KeyError as key:
+                expl = 'Bad personality format: missing %s' % key
+                raise exc.HTTPBadRequest(explanation=expl)
+            except TypeError:
+                raise exc.HTTPBadRequest(explanation='Bad personality format')
+            try:
+                contents = base64.b64decode(contents)
+            except TypeError:
+                msg = 'Personality content for %s cannot be decoded' % path
+                raise exc.HTTPBadRequest(explanation=msg)
+            personality_files.append((path, contents))
+        return personality_files
+
     def update(self, req, id):
         """ Updates the server name or password """
         inst_dict = self._deserialize(req.body, req)
@@ -507,13 +512,21 @@ class Controller(wsgi.Controller):
 
 
 class ServerCreateRequestXMLDeserializer(object):
+    """
+    Deserializer to handle xml-formatted server create requests.
+
+    Handles standard server attributes as well as optional metadata
+    and personality attributes
+    """
 
     def deserialize(self, string):
+        """Deserialize an xml-formatted server create request"""
         dom = minidom.parseString(string)
         server = self._extract_server(dom)
         return {'server': server}
 
     def _extract_server(self, node):
+        """Marshal the server attribute of a parsed request"""
         server = {}
         server_node = self._find_first_child_named(node, 'server')
         for attr in ["name", "imageId", "flavorId"]:
@@ -527,6 +540,7 @@ class ServerCreateRequestXMLDeserializer(object):
         return server
 
     def _extract_metadata(self, server_node):
+        """Marshal the metadata attribute of a parsed request"""
         metadata_node = self._find_first_child_named(server_node, "metadata")
         if metadata_node is None:
             return None
@@ -537,6 +551,7 @@ class ServerCreateRequestXMLDeserializer(object):
         return metadata
 
     def _extract_personality(self, server_node):
+        """Marshal the personality attribute of a parsed request"""
         personality_node = \
                 self._find_first_child_named(server_node, "personality")
         if personality_node is None:
@@ -551,12 +566,14 @@ class ServerCreateRequestXMLDeserializer(object):
         return personality
 
     def _find_first_child_named(self, parent, name):
+        """Search a nodes children for the first child with a given name"""
         for node in parent.childNodes:
             if node.nodeName == name:
                 return node
         return None
 
     def _extract_text(self, node):
+        """Get the text field contained by the given node"""
         if len(node.childNodes) == 1:
             child = node.childNodes[0]
             if child.nodeType == child.TEXT_NODE:
-- 
cgit 


From 80a6dc5504378ae3d96829d96c02f50b9daa3029 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Wed, 9 Mar 2011 13:46:05 -0600
Subject: stuff

---
 nova/compute/api.py     | 15 +++++++++++++--
 nova/compute/manager.py | 17 ++++++++++++++---
 2 files changed, 27 insertions(+), 5 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/api.py b/nova/compute/api.py
index 33d25fc4b..93f0a12c1 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -456,12 +456,23 @@ class API(base.Base):
         self.db.instance_update(context, instance_id,
                 {'host': migration_ref['dest_compute'], })
 
-    def resize(self, context, instance_id, flavor):
+    def resize(self, context, instance_id, flavor_id):
         """Resize a running instance."""
+        instance = self.db.instance_get(context, instance_id)
+        current_instance_type = self.db.instance_type_get_by_flavor_id(
+            context, instance['flavor_id'])
+        new_instance_type = self.db.instance_type_get_by_flavor_id(
+            context, flavor_id)
+
+        if current_instance_type.memory_mb > new_instance_typ.memory_mb:
+            raise exception.ApiError(_("Invalid flavor: cannot downsize"
+                    "instances"))
+
         self._cast_scheduler_message(context,
                     {"method": "prep_resize",
                      "args": {"topic": FLAGS.compute_topic,
-                              "instance_id": instance_id, }},)
+                              "instance_id": instance_id,
+                              "instance_type": new_instance_type}})
 
     def pause(self, context, instance_id):
         """Pause the given instance."""
diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index b3e864154..f85ad91df 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -447,7 +447,7 @@ class ComputeManager(manager.Manager):
 
     @exception.wrap_exception
     @checks_instance_lock
-    def prep_resize(self, context, instance_id):
+    def prep_resize(self, context, instance_id, flavor_id):
         """Initiates the process of moving a running instance to another
         host, possibly changing the RAM and disk size in the process"""
         context = context.elevated()
@@ -456,12 +456,17 @@ class ComputeManager(manager.Manager):
             raise exception.Error(_(
                     'Migration error: destination same as source!'))
 
+        instance_type = self.db.instance_type_get_by_flavor_id(context,
+                flavor_id)
         migration_ref = self.db.migration_create(context,
                 {'instance_id': instance_id,
                  'source_compute': instance_ref['host'],
                  'dest_compute': FLAGS.host,
                  'dest_host':   self.driver.get_host_ip_addr(),
+                 'old_flavor': instance_type['flavor_id'],
+                 'new_flavor': flavor_id,
                  'status':      'pre-migrating'})
+
         LOG.audit(_('instance %s: migrating to '), instance_id,
                 context=context)
         topic = self.db.queue_get_for(context, FLAGS.compute_topic,
@@ -487,8 +492,14 @@ class ComputeManager(manager.Manager):
         self.db.migration_update(context, migration_id,
                 {'status': 'post-migrating', })
 
-        #TODO(mdietz): This is where we would update the VM record
-        #after resizing
+        #TODO(mdietz): apply the rest of the instance_type attributes going
+        #after they're supported
+        self.db.instance_update(context, instance_ref,
+               dict(memory_mb=instance_type['memory_mb'],
+                    vcpus=instance_type['vcpus'],
+                    local_gb=instance_type['local_gb']))
+        self.driver.resize_instance(context, instance_ref)
+
         service = self.db.service_get_by_host_and_topic(context,
                 migration_ref['dest_compute'], FLAGS.compute_topic)
         topic = self.db.queue_get_for(context, FLAGS.compute_topic,
-- 
cgit 


From a9bd1b456332aaf5f6ab9942979485f2192b6f3e Mon Sep 17 00:00:00 2001
From: Dan Prince <dan.prince@rackspace.com>
Date: Wed, 9 Mar 2011 14:53:44 -0500
Subject: Add password parameter to the set_admin_password call in the compute
 api. Updated servers password to use this parameter.

---
 nova/api/openstack/servers.py | 3 ++-
 nova/compute/api.py           | 5 +++--
 2 files changed, 5 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 7222285e0..41166f810 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -183,7 +183,8 @@ class Controller(wsgi.Controller):
         password = "%s%s" % (server['server']['name'][:4],
                              utils.generate_password(12))
         server['server']['adminPass'] = password
-        self.compute_api.set_admin_password(context, server['server']['id'])
+        self.compute_api.set_admin_password(context, server['server']['id'],
+                                            password)
         return server
 
     def update(self, req, id):
diff --git a/nova/compute/api.py b/nova/compute/api.py
index 33d25fc4b..a0bb2cf04 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -498,9 +498,10 @@ class API(base.Base):
         """Unrescue the given instance."""
         self._cast_compute_message('unrescue_instance', context, instance_id)
 
-    def set_admin_password(self, context, instance_id):
+    def set_admin_password(self, context, instance_id, password=None):
         """Set the root/admin password for the given instance."""
-        self._cast_compute_message('set_admin_password', context, instance_id)
+        self._cast_compute_message('set_admin_password', context, instance_id,
+                                    password)
 
     def inject_file(self, context, instance_id):
         """Write a file to the given instance."""
-- 
cgit 


From 3f723bcf54b4d779c66373dc8f69f43923dd586a Mon Sep 17 00:00:00 2001
From: Brian Waldon <brian.waldon@rackspace.com>
Date: Wed, 9 Mar 2011 15:08:11 -0500
Subject: renaming wsgi.Request.best_match to best_match_content_type;
 correcting calls to that function in code from trunk

---
 nova/api/direct.py                 |  2 +-
 nova/api/openstack/__init__.py     |  2 +-
 nova/api/openstack/faults.py       |  2 +-
 nova/api/openstack/servers.py      |  2 +-
 nova/tests/api/openstack/common.py |  1 +
 nova/tests/api/test_wsgi.py        | 18 +++++++++---------
 nova/wsgi.py                       |  4 ++--
 7 files changed, 16 insertions(+), 15 deletions(-)

(limited to 'nova')

diff --git a/nova/api/direct.py b/nova/api/direct.py
index 1d699f947..dfca250e0 100644
--- a/nova/api/direct.py
+++ b/nova/api/direct.py
@@ -206,7 +206,7 @@ class ServiceWrapper(wsgi.Controller):
         params = dict([(str(k), v) for (k, v) in params.iteritems()])
         result = method(context, **params)
         if type(result) is dict or type(result) is list:
-            return self._serialize(result, req.best_match())
+            return self._serialize(result, req.best_match_content_type())
         else:
             return result
 
diff --git a/nova/api/openstack/__init__.py b/nova/api/openstack/__init__.py
index 6e1a2a06c..197fcc619 100644
--- a/nova/api/openstack/__init__.py
+++ b/nova/api/openstack/__init__.py
@@ -125,5 +125,5 @@ class Versions(wsgi.Application):
             "application/xml": {
                 "attributes": dict(version=["status", "id"])}}
 
-        content_type = req.best_match()
+        content_type = req.best_match_content_type()
         return wsgi.Serializer(metadata).serialize(response, content_type)
diff --git a/nova/api/openstack/faults.py b/nova/api/openstack/faults.py
index 075fdb997..2fd733299 100644
--- a/nova/api/openstack/faults.py
+++ b/nova/api/openstack/faults.py
@@ -58,6 +58,6 @@ class Fault(webob.exc.HTTPException):
         # 'code' is an attribute on the fault tag itself
         metadata = {'application/xml': {'attributes': {fault_name: 'code'}}}
         serializer = wsgi.Serializer(metadata)
-        content_type = req.best_match()
+        content_type = req.best_match_content_type()
         self.wrapped_exc.body = serializer.serialize(fault_data, content_type)
         return self.wrapped_exc
diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 8dd078a31..25c667532 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -217,7 +217,7 @@ class Controller(wsgi.Controller):
             'rebuild':       self._action_rebuild,
             }
 
-        input_dict = self._deserialize(req.body, req)
+        input_dict = self._deserialize(req.body, req.get_content_type())
         for key in actions.keys():
             if key in input_dict:
                 return actions[key](input_dict, req, id)
diff --git a/nova/tests/api/openstack/common.py b/nova/tests/api/openstack/common.py
index 3f9c7d3cf..74bb8729a 100644
--- a/nova/tests/api/openstack/common.py
+++ b/nova/tests/api/openstack/common.py
@@ -28,6 +28,7 @@ def webob_factory(url):
     def web_request(url, method=None, body=None):
         req = webob.Request.blank("%s%s" % (base_url, url))
         if method:
+            req.content_type = "application/json"
             req.method = method
         if body:
             req.body = json.dumps(body)
diff --git a/nova/tests/api/test_wsgi.py b/nova/tests/api/test_wsgi.py
index 7c0135656..b1a849cf9 100644
--- a/nova/tests/api/test_wsgi.py
+++ b/nova/tests/api/test_wsgi.py
@@ -139,48 +139,48 @@ class RequestTest(test.TestCase):
     def test_content_type_from_accept_xml(self):
         request = wsgi.Request.blank('/tests/123')
         request.headers["Accept"] = "application/xml"
-        result = request.best_match()
+        result = request.best_match_content_type()
         self.assertEqual(result, "application/xml")
 
         request = wsgi.Request.blank('/tests/123')
         request.headers["Accept"] = "application/json"
-        result = request.best_match()
+        result = request.best_match_content_type()
         self.assertEqual(result, "application/json")
 
         request = wsgi.Request.blank('/tests/123')
         request.headers["Accept"] = "application/xml, application/json"
-        result = request.best_match()
+        result = request.best_match_content_type()
         self.assertEqual(result, "application/json")
 
         request = wsgi.Request.blank('/tests/123')
         request.headers["Accept"] = \
             "application/json; q=0.3, application/xml; q=0.9"
-        result = request.best_match()
+        result = request.best_match_content_type()
         self.assertEqual(result, "application/xml")
 
     def test_content_type_from_query_extension(self):
         request = wsgi.Request.blank('/tests/123.xml')
-        result = request.best_match()
+        result = request.best_match_content_type()
         self.assertEqual(result, "application/xml")
 
         request = wsgi.Request.blank('/tests/123.json')
-        result = request.best_match()
+        result = request.best_match_content_type()
         self.assertEqual(result, "application/json")
 
         request = wsgi.Request.blank('/tests/123.invalid')
-        result = request.best_match()
+        result = request.best_match_content_type()
         self.assertEqual(result, "application/json")
 
     def test_content_type_accept_and_query_extension(self):
         request = wsgi.Request.blank('/tests/123.xml')
         request.headers["Accept"] = "application/json"
-        result = request.best_match()
+        result = request.best_match_content_type()
         self.assertEqual(result, "application/xml")
 
     def test_content_type_accept_default(self):
         request = wsgi.Request.blank('/tests/123.unsupported')
         request.headers["Accept"] = "application/unsupported1"
-        result = request.best_match()
+        result = request.best_match_content_type()
         self.assertEqual(result, "application/json")
 
 
diff --git a/nova/wsgi.py b/nova/wsgi.py
index c3e08522d..2d18da8fb 100644
--- a/nova/wsgi.py
+++ b/nova/wsgi.py
@@ -85,7 +85,7 @@ class Server(object):
 
 class Request(webob.Request):
 
-    def best_match(self):
+    def best_match_content_type(self):
         """
         Determine the most acceptable content-type based on the
         query extension then the Accept header
@@ -354,7 +354,7 @@ class Controller(object):
         result = method(**arg_dict)
 
         if type(result) is dict:
-            content_type = req.best_match()
+            content_type = req.best_match_content_type()
             body = self._serialize(result, content_type)
 
             response = webob.Response()
-- 
cgit 


From fc9840bae6200c8f89fb8a3ba0ab45663c872b3c Mon Sep 17 00:00:00 2001
From: Eric Windisch <eric@cloudscaling.com>
Date: Wed, 9 Mar 2011 15:33:20 -0500
Subject: execvp passes pep8

---
 nova/console/xvp.py       |  6 +++---
 nova/crypto.py            |  3 ++-
 nova/network/linux_net.py | 19 ++++++++++++-------
 nova/tests/test_virt.py   |  2 +-
 nova/utils.py             | 19 ++++++++++---------
 nova/volume/driver.py     |  4 ++--
 6 files changed, 30 insertions(+), 23 deletions(-)

(limited to 'nova')

diff --git a/nova/console/xvp.py b/nova/console/xvp.py
index 271dffa54..68d8c8565 100644
--- a/nova/console/xvp.py
+++ b/nova/console/xvp.py
@@ -134,9 +134,9 @@ class XVPConsoleProxy(object):
         logging.debug(_("Starting xvp"))
         try:
             utils.execute('xvp',
-                          '-p',FLAGS.console_xvp_pid,
-			  '-c',FLAGS.console_xvp_conf,
-			  '-l',FLAGS.console_xvp_log)
+                          '-p', FLAGS.console_xvp_pid,
+                          '-c', FLAGS.console_xvp_conf,
+                          '-l', FLAGS.console_xvp_log)
         except exception.ProcessExecutionError, err:
             logging.error(_("Error starting xvp: %s") % err)
 
diff --git a/nova/crypto.py b/nova/crypto.py
index 20bb570a5..717ea0041 100644
--- a/nova/crypto.py
+++ b/nova/crypto.py
@@ -120,7 +120,8 @@ def generate_key_pair(bits=1024):
     # bio = M2Crypto.BIO.MemoryBuffer()
     # key.save_pub_key_bio(bio)
     # public_key = bio.read()
-    # public_key, err = execute('ssh-keygen', '-y', '-f', '/dev/stdin', private_key)
+    # public_key, err = execute('ssh-keygen', '-y', '-f',
+    #                           '/dev/stdin', private_key)
 
     return (private_key, public_key, fingerprint)
 
diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index b66a1adb7..228a4d9ea 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -68,7 +68,8 @@ def metadata_forward():
     _confirm_rule("PREROUTING", '-t', 'nat', '-s', '0.0.0.0/0',
              '-d', '169.254.169.254/32', '-p', 'tcp', '-m', 'tcp',
              '--dport', '80', '-j', 'DNAT',
-             '--to-destination', '%s:%s' % (FLAGS.ec2_dmz_host, FLAGS.ec2_port))
+             '--to-destination',
+             '%s:%s' % (FLAGS.ec2_dmz_host, FLAGS.ec2_port))
 
 
 def init_host():
@@ -86,7 +87,8 @@ def init_host():
         _execute('sudo', 'iptables', '-D', 'FORWARD', '-j', 'nova_forward',
                  check_exit_code=False)
         _execute('sudo', 'iptables', '-A', 'FORWARD', '-j', 'nova_forward')
-        _execute('sudo', 'iptables', '-N', 'nova_output', check_exit_code=False)
+        _execute('sudo', 'iptables', '-N', 'nova_output',
+                 check_exit_code=False)
         _execute('sudo', 'iptables', '-D', 'OUTPUT', '-j', 'nova_output',
                  check_exit_code=False)
         _execute('sudo', 'iptables', '-A', 'OUTPUT', '-j', 'nova_output')
@@ -220,7 +222,7 @@ def ensure_bridge(bridge, interface, net_attrs=None):
         #             bridge for it to respond to reqests properly
         suffix = net_attrs['cidr'].rpartition('/')[2]
         out, err = _execute('sudo', 'ip', 'addr', 'add',
-                            "%s/%s" % 
+                            "%s/%s" %
                             (net_attrs['gateway'], suffix),
                             'brd',
                             net_attrs['broadcast'],
@@ -237,7 +239,8 @@ def ensure_bridge(bridge, interface, net_attrs=None):
         #             bridge, then the bridge has to be in promiscuous
         #             to forward packets properly.
         if(FLAGS.public_interface == bridge):
-            _execute('sudo', 'ip', 'link', 'set', 'dev', bridge, 'promisc', 'on')
+            _execute('sudo', 'ip', 'link', 'set',
+                     'dev', bridge, 'promisc', 'on')
     if interface:
         # NOTE(vish): This will break if there is already an ip on the
         #             interface, so we move any ips to the bridge
@@ -253,8 +256,10 @@ def ensure_bridge(bridge, interface, net_attrs=None):
             fields = line.split()
             if fields and fields[0] == "inet":
                 params = ' '.join(fields[1:-1])
-                _execute('sudo', 'ip', 'addr', 'del', params, 'dev', fields[-1])
-                _execute('sudo', 'ip', 'addr', 'add', params, 'dev', bridge)
+                _execute('sudo', 'ip', 'addr',
+                         'del', params, 'dev', fields[-1])
+                _execute('sudo', 'ip', 'addr',
+                         'add', params, 'dev', bridge)
         if gateway:
             _execute('sudo', 'route', 'add', '0.0.0.0', 'gw', gateway)
         out, err = _execute('sudo', 'brctl', 'addif', bridge, interface,
@@ -397,7 +402,7 @@ def _device_exists(device):
 
 
 def _confirm_rule(chain, *cmd, **kwargs):
-    append=kwargs.get('append',False)
+    append = kwargs.get('append', False)
     """Delete and re-add iptables rule"""
     if FLAGS.use_nova_chains:
         chain = "nova_%s" % chain.lower()
diff --git a/nova/tests/test_virt.py b/nova/tests/test_virt.py
index 7f1ad002e..dfa607f14 100644
--- a/nova/tests/test_virt.py
+++ b/nova/tests/test_virt.py
@@ -316,7 +316,7 @@ class IptablesFirewallTestCase(test.TestCase):
 
 #        self.fw.add_instance(instance_ref)
         def fake_iptables_execute(*cmd, **kwargs):
-            process_input=kwargs.get('process_input', None)
+            process_input = kwargs.get('process_input', None)
             if cmd == ('sudo', 'ip6tables-save', '-t', 'filter'):
                 return '\n'.join(self.in6_rules), None
             if cmd == ('sudo', 'iptables-save', '-t', 'filter'):
diff --git a/nova/utils.py b/nova/utils.py
index 0937522ec..3a4ec3c6a 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -40,7 +40,7 @@ import netaddr
 from eventlet import event
 from eventlet import greenthread
 from eventlet.green import subprocess
-
+None
 from nova import exception
 from nova.exception import ProcessExecutionError
 from nova import log as logging
@@ -129,13 +129,13 @@ def fetchfile(url, target):
 
 
 def execute(*cmd, **kwargs):
-    process_input=kwargs.get('process_input', None)
-    addl_env=kwargs.get('addl_env', None)
-    check_exit_code=kwargs.get('check_exit_code', 0)
-    stdin=kwargs.get('stdin', subprocess.PIPE)
-    stdout=kwargs.get('stdout', subprocess.PIPE)
-    stderr=kwargs.get('stderr', subprocess.PIPE)
-    cmd=map(str,cmd)
+    process_input = kwargs.get('process_input', None)
+    addl_env = kwargs.get('addl_env', None)
+    check_exit_code = kwargs.get('check_exit_code', 0)
+    stdin = kwargs.get('stdin', subprocess.PIPE)
+    stdout = kwargs.get('stdout', subprocess.PIPE)
+    stderr = kwargs.get('stderr', subprocess.PIPE)
+    cmd = map(str, cmd)
 
     LOG.debug(_("Running cmd (subprocess): %s"), ' '.join(cmd))
     env = os.environ.copy()
@@ -151,7 +151,8 @@ def execute(*cmd, **kwargs):
     obj.stdin.close()
     if obj.returncode:
         LOG.debug(_("Result was %s") % obj.returncode)
-        if check_exit_code is not None and obj.returncode != check_exit_code:
+        if type(check_exit_code) == types.IntType \
+                and obj.returncode != check_exit_code:
             (stdout, stderr) = result
             raise ProcessExecutionError(exit_code=obj.returncode,
                                         stdout=stdout,
diff --git a/nova/volume/driver.py b/nova/volume/driver.py
index e9bdf162f..45cc800e7 100644
--- a/nova/volume/driver.py
+++ b/nova/volume/driver.py
@@ -112,7 +112,7 @@ class VolumeDriver(object):
             # If the volume isn't present, then don't attempt to delete
             return True
 
-        self._try_execute('sudo', 'lvremove', '-f',"%s/%s" %
+        self._try_execute('sudo', 'lvremove', '-f', "%s/%s" %
                           (FLAGS.volume_group,
                            volume['name']))
 
@@ -256,7 +256,7 @@ class ISCSIDriver(VolumeDriver):
         self._sync_exec('sudo', 'ietadm', '--op', 'new',
                         "--tid=%s" % iscsi_target,
                         '--params',
-                        "Name=%s" % iscsi-name,
+                        "Name=%s" % iscsi_name,
                         check_exit_code=False)
         self._sync_exec('sudo', 'ietadm', '--op', 'new',
                         "--tid=%s" % iscsi_target,
-- 
cgit 


From 75f7a73735957d5ddf04c7c9a23decf1a6fa7f9f Mon Sep 17 00:00:00 2001
From: Josh Kearney <josh@jk0.org>
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')

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 <vishvananda@gmail.com>
Date: Wed, 9 Mar 2011 21:43:35 +0000
Subject: remove the semaphore when there is no one waiting on it

---
 nova/tests/test_virt.py   | 3 ++-
 nova/virt/libvirt_conn.py | 2 ++
 2 files changed, 4 insertions(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/tests/test_virt.py b/nova/tests/test_virt.py
index 113632a0c..56a271365 100644
--- a/nova/tests/test_virt.py
+++ b/nova/tests/test_virt.py
@@ -23,7 +23,6 @@ from xml.dom.minidom import parseString as xml_to_dom
 from nova import context
 from nova import db
 from nova import flags
-from nova import log as logging
 from nova import test
 from nova import utils
 from nova.api.ec2 import cloud
@@ -70,11 +69,13 @@ class CacheConcurrencyTestCase(test.TestCase):
         eventlet.sleep(0)
         try:
             self.assertFalse(done2.ready())
+            self.assertTrue('fname' in conn._image_sems)
         finally:
             wait1.send()
         done1.wait()
         eventlet.sleep(0)
         self.assertTrue(done2.ready())
+        self.assertFalse('fname' in conn._image_sems)
 
     def test_different_fname_concurrency(self):
         """Ensures that two different fname caches are concurrent"""
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 e8554da80ac916f168461cb48078488700081c02 Mon Sep 17 00:00:00 2001
From: Eric Windisch <eric@cloudscaling.com>
Date: Wed, 9 Mar 2011 16:44:48 -0500
Subject: execvp: cleanup.

---
 nova/crypto.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/crypto.py b/nova/crypto.py
index 717ea0041..2a8d4abca 100644
--- a/nova/crypto.py
+++ b/nova/crypto.py
@@ -105,7 +105,7 @@ def generate_key_pair(bits=1024):
 
     tmpdir = tempfile.mkdtemp()
     keyfile = os.path.join(tmpdir, 'temp')
-    utils.execute('ssh-keygen', '-q', '-b', '%d' % bits, '-N', '',
+    utils.execute('ssh-keygen', '-q', '-b', bits, '-N', '',
                   '-f', keyfile)
     (out, err) = utils.execute('ssh-keygen', '-q', '-l', '-f',
                                '%s.pub' % (keyfile))
@@ -147,9 +147,9 @@ def revoke_cert(project_id, file_name):
     os.chdir(ca_folder(project_id))
     # NOTE(vish): potential race condition here
     utils.execute('openssl', 'ca', '-config', './openssl.cnf', '-revoke',
-                  '%s' % file_name)
+                  file_name)
     utils.execute('openssl', 'ca', '-gencrl', '-config', './openssl.cnf',
-                  '-out', '%s' % FLAGS.crl_file)
+                  '-out', FLAGS.crl_file)
     os.chdir(start)
 
 
-- 
cgit 


From fb4785b85c1bef4179140cfb85ce01eca9fb5da5 Mon Sep 17 00:00:00 2001
From: Cory Wright <cory.wright@rackspace.com>
Date: Wed, 9 Mar 2011 21:46:27 +0000
Subject: fix the copyright notice in migration

---
 .../sqlalchemy/migrate_repo/versions/010_add_os_type_to_instances.py  | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/migrate_repo/versions/010_add_os_type_to_instances.py b/nova/db/sqlalchemy/migrate_repo/versions/010_add_os_type_to_instances.py
index 514b92b81..eb3066894 100644
--- a/nova/db/sqlalchemy/migrate_repo/versions/010_add_os_type_to_instances.py
+++ b/nova/db/sqlalchemy/migrate_repo/versions/010_add_os_type_to_instances.py
@@ -1,8 +1,6 @@
 # vim: tabstop=4 shiftwidth=4 softtabstop=4
 
-# Copyright 2010 United States Government as represented by the
-# Administrator of the National Aeronautics and Space Administration.
-# All Rights Reserved.
+# 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
-- 
cgit 


From 203e23ebebc73a98dc8e8497fd2b28d3a6bf01da Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Wed, 9 Mar 2011 14:13:52 -0800
Subject: initializing instance power state on launch to 0 (fixes EC2 API bug)

---
 nova/compute/api.py | 1 +
 1 file changed, 1 insertion(+)

(limited to 'nova')

diff --git a/nova/compute/api.py b/nova/compute/api.py
index a0bb2cf04..2358b562c 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -165,6 +165,7 @@ class API(base.Base):
             'image_id': image_id,
             'kernel_id': kernel_id or '',
             'ramdisk_id': ramdisk_id or '',
+            'state': "0",
             'state_description': 'scheduling',
             'user_id': context.user_id,
             'project_id': context.project_id,
-- 
cgit 


From 9822af58162dc520c4a17646a013560e422efcf9 Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Wed, 9 Mar 2011 14:54:57 -0800
Subject: maybe a int instead ?

---
 nova/compute/api.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/compute/api.py b/nova/compute/api.py
index 2358b562c..5334acfcf 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -165,7 +165,7 @@ class API(base.Base):
             'image_id': image_id,
             'kernel_id': kernel_id or '',
             'ramdisk_id': ramdisk_id or '',
-            'state': "0",
+            'state': 0,
             'state_description': 'scheduling',
             'user_id': context.user_id,
             'project_id': context.project_id,
-- 
cgit 


From 21937b48fcac81fa108f37f307b1b2e969bb7b4f Mon Sep 17 00:00:00 2001
From: "Kevin L. Mitchell" <kevin.mitchell@rackspace.com>
Date: Thu, 10 Mar 2011 00:01:15 +0000
Subject: Replace session.execute() calls performing raw UPDATE statements with
 SQLAlchemy code, with the exception of fixed_ip_disassociate_all_by_timeout()

---
 nova/db/sqlalchemy/api.py | 97 ++++++++++++++++++++++++++++++-----------------
 1 file changed, 62 insertions(+), 35 deletions(-)

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 5e498fc6f..22c85106d 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -701,14 +701,18 @@ def instance_data_get_for_project(context, project_id):
 def instance_destroy(context, instance_id):
     session = get_session()
     with session.begin():
-        session.execute('update instances set deleted=1,'
-                        'deleted_at=:at where id=:id',
-                        {'id': instance_id,
-                         'at': datetime.datetime.utcnow()})
-        session.execute('update security_group_instance_association '
-                        'set deleted=1,deleted_at=:at where instance_id=:id',
-                        {'id': instance_id,
-                         'at': datetime.datetime.utcnow()})
+        session.query(models.Instance).\
+                     filter_by(id=instance_id).\
+                     update({'deleted': 1,
+                             'deleted_at': datetime.datetime.utcnow(),
+                             'updated_at': models.Instance.updated_at + 0})
+        session.query(models.SecurityGroupInstanceAssociation).\
+                     filter_by(instance_id=instance_id).\
+                     update({'deleted': 1,
+                             'deleted_at': datetime.datetime.utcnow(),
+                             'updated_at':
+                                 (models.SecurityGroupInstanceAssociation.
+                                  updated_at + 0)})
 
 
 @require_context
@@ -950,9 +954,11 @@ def key_pair_destroy_all_by_user(context, user_id):
     authorize_user_context(context, user_id)
     session = get_session()
     with session.begin():
-        # TODO(vish): do we have to use sql here?
-        session.execute('update key_pairs set deleted=1 where user_id=:id',
-                        {'id': user_id})
+        session.query(models.KeyPair).\
+                     filter_by(user_id=user_id).\
+                     update({'deleted': 1,
+                             'deleted_at': datetime.datetime.utcnow(),
+                             'updated_at': models.KeyPair.updated_at + 0})
 
 
 @require_context
@@ -1063,7 +1069,9 @@ def network_disassociate(context, network_id):
 @require_admin_context
 def network_disassociate_all(context):
     session = get_session()
-    session.execute('update networks set project_id=NULL')
+    session.query(models.Network).\
+                 update({'project_id': None,
+                         'updated_at': models.Network.updated_at + 0})
 
 
 @require_context
@@ -1433,15 +1441,17 @@ def volume_data_get_for_project(context, project_id):
 def volume_destroy(context, volume_id):
     session = get_session()
     with session.begin():
-        # TODO(vish): do we have to use sql here?
-        session.execute('update volumes set deleted=1 where id=:id',
-                        {'id': volume_id})
-        session.execute('update export_devices set volume_id=NULL '
-                        'where volume_id=:id',
-                        {'id': volume_id})
-        session.execute('update iscsi_targets set volume_id=NULL '
-                        'where volume_id=:id',
-                        {'id': volume_id})
+        session.query(models.Volume).\
+                     filter_by(id=volume_id).\
+                     update({'deleted': 1,
+                             'deleted_at': datetime.datetime.utcnow(),
+                             'updated_at': models.Volume.updated_at + 0})
+        session.query(models.ExportDevice).\
+                     filter_by(volume_id=volume_id).\
+                     update({'volume_id': None})
+        session.query(models.IscsiTarget).\
+                     filter_by(volume_id=volume_id).\
+                     update({'volume_id': None})
 
 
 @require_admin_context
@@ -1661,17 +1671,26 @@ def security_group_create(context, values):
 def security_group_destroy(context, security_group_id):
     session = get_session()
     with session.begin():
-        # TODO(vish): do we have to use sql here?
-        session.execute('update security_groups set deleted=1 where id=:id',
-                        {'id': security_group_id})
-        session.execute('update security_group_instance_association '
-                        'set deleted=1,deleted_at=:at '
-                        'where security_group_id=:id',
-                        {'id': security_group_id,
-                         'at': datetime.datetime.utcnow()})
-        session.execute('update security_group_rules set deleted=1 '
-                        'where group_id=:id',
-                        {'id': security_group_id})
+        session.query(models.SecurityGroup).\
+                     filter_by(id=security_group_id).\
+                     update({'deleted': 1,
+                             'deleted_at': datetime.datetime.utcnow(),
+                             'updated_at':
+                                 models.SecurityGroup.updated_at + 0})
+        session.query(models.SecurityGroupInstanceAssociation).\
+                     filter_by(security_group_id=security_group_id).\
+                     update({'deleted': 1,
+                             'deleted_at': datetime.datetime.utcnow(),
+                             'updated_at':
+                                 (models.SecurityGroupInstanceAssocation.
+                                  updated_at + 0)})
+        session.query(models.SecurityGroupIngressRule).\
+                     filter_by(group_id=security_group_id).\
+                     update({'deleted': 1,
+                             'deleted_at': datetime.datetime.utcnow(),
+                             'updated_at':
+                                 (models.SecurityGroupIngressRule.
+                                  updated_at + 0)})
 
 
 @require_context
@@ -1679,9 +1698,17 @@ def security_group_destroy_all(context, session=None):
     if not session:
         session = get_session()
     with session.begin():
-        # TODO(vish): do we have to use sql here?
-        session.execute('update security_groups set deleted=1')
-        session.execute('update security_group_rules set deleted=1')
+        session.query(models.SecurityGroup).\
+                     update({'deleted': 1,
+                             'deleted_at': datetime.datetime.utcnow(),
+                             'updated_at':
+                                 models.SecurityGroup.updated_at + 0})
+        session.query(models.SecurityGroupIngressRule).\
+                     update({'deleted': 1,
+                             'deleted_at': datetime.datetime.utcnow(),
+                             'updated_at':
+                                 (models.SecurityGroupIngressRule.
+                                  updated_at + 0)})
 
 
 ###################
-- 
cgit 


From f0bb6d9fc47b92d335c7d7fa238dfd43f0dbdf69 Mon Sep 17 00:00:00 2001
From: Kei Masumoto <masumotok@nttdata.co.jp>
Date: Thu, 10 Mar 2011 13:30:52 +0900
Subject: fixed based on reviewer's comment.

---
 nova/compute/manager.py      | 22 ++++++-------
 nova/db/sqlalchemy/api.py    |  4 +--
 nova/scheduler/driver.py     | 10 +++---
 nova/tests/test_compute.py   | 24 +++++++-------
 nova/tests/test_scheduler.py |  5 +--
 nova/tests/test_service.py   | 77 +++++++++++++++++---------------------------
 nova/tests/test_virt.py      |  6 ++--
 nova/tests/test_volume.py    |  7 ++--
 nova/virt/libvirt_conn.py    | 22 ++++++++-----
 nova/volume/driver.py        |  2 +-
 10 files changed, 85 insertions(+), 94 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 3675cc92e..0cab10fc3 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -64,7 +64,7 @@ flags.DEFINE_integer('password_length', 12,
 flags.DEFINE_string('console_host', socket.gethostname(),
                     'Console proxy host to use to connect to instances on'
                     'this host.')
-flags.DEFINE_string('live_migration_retry_count', 30,
+flags.DEFINE_integer('live_migration_retry_count', 30,
                     ("Retry count needed in live_migration."
                      " sleep 1 sec for each count"))
 
@@ -757,8 +757,9 @@ class ComputeManager(manager.Manager):
         dirpath = FLAGS.instances_path
         fd, tmp_file = tempfile.mkstemp(dir=dirpath)
         LOG.debug(_("Creating tmpfile %s to notify to other "
-                    "compute node that they mounts same storage.") % tmp_file)
-        os.fdopen(fd, 'w+').close()
+                    "compute nodes that they should mount "
+                    "the same storage.") % tmp_file)
+        os.close(fd)
         return os.path.basename(tmp_file)
 
     @exception.wrap_exception
@@ -812,7 +813,7 @@ class ComputeManager(manager.Manager):
         # Getting fixed ips
         fixed_ip = self.db.instance_get_fixed_address(context, instance_id)
         if not fixed_ip:
-            msg = _("%(instance_id)s(%(ec2_id)s) does'nt have fixed_ip")
+            msg = _("%(instance_id)s(%(ec2_id)s) does not have fixed_ip.")
             raise exception.NotFound(msg % locals())
 
         # If any volume is mounted, prepare here.
@@ -929,7 +930,7 @@ class ComputeManager(manager.Manager):
             floating_ip = self.db.instance_get_floating_address(ctxt,
                                                          instance_id)
             if not floating_ip:
-                LOG.info(_('floating_ip is not found for %s'), i_name)
+                LOG.info(_('No floating_ip is found for %s.'), i_name)
             else:
                 floating_ip_ref = self.db.floating_ip_get_by_address(ctxt,
                                                               floating_ip)
@@ -937,7 +938,7 @@ class ComputeManager(manager.Manager):
                                            floating_ip_ref['address'],
                                            {'host': dest})
         except exception.NotFound:
-            LOG.info(_('Floating_ip is not found for %s'), i_name)
+            LOG.info(_('No floating_ip is found for %s.'), i_name)
         except:
             LOG.error(_("Live migration: Unexpected error:"
                         "%s cannot inherit floating ip..") % i_name)
@@ -945,12 +946,11 @@ class ComputeManager(manager.Manager):
         # Restore instance/volume state
         self.recover_live_migration(ctxt, instance_ref, dest)
 
-        LOG.info(_('Migrating %(i_name)s to %(dest)s finishes successfully.')
+        LOG.info(_('Migrating %(i_name)s to %(dest)s finished successfully.')
                  % locals())
-        LOG.info(_("The below error is normally occurs. "
-                "Just check if instance is successfully migrated.\n"
-                "libvir: QEMU error : Domain not found: no domain "
-                "with matching name.."))
+        LOG.info(_("You may see the error \"libvirt: QEMU error: "
+                   "Domain not found: no domain with matching name.\" "
+                   "This error can be safely ignored."))
 
     def recover_live_migration(self, ctxt, instance_ref, host=None):
         """Recovers Instance/volume state from migrating -> running.
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 8ea5062ae..f44ca0fa3 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -192,8 +192,8 @@ def service_get_all_compute_by_host(context, host):
                   all()
 
     if not result:
-        raise exception.NotFound(_("%s does not exist or not "
-                                   "compute node.") % host)
+        raise exception.NotFound(_("%s does not exist or is not "
+                                   "a compute node.") % host)
 
     return result
 
diff --git a/nova/scheduler/driver.py b/nova/scheduler/driver.py
index 791f9000d..ed3dfe1c0 100644
--- a/nova/scheduler/driver.py
+++ b/nova/scheduler/driver.py
@@ -226,7 +226,6 @@ class Scheduler(object):
                       "args": {'cpu_info': oservice_ref['cpu_info']}})
 
         except rpc.RemoteError:
-            ec2_id = instance_ref['hostname']
             src = instance_ref['host']
             logging.exception(_("host %(dest)s is not compatible with "
                                 "original host %(src)s.") % locals())
@@ -259,9 +258,10 @@ class Scheduler(object):
         mem_avail = mem_total - mem_used
         mem_inst = instance_ref['memory_mb']
         if mem_avail <= mem_inst:
-            raise exception.NotEmpty(_("%(ec2_id)s is not capable to "
-                                       "migrate %(dest)s (host:%(mem_avail)s "
-                                       " <= instance:%(mem_inst)s)")
+            raise exception.NotEmpty(_("Unable to migrate %(ec2_id)s "
+                                       "to destination: %(dest)s "
+                                       "(host:%(mem_avail)s "
+                                       "<= instance:%(mem_inst)s)")
                                        % locals())
 
     def mounted_on_same_shared_storage(self, context, instance_ref, dest):
@@ -292,7 +292,7 @@ class Scheduler(object):
 
         except rpc.RemoteError:
             ipath = FLAGS.instances_path
-            logging.error(_("Cannot comfirm tmpfile at %(ipath)s is on "
+            logging.error(_("Cannot confirm tmpfile at %(ipath)s is on "
                             "same shared storage between %(src)s "
                             "and %(dest)s.") % locals())
             raise
diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index 85c2c948b..71899ba9e 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -89,14 +89,14 @@ class ComputeTestCase(test.TestCase):
            Use this when any testcase executed later than test_run_terminate
         """
         vol1 = models.Volume()
-        vol1.__setitem__('id', 1)
+        vol1['id'] = 1
         vol2 = models.Volume()
-        vol2.__setitem__('id', 2)
+        vol2['id'] = 2
         instance_ref = models.Instance()
-        instance_ref.__setitem__('id', 1)
-        instance_ref.__setitem__('volumes', [vol1, vol2])
-        instance_ref.__setitem__('hostname', 'i-00000001')
-        instance_ref.__setitem__('host', 'dummy')
+        instance_ref['id'] = 1
+        instance_ref['volumes'] = [vol1, vol2]
+        instance_ref['hostname'] = 'i-00000001'
+        instance_ref['host'] = 'dummy'
         return instance_ref
 
     def test_create_instance_defaults_display_name(self):
@@ -114,9 +114,9 @@ class ComputeTestCase(test.TestCase):
         """Make sure create associates security groups"""
         group = self._create_group()
         instance_ref = models.Instance()
-        instance_ref.__setitem__('id', 1)
-        instance_ref.__setitem__('volumes', [{'id': 1}, {'id': 2}])
-        instance_ref.__setitem__('hostname', 'i-00000001')
+        instance_ref['id'] = 1
+        instance_ref['volumes'] = [{'id': 1}, {'id': 2}]
+        instance_ref['hostname'] = 'i-00000001'
         return instance_ref
 
     def test_create_instance_defaults_display_name(self):
@@ -390,7 +390,7 @@ class ComputeTestCase(test.TestCase):
     def test_pre_live_migration_instance_has_no_volume(self):
         """Confirm log meg when instance doesn't mount any volumes."""
         i_ref = self._get_dummy_instance()
-        i_ref.__setitem__('volumes', [])
+        i_ref['volumes'] = []
         c = context.get_admin_context()
 
         self._setup_other_managers()
@@ -501,7 +501,7 @@ class ComputeTestCase(test.TestCase):
     def test_live_migration_dest_raises_exception_no_volume(self):
         """Same as above test(input pattern is different) """
         i_ref = self._get_dummy_instance()
-        i_ref.__setitem__('volumes', [])
+        i_ref['volumes'] = []
         c = context.get_admin_context()
         topic = db.queue_get_for(c, FLAGS.compute_topic, i_ref['host'])
 
@@ -526,7 +526,7 @@ class ComputeTestCase(test.TestCase):
     def test_live_migration_works_correctly_no_volume(self):
         """Confirm live_migration() works as expected correctly."""
         i_ref = self._get_dummy_instance()
-        i_ref.__setitem__('volumes', [])
+        i_ref['volumes'] = []
         c = context.get_admin_context()
         topic = db.queue_get_for(c, FLAGS.compute_topic, i_ref['host'])
 
diff --git a/nova/tests/test_scheduler.py b/nova/tests/test_scheduler.py
index 711b66af7..8ac02c5a4 100644
--- a/nova/tests/test_scheduler.py
+++ b/nova/tests/test_scheduler.py
@@ -119,7 +119,8 @@ class SchedulerTestCase(test.TestCase):
         try:
             scheduler.show_host_resources(ctxt, dest)
         except exception.NotFound, e:
-            c1 = (0 <= e.message.find('does not exist or not compute node'))
+            c1 = (e.message.find(_("does not exist or is not a "
+                                   "compute node.")) >= 0)
         self.assertTrue(c1)
 
     def _dic_is_equal(self, dic1, dic2, keys=None):
@@ -786,7 +787,7 @@ class SimpleDriverTestCase(test.TestCase):
                                                              i_ref,
                                                              'somewhere')
         except exception.NotEmpty, e:
-            c = (e.message.find('is not capable to migrate') >= 0)
+            c = (e.message.find('Unable to migrate') >= 0)
 
         self.assertTrue(c)
         db.instance_destroy(self.context, instance_id)
diff --git a/nova/tests/test_service.py b/nova/tests/test_service.py
index d17f6a22a..666c4a11d 100644
--- a/nova/tests/test_service.py
+++ b/nova/tests/test_service.py
@@ -42,24 +42,6 @@ class FakeManager(manager.Manager):
     def test_method(self):
         return 'manager'
 
-# temporary variable to store host/binary/self.mox
-# from each method to fake class.
-global_host = None
-global_binary = None
-global_mox = None
-
-
-class FakeComputeManager(compute_manager.ComputeManager):
-    """Fake computemanager manager for tests"""
-
-    def __init__(self, compute_driver=None, *args, **kwargs):
-        global ghost, gbinary, gmox
-        self.update_available_resource(mox.IgnoreArg())
-        gmox.ReplayAll()
-        super(FakeComputeManager, self).__init__(compute_driver,
-                                                 *args,
-                                                 **kwargs)
-
 
 class ExtendedService(service.Service):
     def test_method(self):
@@ -275,37 +257,38 @@ class ServiceTestCase(test.TestCase):
         """Confirm compute updates their record of compute-service table."""
         host = 'foo'
         binary = 'nova-compute'
-        topic = 'compute1'
-        service_create = {'host': host,
-                          'binary': binary,
-                          'topic': topic,
-                          'report_count': 0,
-                          'availability_zone': 'nova'}
-        service_ref = {'host': host,
-                          'binary': binary,
-                          'topic': topic,
-                          'report_count': 0,
-                          'availability_zone': 'nova',
-                          'id': 1}
-
-        service.db.service_get_by_args(mox.IgnoreArg(),
-                                      host,
-                                      binary).AndRaise(exception.NotFound())
-        service.db.service_create(mox.IgnoreArg(),
-                                  service_create).AndReturn(service_ref)
-        self.mox.StubOutWithMock(compute_manager.ComputeManager,
-                                 'update_available_resource')
-
-        global ghost, gbinary, gmox
-        ghost = host
-        gbinary = binary
-        gmox = self.mox
-
+        topic = 'compute'
+
+        # Any mocks are not working without UnsetStubs() here.
+        self.mox.UnsetStubs()
+        ctxt = context.get_admin_context()
+        service_ref = db.service_create(ctxt, {'host': host,
+                                               'binary': binary,
+                                               'topic': topic})
         serv = service.Service(host,
                                binary,
                                topic,
-                               'nova.tests.test_service.FakeComputeManager')
-        # ReplayAll has been executed FakeComputeManager.__init__()
-        #self.mox.ReplayAll()
+                               'nova.compute.manager.ComputeManager')
+
+        # This testcase want to test calling update_available_resource.
+        # No need to call periodic call, then below variable must be set 0.
+        serv.report_interval = 0
+        serv.periodic_interval = 0
+
+        # Creating mocks
+        self.mox.StubOutWithMock(service.rpc.Connection, 'instance')
+        service.rpc.Connection.instance(new=mox.IgnoreArg())
+        service.rpc.Connection.instance(new=mox.IgnoreArg())
+        self.mox.StubOutWithMock(serv.manager.driver,
+                                 'update_available_resource')
+        serv.manager.driver.update_available_resource(mox.IgnoreArg(), host)
+
+        # Just doing start()-stop(), not confirm new db record is created,
+        # because update_available_resource() works only in libvirt environment.
+        # This testcase confirms update_available_resource() is called.
+        # Otherwise, mox complains.
+        self.mox.ReplayAll()
         serv.start()
         serv.stop()
+
+        db.service_destroy(ctxt, service_ref['id'])
diff --git a/nova/tests/test_virt.py b/nova/tests/test_virt.py
index 7ea8c0fb5..ee41ae732 100644
--- a/nova/tests/test_virt.py
+++ b/nova/tests/test_virt.py
@@ -283,7 +283,7 @@ class LibvirtConnTestCase(test.TestCase):
             self.assertEquals(uri, testuri)
         db.instance_destroy(user_context, instance_ref['id'])
 
-    def tes1t_update_available_resource_works_correctly(self):
+    def test_update_available_resource_works_correctly(self):
         """Confirm compute_node table is updated successfully."""
         org_path = FLAGS.instances_path = ''
         FLAGS.instances_path = '.'
@@ -314,7 +314,7 @@ class LibvirtConnTestCase(test.TestCase):
         compute_node = service_ref['compute_node'][0]
 
         if sys.platform.upper() == 'LINUX2':
-            self.assertTrue(compute_node['vcpus'] > 0)
+            self.assertTrue(compute_node['vcpus'] >= 0)
             self.assertTrue(compute_node['memory_mb'] > 0)
             self.assertTrue(compute_node['local_gb'] > 0)
             self.assertTrue(compute_node['vcpus_used'] == 0)
@@ -323,7 +323,7 @@ class LibvirtConnTestCase(test.TestCase):
             self.assertTrue(len(compute_node['hypervisor_type']) > 0)
             self.assertTrue(compute_node['hypervisor_version'] > 0)
         else:
-            self.assertTrue(compute_node['vcpus'] > 0)
+            self.assertTrue(compute_node['vcpus'] >= 0)
             self.assertTrue(compute_node['memory_mb'] == 0)
             self.assertTrue(compute_node['local_gb'] > 0)
             self.assertTrue(compute_node['vcpus_used'] == 0)
diff --git a/nova/tests/test_volume.py b/nova/tests/test_volume.py
index e8b4ceee8..d88e363da 100644
--- a/nova/tests/test_volume.py
+++ b/nova/tests/test_volume.py
@@ -284,9 +284,10 @@ class AOETestCase(DriverTestCase):
             self.volume.check_for_export(self.context, self.instance_id)
         except exception.ProcessExecutionError, e:
             volume_id = volume_id_list[0]
-            msg = _("""Cannot confirm exported volume id:%(volume_id)s."""
-                    """vblade process for e%(shelf_id)s.%(blade_id)s """
-                    """isn't running.""") % locals()
+            msg = _("Cannot confirm exported volume id:%(volume_id)s. "
+                    "vblade process for e%(shelf_id)s.%(blade_id)s "
+                    "isn't running.") % locals()
+
             msg_is_match = (0 <= e.message.find(msg))
 
         self.assertTrue(msg_is_match)
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))
diff --git a/nova/volume/driver.py b/nova/volume/driver.py
index a902da6ac..31a6a02ee 100644
--- a/nova/volume/driver.py
+++ b/nova/volume/driver.py
@@ -234,7 +234,7 @@ class AOEDriver(VolumeDriver):
                 break
         if not exported:
             # Instance will be terminated in this case.
-            desc = _("Cannot confirm exported volume id:%(volume_id)s."
+            desc = _("Cannot confirm exported volume id:%(volume_id)s. "
                      "vblade process for e%(shelf_id)s.%(blade_id)s "
                      "isn't running.") % locals()
             raise exception.ProcessExecutionError(out, _err, cmd=cmd,
-- 
cgit 


From a83b4879f38d11634d405d0efe977d482abdc344 Mon Sep 17 00:00:00 2001
From: Vishvananda Ishaya <vishvananda@gmail.com>
Date: Thu, 10 Mar 2011 05:02:24 +0000
Subject: minor fixes from review

---
 nova/image/glance.py |  2 +-
 nova/image/s3.py     | 18 +++++++++---------
 2 files changed, 10 insertions(+), 10 deletions(-)

(limited to 'nova')

diff --git a/nova/image/glance.py b/nova/image/glance.py
index fb383f5e6..15fca69b8 100644
--- a/nova/image/glance.py
+++ b/nova/image/glance.py
@@ -74,7 +74,7 @@ class GlanceImageService(service.BaseImageService):
             if name == cantidate.get('name'):
                 image = cantidate
                 break
-        if image == None:
+        if image is None:
             raise exception.NotFound
         return image
 
diff --git a/nova/image/s3.py b/nova/image/s3.py
index bf104c29a..bbc54c263 100644
--- a/nova/image/s3.py
+++ b/nova/image/s3.py
@@ -77,17 +77,17 @@ class S3ImageService(service.BaseImageService):
         # FIXME(vish): detail doesn't filter so we do it manually
         return self._filter(context, images)
 
-    @staticmethod
-    def _is_visible(context, image):
+    @classmethod
+    def _is_visible(cls, context, image):
         return (context.is_admin
                 or context.project_id == image['properties']['owner_id']
                 or image['properties']['is_public'] == 'True')
 
-    @staticmethod
-    def _filter(context, images):
+    @classmethod
+    def _filter(cls, context, images):
         filtered = []
         for image in images:
-            if not S3ImageService._is_visible(context, image):
+            if not cls._is_visible(context, image):
                 continue
             filtered.append(image)
         return filtered
@@ -148,7 +148,7 @@ class S3ImageService(service.BaseImageService):
                 image_format = 'aki'
                 image_type = 'kernel'
                 kernel_id = None
-        except:
+        except Exception:
             kernel_id = None
 
         try:
@@ -157,12 +157,12 @@ class S3ImageService(service.BaseImageService):
                 image_format = 'ari'
                 image_type = 'ramdisk'
                 ramdisk_id = None
-        except:
+        except Exception:
             ramdisk_id = None
 
         try:
             arch = manifest.find("machine_configuration/architecture").text
-        except:
+        except Exception:
             arch = 'x86_64'
 
         properties = metadata['properties']
@@ -235,7 +235,7 @@ class S3ImageService(service.BaseImageService):
 
     @staticmethod
     def _decrypt_image(encrypted_filename, encrypted_key, encrypted_iv,
-                      cloud_private_key, decrypted_filename):
+                       cloud_private_key, decrypted_filename):
         key, err = utils.execute(
                 'openssl rsautl -decrypt -inkey %s' % cloud_private_key,
                 process_input=encrypted_key,
-- 
cgit 


From 90f38451e5df4f0ca862401cf898f01ffede6174 Mon Sep 17 00:00:00 2001
From: Mark Washenberger <mark.washenberger@rackspace.com>
Date: Thu, 10 Mar 2011 00:26:25 -0500
Subject: add tests to verify the serialization of adminPass in server creation
 response

---
 nova/tests/api/openstack/test_servers.py | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 2fc28fe67..0561ad499 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -19,6 +19,7 @@ import base64
 import datetime
 import json
 import unittest
+from xml.dom import minidom
 
 import stubout
 import webob
@@ -908,6 +909,7 @@ class TestServerInstanceCreation(test.TestCase):
     def _get_create_request_xml(self, body_dict):
         req = webob.Request.blank('/v1.0/servers')
         req.content_type = 'application/xml'
+        req.accept = 'application/xml'
         req.method = 'POST'
         req.body = self._format_xml_request_body(body_dict)
         return req
@@ -1034,6 +1036,23 @@ class TestServerInstanceCreation(test.TestCase):
         self.assertEquals(response.status_int, 200)
         self.assertEquals(personality_files, [(path, contents)])
 
+    def test_create_instance_admin_pass_json(self):
+        request, response, dummy = \
+            self._create_instance_with_personality_json(None)
+        self.assertEquals(response.status_int, 200)
+        response = json.loads(response.body)
+        self.assertTrue('adminPass' in response['server'])
+        self.assertTrue(response['server']['adminPass'].startswith('fake'))
+
+    def test_create_instance_admin_pass_xml(self):
+        request, response, dummy = \
+            self._create_instance_with_personality_xml(None)
+        self.assertEquals(response.status_int, 200)
+        dom = minidom.parseString(response.body)
+        server = dom.childNodes[0]
+        self.assertEquals(server.nodeName, 'server')
+        self.assertTrue(server.getAttribute('adminPass').startswith('fake'))
+
 
 if __name__ == "__main__":
     unittest.main()
-- 
cgit 


From b75ab789194f1ced801b1d68ae8cc54051716414 Mon Sep 17 00:00:00 2001
From: Kei Masumoto <masumotok@nttdata.co.jp>
Date: Thu, 10 Mar 2011 15:16:03 +0900
Subject: fix pep8 check

---
 nova/tests/test_service.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/test_service.py b/nova/tests/test_service.py
index 666c4a11d..393f9d20b 100644
--- a/nova/tests/test_service.py
+++ b/nova/tests/test_service.py
@@ -284,9 +284,9 @@ class ServiceTestCase(test.TestCase):
         serv.manager.driver.update_available_resource(mox.IgnoreArg(), host)
 
         # Just doing start()-stop(), not confirm new db record is created,
-        # because update_available_resource() works only in libvirt environment.
-        # This testcase confirms update_available_resource() is called.
-        # Otherwise, mox complains.
+        # because update_available_resource() works only in
+        # libvirt environment. This testcase confirms
+        # update_available_resource() is called. Otherwise, mox complains.
         self.mox.ReplayAll()
         serv.start()
         serv.stop()
-- 
cgit 


From 1fa41c5c621f3190c8c2b1c3d885c95b6b627b23 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
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')

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 9e77a0c6f6b43494e0eb87a16f33cd566f0746d2 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Thu, 10 Mar 2011 09:55:45 +0100
Subject: Split dnsmasq and radvd commands into their respective argv's.

---
 nova/network/linux_net.py | 38 +++++++++++++++++++-------------------
 1 file changed, 19 insertions(+), 19 deletions(-)

(limited to 'nova')

diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index 228a4d9ea..9fd6c82de 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -424,30 +424,30 @@ def _remove_rule(chain, *cmd):
 
 def _dnsmasq_cmd(net):
     """Builds dnsmasq command"""
-    cmd = ['sudo -E dnsmasq',
-           ' --strict-order',
-           ' --bind-interfaces',
-           ' --conf-file=',
-           ' --domain=%s' % FLAGS.dhcp_domain,
-           ' --pid-file=%s' % _dhcp_file(net['bridge'], 'pid'),
-           ' --listen-address=%s' % net['gateway'],
-           ' --except-interface=lo',
-           ' --dhcp-range=%s,static,120s' % net['dhcp_start'],
-           ' --dhcp-hostsfile=%s' % _dhcp_file(net['bridge'], 'conf'),
-           ' --dhcp-script=%s' % FLAGS.dhcpbridge,
-           ' --leasefile-ro']
+    cmd = ['sudo', '-E', 'dnsmasq',
+           '--strict-order',
+           '--bind-interfaces',
+           '--conf-file=',
+           '--domain=%s' % FLAGS.dhcp_domain,
+           '--pid-file=%s' % _dhcp_file(net['bridge'], 'pid'),
+           '--listen-address=%s' % net['gateway'],
+           '--except-interface=lo',
+           '--dhcp-range=%s,static,120s' % net['dhcp_start'],
+           '--dhcp-hostsfile=%s' % _dhcp_file(net['bridge'], 'conf'),
+           '--dhcp-script=%s' % FLAGS.dhcpbridge,
+           '--leasefile-ro']
     if FLAGS.dns_server:
-        cmd.append(' -h -R --server=%s' % FLAGS.dns_server)
-    return ''.join(cmd)
+        cmd += ['-h', '-R', '--server=%s' % FLAGS.dns_server]
+    return cmd
 
 
 def _ra_cmd(net):
     """Builds radvd command"""
-    cmd = ['sudo -E radvd',
-#           ' -u nobody',
-           ' -C %s' % _ra_file(net['bridge'], 'conf'),
-           ' -p %s' % _ra_file(net['bridge'], 'pid')]
-    return ''.join(cmd)
+    cmd = ['sudo', '-E', 'radvd',
+#           '-u', 'nobody',
+           '-C', '%s' % _ra_file(net['bridge'], 'conf'),
+           '-p', '%s' % _ra_file(net['bridge'], 'pid')]
+    return cmd
 
 
 def _stop_dnsmasq(network):
-- 
cgit 


From e575f5ddd46055f2e491606052493b6d648506f6 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Thu, 10 Mar 2011 10:16:07 +0100
Subject: Pass argv of dnsmasq and radvd to execute as individual args, not as
 a list.

---
 nova/network/linux_net.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index 9fd6c82de..e64c052f9 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -330,7 +330,7 @@ def update_dhcp(context, network_id):
     env = {'FLAGFILE': FLAGS.dhcpbridge_flagfile,
            'DNSMASQ_INTERFACE': network_ref['bridge']}
     command = _dnsmasq_cmd(network_ref)
-    _execute(command, addl_env=env)
+    _execute(*command, addl_env=env)
 
 
 def update_ra(context, network_id):
@@ -370,7 +370,7 @@ interface %s
         else:
             LOG.debug(_("Pid %d is stale, relaunching radvd"), pid)
     command = _ra_cmd(network_ref)
-    _execute(command)
+    _execute(*command)
     db.network_update(context, network_id,
                       {"ra_server":
                        utils.get_my_linklocal(network_ref['bridge'])})
-- 
cgit 


From 6601d52bfa501ac1ae266647be19fac2f6792efc Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Thu, 10 Mar 2011 11:35:42 +0100
Subject: Make nova.image.s3 catch up with the new execute syntax.

---
 nova/image/s3.py | 31 +++++++++++++++++++------------
 1 file changed, 19 insertions(+), 12 deletions(-)

(limited to 'nova')

diff --git a/nova/image/s3.py b/nova/image/s3.py
index bbc54c263..85a2c651c 100644
--- a/nova/image/s3.py
+++ b/nova/image/s3.py
@@ -236,25 +236,32 @@ class S3ImageService(service.BaseImageService):
     @staticmethod
     def _decrypt_image(encrypted_filename, encrypted_key, encrypted_iv,
                        cloud_private_key, decrypted_filename):
-        key, err = utils.execute(
-                'openssl rsautl -decrypt -inkey %s' % cloud_private_key,
-                process_input=encrypted_key,
-                check_exit_code=False)
+        key, err = utils.execute('openssl',
+                                 'rsautl',
+                                 '-decrypt',
+                                 '-inkey', '%s' % cloud_private_key,
+                                 process_input=encrypted_key,
+                                 check_exit_code=False)
         if err:
             raise exception.Error(_("Failed to decrypt private key: %s")
                                   % err)
-        iv, err = utils.execute(
-                'openssl rsautl -decrypt -inkey %s' % cloud_private_key,
-                process_input=encrypted_iv,
-                check_exit_code=False)
+        iv, err = utils.execute('openssl',
+                                'rsautl',
+                                '-decrypt',
+                                '-inkey', '%s' % cloud_private_key,
+                                process_input=encrypted_iv,
+                                check_exit_code=False)
         if err:
             raise exception.Error(_("Failed to decrypt initialization "
                                     "vector: %s") % err)
 
-        _out, err = utils.execute(
-                'openssl enc -d -aes-128-cbc -in %s -K %s -iv %s -out %s'
-                 % (encrypted_filename, key, iv, decrypted_filename),
-                 check_exit_code=False)
+        _out, err = utils.execute('openssl', 'enc',
+                                  '-d', '-aes-128-cbc',
+                                  '-in', '%s' % (encrypted_filename,),
+                                  '-K', '%s' % (key,),
+                                  '-iv', '%s' % (iv,),
+                                  '-out', '%s' % (decrypted_filename,),
+                                  check_exit_code=False)
         if err:
             raise exception.Error(_("Failed to decrypt image file "
                                     "%(image_file)s: %(err)s") %
-- 
cgit 


From bd3411f88532619b760aa8f51379db2f9c1cf5d0 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Thu, 10 Mar 2011 11:59:50 +0100
Subject: More execvp fallout

---
 nova/objectstore/image.py | 33 +++++++++++++++++++++------------
 1 file changed, 21 insertions(+), 12 deletions(-)

(limited to 'nova')

diff --git a/nova/objectstore/image.py b/nova/objectstore/image.py
index 8013cbd9c..c90b5b54b 100644
--- a/nova/objectstore/image.py
+++ b/nova/objectstore/image.py
@@ -253,25 +253,34 @@ class Image(object):
     @staticmethod
     def decrypt_image(encrypted_filename, encrypted_key, encrypted_iv,
                       cloud_private_key, decrypted_filename):
-        key, err = utils.execute(
-                'openssl rsautl -decrypt -inkey %s' % cloud_private_key,
-                process_input=encrypted_key,
-                check_exit_code=False)
+        key, err = utils.execute('openssl',
+                                 'rsautl',
+                                 '-decrypt',
+                                 '-inkey', '%s' % cloud_private_key,
+                                 process_input=encrypted_key,
+                                 check_exit_code=False)
         if err:
             raise exception.Error(_("Failed to decrypt private key: %s")
                                   % err)
-        iv, err = utils.execute(
-                'openssl rsautl -decrypt -inkey %s' % cloud_private_key,
-                process_input=encrypted_iv,
-                check_exit_code=False)
+        iv, err = utils.execute('openssl',
+                                'rsautl',
+                                '-decrypt',
+                                '-inkey', '%s' % cloud_private_key,
+                                process_input=encrypted_iv,
+                                check_exit_code=False)
         if err:
             raise exception.Error(_("Failed to decrypt initialization "
                                     "vector: %s") % err)
 
-        _out, err = utils.execute(
-                'openssl enc -d -aes-128-cbc -in %s -K %s -iv %s -out %s'
-                 % (encrypted_filename, key, iv, decrypted_filename),
-                 check_exit_code=False)
+        _out, err = utils.execute('openssl',
+                                  'enc',
+                                  '-d',
+                                  '-aes-128-cbc',
+                                  '-in', '%s' % (encrypted_filename,),
+                                  '-K', '%s' % (key,),
+                                  '-iv', '%s' % (iv,),
+                                  '-out', '%s' % (decrypted_filename,),
+                                  check_exit_code=False)
         if err:
             raise exception.Error(_("Failed to decrypt image file "
                                     "%(image_file)s: %(err)s") %
-- 
cgit 


From e76aad24ce8a9b1b7de1b2f874c22c9995f3071f Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Thu, 10 Mar 2011 14:30:17 +0100
Subject: Only include ramdisk and kernel id if they are actually set.

---
 nova/api/ec2/cloud.py | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

(limited to 'nova')

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index b1917e9ea..1d2254225 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -147,8 +147,6 @@ class CloudController(object):
                                                        instance_ref['id'])
         ec2_id = ec2utils.id_to_ec2_id(instance_ref['id'])
         image_ec2_id = self._image_ec2_id(instance_ref['image_id'], 'machine')
-        k_ec2_id = self._image_ec2_id(instance_ref['kernel_id'], 'kernel')
-        r_ec2_id = self._image_ec2_id(instance_ref['ramdisk_id'], 'ramdisk')
         data = {
             'user-data': base64.b64decode(instance_ref['user_data']),
             'meta-data': {
@@ -167,8 +165,6 @@ class CloudController(object):
                 'instance-type': instance_ref['instance_type'],
                 'local-hostname': hostname,
                 'local-ipv4': address,
-                'kernel-id': k_ec2_id,
-                'ramdisk-id': r_ec2_id,
                 'placement': {'availability-zone': availability_zone},
                 'public-hostname': hostname,
                 'public-ipv4': floating_ip or '',
@@ -176,6 +172,13 @@ class CloudController(object):
                 'reservation-id': instance_ref['reservation_id'],
                 'security-groups': '',
                 'mpi': mpi}}
+
+        for image_type in ['kernel', 'ramdisk']:
+            if '%s_id' % image_type in instance_ref:
+                ec2_id = self._image_ec2_id(instance_ref['%s_id' % image_type],
+                                            image_type)
+                data['meta-data']['%s-id' % image_type] = ec2_id
+
         if False:  # TODO(vish): store ancestor ids
             data['ancestor-ami-ids'] = []
         if False:  # TODO(vish): store product codes
-- 
cgit 


From b64cf7352a24d8ced69aa408f7ceadd9da71da14 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Thu, 10 Mar 2011 15:47:09 +0100
Subject: One more thing..

---
 nova/network/linux_net.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index e64c052f9..c0bd76adf 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -216,7 +216,7 @@ def ensure_bridge(bridge, interface, net_attrs=None):
         _execute('sudo', 'brctl', 'setfd', bridge, 0)
         # _execute("sudo brctl setageing %s 10" % bridge)
         _execute('sudo', 'brctl', 'stp', bridge, 'off')
-        _execute('sudo', 'ip', 'link', 'set', bridge, up)
+        _execute('sudo', 'ip', 'link', 'set', bridge, 'up')
     if net_attrs:
         # NOTE(vish): The ip for dnsmasq has to be the first address on the
         #             bridge for it to respond to reqests properly
-- 
cgit 


From b38af111532717cbe9f4bef1d3c3d58e7082c8b9 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
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')

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 <sateesh.chodapuneedi@citrix.com>
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/console/vmrc.py                 |  2 +-
 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 ++++++----
 7 files changed, 178 insertions(+), 68 deletions(-)
 create mode 100644 nova/virt/vmwareapi/error_util.py

(limited to 'nova')

diff --git a/nova/console/vmrc.py b/nova/console/vmrc.py
index 09f8067e5..9c5e3b444 100644
--- a/nova/console/vmrc.py
+++ b/nova/console/vmrc.py
@@ -119,7 +119,7 @@ class VMRCSessionConsole(VMRCConsole):
             vim_session._get_vim(),
             "AcquireCloneTicket",
             vim_session._get_vim().get_service_content().sessionManager)
-        return str(vm_ref) + ":" + virtual_machine_ticket
+        return str(vm_ref.value) + ":" + virtual_machine_ticket
 
     def is_otp(self):
         """Is one time password."""
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 <cory.wright@rackspace.com>
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')

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 b361153a160ba1d61ed1d52de419cd27a8b4feda Mon Sep 17 00:00:00 2001
From: "Kevin L. Mitchell" <kevin.mitchell@rackspace.com>
Date: Thu, 10 Mar 2011 16:42:13 +0000
Subject: Correct a misspelling

---
 nova/db/sqlalchemy/api.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 22c85106d..2b60ab7d5 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -1682,7 +1682,7 @@ def security_group_destroy(context, security_group_id):
                      update({'deleted': 1,
                              'deleted_at': datetime.datetime.utcnow(),
                              'updated_at':
-                                 (models.SecurityGroupInstanceAssocation.
+                                 (models.SecurityGroupInstanceAssociation.
                                   updated_at + 0)})
         session.query(models.SecurityGroupIngressRule).\
                      filter_by(group_id=security_group_id).\
-- 
cgit 


From 4ead485ab69ee1e92635857ba73133a9e1d3bbcb Mon Sep 17 00:00:00 2001
From: Josh Kearney <josh@jk0.org>
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')

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 25bbe2afb0be3c79264376dd6a11e2bc97847702 Mon Sep 17 00:00:00 2001
From: Tushar Patil <tushar.vitthal.patil@gmail.com>
Date: Thu, 10 Mar 2011 11:17:34 -0800
Subject: fixed formatting and redundant imports

---
 nova/api/ec2/cloud.py                                               | 6 +++---
 .../db/sqlalchemy/migrate_repo/versions/007_add_ipv6_flatmanager.py | 1 -
 2 files changed, 3 insertions(+), 4 deletions(-)

(limited to 'nova')

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 6ed6186be..c6309f03c 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -701,9 +701,9 @@ class CloudController(object):
                     fixed = instance['fixed_ip']
                     floating_addr = fixed['floating_ips'][0]['address']
                 if instance['fixed_ip']['network'] and 'use_v6' in kwargs:
-                        i['dnsNameV6'] = utils.to_global_ipv6(
-                            instance['fixed_ip']['network']['cidr_v6'],
-                            instance['mac_address'])
+                    i['dnsNameV6'] = utils.to_global_ipv6(
+                        instance['fixed_ip']['network']['cidr_v6'],
+                        instance['mac_address'])
 
             i['privateDnsName'] = fixed_addr
             i['publicDnsName'] = floating_addr
diff --git a/nova/db/sqlalchemy/migrate_repo/versions/007_add_ipv6_flatmanager.py b/nova/db/sqlalchemy/migrate_repo/versions/007_add_ipv6_flatmanager.py
index d14f52af1..b8514c439 100644
--- a/nova/db/sqlalchemy/migrate_repo/versions/007_add_ipv6_flatmanager.py
+++ b/nova/db/sqlalchemy/migrate_repo/versions/007_add_ipv6_flatmanager.py
@@ -12,7 +12,6 @@
 #    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 lib2to3.fixer_util import String
 
 from sqlalchemy import *
 from migrate import *
-- 
cgit 


From 616723fe4e7d52b0b8ddafda10fcfe07a87609c8 Mon Sep 17 00:00:00 2001
From: Mark Washenberger <mark.washenberger@rackspace.com>
Date: Thu, 10 Mar 2011 14:53:13 -0500
Subject: add docstring

---
 nova/compute/api.py | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'nova')

diff --git a/nova/compute/api.py b/nova/compute/api.py
index 2766ddc9c..efa051d10 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -81,6 +81,11 @@ class API(base.Base):
                         {"method": "get_network_topic", "args": {'fake': 1}})
 
     def _check_personality_file_quota(self, context, personality_files):
+        """
+        Enforce quota limits on personality files
+
+        Raises a QuotaError if any limit is exceeded
+        """
         limit = quota.allowed_personality_files(context)
         if len(personality_files) > limit:
             raise quota.QuotaError(_("Personality limit exceeded. You can "
-- 
cgit 


From 03e5b8f7c4e1afc6637774acb3d28100035cd323 Mon Sep 17 00:00:00 2001
From: "Kevin L. Mitchell" <kevin.mitchell@rackspace.com>
Date: Thu, 10 Mar 2011 20:04:21 +0000
Subject: Partial revert of one conversion due to phantom magic exception from
 SQLAlchemy in unrelated code; convert all deletes

---
 nova/db/sqlalchemy/api.py | 65 ++++++++++++++++++++++++++++++-----------------
 1 file changed, 41 insertions(+), 24 deletions(-)

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 2b60ab7d5..31adb33ee 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -701,11 +701,21 @@ def instance_data_get_for_project(context, project_id):
 def instance_destroy(context, instance_id):
     session = get_session()
     with session.begin():
-        session.query(models.Instance).\
-                     filter_by(id=instance_id).\
-                     update({'deleted': 1,
-                             'deleted_at': datetime.datetime.utcnow(),
-                             'updated_at': models.Instance.updated_at + 0})
+        session.execute('update instances set deleted=1,'
+                        'deleted_at=:at where id=:id',
+                        {'id': instance_id,
+                         'at': datetime.datetime.utcnow()})
+        # NOTE(klmitch): for some reason, using the SQLAlchemy code
+        # here instead of the direct SQL update above causes the
+        # test_run_terminate_timestamps test (and only that one) to
+        # fail with an obscure TypeError exception from deep within
+        # SQLAlchemy; the nearest nova function in the traceback is
+        # instance_get()
+        # session.query(models.Instance).\
+        #              filter_by(id=instance_id).\
+        #              update({'deleted': 1,
+        #                      'deleted_at': datetime.datetime.utcnow(),
+        #                      'updated_at': models.Instance.updated_at + 0})
         session.query(models.SecurityGroupInstanceAssociation).\
                      filter_by(instance_id=instance_id).\
                      update({'deleted': 1,
@@ -1837,12 +1847,15 @@ def user_create(_context, values):
 def user_delete(context, id):
     session = get_session()
     with session.begin():
-        session.execute('delete from user_project_association '
-                        'where user_id=:id', {'id': id})
-        session.execute('delete from user_role_association '
-                        'where user_id=:id', {'id': id})
-        session.execute('delete from user_project_role_association '
-                        'where user_id=:id', {'id': id})
+        session.query(models.UserProjectAssociation).\
+                     filter_by(user_id=id).\
+                     delete()
+        session.query(models.UserRoleAssociation).\
+                     filter_by(user_id=id).\
+                     delete()
+        session.query(models.UserProjectRoleAssociation).\
+                     filter_by(user_id=id).\
+                     delete()
         user_ref = user_get(context, id, session=session)
         session.delete(user_ref)
 
@@ -1933,10 +1946,12 @@ def project_update(context, project_id, values):
 def project_delete(context, id):
     session = get_session()
     with session.begin():
-        session.execute('delete from user_project_association '
-                        'where project_id=:id', {'id': id})
-        session.execute('delete from user_project_role_association '
-                        'where project_id=:id', {'id': id})
+        session.query(models.UserProjectAssociation).\
+                     filter_by(project_id=id).\
+                     delete()
+        session.query(models.UserProjectRoleAssociation).\
+                     filter_by(project_id=id).\
+                     delete()
         project_ref = project_get(context, id, session=session)
         session.delete(project_ref)
 
@@ -1961,11 +1976,11 @@ def user_get_roles_for_project(context, user_id, project_id):
 def user_remove_project_role(context, user_id, project_id, role):
     session = get_session()
     with session.begin():
-        session.execute('delete from user_project_role_association where '
-                        'user_id=:user_id and project_id=:project_id and '
-                        'role=:role', {'user_id': user_id,
-                                       'project_id': project_id,
-                                       'role': role})
+        session.query(models.UserProjectRoleAssociation).\
+                     filter_by(user_id=user_id).\
+                     filter_by(project_id=project_id).\
+                     filter_by(role=role).\
+                     delete()
 
 
 def user_remove_role(context, user_id, role):
@@ -2116,8 +2131,9 @@ def console_delete(context, console_id):
     session = get_session()
     with session.begin():
         # consoles are meant to be transient. (mdragon)
-        session.execute('delete from consoles '
-                        'where id=:id', {'id': console_id})
+        session.query(models.Console).\
+                     filter_by(id=console_id).\
+                     delete()
 
 
 def console_get_by_pool_instance(context, pool_id, instance_id):
@@ -2273,8 +2289,9 @@ def zone_update(context, zone_id, values):
 def zone_delete(context, zone_id):
     session = get_session()
     with session.begin():
-        session.execute('delete from zones '
-                        'where id=:id', {'id': zone_id})
+        session.query(models.Zone).\
+                     filter_by(id=zone_id).\
+                     delete()
 
 
 @require_admin_context
-- 
cgit 


From 6b95c5133452ae26da2cb7f08267aa4cb056e7af Mon Sep 17 00:00:00 2001
From: Dan Prince <dan.prince@rackspace.com>
Date: Thu, 10 Mar 2011 15:05:04 -0500
Subject: Initial support fo extension resources. Tests.

---
 nova/api/openstack/__init__.py              |  8 ++-
 nova/api/openstack/extensions.py            | 29 ++++++++++
 nova/tests/api/openstack/test_extensions.py | 83 +++++++++++++++++++++++++++++
 3 files changed, 119 insertions(+), 1 deletion(-)
 create mode 100644 nova/api/openstack/extensions.py
 create mode 100644 nova/tests/api/openstack/test_extensions.py

(limited to 'nova')

diff --git a/nova/api/openstack/__init__.py b/nova/api/openstack/__init__.py
index ab9dbb780..28e2a1691 100644
--- a/nova/api/openstack/__init__.py
+++ b/nova/api/openstack/__init__.py
@@ -30,6 +30,7 @@ from nova import wsgi
 from nova.api.openstack import faults
 from nova.api.openstack import backup_schedules
 from nova.api.openstack import consoles
+from nova.api.openstack import extensions
 from nova.api.openstack import flavors
 from nova.api.openstack import images
 from nova.api.openstack import servers
@@ -68,7 +69,7 @@ class APIRouter(wsgi.Router):
         """Simple paste factory, :class:`nova.wsgi.Router` doesn't have one"""
         return cls()
 
-    def __init__(self):
+    def __init__(self, ext_manager=None):
         mapper = routes.Mapper()
 
         server_members = {'action': 'POST'}
@@ -111,6 +112,11 @@ class APIRouter(wsgi.Router):
                         collection={'detail': 'GET'},
                         controller=shared_ip_groups.Controller())
 
+        if ext_manager is None:
+            ext_manager = extensions.ExtensionManager()
+        for resource in ext_manager.get_resources():
+            resource.add_routes(mapper)
+
         super(APIRouter, self).__init__(mapper)
 
 
diff --git a/nova/api/openstack/extensions.py b/nova/api/openstack/extensions.py
new file mode 100644
index 000000000..1c539c500
--- /dev/null
+++ b/nova/api/openstack/extensions.py
@@ -0,0 +1,29 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# 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.
+
+class ExtensionManager(object):
+
+    def get_resources(self):
+        """
+        returns a list of ExtensionResource objects
+        """
+        return []
+
+class ExtensionResource(object):
+
+    def add_routes(self, mapper):
+        pass
diff --git a/nova/tests/api/openstack/test_extensions.py b/nova/tests/api/openstack/test_extensions.py
new file mode 100644
index 000000000..f5332c84a
--- /dev/null
+++ b/nova/tests/api/openstack/test_extensions.py
@@ -0,0 +1,83 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# 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.
+
+import unittest
+
+import webob
+
+from nova.api import openstack
+import nova.wsgi
+
+class StubController(nova.wsgi.Controller):
+
+    def __init__(self, body):
+        self.body = body
+
+    def index(self, req):
+        return self.body
+
+class StubExtensionManager(object):
+
+    def __init__(self, resources):
+        self.resources = resources
+
+    def get_resources(self):
+        return self.resources
+
+class WidgetExtensionResource(object):
+
+    def __init__(self, name, collection, wsgi_app):
+        self.name = name
+        self.collection = collection
+        self.wsgi_app = wsgi_app
+
+    def add_routes(self, mapper):
+        mapper.resource(self.name, self.collection, controller=self.wsgi_app)
+
+class ExtensionTest(unittest.TestCase):
+
+    def test_no_extension_present(self):
+        manager = StubExtensionManager([])
+        router = openstack.APIRouter(manager)
+        request = webob.Request.blank("/widgets")
+        response = request.get_response(router)
+        self.assertEqual(404, response.status_int)
+
+    def test_get_resources(self):
+        response_body = "Buy more widgets!"
+        response = webob.Response()
+        response.body = response_body
+        resource1 = WidgetExtensionResource("widget", "widgets", response)
+        manager = StubExtensionManager([resource1])
+        router = openstack.APIRouter(manager)
+        request = webob.Request.blank("/widgets")
+        response = request.get_response(router)
+        self.assertEqual(200, response.status_int)
+        self.assertEqual(response_body, response.body)
+
+    def test_get_resources_with_controller(self):
+        response_body = "Buy more widgets!"
+        controller = StubController(response_body)
+        resource1 = WidgetExtensionResource("widget", "widgets", controller)
+        manager = StubExtensionManager([resource1])
+        router = openstack.APIRouter(manager)
+        request = webob.Request.blank("/widgets")
+        response = request.get_response(router)
+        self.assertEqual(200, response.status_int)
+        self.assertEqual(response_body, response.body)
+
+
-- 
cgit 


From c177074649055f1da2ca97eb3c07139571d4a664 Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Thu, 10 Mar 2011 12:10:49 -0800
Subject: Implements basic OpenStack API client, ready to support API tests

---
 nova/tests/integrated/__init__.py     |  20 +++
 nova/tests/integrated/api/__init__.py |  20 +++
 nova/tests/integrated/api/client.py   | 224 ++++++++++++++++++++++++++++++++++
 3 files changed, 264 insertions(+)
 create mode 100644 nova/tests/integrated/__init__.py
 create mode 100644 nova/tests/integrated/api/__init__.py
 create mode 100644 nova/tests/integrated/api/client.py

(limited to 'nova')

diff --git a/nova/tests/integrated/__init__.py b/nova/tests/integrated/__init__.py
new file mode 100644
index 000000000..10e0a91d7
--- /dev/null
+++ b/nova/tests/integrated/__init__.py
@@ -0,0 +1,20 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+#    Copyright (c) 2011 Justin Santa Barbara
+#
+#    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.
+
+"""
+:mod:`integrated` -- Tests whole systems, using mock services where needed
+=================================
+"""
diff --git a/nova/tests/integrated/api/__init__.py b/nova/tests/integrated/api/__init__.py
new file mode 100644
index 000000000..5798ab3d1
--- /dev/null
+++ b/nova/tests/integrated/api/__init__.py
@@ -0,0 +1,20 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+#    Copyright (c) 2011 Justin Santa Barbara
+#
+#    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.
+
+"""
+:mod:`api` -- OpenStack API client, for testing rather than production
+=================================
+"""
diff --git a/nova/tests/integrated/api/client.py b/nova/tests/integrated/api/client.py
new file mode 100644
index 000000000..5ab247fab
--- /dev/null
+++ b/nova/tests/integrated/api/client.py
@@ -0,0 +1,224 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+#    Copyright (c) 2011 Justin Santa Barbara
+#
+#    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 json
+import httplib
+import urlparse
+
+from nova import log as logging
+
+
+LOG = logging.getLogger('nova.tests.api')
+
+
+class OpenstackApiException(Exception):
+    def __init__(self, message=None, response=None):
+        self.response = response
+        if not message:
+            message = 'Unspecified error'
+
+        if response:
+            _status = response.status
+            _body = response.read()
+
+            message = _('%(message)s\nStatus Code: %(_status)s\n'
+                        'Body: %(_body)s') % locals()
+
+        super(OpenstackApiException, self).__init__(message)
+
+
+class OpenstackApiAuthenticationException(OpenstackApiException):
+    def __init__(self, response=None, message=None):
+        if not message:
+            message = _("Authentication error")
+        super(OpenstackApiAuthenticationException, self).__init__(message,
+                                                                  response)
+
+
+class OpenstackApiNotFoundException(OpenstackApiException):
+    def __init__(self, response=None, message=None):
+        if not message:
+            message = _("Item not found")
+        super(OpenstackApiNotFoundException, self).__init__(message, response)
+
+
+class TestOpenStackClient(object):
+    """ A really basic OpenStack API client that is under our control,
+    so we can make changes / insert hooks for testing"""
+
+    def __init__(self, auth_user, auth_key, auth_uri):
+        super(TestOpenStackClient, self).__init__()
+        self.auth_result = None
+        self.auth_user = auth_user
+        self.auth_key = auth_key
+        self.auth_uri = auth_uri
+
+    def request(self, url, method='GET', body=None, headers=None):
+        if headers is None:
+            headers = {}
+
+        parsed_url = urlparse.urlparse(url)
+        port = parsed_url.port
+        hostname = parsed_url.hostname
+        scheme = parsed_url.scheme
+
+        if scheme == 'http':
+            conn = httplib.HTTPConnection(hostname,
+                                          port=port)
+        elif scheme == 'https':
+            conn = httplib.HTTPSConnection(hostname,
+                                           port=port)
+        else:
+            raise OpenstackApiException("Unknown scheme: %s" % url)
+
+        relative_url = parsed_url.path
+        if parsed_url.query:
+            relative_url = relative_url + parsed_url.query
+        LOG.info(_("Doing %(method)s on %(relative_url)s") % locals())
+        if body:
+            LOG.info(_("Body: %s") % body)
+
+        conn.request(method, relative_url, body, headers)
+        response = conn.getresponse()
+        return response
+
+    def _authenticate(self):
+        if self.auth_result:
+            return self.auth_result
+
+        headers = {'X-Auth-User': self.auth_user,
+                   'X-Auth-Key': self.auth_key}
+        response = self.request(self.auth_uri,
+                                headers=headers)
+        if not response.status in [204]:
+            raise OpenstackApiAuthenticationException(response=response)
+
+        auth_headers = {}
+        for k, v in response.getheaders():
+            auth_headers[k] = v
+
+        self.auth_result = auth_headers
+        return self.auth_result
+
+    def api_request(self, relative_uri, check_response_status=None, **kwargs):
+        auth_result = self._authenticate()
+
+        base_uri = auth_result['X-Server-Management-Url']
+        full_uri = base_uri + relative_uri
+
+        headers = kwargs.setdefault('headers', {})
+        headers['X-Auth-Token'] = auth_result['X-Auth-Token']
+
+        LOG.debug(_("HTTP request on %s") % (relative_uri))
+
+        response = self.request(full_uri, **kwargs)
+
+        LOG.debug(_("Response => code %s") % (response.status))
+
+        if check_response_status:
+            if not response.status in check_response_status:
+                if response.status == 404:
+                    raise OpenstackApiNotFoundException(response=response)
+                else:
+                    raise OpenstackApiException(
+                                        message=_("Unexpected status code"),
+                                        response=response)
+
+        return response
+
+    def _decode_json(self, response):
+        body = response.read()
+        LOG.debug(_("Decoding JSON: %s") % (body))
+        return json.loads(body)
+
+    def api_get(self, relative_uri, **kwargs):
+        kwargs.setdefault('check_response_status', [200])
+        response = self.api_request(relative_uri, **kwargs)
+        return self._decode_json(response)
+
+    def api_post(self, relative_uri, body, **kwargs):
+        kwargs['method'] = 'POST'
+        if body:
+            headers = kwargs.setdefault('headers', {})
+            headers['Content-Type'] = 'application/json'
+            kwargs['body'] = json.dumps(body)
+
+        kwargs.setdefault('check_response_status', [200])
+        response = self.api_request(relative_uri, **kwargs)
+        return self._decode_json(response)
+
+    def api_delete(self, relative_uri, **kwargs):
+        kwargs['method'] = 'DELETE'
+        kwargs.setdefault('check_response_status', [200, 202])
+        return self.api_request(relative_uri, **kwargs)
+
+    def get_keys_detail(self):
+        return self.api_get('/keys/detail')['keys']
+
+    def post_key(self, key):
+        return self.api_post('/keys', key)['key']
+
+    def delete_key(self, key_id):
+        return self.api_delete('/keys/%s' % key_id)
+
+    def get_volume(self, volume_id):
+        return self.api_get('/volumes/%s' % volume_id)['volume']
+
+    def get_volumes_detail(self):
+        return self.api_get('/volumes/detail')['volumes']
+
+    def post_volume(self, volume):
+        return self.api_post('/volumes', volume)['volume']
+
+    def delete_volume(self, volume_id):
+        return self.api_delete('/volumes/%s' % volume_id)
+
+    def get_server(self, server_id):
+        return self.api_get('/servers/%s' % server_id)['server']
+
+    def get_servers(self, detail=True):
+        rel_url = '/servers/detail' if detail else '/servers'
+        return self.api_get(rel_url)['servers']
+
+    def post_server(self, server):
+        return self.api_post('/servers', server)['server']
+
+    def delete_server(self, server_id):
+        return self.api_delete('/servers/%s' % server_id)
+
+    def get_image(self, image_id):
+        return self.api_get('/images/%s' % image_id)['image']
+
+    def get_images_detail(self):
+        return self.api_get('/images/detail')['images']
+
+    def post_image(self, image):
+        return self.api_post('/images', image)['image']
+
+    def delete_image(self, image_id):
+        return self.api_delete('/images/%s' % image_id)
+
+    def get_flavor(self, flavor_id):
+        return self.api_get('/flavors/%s' % flavor_id)['flavor']
+
+    def get_flavors_detail(self):
+        return self.api_get('/flavors/detail')['flavors']
+
+    def post_flavor(self, flavor):
+        return self.api_post('/flavors', flavor)['flavor']
+
+    def delete_flavor(self, flavor_id):
+        return self.api_delete('/flavors/%s' % flavor_id)
-- 
cgit 


From 8aabc32a69bf47075a3fd8e677d1bd70cbbca339 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Thu, 10 Mar 2011 21:13:07 +0100
Subject: Add basic test case.

---
 nova/tests/test_cloud.py | 12 ++++++++++++
 1 file changed, 12 insertions(+)

(limited to 'nova')

diff --git a/nova/tests/test_cloud.py b/nova/tests/test_cloud.py
index cf8ee7eff..db7c15aeb 100644
--- a/nova/tests/test_cloud.py
+++ b/nova/tests/test_cloud.py
@@ -353,6 +353,18 @@ class CloudTestCase(test.TestCase):
         self.assertEqual('', img.metadata['description'])
         shutil.rmtree(pathdir)
 
+    def test_metadata_works_without_kernel_and_ramdisk(self):
+        inst = db.instance_create(self.context, {'host': self.compute.host,
+                                                 'vcpus': 2,
+                                                 'image_id': '123456',
+                                                 'user_data': '' })
+        fixed = self.network.allocate_fixed_ip(self.context, inst['id'])
+        try:
+            self.cloud.get_metadata(fixed)
+        finally:
+            self.network.deallocate_fixed_ip(self.context, fixed)
+            db.instance_destroy(self.context, inst['id'])
+
     def test_update_of_instance_display_fields(self):
         inst = db.instance_create(self.context, {})
         ec2_id = ec2utils.id_to_ec2_id(inst['id'])
-- 
cgit 


From 11f2d788fd63c66af0e992f7b75b61273c059bcb Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Thu, 10 Mar 2011 21:31:47 +0100
Subject: PEP8

---
 nova/utils.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/utils.py b/nova/utils.py
index 3008a512e..87e726394 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -166,9 +166,9 @@ def execute(*cmd, **kwargs):
                                                 stdout=stdout,
                                                 stderr=stderr,
                                                 cmd=' '.join(cmd))
-            # NOTE(termie): this appears to be necessary to let the subprocess call
-            #               clean something up in between calls, without it two
-            #               execute calls in a row hangs the second one
+            # NOTE(termie): this appears to be necessary to let the subprocess
+            #               call clean something up in between calls, without
+            #               it two execute calls in a row hangs the second one
             greenthread.sleep(0)
             return result
         except ProcessExecutionError:
-- 
cgit 


From bd06f0ac0d0d3e3c9d7b296c5fe4bb8a0dd44c89 Mon Sep 17 00:00:00 2001
From: "Kevin L. Mitchell" <kevin.mitchell@rackspace.com>
Date: Thu, 10 Mar 2011 20:36:36 +0000
Subject: Last un-magiced session.execute() replaced with SQLAlchemy code...

---
 nova/db/sqlalchemy/api.py | 21 +++++++++++----------
 1 file changed, 11 insertions(+), 10 deletions(-)

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 31adb33ee..88125aaf5 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -579,16 +579,17 @@ def fixed_ip_disassociate_all_by_timeout(_context, host, time):
     session = get_session()
     # NOTE(vish): The nested select is because sqlite doesn't support
     #             JOINs in UPDATEs.
-    result = session.execute('UPDATE fixed_ips SET instance_id = NULL, '
-                                                  'leased = 0 '
-                             'WHERE network_id IN (SELECT id FROM networks '
-                                                  'WHERE host = :host) '
-                             'AND updated_at < :time '
-                             'AND instance_id IS NOT NULL '
-                             'AND allocated = 0',
-                    {'host': host,
-                     'time': time})
-    return result.rowcount
+    inner_q = session.query(models.Network.id).\
+                 filter_by(host=host).\
+                 subquery()
+    result = session.query(models.FixedIp).\
+                 filter(models.FixedIp.network_id.in_(inner_q)).\
+                 filter(models.FixedIp.updated_at < time).\
+                 filter(models.FixedIp.instance_id != None).\
+                 filter_by(allocated=0).\
+                 update({'instance_id': None,
+                         'leased': 0})
+    return result
 
 
 @require_admin_context
-- 
cgit 


From 6b4beef8093b4a7b4d42818567b5afb023af9251 Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Thu, 10 Mar 2011 12:55:06 -0800
Subject: Don't wrap keys and volumes till they're in the API

---
 nova/tests/integrated/api/client.py | 21 ---------------------
 1 file changed, 21 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/integrated/api/client.py b/nova/tests/integrated/api/client.py
index 5ab247fab..8ec46b5ae 100644
--- a/nova/tests/integrated/api/client.py
+++ b/nova/tests/integrated/api/client.py
@@ -165,27 +165,6 @@ class TestOpenStackClient(object):
         kwargs.setdefault('check_response_status', [200, 202])
         return self.api_request(relative_uri, **kwargs)
 
-    def get_keys_detail(self):
-        return self.api_get('/keys/detail')['keys']
-
-    def post_key(self, key):
-        return self.api_post('/keys', key)['key']
-
-    def delete_key(self, key_id):
-        return self.api_delete('/keys/%s' % key_id)
-
-    def get_volume(self, volume_id):
-        return self.api_get('/volumes/%s' % volume_id)['volume']
-
-    def get_volumes_detail(self):
-        return self.api_get('/volumes/detail')['volumes']
-
-    def post_volume(self, volume):
-        return self.api_post('/volumes', volume)['volume']
-
-    def delete_volume(self, volume_id):
-        return self.api_delete('/volumes/%s' % volume_id)
-
     def get_server(self, server_id):
         return self.api_get('/servers/%s' % server_id)['server']
 
-- 
cgit 


From f81d925f86670e3ed32d815c219824f627d82bc2 Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Thu, 10 Mar 2011 13:51:26 -0800
Subject: Better logging, be more careful about when we throw login errors re
 bug732866

---
 nova/tests/integrated/api/client.py | 37 +++++++++++++++++++++++--------------
 1 file changed, 23 insertions(+), 14 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/integrated/api/client.py b/nova/tests/integrated/api/client.py
index 8ec46b5ae..d424a6428 100644
--- a/nova/tests/integrated/api/client.py
+++ b/nova/tests/integrated/api/client.py
@@ -99,11 +99,18 @@ class TestOpenStackClient(object):
         if self.auth_result:
             return self.auth_result
 
+        auth_uri = self.auth_uri
         headers = {'X-Auth-User': self.auth_user,
                    'X-Auth-Key': self.auth_key}
-        response = self.request(self.auth_uri,
+        response = self.request(auth_uri,
                                 headers=headers)
-        if not response.status in [204]:
+        
+        http_status = response.status
+        LOG.debug(_("%(auth_uri)s => code %(http_status)s") % locals())
+
+        # Until bug732866 is fixed, we can't check this properly...
+        #if http_status == 401:
+        if http_status != 204:
             raise OpenstackApiAuthenticationException(response=response)
 
         auth_headers = {}
@@ -116,21 +123,21 @@ class TestOpenStackClient(object):
     def api_request(self, relative_uri, check_response_status=None, **kwargs):
         auth_result = self._authenticate()
 
-        base_uri = auth_result['X-Server-Management-Url']
+        #NOTE(justinsb): httplib 'helpfully' converts headers to lower case
+        base_uri = auth_result['x-server-management-url']
         full_uri = base_uri + relative_uri
 
         headers = kwargs.setdefault('headers', {})
-        headers['X-Auth-Token'] = auth_result['X-Auth-Token']
-
-        LOG.debug(_("HTTP request on %s") % (relative_uri))
+        headers['X-Auth-Token'] = auth_result['x-auth-token']
 
         response = self.request(full_uri, **kwargs)
-
-        LOG.debug(_("Response => code %s") % (response.status))
+        
+        http_status = response.status
+        LOG.debug(_("%(relative_uri)s => code %(http_status)s") % locals())
 
         if check_response_status:
-            if not response.status in check_response_status:
-                if response.status == 404:
+            if not http_status in check_response_status:
+                if http_status == 404:
                     raise OpenstackApiNotFoundException(response=response)
                 else:
                     raise OpenstackApiException(
@@ -181,8 +188,9 @@ class TestOpenStackClient(object):
     def get_image(self, image_id):
         return self.api_get('/images/%s' % image_id)['image']
 
-    def get_images_detail(self):
-        return self.api_get('/images/detail')['images']
+    def get_images(self, detail=True):
+        rel_url = '/images/detail' if detail else '/images'
+        return self.api_get(rel_url)['images']
 
     def post_image(self, image):
         return self.api_post('/images', image)['image']
@@ -193,8 +201,9 @@ class TestOpenStackClient(object):
     def get_flavor(self, flavor_id):
         return self.api_get('/flavors/%s' % flavor_id)['flavor']
 
-    def get_flavors_detail(self):
-        return self.api_get('/flavors/detail')['flavors']
+    def get_flavors(self, detail=True):
+        rel_url = '/flavors/detail' if detail else '/flavors'
+        return self.api_get(rel_url)['flavors']
 
     def post_flavor(self, flavor):
         return self.api_post('/flavors', flavor)['flavor']
-- 
cgit 


From 998975651ac2f2df7a3f8af16d62d197f451180f Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Thu, 10 Mar 2011 13:53:27 -0800
Subject: Test login.  Uncovered bug732866

---
 nova/tests/integrated/integrated_helpers.py | 182 ++++++++++++++++++++++++++++
 nova/tests/integrated/test_login.py         |  77 ++++++++++++
 2 files changed, 259 insertions(+)
 create mode 100644 nova/tests/integrated/integrated_helpers.py
 create mode 100644 nova/tests/integrated/test_login.py

(limited to 'nova')

diff --git a/nova/tests/integrated/integrated_helpers.py b/nova/tests/integrated/integrated_helpers.py
new file mode 100644
index 000000000..691ead6e1
--- /dev/null
+++ b/nova/tests/integrated/integrated_helpers.py
@@ -0,0 +1,182 @@
+# 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.
+
+"""
+Provides common functionality for integrated unit tests
+"""
+
+import random
+import string
+
+from nova import exception
+from nova import flags
+from nova import service
+from nova import test  # For the flags
+from nova.auth import manager
+from nova.exception import Error
+from nova.log import logging
+from nova.tests.integrated.api import client
+
+
+FLAGS = flags.FLAGS
+
+LOG = logging.getLogger('nova.tests.integrated')
+
+
+def generate_random_alphanumeric(length):
+    """Creates a random alphanumeric string of specified length"""
+    return ''.join(random.choice(string.ascii_uppercase + string.digits)
+                   for _x in range(length))
+
+
+def generate_random_numeric(length):
+    """Creates a random numeric string of specified length"""
+    return ''.join(random.choice(string.digits)
+                   for _x in range(length))
+
+
+def generate_new_element(items, prefix, numeric=False):
+    """Creates a random string with prefix, that is not in 'items' list"""
+    while True:
+        if numeric:
+            candidate = prefix + generate_random_numeric(8)
+        else:
+            candidate = prefix + generate_random_alphanumeric(8)
+        if not candidate in items:
+            return candidate
+        print "Random collision on %s" % candidate
+
+
+class TestUser(object):
+    def __init__(self, name, secret, auth_url):
+        self.name = name
+        self.secret = secret
+        self.auth_url = auth_url
+
+        if not auth_url:
+            raise exception.Error("auth_url is required")
+        self.openstack_api = client.TestOpenStackClient(self.name,
+                                                        self.secret,
+                                                        self.auth_url)
+
+
+class IntegratedUnitTestContext(object):
+    __INSTANCE = None
+
+    def __init__(self):
+        self.auth_manager = manager.AuthManager()
+
+        self.wsgi_server = None
+        self.wsgi_apps = []
+        self.api_service = None
+
+        self.services = []
+        self.auth_url = None
+        self.project_name = None
+
+        self.setup()
+
+    def setup(self):
+        self._start_services()
+
+        self._create_test_user()
+
+    def _create_test_user(self):
+        self.test_user = self._create_unittest_user()
+
+        # No way to currently pass this through the OpenStack API
+        self.project_name = 'openstack'
+        self._configure_project(self.project_name, self.test_user)
+
+    def _start_services(self):
+        # WSGI shutdown broken :-(
+        if not self.api_service:
+            self._start_api_service()
+
+    def cleanup(self):
+        for service in self.services:
+            service.kill()
+        self.services = []
+        # TODO(justinsb): Shutdown WSGI & anything else we startup
+        # WSGI shutdown broken :-(
+        # self.wsgi_server.terminate()
+        # self.wsgi_server = None
+        self.test_user = None
+
+    def _create_unittest_user(self):
+        users = self.auth_manager.get_users()
+        user_names = [user.name for user in users]
+        auth_name = generate_new_element(user_names, 'unittest_user_')
+        auth_key = generate_random_alphanumeric(16)
+
+        # Right now there's a bug where auth_name and auth_key are reversed
+        auth_key = auth_name
+
+        self.auth_manager.create_user(auth_name, auth_name, auth_key, False)
+        return TestUser(auth_name, auth_key, self.auth_url)
+
+    def _configure_project(self, project_name, user):
+        projects = self.auth_manager.get_projects()
+        project_names = [project.name for project in projects]
+        if not project_name in project_names:
+            project = self.auth_manager.create_project(project_name,
+                                                       user.name,
+                                                       description=None,
+                                                       member_users=None)
+        else:
+            self.auth_manager.add_to_project(user.name, project_name)
+
+    def _start_api_service(self):
+        api_service = service.ApiService.create()
+        api_service.start()
+
+        if not api_service:
+            raise Exception("API Service was None")
+
+        # WSGI shutdown broken :-(
+        #self.services.append(volume_service)
+        self.api_service = api_service
+
+        self.auth_url = 'http://localhost:8774/v1.0'
+
+        return api_service
+
+    # WSGI shutdown broken :-(
+    #@staticmethod
+    #def get():
+    #    if not IntegratedUnitTestContext.__INSTANCE:
+    #        IntegratedUnitTestContext.startup()
+    #        #raise Error("Must call IntegratedUnitTestContext::startup")
+    #    return IntegratedUnitTestContext.__INSTANCE
+
+    @staticmethod
+    def startup():
+        # Because WSGI shutdown is broken at the moment, we have to recycle
+        if IntegratedUnitTestContext.__INSTANCE:
+            #raise Error("Multiple calls to IntegratedUnitTestContext.startup")
+            IntegratedUnitTestContext.__INSTANCE.setup()
+        else:
+            IntegratedUnitTestContext.__INSTANCE = IntegratedUnitTestContext()
+        return IntegratedUnitTestContext.__INSTANCE
+
+    @staticmethod
+    def shutdown():
+        if not IntegratedUnitTestContext.__INSTANCE:
+            raise Error("Must call IntegratedUnitTestContext::startup")
+        IntegratedUnitTestContext.__INSTANCE.cleanup()
+        # WSGI shutdown broken :-(
+        #IntegratedUnitTestContext.__INSTANCE = None
diff --git a/nova/tests/integrated/test_login.py b/nova/tests/integrated/test_login.py
new file mode 100644
index 000000000..990dcaaf4
--- /dev/null
+++ b/nova/tests/integrated/test_login.py
@@ -0,0 +1,77 @@
+# 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.
+
+import unittest
+
+from nova import flags
+from nova.log import logging
+from nova.tests.integrated import integrated_helpers
+from nova.tests.integrated.api import client
+
+LOG = logging.getLogger('nova.tests.integrated')
+
+FLAGS = flags.FLAGS
+FLAGS.verbose = True
+
+
+class LoginTest(unittest.TestCase):
+    def setUp(self):
+        super(LoginTest, self).setUp()
+        context = integrated_helpers.IntegratedUnitTestContext.startup()
+        self.user = context.test_user
+        self.api = self.user.openstack_api
+
+    def tearDown(self):
+        integrated_helpers.IntegratedUnitTestContext.shutdown()
+        super(LoginTest, self).tearDown()
+
+    def test_login(self):
+        """Simple check - we list flavors - so we know we're logged in"""
+        flavors = self.api.get_flavors()
+        for flavor in flavors:
+            LOG.debug(_("flavor: %s") % flavor)
+
+    def test_bad_login_password(self):
+        """Test that I get a 401 with a bad username"""
+        bad_credentials_api = client.TestOpenStackClient(self.user.name,
+                                                         "notso_password",
+                                                         self.user.auth_url)
+
+        self.assertRaises(client.OpenstackApiAuthenticationException,
+                          bad_credentials_api.get_flavors)
+
+    def test_bad_login_username(self):
+        """Test that I get a 401 with a bad password"""
+        bad_credentials_api = client.TestOpenStackClient("notso_username",
+                                                         self.user.secret,
+                                                         self.user.auth_url)
+
+        self.assertRaises(client.OpenstackApiAuthenticationException,
+                          bad_credentials_api.get_flavors)
+
+
+    def test_bad_login_both_bad(self):
+        """Test that I get a 401 with both bad username and bad password"""
+        bad_credentials_api = client.TestOpenStackClient("notso_username",
+                                                         "notso_password",
+                                                         self.user.auth_url)
+
+        self.assertRaises(client.OpenstackApiAuthenticationException,
+                          bad_credentials_api.get_flavors)
+
+if __name__ == "__main__":
+    unittest.main()
-- 
cgit 


From f110e718807ea4747a0ff95138c488961257aa7f Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Thu, 10 Mar 2011 13:56:24 -0800
Subject: pep8 fun

---
 nova/tests/integrated/api/client.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/integrated/api/client.py b/nova/tests/integrated/api/client.py
index d424a6428..da8d87e07 100644
--- a/nova/tests/integrated/api/client.py
+++ b/nova/tests/integrated/api/client.py
@@ -104,7 +104,7 @@ class TestOpenStackClient(object):
                    'X-Auth-Key': self.auth_key}
         response = self.request(auth_uri,
                                 headers=headers)
-        
+
         http_status = response.status
         LOG.debug(_("%(auth_uri)s => code %(http_status)s") % locals())
 
@@ -131,7 +131,7 @@ class TestOpenStackClient(object):
         headers['X-Auth-Token'] = auth_result['x-auth-token']
 
         response = self.request(full_uri, **kwargs)
-        
+
         http_status = response.status
         LOG.debug(_("%(relative_uri)s => code %(http_status)s") % locals())
 
-- 
cgit 


From 4a9f4f4eef4e6fd6ab84ec2e03437144f9ab62f8 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Thu, 10 Mar 2011 16:07:50 -0600
Subject: More resize

---
 nova/compute/manager.py   | 68 ++++++++++++++++++++++++++++++-----------------
 nova/virt/xenapi/vmops.py | 13 +++++++--
 nova/virt/xenapi_conn.py  |  9 ++++---
 3 files changed, 60 insertions(+), 30 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 399356a13..f73e81345 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -429,21 +429,37 @@ class ComputeManager(manager.Manager):
         instance_ref = self.db.instance_get(context, instance_id)
         migration_ref = self.db.migration_get(context, migration_id)
 
-        #TODO(mdietz): we may want to split these into separate methods.
-        if migration_ref['source_compute'] == FLAGS.host:
-            self.driver._start(instance_ref)
-            self.db.migration_update(context, migration_id,
-                    {'status': 'reverted'})
-        else:
-            self.driver.destroy(instance_ref)
-            topic = self.db.queue_get_for(context, FLAGS.compute_topic,
-                    instance_ref['host'])
-            rpc.cast(context, topic,
-                    {'method': 'revert_resize',
-                     'args': {
-                           'migration_id': migration_ref['id'],
-                           'instance_id': instance_id, },
-                    })
+        self.driver.destroy(instance_ref)
+        topic = self.db.queue_get_for(context, FLAGS.compute_topic,
+                instance_ref['host'])
+        rpc.cast(context, topic,
+                {'method': 'finish_revert_resize',
+                 'args': {
+                       'migration_id': migration_ref['id'],
+                       'instance_id': instance_id, },
+                })
+
+    @exception.wrap_exception
+    @checks_instance_lock
+    def finish_revert_resize(self, context, instance_id, migration_id):
+        """Finishes the second half of reverting a resize, powering back on
+        the source instance and reverting the resized attributes in the
+        database"""
+        instance_ref = self.db.instance_get(context, instance_id)
+        migration_ref = self.db.migration_get(context, migration_id)
+        instance_type = self.db.instance_type_get_by_flavor_id(context,
+                migration_ref['old_flavor_id'])
+
+        #Just roll back the record. There's no need to resize down since
+        #the 'old' VM already has the preferred attributes
+        self.db.instance_update(context,
+           dict(memory_mb=instance_type['memory_mb'],
+                vcpus=instance_type['vcpus'],
+                local_gb=instance_type['local_gb']))
+
+        self.driver._start(instance_ref)
+        self.db.migration_update(context, migration_id,
+                {'status': 'reverted'})
 
     @exception.wrap_exception
     @checks_instance_lock
@@ -463,8 +479,8 @@ class ComputeManager(manager.Manager):
                  'source_compute': instance_ref['host'],
                  'dest_compute': FLAGS.host,
                  'dest_host':   self.driver.get_host_ip_addr(),
-                 'old_flavor': instance_type['flavor_id'],
-                 'new_flavor': flavor_id,
+                 'old_flavor_id': instance_type['flavor_id'],
+                 'new_flavor_id': flavor_id,
                  'status':      'pre-migrating'})
 
         LOG.audit(_('instance %s: migrating to '), instance_id,
@@ -492,13 +508,7 @@ class ComputeManager(manager.Manager):
         self.db.migration_update(context, migration_id,
                 {'status': 'post-migrating', })
 
-        #TODO(mdietz): apply the rest of the instance_type attributes going
-        #after they're supported
-        self.db.instance_update(context, instance_ref,
-               dict(memory_mb=instance_type['memory_mb'],
-                    vcpus=instance_type['vcpus'],
-                    local_gb=instance_type['local_gb']))
-        self.driver.resize_instance(context, instance_ref)
+        
 
         service = self.db.service_get_by_host_and_topic(context,
                 migration_ref['dest_compute'], FLAGS.compute_topic)
@@ -520,7 +530,17 @@ class ComputeManager(manager.Manager):
         migration_ref = self.db.migration_get(context, migration_id)
         instance_ref = self.db.instance_get(context,
                 migration_ref['instance_id'])
+        
+        #TODO(mdietz): apply the rest of the instance_type attributes going
+        #after they're supported
+        instance_type = self.db.instance_type_get_by_flavor_id(context,
+                migration_ref['new_flavor_id'])
+        self.db.instance_update(context, instance_ref,
+               dict(memory_mb=instance_type['memory_mb'],
+                    vcpus=instance_type['vcpus'],
+                    local_gb=instance_type['local_gb']))
 
+        self.driver.resize_instance(instance_ref, disk_info)
         self.driver.finish_resize(instance_ref, disk_info)
 
         self.db.migration_update(context, migration_id,
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 3d6430ecd114daa21c72c3d215daaa94f0e87e62 Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Thu, 10 Mar 2011 14:12:41 -0800
Subject: Re-removed the code that was deleted upstream but somehow didn't get
 merged in.  Bizarre!

---
 nova/tests/integrated/api/client.py | 21 ---------------------
 1 file changed, 21 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/integrated/api/client.py b/nova/tests/integrated/api/client.py
index 0ce480ae7..da8d87e07 100644
--- a/nova/tests/integrated/api/client.py
+++ b/nova/tests/integrated/api/client.py
@@ -172,27 +172,6 @@ class TestOpenStackClient(object):
         kwargs.setdefault('check_response_status', [200, 202])
         return self.api_request(relative_uri, **kwargs)
 
-    def get_keys_detail(self):
-        return self.api_get('/keys/detail')['keys']
-
-    def post_key(self, key):
-        return self.api_post('/keys', key)['key']
-
-    def delete_key(self, key_id):
-        return self.api_delete('/keys/%s' % key_id)
-
-    def get_volume(self, volume_id):
-        return self.api_get('/volumes/%s' % volume_id)['volume']
-
-    def get_volumes_detail(self):
-        return self.api_get('/volumes/detail')['volumes']
-
-    def post_volume(self, volume):
-        return self.api_post('/volumes', volume)['volume']
-
-    def delete_volume(self, volume_id):
-        return self.api_delete('/volumes/%s' % volume_id)
-
     def get_server(self, server_id):
         return self.api_get('/servers/%s' % server_id)['server']
 
-- 
cgit 


From 29bc4f5074ca3ada98a25a745077b998b4c5509c Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Thu, 10 Mar 2011 14:14:01 -0800
Subject: Pep8 / Style

---
 nova/tests/integrated/test_login.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/tests/integrated/test_login.py b/nova/tests/integrated/test_login.py
index 990dcaaf4..e362f92d6 100644
--- a/nova/tests/integrated/test_login.py
+++ b/nova/tests/integrated/test_login.py
@@ -22,6 +22,7 @@ from nova.log import logging
 from nova.tests.integrated import integrated_helpers
 from nova.tests.integrated.api import client
 
+
 LOG = logging.getLogger('nova.tests.integrated')
 
 FLAGS = flags.FLAGS
@@ -63,7 +64,6 @@ class LoginTest(unittest.TestCase):
         self.assertRaises(client.OpenstackApiAuthenticationException,
                           bad_credentials_api.get_flavors)
 
-
     def test_bad_login_both_bad(self):
         """Test that I get a 401 with both bad username and bad password"""
         bad_credentials_api = client.TestOpenStackClient("notso_username",
-- 
cgit 


From be66b329d5b94ffbfb782355ef342eadbaed72a5 Mon Sep 17 00:00:00 2001
From: Monsyne Dragon <mdragon@rackspace.com>
Date: Thu, 10 Mar 2011 22:14:53 +0000
Subject: Fix a fer nits jaypipes found in review.

---
 nova/api/openstack/accounts.py            | 18 +++++++++++++++---
 nova/api/openstack/users.py               |  4 ++--
 nova/tests/api/openstack/test_accounts.py |  6 +++---
 nova/tests/api/openstack/test_auth.py     | 15 ++++-----------
 nova/tests/api/openstack/test_users.py    |  2 +-
 5 files changed, 25 insertions(+), 20 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/accounts.py b/nova/api/openstack/accounts.py
index 3b90d2776..dd88c3390 100644
--- a/nova/api/openstack/accounts.py
+++ b/nova/api/openstack/accounts.py
@@ -21,6 +21,7 @@ from nova import log as logging
 from nova import wsgi
 
 from nova.auth import manager
+from nova.api.openstack import faults
 
 FLAGS = flags.FLAGS
 LOG = logging.getLogger('nova.api.openstack')
@@ -44,11 +45,17 @@ class Controller(wsgi.Controller):
         self.manager = manager.AuthManager()
 
     def _check_admin(self, context):
-        """ We cannot depend on the db layer to check for admin access
-            for the auth manager, so we do it here """
+        """We cannot depend on the db layer to check for admin access
+           for the auth manager, so we do it here"""
         if not context.is_admin:
             raise exception.NotAuthorized(_("Not admin user."))
 
+    def index(self, req):
+        raise faults.Fault(exc.HTTPNotImplemented())
+
+    def detail(self, req):
+        raise faults.Fault(exc.HTTPNotImplemented())
+
     def show(self, req, id):
         """Return data about the given account id"""
         account = self.manager.get_project(id)
@@ -59,8 +66,13 @@ class Controller(wsgi.Controller):
         self.manager.delete_project(id)
         return {}
 
+    def create(self, req):
+        """We use update with create-or-update semantics
+           because the id comes from an external source"""
+        raise faults.Fault(exc.HTTPNotImplemented())
+
     def update(self, req, id):
-        """ This is really create or update. """
+        """This is really create or update."""
         self._check_admin(req.environ['nova.context'])
         env = self._deserialize(req.body, req)
         description = env['account'].get('description')
diff --git a/nova/api/openstack/users.py b/nova/api/openstack/users.py
index 83ebec964..5bb20a718 100644
--- a/nova/api/openstack/users.py
+++ b/nova/api/openstack/users.py
@@ -45,8 +45,8 @@ class Controller(wsgi.Controller):
         self.manager = manager.AuthManager()
 
     def _check_admin(self, context):
-        """ We cannot depend on the db layer to check for admin access
-            for the auth manager, so we do it here """
+        """We cannot depend on the db layer to check for admin access
+           for the auth manager, so we do it here"""
         if not context.is_admin:
             raise exception.NotAuthorized(_("Not admin user"))
 
diff --git a/nova/tests/api/openstack/test_accounts.py b/nova/tests/api/openstack/test_accounts.py
index 746f02f57..78fceb47c 100644
--- a/nova/tests/api/openstack/test_accounts.py
+++ b/nova/tests/api/openstack/test_accounts.py
@@ -14,9 +14,10 @@
 #    under the License.
 
 
+import json
+
 import stubout
 import webob
-import json
 
 import nova.api
 import nova.api.openstack.auth
@@ -47,8 +48,7 @@ class AccountsTest(test.TestCase):
                        fake_init)
         self.stubs.Set(nova.api.openstack.accounts.Controller, '_check_admin',
                        fake_admin_check)
-        fakes.FakeAuthManager.auth_data = {}
-        fakes.FakeAuthManager.projects = {}
+        fakes.FakeAuthManager.clear_fakes()
         fakes.FakeAuthDatabase.data = {}
         fakes.stub_out_networking(self.stubs)
         fakes.stub_out_rate_limiting(self.stubs)
diff --git a/nova/tests/api/openstack/test_auth.py b/nova/tests/api/openstack/test_auth.py
index 49f90879d..437a79ec5 100644
--- a/nova/tests/api/openstack/test_auth.py
+++ b/nova/tests/api/openstack/test_auth.py
@@ -51,9 +51,7 @@ class Test(test.TestCase):
 
     def test_authorize_user(self):
         f = fakes.FakeAuthManager()
-        u = nova.auth.manager.User(1, 'herp', None, None, None)
-        f.add_user('derp', u)
-        f.create_project('test', u)
+        f.add_user('derp', nova.auth.manager.User(1, 'herp', None, None, None))
 
         req = webob.Request.blank('/v1.0/')
         req.headers['X-Auth-User'] = 'herp'
@@ -67,9 +65,7 @@ class Test(test.TestCase):
 
     def test_authorize_token(self):
         f = fakes.FakeAuthManager()
-        u = nova.auth.manager.User(1, 'herp', None, None, None)
-        f.add_user('derp', u)
-        f.create_project('test', u)
+        f.add_user('derp', nova.auth.manager.User(1, 'herp', None, None, None))
 
         req = webob.Request.blank('/v1.0/', {'HTTP_HOST': 'foo'})
         req.headers['X-Auth-User'] = 'herp'
@@ -86,7 +82,7 @@ class Test(test.TestCase):
         token = result.headers['X-Auth-Token']
         self.stubs.Set(nova.api.openstack, 'APIRouter',
             fakes.FakeRouter)
-        req = webob.Request.blank('/v1.0/test/fake')
+        req = webob.Request.blank('/v1.0/fake')
         req.headers['X-Auth-Token'] = token
         result = req.get_response(fakes.wsgi_app())
         self.assertEqual(result.status, '200 OK')
@@ -180,9 +176,6 @@ class TestLimiter(test.TestCase):
 
     def test_authorize_token(self):
         f = fakes.FakeAuthManager()
-        u = nova.auth.manager.User(1, 'herp', None, None, None)
-        f.add_user('derp', u)
-        f.create_project('test', u)
         f.add_user('derp', nova.auth.manager.User(1, 'herp', None, None, None))
 
         req = webob.Request.blank('/v1.0/')
@@ -194,7 +187,7 @@ class TestLimiter(test.TestCase):
         token = result.headers['X-Auth-Token']
         self.stubs.Set(nova.api.openstack, 'APIRouter',
             fakes.FakeRouter)
-        req = webob.Request.blank('/v1.0/test/fake')
+        req = webob.Request.blank'/v1.0/fake')
         req.method = 'POST'
         req.headers['X-Auth-Token'] = token
         result = req.get_response(fakes.wsgi_app())
diff --git a/nova/tests/api/openstack/test_users.py b/nova/tests/api/openstack/test_users.py
index 14c7897f0..1edefe713 100644
--- a/nova/tests/api/openstack/test_users.py
+++ b/nova/tests/api/openstack/test_users.py
@@ -13,10 +13,10 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+import json
 
 import stubout
 import webob
-import json
 
 import nova.api
 import nova.api.openstack.auth
-- 
cgit 


From f251ef70bf83eebce0f851f8a1b052174be1d615 Mon Sep 17 00:00:00 2001
From: Monsyne Dragon <mdragon@rackspace.com>
Date: Thu, 10 Mar 2011 22:20:51 +0000
Subject: fix minor typo

---
 nova/tests/api/openstack/test_auth.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/test_auth.py b/nova/tests/api/openstack/test_auth.py
index 437a79ec5..ff8d42a14 100644
--- a/nova/tests/api/openstack/test_auth.py
+++ b/nova/tests/api/openstack/test_auth.py
@@ -187,7 +187,7 @@ class TestLimiter(test.TestCase):
         token = result.headers['X-Auth-Token']
         self.stubs.Set(nova.api.openstack, 'APIRouter',
             fakes.FakeRouter)
-        req = webob.Request.blank'/v1.0/fake')
+        req = webob.Request.blank('/v1.0/fake')
         req.method = 'POST'
         req.headers['X-Auth-Token'] = token
         result = req.get_response(fakes.wsgi_app())
-- 
cgit 


From 0d3e950ed4b0c8abbd619d4ac8724b4c3ce45bf1 Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Thu, 10 Mar 2011 14:21:36 -0800
Subject: Document known bug numbers by the code which is degraded until the
 bugs are fixed

---
 nova/tests/integrated/api/client.py         | 1 +
 nova/tests/integrated/integrated_helpers.py | 6 ++++++
 2 files changed, 7 insertions(+)

(limited to 'nova')

diff --git a/nova/tests/integrated/api/client.py b/nova/tests/integrated/api/client.py
index da8d87e07..6fba2930a 100644
--- a/nova/tests/integrated/api/client.py
+++ b/nova/tests/integrated/api/client.py
@@ -109,6 +109,7 @@ class TestOpenStackClient(object):
         LOG.debug(_("%(auth_uri)s => code %(http_status)s") % locals())
 
         # Until bug732866 is fixed, we can't check this properly...
+        # bug732866
         #if http_status == 401:
         if http_status != 204:
             raise OpenstackApiAuthenticationException(response=response)
diff --git a/nova/tests/integrated/integrated_helpers.py b/nova/tests/integrated/integrated_helpers.py
index 691ead6e1..47093636e 100644
--- a/nova/tests/integrated/integrated_helpers.py
+++ b/nova/tests/integrated/integrated_helpers.py
@@ -104,6 +104,7 @@ class IntegratedUnitTestContext(object):
 
     def _start_services(self):
         # WSGI shutdown broken :-(
+        # bug731668
         if not self.api_service:
             self._start_api_service()
 
@@ -112,6 +113,7 @@ class IntegratedUnitTestContext(object):
             service.kill()
         self.services = []
         # TODO(justinsb): Shutdown WSGI & anything else we startup
+        # bug731668
         # WSGI shutdown broken :-(
         # self.wsgi_server.terminate()
         # self.wsgi_server = None
@@ -124,6 +126,7 @@ class IntegratedUnitTestContext(object):
         auth_key = generate_random_alphanumeric(16)
 
         # Right now there's a bug where auth_name and auth_key are reversed
+        # bug732907
         auth_key = auth_name
 
         self.auth_manager.create_user(auth_name, auth_name, auth_key, False)
@@ -156,6 +159,7 @@ class IntegratedUnitTestContext(object):
         return api_service
 
     # WSGI shutdown broken :-(
+    # bug731668
     #@staticmethod
     #def get():
     #    if not IntegratedUnitTestContext.__INSTANCE:
@@ -166,6 +170,7 @@ class IntegratedUnitTestContext(object):
     @staticmethod
     def startup():
         # Because WSGI shutdown is broken at the moment, we have to recycle
+        # bug731668
         if IntegratedUnitTestContext.__INSTANCE:
             #raise Error("Multiple calls to IntegratedUnitTestContext.startup")
             IntegratedUnitTestContext.__INSTANCE.setup()
@@ -179,4 +184,5 @@ class IntegratedUnitTestContext(object):
             raise Error("Must call IntegratedUnitTestContext::startup")
         IntegratedUnitTestContext.__INSTANCE.cleanup()
         # WSGI shutdown broken :-(
+        # bug731668
         #IntegratedUnitTestContext.__INSTANCE = None
-- 
cgit 


From 7e95a65ccec2336176f389d614a85c9e70da374d Mon Sep 17 00:00:00 2001
From: Monsyne Dragon <mdragon@rackspace.com>
Date: Thu, 10 Mar 2011 22:33:45 +0000
Subject: re-added a test change I removed thinking it was related to removed
 code. It wasn't :>

---
 nova/tests/api/openstack/test_auth.py | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/test_auth.py b/nova/tests/api/openstack/test_auth.py
index ff8d42a14..aaaa4e415 100644
--- a/nova/tests/api/openstack/test_auth.py
+++ b/nova/tests/api/openstack/test_auth.py
@@ -65,7 +65,9 @@ class Test(test.TestCase):
 
     def test_authorize_token(self):
         f = fakes.FakeAuthManager()
-        f.add_user('derp', nova.auth.manager.User(1, 'herp', None, None, None))
+        u = nova.auth.manager.User(1, 'herp', None, None, None)
+        f.add_user('derp', u)
+        f.create_project('test', u)
 
         req = webob.Request.blank('/v1.0/', {'HTTP_HOST': 'foo'})
         req.headers['X-Auth-User'] = 'herp'
@@ -176,7 +178,9 @@ class TestLimiter(test.TestCase):
 
     def test_authorize_token(self):
         f = fakes.FakeAuthManager()
-        f.add_user('derp', nova.auth.manager.User(1, 'herp', None, None, None))
+        u = nova.auth.manager.User(1, 'herp', None, None, None)
+        f.add_user('derp', u)
+        f.create_project('test', u)
 
         req = webob.Request.blank('/v1.0/')
         req.headers['X-Auth-User'] = 'herp'
-- 
cgit 


From c967679fa8144af57d79d89666ee29a0241d38a9 Mon Sep 17 00:00:00 2001
From: Mark Washenberger <mark.washenberger@rackspace.com>
Date: Thu, 10 Mar 2011 17:36:41 -0500
Subject: switch to a more consistent usage of onset_files variable names

---
 nova/api/openstack/servers.py            | 59 ++++++++++++++++++++-----------
 nova/compute/api.py                      | 38 ++++++++------------
 nova/compute/manager.py                  |  2 +-
 nova/quota.py                            | 30 ++++++++--------
 nova/tests/api/openstack/test_servers.py | 48 ++++++++++++-------------
 nova/tests/test_quota.py                 | 60 ++++++++++++++++----------------
 6 files changed, 124 insertions(+), 113 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 7bef8eb32..adb5c5f99 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -169,20 +169,23 @@ class Controller(wsgi.Controller):
                 metadata.append({'key': k, 'value': v})
 
         personality = env['server'].get('personality', [])
-        personality_files = self._get_personality_files(personality)
-
-        instances = self.compute_api.create(
-            context,
-            instance_types.get_by_flavor_id(env['server']['flavorId']),
-            image_id,
-            kernel_id=kernel_id,
-            ramdisk_id=ramdisk_id,
-            display_name=env['server']['name'],
-            display_description=env['server']['name'],
-            key_name=key_pair['name'],
-            key_data=key_pair['public_key'],
-            metadata=metadata,
-            personality_files=personality_files)
+        onset_files = self._get_onset_files(personality)
+
+        try:
+            instances = self.compute_api.create(
+                context,
+                instance_types.get_by_flavor_id(env['server']['flavorId']),
+                image_id,
+                kernel_id=kernel_id,
+                ramdisk_id=ramdisk_id,
+                display_name=env['server']['name'],
+                display_description=env['server']['name'],
+                key_name=key_pair['name'],
+                key_data=key_pair['public_key'],
+                metadata=metadata,
+                onset_files=onset_files)
+        except QuotaError as error:
+            self._handle_quota_error(error)
 
         server = _translate_keys(instances[0])
         password = "%s%s" % (server['server']['name'][:4],
@@ -204,15 +207,15 @@ class Controller(wsgi.Controller):
         else:
             return self._deserialize(request.body, request.get_content_type())
 
-    def _get_personality_files(self, personality):
+    def _get_onset_files(self, personality):
         """
-        Create a list of personality files from the personality attribute
+        Create a list of onset files from the personality attribute
 
-        At this time, personality_files must be formatted as a list of
+        At this time, onset_files must be formatted as a list of
         (file_path, file_content) pairs for compatibility with the
         underlying compute service.
         """
-        personality_files = []
+        onset_files = []
         for item in personality:
             try:
                 path = item['path']
@@ -227,8 +230,24 @@ class Controller(wsgi.Controller):
             except TypeError:
                 msg = 'Personality content for %s cannot be decoded' % path
                 raise exc.HTTPBadRequest(explanation=msg)
-            personality_files.append((path, contents))
-        return personality_files
+            onset_files.append((path, contents))
+        return onset_files
+
+    def _handle_quota_errors(self, error):
+        """
+        Reraise quota errors as api-specific http exceptions
+        """
+        if error.code == "OnsetFileLimitExceeded":
+            expl = "Personality file limit exceeded"
+            raise exc.HTTPBadRequest(explanation=expl)
+        if error.code == "OnsetFilePathLimitExceeded":
+            expl = "Personality file path too long"
+            raise exc.HTTPBadRequest(explanation=expl)
+        if error.code == "OnsetFileContentLimitExceeded":
+            expl = "Personality file content too long"
+            raise exc.HTTPBadRequest(explanation=expl)
+        # if the original error is okay, just reraise it
+        raise error
 
     def update(self, req, id):
         """ Updates the server name or password """
diff --git a/nova/compute/api.py b/nova/compute/api.py
index b97cadf61..140bbb3aa 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -80,30 +80,23 @@ class API(base.Base):
                         topic,
                         {"method": "get_network_topic", "args": {'fake': 1}})
 
-    def _check_personality_file_quota(self, context, personality_files):
+    def _check_onset_file_quota(self, context, onset_files):
         """
-        Enforce quota limits on personality files
+        Enforce quota limits on onset files
 
         Raises a QuotaError if any limit is exceeded
         """
-        limit = quota.allowed_personality_files(context)
-        if len(personality_files) > limit:
-            raise quota.QuotaError(_("Personality limit exceeded. You can "
-                                     "only have %d personalities when "
-                                     "creating an instance.") % limit,
-                                   "PersonalityLimitExceeded")
-        path_limit = quota.allowed_personality_path_bytes(context)
-        content_limit = quota.allowed_personality_content_bytes(context)
-        for path, content in personality_files:
+        limit = quota.allowed_onset_files(context)
+        if len(onset_files) > limit:
+            raise quota.QuotaError(code="OnsetFileLimitExceeded")
+        path_limit = quota.allowed_onset_file_path_bytes(context)
+        content_limit = quota.allowed_onset_file_content_bytes(context)
+        for path, content in onset_files:
             if len(path) > path_limit:
-                raise quota.QuotaError(
-                        _("Personality file path limit exceeded."),
-                        "PersonalityLimitExceeded")
+                raise quota.QuotaError(code="OnsetFilePathLimitExceeded")
             if len(content) > content_limit:
-                raise quota.QuotaError(
-                        _("Personality file content limit exceeded."),
-                        "PersonalityLimitExceeded")
-        return personality_files
+                raise quota.QuotaError(code="OnsetFileContentLimitExceeded")
+        return onset_files
 
     def create(self, context, instance_type,
                image_id, kernel_id=None, ramdisk_id=None,
@@ -111,7 +104,7 @@ class API(base.Base):
                display_name='', display_description='',
                key_name=None, key_data=None, security_group='default',
                availability_zone=None, user_data=None, metadata=[],
-               personality_files=None):
+               onset_files=None):
         """Create the number of instances requested if quota and
         other arguments check out ok."""
 
@@ -149,9 +142,8 @@ class API(base.Base):
                 LOG.warn(msg)
                 raise quota.QuotaError(msg, "MetadataLimitExceeded")
 
-        if personality_files is not None:
-            personality_files = \
-                self._check_personality_file_quota(context, personality_files)
+        if onset_files is not None:
+            onset_files = self._check_onset_file_quota(context, onset_files)
 
         image = self.image_service.show(context, image_id)
         if kernel_id is None:
@@ -248,7 +240,7 @@ class API(base.Base):
                       "args": {"topic": FLAGS.compute_topic,
                                "instance_id": instance_id,
                                "availability_zone": availability_zone,
-                               "personality_files": personality_files}})
+                               "onset_files": onset_files}})
 
         for group_id in security_groups:
             self.trigger_security_group_members_refresh(elevated, group_id)
diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index d87290aae..601bb3084 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -173,7 +173,7 @@ class ComputeManager(manager.Manager):
         """Launch a new instance with specified options."""
         context = context.elevated()
         instance_ref = self.db.instance_get(context, instance_id)
-        instance_ref.onset_files = kwargs.get('personality_files', [])
+        instance_ref.onset_files = kwargs.get('onset_files', [])
         if instance_ref['name'] in self.driver.list_instances():
             raise exception.Error(_("Instance has already been created"))
         LOG.audit(_("instance %s: starting..."), instance_id,
diff --git a/nova/quota.py b/nova/quota.py
index fdef42bc5..e0fb97542 100644
--- a/nova/quota.py
+++ b/nova/quota.py
@@ -37,12 +37,12 @@ flags.DEFINE_integer('quota_floating_ips', 10,
                      'number of floating ips allowed per project')
 flags.DEFINE_integer('quota_metadata_items', 128,
                      'number of metadata items allowed per instance')
-flags.DEFINE_integer('quota_personality_max_files', 5,
-                     'number of personality files allowed')
-flags.DEFINE_integer('quota_personality_max_content_bytes', 10 * 1024,
-                     'number of bytes allowed per personality file')
-flags.DEFINE_integer('quota_personality_max_path_bytes', 255,
-                     'number of bytes allowed per personality file path')
+flags.DEFINE_integer('quota_max_onset_files', 5,
+                     'number of onset files allowed')
+flags.DEFINE_integer('quota_max_onset_file_content_bytes', 10 * 1024,
+                     'number of bytes allowed per onset file')
+flags.DEFINE_integer('quota_max_onset_file_path_bytes', 255,
+                     'number of bytes allowed per onset file path')
 
 
 def get_quota(context, project_id):
@@ -113,19 +113,19 @@ def allowed_metadata_items(context, num_metadata_items):
     return min(num_metadata_items, num_allowed_metadata_items)
 
 
-def allowed_personality_files(context):
-    """Return the number of personality files allowed"""
-    return int(FLAGS.quota_personality_max_files)
+def allowed_onset_files(context):
+    """Return the number of onset files allowed"""
+    return int(FLAGS.quota_max_onset_files)
 
 
-def allowed_personality_content_bytes(context):
-    """Return the number of bytes allowed per personality content"""
-    return int(FLAGS.quota_personality_max_content_bytes)
+def allowed_onset_file_content_bytes(context):
+    """Return the number of bytes allowed per onset file content"""
+    return int(FLAGS.quota_max_onset_file_content_bytes)
 
 
-def allowed_personality_path_bytes(context):
-    """Return the number of bytes allowed in a personality file path"""
-    return int(FLAGS.quota_personality_max_path_bytes)
+def allowed_onset_file_path_bytes(context):
+    """Return the number of bytes allowed in an onset file path"""
+    return int(FLAGS.quota_max_onset_file_path_bytes)
 
 
 class QuotaError(exception.ApiError):
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 0561ad499..b6d88d833 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -833,13 +833,13 @@ class TestServerInstanceCreation(test.TestCase):
         class MockComputeAPI(object):
 
             def __init__(self):
-                self.personality_files = None
+                self.onset_files = None
 
             def create(self, *args, **kwargs):
-                if 'personality_files' in kwargs:
-                    self.personality_files = kwargs['personality_files']
+                if 'onset_files' in kwargs:
+                    self.onset_files = kwargs['onset_files']
                 else:
-                    self.personality_files = None
+                    self.onset_files = None
                 return [{'id': '1234', 'display_name': 'fakeinstance'}]
 
             def set_admin_password(self, *args, **kwargs):
@@ -919,46 +919,46 @@ class TestServerInstanceCreation(test.TestCase):
         request = self._get_create_request_json(body_dict)
         compute_api, response = \
             self._run_create_instance_with_mock_compute_api(request)
-        return request, response, compute_api.personality_files
+        return request, response, compute_api.onset_files
 
     def _create_instance_with_personality_xml(self, personality):
         body_dict = self._create_personality_request_dict(personality)
         request = self._get_create_request_xml(body_dict)
         compute_api, response = \
             self._run_create_instance_with_mock_compute_api(request)
-        return request, response, compute_api.personality_files
+        return request, response, compute_api.onset_files
 
     def test_create_instance_with_no_personality(self):
-        request, response, personality_files = \
+        request, response, onset_files = \
                 self._create_instance_with_personality_json(personality=None)
         self.assertEquals(response.status_int, 200)
-        self.assertEquals(personality_files, [])
+        self.assertEquals(onset_files, [])
 
     def test_create_instance_with_no_personality_xml(self):
-        request, response, personality_files = \
+        request, response, onset_files = \
                 self._create_instance_with_personality_xml(personality=None)
         self.assertEquals(response.status_int, 200)
-        self.assertEquals(personality_files, [])
+        self.assertEquals(onset_files, [])
 
     def test_create_instance_with_personality(self):
         path = '/my/file/path'
         contents = '#!/bin/bash\necho "Hello, World!"\n'
         b64contents = base64.b64encode(contents)
         personality = [(path, b64contents)]
-        request, response, personality_files = \
+        request, response, onset_files = \
             self._create_instance_with_personality_json(personality)
         self.assertEquals(response.status_int, 200)
-        self.assertEquals(personality_files, [(path, contents)])
+        self.assertEquals(onset_files, [(path, contents)])
 
     def test_create_instance_with_personality_xml(self):
         path = '/my/file/path'
         contents = '#!/bin/bash\necho "Hello, World!"\n'
         b64contents = base64.b64encode(contents)
         personality = [(path, b64contents)]
-        request, response, personality_files = \
+        request, response, onset_files = \
             self._create_instance_with_personality_xml(personality)
         self.assertEquals(response.status_int, 200)
-        self.assertEquals(personality_files, [(path, contents)])
+        self.assertEquals(onset_files, [(path, contents)])
 
     def test_create_instance_with_personality_no_path(self):
         personality = [('/remove/this/path',
@@ -969,7 +969,7 @@ class TestServerInstanceCreation(test.TestCase):
         compute_api, response = \
             self._run_create_instance_with_mock_compute_api(request)
         self.assertEquals(response.status_int, 400)
-        self.assertEquals(compute_api.personality_files, None)
+        self.assertEquals(compute_api.onset_files, None)
 
     def _test_create_instance_with_personality_no_path_xml(self):
         personality = [('/remove/this/path',
@@ -980,7 +980,7 @@ class TestServerInstanceCreation(test.TestCase):
         compute_api, response = \
             self._run_create_instance_with_mock_compute_api(request)
         self.assertEquals(response.status_int, 400)
-        self.assertEquals(compute_api.personality_files, None)
+        self.assertEquals(compute_api.onset_files, None)
 
     def test_create_instance_with_personality_no_contents(self):
         personality = [('/test/path',
@@ -991,7 +991,7 @@ class TestServerInstanceCreation(test.TestCase):
         compute_api, response = \
             self._run_create_instance_with_mock_compute_api(request)
         self.assertEquals(response.status_int, 400)
-        self.assertEquals(compute_api.personality_files, None)
+        self.assertEquals(compute_api.onset_files, None)
 
     def test_create_instance_with_personality_not_a_list(self):
         personality = [('/test/path', base64.b64encode('test\ncontents\n'))]
@@ -1002,16 +1002,16 @@ class TestServerInstanceCreation(test.TestCase):
         compute_api, response = \
             self._run_create_instance_with_mock_compute_api(request)
         self.assertEquals(response.status_int, 400)
-        self.assertEquals(compute_api.personality_files, None)
+        self.assertEquals(compute_api.onset_files, None)
 
     def test_create_instance_with_personality_with_non_b64_content(self):
         path = '/my/file/path'
         contents = '#!/bin/bash\necho "Oh no!"\n'
         personality = [(path, contents)]
-        request, response, personality_files = \
+        request, response, onset_files = \
             self._create_instance_with_personality_json(personality)
         self.assertEquals(response.status_int, 400)
-        self.assertEquals(personality_files, None)
+        self.assertEquals(onset_files, None)
 
     def test_create_instance_with_three_personalities(self):
         files = [
@@ -1022,19 +1022,19 @@ class TestServerInstanceCreation(test.TestCase):
         personality = []
         for path, content in files:
             personality.append((path, base64.b64encode(content)))
-        request, response, personality_files = \
+        request, response, onset_files = \
             self._create_instance_with_personality_json(personality)
         self.assertEquals(response.status_int, 200)
-        self.assertEquals(personality_files, files)
+        self.assertEquals(onset_files, files)
 
     def test_create_instance_personality_empty_content(self):
         path = '/my/file/path'
         contents = ''
         personality = [(path, contents)]
-        request, response, personality_files = \
+        request, response, onset_files = \
             self._create_instance_with_personality_json(personality)
         self.assertEquals(response.status_int, 200)
-        self.assertEquals(personality_files, [(path, contents)])
+        self.assertEquals(onset_files, [(path, contents)])
 
     def test_create_instance_admin_pass_json(self):
         request, response, dummy = \
diff --git a/nova/tests/test_quota.py b/nova/tests/test_quota.py
index 86b1d40fb..d94381aa2 100644
--- a/nova/tests/test_quota.py
+++ b/nova/tests/test_quota.py
@@ -200,66 +200,66 @@ class QuotaTestCase(test.TestCase):
                                             image_id='fake',
                                             metadata=metadata)
 
-    def test_allowed_personality_files(self):
+    def test_allowed_onset_files(self):
         self.assertEqual(
-                quota.allowed_personality_files(self.context),
-                FLAGS.quota_personality_max_files)
+                quota.allowed_onset_files(self.context),
+                FLAGS.quota_max_onset_files)
 
-    def _create_with_personality(self, files):
+    def _create_with_onset_files(self, files):
         api = compute.API(image_service=self.StubImageService())
         api.create(self.context, min_count=1, max_count=1,
                 instance_type='m1.small', image_id='fake',
-                personality_files=files)
+                onset_files=files)
 
-    def test_no_personality_files(self):
+    def test_no_onset_files(self):
         api = compute.API(image_service=self.StubImageService())
         api.create(self.context, instance_type='m1.small', image_id='fake')
 
-    def test_max_personality_files(self):
+    def test_max_onset_files(self):
         files = []
-        for i in xrange(FLAGS.quota_personality_max_files):
+        for i in xrange(FLAGS.quota_max_onset_files):
             files.append(('/my/path%d' % i, 'config = test\n'))
-        self._create_with_personality(files)  # no QuotaError
+        self._create_with_onset_files(files)  # no QuotaError
 
-    def test_too_many_personality_files(self):
+    def test_too_many_onset_files(self):
         files = []
-        for i in xrange(FLAGS.quota_personality_max_files + 1):
+        for i in xrange(FLAGS.quota_max_onset_files + 1):
             files.append(('/my/path%d' % i, 'my\ncontent%d\n' % i))
         self.assertRaises(quota.QuotaError,
-                          self._create_with_personality, files)
+                          self._create_with_onset_files, files)
 
-    def test_allowed_personality_content_bytes(self):
+    def test_allowed_onset_file_content_bytes(self):
         self.assertEqual(
-                quota.allowed_personality_content_bytes(self.context),
-                FLAGS.quota_personality_max_content_bytes)
+                quota.allowed_onset_file_content_bytes(self.context),
+                FLAGS.quota_max_onset_file_content_bytes)
 
-    def test_max_personality_content_bytes(self):
-        max = FLAGS.quota_personality_max_content_bytes
+    def test_max_onset_file_content_bytes(self):
+        max = FLAGS.quota_max_onset_file_content_bytes
         content = ''.join(['a' for i in xrange(max)])
         files = [('/test/path', content)]
-        self._create_with_personality(files)  # no QuotaError
+        self._create_with_onset_files(files)  # no QuotaError
 
-    def test_too_many_personality_content_bytes(self):
-        max = FLAGS.quota_personality_max_content_bytes
+    def test_too_many_onset_file_content_bytes(self):
+        max = FLAGS.quota_max_onset_file_content_bytes
         content = ''.join(['a' for i in xrange(max + 1)])
         files = [('/test/path', content)]
         self.assertRaises(quota.QuotaError,
-                          self._create_with_personality, files)
+                          self._create_with_onset_files, files)
 
-    def test_allowed_personality_path_bytes(self):
+    def test_allowed_onset_file_path_bytes(self):
         self.assertEqual(
-                quota.allowed_personality_path_bytes(self.context),
-                FLAGS.quota_personality_max_path_bytes)
+                quota.allowed_onset_file_path_bytes(self.context),
+                FLAGS.quota_max_onset_file_path_bytes)
 
-    def test_max_personality_path_bytes(self):
-        max = FLAGS.quota_personality_max_path_bytes
+    def test_max_onset_file_path_bytes(self):
+        max = FLAGS.quota_max_onset_file_path_bytes
         path = ''.join(['a' for i in xrange(max)])
         files = [(path, 'config = quotatest')]
-        self._create_with_personality(files)  # no QuotaError
+        self._create_with_onset_files(files)  # no QuotaError
 
-    def test_too_many_personality_path_bytes(self):
-        max = FLAGS.quota_personality_max_path_bytes
+    def test_too_many_onset_file_path_bytes(self):
+        max = FLAGS.quota_max_onset_file_path_bytes
         path = ''.join(['a' for i in xrange(max + 1)])
         files = [(path, 'config = quotatest')]
         self.assertRaises(quota.QuotaError,
-                          self._create_with_personality, files)
+                          self._create_with_onset_files, files)
-- 
cgit 


From c540d6d7fef1da68a42c16ac1f9a44337661bb0d Mon Sep 17 00:00:00 2001
From: Naveed Massjouni <naveedm9@gmail.com>
Date: Thu, 10 Mar 2011 20:12:58 -0500
Subject: Added version attribute to RequestContext class. Set the version in
 the nova.context object at the middleware level. Prototyped how we can
 serialize ip addresses based on the version.

---
 nova/api/openstack/auth.py    |  3 ++-
 nova/api/openstack/servers.py | 38 ++++++++++++++++++++++++++------------
 nova/context.py               |  7 +++++--
 3 files changed, 33 insertions(+), 15 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/auth.py b/nova/api/openstack/auth.py
index de8905f46..320443935 100644
--- a/nova/api/openstack/auth.py
+++ b/nova/api/openstack/auth.py
@@ -57,7 +57,8 @@ class AuthMiddleware(wsgi.Middleware):
             return faults.Fault(webob.exc.HTTPUnauthorized())
 
         project = self.auth.get_project(FLAGS.default_project)
-        req.environ['nova.context'] = context.RequestContext(user, project)
+        req.environ['nova.context'] = context.RequestContext(user, project,
+            version=req.script_name.replace('/v', ''))
         return self.application
 
     def has_authentication(self, req):
diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index dc28a0782..ec542bc92 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -39,7 +39,7 @@ LOG = logging.getLogger('server')
 FLAGS = flags.FLAGS
 
 
-def _translate_detail_keys(inst):
+def _translate_detail_keys(req, inst):
     """ Coerces into dictionary format, mapping everything to Rackspace-like
     attributes for return"""
     power_mapping = {
@@ -54,6 +54,7 @@ def _translate_detail_keys(inst):
         power_state.CRASHED: 'error',
         power_state.FAILED: 'error'}
     inst_dict = {}
+    version = req.environ['nova.context'].version
 
     mapped_keys = dict(status='state', imageId='image_id',
         flavorId='instance_type', name='display_name', id='id')
@@ -62,15 +63,7 @@ def _translate_detail_keys(inst):
         inst_dict[k] = inst[v]
 
     inst_dict['status'] = power_mapping[inst_dict['status']]
-    inst_dict['addresses'] = dict(public=[], private=[])
-
-    # grab single private fixed ip
-    private_ips = utils.get_from_path(inst, 'fixed_ip/address')
-    inst_dict['addresses']['private'] = private_ips
-
-    # grab all public floating ips
-    public_ips = utils.get_from_path(inst, 'fixed_ip/floating_ips/address')
-    inst_dict['addresses']['public'] = public_ips
+    inst_dict['addresses'] = _addresses_generator(version)(inst)
 
     # Return the metadata as a dictionary
     metadata = {}
@@ -91,6 +84,27 @@ def _translate_keys(inst):
     return dict(server=dict(id=inst['id'], name=inst['display_name']))
 
 
+def _addresses_generator(version):
+
+    def _gen_addresses_1_0(inst):
+        private_ips = utils.get_from_path(inst, 'fixed_ip/address')
+        public_ips = utils.get_from_path(inst, 'fixed_ip/floating_ips/address')
+        return dict(public=public_ips, private=private_ips)
+
+    def _gen_addresses_1_1(inst):
+        private_ips = utils.get_from_path(inst, 'fixed_ip/address')
+        private_ips = [dict(version=4, addr=a) for a in private_ips]
+        public_ips = utils.get_from_path(inst, 'fixed_ip/floating_ips/address')
+        public_ips = [dict(version=4, addr=a) for a in public_ips]
+        return dict(public=public_ips, private=private_ips)
+
+    dispatch_table = {
+        '1.0': _gen_addresses_1_0,
+        '1.1': _gen_addresses_1_1,
+    }
+
+    return dispatch_table[version]
+
 class Controller(wsgi.Controller):
     """ The Server API controller for the OpenStack API """
 
@@ -120,14 +134,14 @@ class Controller(wsgi.Controller):
         """
         instance_list = self.compute_api.get_all(req.environ['nova.context'])
         limited_list = common.limited(instance_list, req)
-        res = [entity_maker(inst)['server'] for inst in limited_list]
+        res = [entity_maker(req, inst)['server'] for inst in limited_list]
         return dict(servers=res)
 
     def show(self, req, id):
         """ Returns server details by server id """
         try:
             instance = self.compute_api.get(req.environ['nova.context'], id)
-            return _translate_detail_keys(instance)
+            return _translate_detail_keys(req, instance)
         except exception.NotFound:
             return faults.Fault(exc.HTTPNotFound())
 
diff --git a/nova/context.py b/nova/context.py
index 0256bf448..677bd2e7e 100644
--- a/nova/context.py
+++ b/nova/context.py
@@ -29,7 +29,8 @@ from nova import utils
 
 class RequestContext(object):
     def __init__(self, user, project, is_admin=None, read_deleted=False,
-                 remote_address=None, timestamp=None, request_id=None):
+                 remote_address=None, timestamp=None, request_id=None,
+                 version='1.1'):
         if hasattr(user, 'id'):
             self._user = user
             self.user_id = user.id
@@ -60,6 +61,7 @@ class RequestContext(object):
             chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890-'
             request_id = ''.join([random.choice(chars) for x in xrange(20)])
         self.request_id = request_id
+        self.version = version
 
     @property
     def user(self):
@@ -93,7 +95,8 @@ class RequestContext(object):
                 'read_deleted': self.read_deleted,
                 'remote_address': self.remote_address,
                 'timestamp': utils.isotime(self.timestamp),
-                'request_id': self.request_id}
+                'request_id': self.request_id,
+                'version': self.version}
 
     @classmethod
     def from_dict(cls, values):
-- 
cgit 


From 76b5871adbb1bfc2e3d2a1151a00fa654c45953d Mon Sep 17 00:00:00 2001
From: Naveed Massjouni <naveedm9@gmail.com>
Date: Thu, 10 Mar 2011 20:35:37 -0500
Subject: _translate_keys now needs one more argument, the request object.

---
 nova/api/openstack/servers.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index ec542bc92..bd317f995 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -78,7 +78,7 @@ def _translate_detail_keys(req, inst):
     return dict(server=inst_dict)
 
 
-def _translate_keys(inst):
+def _translate_keys(req, inst):
     """ Coerces into dictionary format, excluding all model attributes
     save for id and name """
     return dict(server=dict(id=inst['id'], name=inst['display_name']))
@@ -193,7 +193,7 @@ class Controller(wsgi.Controller):
             metadata=metadata,
             onset_files=env.get('onset_files', []))
 
-        server = _translate_keys(instances[0])
+        server = _translate_keys(req, instances[0])
         password = "%s%s" % (server['server']['name'][:4],
                              utils.generate_password(12))
         server['server']['adminPass'] = password
-- 
cgit 


From b9a479ffc8e9db0c1888047d7f3df99b3b57b2ec Mon Sep 17 00:00:00 2001
From: Dan Prince <dan.prince@rackspace.com>
Date: Thu, 10 Mar 2011 21:44:01 -0500
Subject: Make linux_net ensure_bridge commands that add and remove ip addr's
 from devices/bridges work with with the latest utils.execute method (execvp).

---
 nova/network/linux_net.py | 17 ++++++++++++-----
 1 file changed, 12 insertions(+), 5 deletions(-)

(limited to 'nova')

diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index 9f9d282b6..e69ed2f75 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -513,11 +513,9 @@ def ensure_bridge(bridge, interface, net_attrs=None):
         for line in out.split("\n"):
             fields = line.split()
             if fields and fields[0] == "inet":
-                params = ' '.join(fields[1:-1])
-                _execute('sudo', 'ip', 'addr',
-                         'del', params, 'dev', fields[-1])
-                _execute('sudo', 'ip', 'addr',
-                         'add', params, 'dev', bridge)
+                params = fields[1:-1]
+                _execute(*_ip_bridge_cmd('del', params, fields[-1]))
+                _execute(*_ip_bridge_cmd('add', params, bridge))
         if gateway:
             _execute('sudo', 'route', 'add', '0.0.0.0', 'gw', gateway)
         out, err = _execute('sudo', 'brctl', 'addif', bridge, interface,
@@ -739,3 +737,12 @@ def _ra_pid_for(bridge):
     if os.path.exists(pid_file):
         with open(pid_file, 'r') as f:
             return int(f.read())
+
+
+def _ip_bridge_cmd(action, params, device):
+    """Build commands to add/del ips to bridges/devices"""
+
+    cmd = ['sudo', 'ip', 'addr', action]
+    cmd.extend(params)
+    cmd.extend(['dev', device])
+    return cmd
-- 
cgit 


From 67a8d635af0a64ad220b163c00b96eadf7daf93f Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Fri, 11 Mar 2011 09:54:08 +0100
Subject: Make Authors check account for tests being run with different
 os.getcwd() depending on how they're run. Add missing people to Authors.

---
 nova/tests/test_misc.py | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/test_misc.py b/nova/tests/test_misc.py
index a658e4978..1fbaf304f 100644
--- a/nova/tests/test_misc.py
+++ b/nova/tests/test_misc.py
@@ -24,18 +24,19 @@ from nova.utils import parse_mailmap, str_dict_replace, synchronized
 
 class ProjectTestCase(test.TestCase):
     def test_authors_up_to_date(self):
-        if os.path.exists('.bzr'):
+        topdir = os.path.normpath(os.path.dirname(__file__) + '/../../')
+        if os.path.exists(os.path.join(topdir, '.bzr')):
             contributors = set()
 
-            mailmap = parse_mailmap('.mailmap')
+            mailmap = parse_mailmap(os.path.join(topdir, '.mailmap'))
 
             import bzrlib.workingtree
-            tree = bzrlib.workingtree.WorkingTree.open('.')
+            tree = bzrlib.workingtree.WorkingTree.open(topdir)
             tree.lock_read()
             try:
                 parents = tree.get_parent_ids()
                 g = tree.branch.repository.get_graph()
-                for p in parents[1:]:
+                for p in parents:
                     rev_ids = [r for r, _ in g.iter_ancestry(parents)
                                if r != "null:"]
                     revs = tree.branch.repository.get_revisions(rev_ids)
@@ -44,7 +45,8 @@ class ProjectTestCase(test.TestCase):
                             email = author.split(' ')[-1]
                             contributors.add(str_dict_replace(email, mailmap))
 
-                authors_file = open('Authors', 'r').read()
+                authors_file = open(os.path.join(topdir, 'Authors'),
+                                    'r').read()
 
                 missing = set()
                 for contributor in contributors:
-- 
cgit 


From 46d1f6a8c888c1f6fdf12cf26df67eada1e8505b Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
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')

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 7f28cb611c6bc802ad78242275b18bb0278e43bd Mon Sep 17 00:00:00 2001
From: sateesh <sateesh.chodapuneedi@citrix.com>
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/console/vmrc.py                 | 50 +++++++++++++++++++++++-------------
 nova/network/vmwareapi_net.py        | 20 +++++++--------
 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 ++-
 8 files changed, 104 insertions(+), 69 deletions(-)

(limited to 'nova')

diff --git a/nova/console/vmrc.py b/nova/console/vmrc.py
index 9c5e3b444..f448d094b 100644
--- a/nova/console/vmrc.py
+++ b/nova/console/vmrc.py
@@ -19,10 +19,13 @@
 VMRC console drivers.
 """
 
+import base64
+import json
+
+from nova import exception
 from nova import flags
 from nova import log as logging
 from nova.virt.vmwareapi import vim_util
-from nova.virt.vmwareapi_conn import VMWareAPISession
 
 flags.DEFINE_integer('console_vmrc_port',
                      443,
@@ -65,23 +68,34 @@ class VMRCConsole(object):
         #TODO:Encrypt pool password
         return password
 
-    def generate_password(self, address, username, password, instance_name):
+    def generate_password(self, vim_session, pool, instance_name):
         """Returns a VMRC Connection credentials
-        Return string is of the form '<VM MOID>:<ESX Username>@<ESX Password>'.
+        Return string is of the form '<VM PATH>:<ESX Username>@<ESX Password>'.
         """
-        vim_session = VMWareAPISession(address,
-                                       username,
-                                       password,
-                                       FLAGS.console_vmrc_error_retries)
+        username, password = pool['username'], pool['password']
         vms = vim_session._call_method(vim_util, "get_objects",
-                    "VirtualMachine", ["name"])
+                    "VirtualMachine", ["name", "config.files.vmPathName"])
+        vm_ds_path_name = None
         vm_ref = None
         for vm in vms:
-            if vm.propSet[0].val == instance_name:
+            vm_name = None
+            ds_path_name = None
+            for prop in vm.propSet:
+                if prop.name == "name":
+                    vm_name = prop.val
+                elif prop.name == "config.files.vmPathName":
+                    ds_path_name = prop.val
+            if vm_name == instance_name:
                 vm_ref = vm.obj
+                vm_ds_path_name = ds_path_name
+                break
         if vm_ref is None:
-            raise Exception(_("instance - %s not present") % instance_name)
-        return str(vm_ref) + ":" + username + "@" + password
+            raise exception.NotFound(_("instance - %s not present") %
+                                     instance_name)
+        json_data = json.dumps({"vm_id": vm_ds_path_name,
+                    "username": username,
+                    "password": password})
+        return base64.b64encode(json_data)
 
     def is_otp(self):
         """Is one time password."""
@@ -98,14 +112,10 @@ class VMRCSessionConsole(VMRCConsole):
     def console_type(self):
         return 'vmrc+session'
 
-    def generate_password(self, address, username, password, instance_name):
+    def generate_password(self, vim_session, pool, instance_name):
         """Returns a VMRC Session
         Return string is of the form '<VM MOID>:<VMRC Ticket>'.
         """
-        vim_session = VMWareAPISession(address,
-                                       username,
-                                       password,
-                                       FLAGS.console_vmrc_error_retries)
         vms = vim_session._call_method(vim_util, "get_objects",
                     "VirtualMachine", ["name"])
         vm_ref = None
@@ -113,13 +123,17 @@ class VMRCSessionConsole(VMRCConsole):
             if vm.propSet[0].val == instance_name:
                 vm_ref = vm.obj
         if vm_ref is None:
-            raise Exception(_("instance - %s not present") % instance_name)
+            raise exception.NotFound(_("instance - %s not present") %
+                                     instance_name)
         virtual_machine_ticket = \
                         vim_session._call_method(
             vim_session._get_vim(),
             "AcquireCloneTicket",
             vim_session._get_vim().get_service_content().sessionManager)
-        return str(vm_ref.value) + ":" + virtual_machine_ticket
+        json_data = json.dumps({"vm_id": str(vm_ref.value),
+                     "username": virtual_machine_ticket,
+                     "password": virtual_machine_ticket})
+        return base64.b64encode(json_data)
 
     def is_otp(self):
         """Is one time password."""
diff --git a/nova/network/vmwareapi_net.py b/nova/network/vmwareapi_net.py
index 1bda1702a..13b619df5 100644
--- a/nova/network/vmwareapi_net.py
+++ b/nova/network/vmwareapi_net.py
@@ -52,19 +52,19 @@ def ensure_vlan_bridge(vlan_num, bridge, net_attrs=None):
     #Check if the vlan_interface physical network adapter exists on the host
     if not NetworkHelper.check_if_vlan_interface_exists(session,
                                                         vlan_interface):
-        raise Exception(_("There is no physical network adapter with the name"
-                          " %s on the ESX host") % vlan_interface)
-    #check whether bridge already exists and retrieve the the ref of the
-    #network whose name_label is "bridge"
-    network_ref = NetworkHelper.get_network_with_the_name(session, bridge)
+        raise exception.NotFound(_("There is no physical network adapter with "
+                          "the name %s on the ESX host") % vlan_interface)
 
     #Get the vSwitch associated with the Physical Adapter
     vswitch_associated = NetworkHelper.get_vswitch_for_vlan_interface(
                                         session, vlan_interface)
     if vswitch_associated is None:
-        raise Exception(_("There is no virtual switch associated with "
-            "the physical network adapter with name %s") %
+        raise exception.NotFound(_("There is no virtual switch associated "
+            "with the physical network adapter with name %s") %
             vlan_interface)
+    #check whether bridge already exists and retrieve the the ref of the
+    #network whose name_label is "bridge"
+    network_ref = NetworkHelper.get_network_with_the_name(session, bridge)
     if network_ref == None:
         #Create a port group on the vSwitch associated with the vlan_interface
         #corresponding physical network adapter on the ESX host
@@ -77,7 +77,7 @@ def ensure_vlan_bridge(vlan_num, bridge, net_attrs=None):
 
         #Check if the vsiwtch associated is proper
         if pg_vswitch != vswitch_associated:
-            raise Exception(_("vSwitch which contains the port group "
+            raise exception.Invalid(_("vSwitch which contains the port group "
                             "%(bridge)s is not associated with the desired "
                             "physical adapter. Expected vSwitch is "
                             "%(vswitch_associated)s, but the one associated"
@@ -88,8 +88,8 @@ def ensure_vlan_bridge(vlan_num, bridge, net_attrs=None):
 
         #Check if the vlan id is proper for the port group
         if pg_vlanid != vlan_num:
-            raise Exception(_("VLAN tag is not appropriate for the port "
-                            "group %(bridge)s. Expected VLAN tag is "
+            raise exception.Invalid(_("VLAN tag is not appropriate for the "
+                            "port group %(bridge)s. Expected VLAN tag is "
                             "%(vlan_num)s, but the one associated with the "
                             "port group is %(pg_vlanid)s") %\
                             {"bridge": bridge,
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 d250d522b5d6c164435fc254223ff9a0f055cf05 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Fri, 11 Mar 2011 17:55:28 +0100
Subject: Remove broken test. At least this way, it'll actually fix the problem
 and be mergable.

---
 nova/tests/test_cloud.py | 12 ------------
 1 file changed, 12 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/test_cloud.py b/nova/tests/test_cloud.py
index db7c15aeb..cf8ee7eff 100644
--- a/nova/tests/test_cloud.py
+++ b/nova/tests/test_cloud.py
@@ -353,18 +353,6 @@ class CloudTestCase(test.TestCase):
         self.assertEqual('', img.metadata['description'])
         shutil.rmtree(pathdir)
 
-    def test_metadata_works_without_kernel_and_ramdisk(self):
-        inst = db.instance_create(self.context, {'host': self.compute.host,
-                                                 'vcpus': 2,
-                                                 'image_id': '123456',
-                                                 'user_data': '' })
-        fixed = self.network.allocate_fixed_ip(self.context, inst['id'])
-        try:
-            self.cloud.get_metadata(fixed)
-        finally:
-            self.network.deallocate_fixed_ip(self.context, fixed)
-            db.instance_destroy(self.context, inst['id'])
-
     def test_update_of_instance_display_fields(self):
         inst = db.instance_create(self.context, {})
         ec2_id = ec2utils.id_to_ec2_id(inst['id'])
-- 
cgit 


From 36b5f7d9cf377ce2a4dcdad07e7e14062cd3ec4d Mon Sep 17 00:00:00 2001
From: Josh Kearney <josh@jk0.org>
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')

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 cfc7d21b959bc929295868aeb3e84ea56afbfd9c Mon Sep 17 00:00:00 2001
From: "Kevin L. Mitchell" <kevin.mitchell@rackspace.com>
Date: Fri, 11 Mar 2011 17:41:22 +0000
Subject: Discovered literal_column(), which does exactly what I need

---
 nova/db/sqlalchemy/api.py | 49 +++++++++++++++--------------------------------
 1 file changed, 15 insertions(+), 34 deletions(-)

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 88125aaf5..431cf6e8e 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -34,6 +34,7 @@ from sqlalchemy.orm import joinedload
 from sqlalchemy.orm import joinedload_all
 from sqlalchemy.sql import exists
 from sqlalchemy.sql import func
+from sqlalchemy.sql.expression import literal_column
 
 FLAGS = flags.FLAGS
 
@@ -702,28 +703,16 @@ def instance_data_get_for_project(context, project_id):
 def instance_destroy(context, instance_id):
     session = get_session()
     with session.begin():
-        session.execute('update instances set deleted=1,'
-                        'deleted_at=:at where id=:id',
-                        {'id': instance_id,
-                         'at': datetime.datetime.utcnow()})
-        # NOTE(klmitch): for some reason, using the SQLAlchemy code
-        # here instead of the direct SQL update above causes the
-        # test_run_terminate_timestamps test (and only that one) to
-        # fail with an obscure TypeError exception from deep within
-        # SQLAlchemy; the nearest nova function in the traceback is
-        # instance_get()
-        # session.query(models.Instance).\
-        #              filter_by(id=instance_id).\
-        #              update({'deleted': 1,
-        #                      'deleted_at': datetime.datetime.utcnow(),
-        #                      'updated_at': models.Instance.updated_at + 0})
+        session.query(models.Instance).\
+                     filter_by(id=instance_id).\
+                     update({'deleted': 1,
+                             'deleted_at': datetime.datetime.utcnow(),
+                             'updated_at': literal_column('updated_at')})
         session.query(models.SecurityGroupInstanceAssociation).\
                      filter_by(instance_id=instance_id).\
                      update({'deleted': 1,
                              'deleted_at': datetime.datetime.utcnow(),
-                             'updated_at':
-                                 (models.SecurityGroupInstanceAssociation.
-                                  updated_at + 0)})
+                             'updated_at': literal_column('updated_at')})
 
 
 @require_context
@@ -969,7 +958,7 @@ def key_pair_destroy_all_by_user(context, user_id):
                      filter_by(user_id=user_id).\
                      update({'deleted': 1,
                              'deleted_at': datetime.datetime.utcnow(),
-                             'updated_at': models.KeyPair.updated_at + 0})
+                             'updated_at': literal_column('updated_at')})
 
 
 @require_context
@@ -1082,7 +1071,7 @@ def network_disassociate_all(context):
     session = get_session()
     session.query(models.Network).\
                  update({'project_id': None,
-                         'updated_at': models.Network.updated_at + 0})
+                         'updated_at': literal_column('updated_at')})
 
 
 @require_context
@@ -1456,7 +1445,7 @@ def volume_destroy(context, volume_id):
                      filter_by(id=volume_id).\
                      update({'deleted': 1,
                              'deleted_at': datetime.datetime.utcnow(),
-                             'updated_at': models.Volume.updated_at + 0})
+                             'updated_at': literal_column('updated_at')})
         session.query(models.ExportDevice).\
                      filter_by(volume_id=volume_id).\
                      update({'volume_id': None})
@@ -1686,22 +1675,17 @@ def security_group_destroy(context, security_group_id):
                      filter_by(id=security_group_id).\
                      update({'deleted': 1,
                              'deleted_at': datetime.datetime.utcnow(),
-                             'updated_at':
-                                 models.SecurityGroup.updated_at + 0})
+                             'updated_at': literal_column('updated_at')})
         session.query(models.SecurityGroupInstanceAssociation).\
                      filter_by(security_group_id=security_group_id).\
                      update({'deleted': 1,
                              'deleted_at': datetime.datetime.utcnow(),
-                             'updated_at':
-                                 (models.SecurityGroupInstanceAssociation.
-                                  updated_at + 0)})
+                             'updated_at': literal_column('updated_at')})
         session.query(models.SecurityGroupIngressRule).\
                      filter_by(group_id=security_group_id).\
                      update({'deleted': 1,
                              'deleted_at': datetime.datetime.utcnow(),
-                             'updated_at':
-                                 (models.SecurityGroupIngressRule.
-                                  updated_at + 0)})
+                             'updated_at': literal_column('updated_at')})
 
 
 @require_context
@@ -1712,14 +1696,11 @@ def security_group_destroy_all(context, session=None):
         session.query(models.SecurityGroup).\
                      update({'deleted': 1,
                              'deleted_at': datetime.datetime.utcnow(),
-                             'updated_at':
-                                 models.SecurityGroup.updated_at + 0})
+                             'updated_at': literal_column('updated_at')})
         session.query(models.SecurityGroupIngressRule).\
                      update({'deleted': 1,
                              'deleted_at': datetime.datetime.utcnow(),
-                             'updated_at':
-                                 (models.SecurityGroupIngressRule.
-                                  updated_at + 0)})
+                             'updated_at': literal_column('updated_at')})
 
 
 ###################
-- 
cgit 


From a5415e8fc40eaa82761532e5ba83c3800cf9ed78 Mon Sep 17 00:00:00 2001
From: Naveed Massjouni <naveedm9@gmail.com>
Date: Fri, 11 Mar 2011 12:45:53 -0500
Subject: Need to set version to '1.0' in the nova.context in test code for
 tests to be happy.

---
 nova/api/openstack/auth.py        | 3 ++-
 nova/tests/api/openstack/fakes.py | 2 +-
 2 files changed, 3 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/auth.py b/nova/api/openstack/auth.py
index 320443935..8461a8059 100644
--- a/nova/api/openstack/auth.py
+++ b/nova/api/openstack/auth.py
@@ -57,8 +57,9 @@ class AuthMiddleware(wsgi.Middleware):
             return faults.Fault(webob.exc.HTTPUnauthorized())
 
         project = self.auth.get_project(FLAGS.default_project)
+        version = req.path.split('/')[1].replace('v', '')
         req.environ['nova.context'] = context.RequestContext(user, project,
-            version=req.script_name.replace('/v', ''))
+            version=version)
         return self.application
 
     def has_authentication(self, req):
diff --git a/nova/tests/api/openstack/fakes.py b/nova/tests/api/openstack/fakes.py
index 2c4e57246..8ec1629f4 100644
--- a/nova/tests/api/openstack/fakes.py
+++ b/nova/tests/api/openstack/fakes.py
@@ -68,7 +68,7 @@ def fake_auth_init(self, application):
 
 @webob.dec.wsgify
 def fake_wsgi(self, req):
-    req.environ['nova.context'] = context.RequestContext(1, 1)
+    req.environ['nova.context'] = context.RequestContext(1, 1, version='1.0')
     if req.body:
         req.environ['inst_dict'] = json.loads(req.body)
     return self.application
-- 
cgit 


From e891e48b63065a7218627289a908aece0f6a3730 Mon Sep 17 00:00:00 2001
From: Tushar Patil <tushar.vitthal.patil@gmail.com>
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')

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 195926d0635c0217edccf1cd763425163d3e92e7 Mon Sep 17 00:00:00 2001
From: "Kevin L. Mitchell" <kevin.mitchell@rackspace.com>
Date: Fri, 11 Mar 2011 19:22:31 +0000
Subject: Minor stylistic updates affecting indentation

---
 nova/db/sqlalchemy/api.py | 132 +++++++++++++++++++++++-----------------------
 1 file changed, 66 insertions(+), 66 deletions(-)

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 89745aa95..08bc8fe2f 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -581,15 +581,15 @@ def fixed_ip_disassociate_all_by_timeout(_context, host, time):
     # NOTE(vish): The nested select is because sqlite doesn't support
     #             JOINs in UPDATEs.
     inner_q = session.query(models.Network.id).\
-                 filter_by(host=host).\
-                 subquery()
+                      filter_by(host=host).\
+                      subquery()
     result = session.query(models.FixedIp).\
-                 filter(models.FixedIp.network_id.in_(inner_q)).\
-                 filter(models.FixedIp.updated_at < time).\
-                 filter(models.FixedIp.instance_id != None).\
-                 filter_by(allocated=0).\
-                 update({'instance_id': None,
-                         'leased': 0})
+                     filter(models.FixedIp.network_id.in_(inner_q)).\
+                     filter(models.FixedIp.updated_at < time).\
+                     filter(models.FixedIp.instance_id != None).\
+                     filter_by(allocated=0).\
+                     update({'instance_id': None,
+                             'leased': 0})
     return result
 
 
@@ -704,15 +704,15 @@ def instance_destroy(context, instance_id):
     session = get_session()
     with session.begin():
         session.query(models.Instance).\
-                     filter_by(id=instance_id).\
-                     update({'deleted': 1,
-                             'deleted_at': datetime.datetime.utcnow(),
-                             'updated_at': literal_column('updated_at')})
+                filter_by(id=instance_id).\
+                update({'deleted': 1,
+                        'deleted_at': datetime.datetime.utcnow(),
+                        'updated_at': literal_column('updated_at')})
         session.query(models.SecurityGroupInstanceAssociation).\
-                     filter_by(instance_id=instance_id).\
-                     update({'deleted': 1,
-                             'deleted_at': datetime.datetime.utcnow(),
-                             'updated_at': literal_column('updated_at')})
+                filter_by(instance_id=instance_id).\
+                update({'deleted': 1,
+                        'deleted_at': datetime.datetime.utcnow(),
+                        'updated_at': literal_column('updated_at')})
 
 
 @require_context
@@ -955,10 +955,10 @@ def key_pair_destroy_all_by_user(context, user_id):
     session = get_session()
     with session.begin():
         session.query(models.KeyPair).\
-                     filter_by(user_id=user_id).\
-                     update({'deleted': 1,
-                             'deleted_at': datetime.datetime.utcnow(),
-                             'updated_at': literal_column('updated_at')})
+                filter_by(user_id=user_id).\
+                update({'deleted': 1,
+                        'deleted_at': datetime.datetime.utcnow(),
+                        'updated_at': literal_column('updated_at')})
 
 
 @require_context
@@ -1079,8 +1079,8 @@ def network_disassociate(context, network_id):
 def network_disassociate_all(context):
     session = get_session()
     session.query(models.Network).\
-                 update({'project_id': None,
-                         'updated_at': literal_column('updated_at')})
+            update({'project_id': None,
+                    'updated_at': literal_column('updated_at')})
 
 
 @require_context
@@ -1463,16 +1463,16 @@ def volume_destroy(context, volume_id):
     session = get_session()
     with session.begin():
         session.query(models.Volume).\
-                     filter_by(id=volume_id).\
-                     update({'deleted': 1,
-                             'deleted_at': datetime.datetime.utcnow(),
-                             'updated_at': literal_column('updated_at')})
+                filter_by(id=volume_id).\
+                update({'deleted': 1,
+                        'deleted_at': datetime.datetime.utcnow(),
+                        'updated_at': literal_column('updated_at')})
         session.query(models.ExportDevice).\
-                     filter_by(volume_id=volume_id).\
-                     update({'volume_id': None})
+                filter_by(volume_id=volume_id).\
+                update({'volume_id': None})
         session.query(models.IscsiTarget).\
-                     filter_by(volume_id=volume_id).\
-                     update({'volume_id': None})
+                filter_by(volume_id=volume_id).\
+                update({'volume_id': None})
 
 
 @require_admin_context
@@ -1693,20 +1693,20 @@ def security_group_destroy(context, security_group_id):
     session = get_session()
     with session.begin():
         session.query(models.SecurityGroup).\
-                     filter_by(id=security_group_id).\
-                     update({'deleted': 1,
-                             'deleted_at': datetime.datetime.utcnow(),
-                             'updated_at': literal_column('updated_at')})
+                filter_by(id=security_group_id).\
+                update({'deleted': 1,
+                        'deleted_at': datetime.datetime.utcnow(),
+                        'updated_at': literal_column('updated_at')})
         session.query(models.SecurityGroupInstanceAssociation).\
-                     filter_by(security_group_id=security_group_id).\
-                     update({'deleted': 1,
-                             'deleted_at': datetime.datetime.utcnow(),
-                             'updated_at': literal_column('updated_at')})
+                filter_by(security_group_id=security_group_id).\
+                update({'deleted': 1,
+                        'deleted_at': datetime.datetime.utcnow(),
+                        'updated_at': literal_column('updated_at')})
         session.query(models.SecurityGroupIngressRule).\
-                     filter_by(group_id=security_group_id).\
-                     update({'deleted': 1,
-                             'deleted_at': datetime.datetime.utcnow(),
-                             'updated_at': literal_column('updated_at')})
+                filter_by(group_id=security_group_id).\
+                update({'deleted': 1,
+                        'deleted_at': datetime.datetime.utcnow(),
+                        'updated_at': literal_column('updated_at')})
 
 
 @require_context
@@ -1715,13 +1715,13 @@ def security_group_destroy_all(context, session=None):
         session = get_session()
     with session.begin():
         session.query(models.SecurityGroup).\
-                     update({'deleted': 1,
-                             'deleted_at': datetime.datetime.utcnow(),
-                             'updated_at': literal_column('updated_at')})
+                update({'deleted': 1,
+                        'deleted_at': datetime.datetime.utcnow(),
+                        'updated_at': literal_column('updated_at')})
         session.query(models.SecurityGroupIngressRule).\
-                     update({'deleted': 1,
-                             'deleted_at': datetime.datetime.utcnow(),
-                             'updated_at': literal_column('updated_at')})
+                update({'deleted': 1,
+                        'deleted_at': datetime.datetime.utcnow(),
+                        'updated_at': literal_column('updated_at')})
 
 
 ###################
@@ -1851,14 +1851,14 @@ def user_delete(context, id):
     session = get_session()
     with session.begin():
         session.query(models.UserProjectAssociation).\
-                     filter_by(user_id=id).\
-                     delete()
+                filter_by(user_id=id).\
+                delete()
         session.query(models.UserRoleAssociation).\
-                     filter_by(user_id=id).\
-                     delete()
+                filter_by(user_id=id).\
+                delete()
         session.query(models.UserProjectRoleAssociation).\
-                     filter_by(user_id=id).\
-                     delete()
+                filter_by(user_id=id).\
+                delete()
         user_ref = user_get(context, id, session=session)
         session.delete(user_ref)
 
@@ -1950,11 +1950,11 @@ def project_delete(context, id):
     session = get_session()
     with session.begin():
         session.query(models.UserProjectAssociation).\
-                     filter_by(project_id=id).\
-                     delete()
+                filter_by(project_id=id).\
+                delete()
         session.query(models.UserProjectRoleAssociation).\
-                     filter_by(project_id=id).\
-                     delete()
+                filter_by(project_id=id).\
+                delete()
         project_ref = project_get(context, id, session=session)
         session.delete(project_ref)
 
@@ -1980,10 +1980,10 @@ def user_remove_project_role(context, user_id, project_id, role):
     session = get_session()
     with session.begin():
         session.query(models.UserProjectRoleAssociation).\
-                     filter_by(user_id=user_id).\
-                     filter_by(project_id=project_id).\
-                     filter_by(role=role).\
-                     delete()
+                filter_by(user_id=user_id).\
+                filter_by(project_id=project_id).\
+                filter_by(role=role).\
+                delete()
 
 
 def user_remove_role(context, user_id, role):
@@ -2135,8 +2135,8 @@ def console_delete(context, console_id):
     with session.begin():
         # consoles are meant to be transient. (mdragon)
         session.query(models.Console).\
-                     filter_by(id=console_id).\
-                     delete()
+                filter_by(id=console_id).\
+                delete()
 
 
 def console_get_by_pool_instance(context, pool_id, instance_id):
@@ -2293,8 +2293,8 @@ def zone_delete(context, zone_id):
     session = get_session()
     with session.begin():
         session.query(models.Zone).\
-                     filter_by(id=zone_id).\
-                     delete()
+                filter_by(id=zone_id).\
+                delete()
 
 
 @require_admin_context
-- 
cgit 


From 0a130010c26e4ef9ba5b9917ff47766de7805ab9 Mon Sep 17 00:00:00 2001
From: Eric Windisch <eric@cloudscaling.com>
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')

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 7d4eae131f2f844f368aa5ff79c68191756775b6 Mon Sep 17 00:00:00 2001
From: Dan Prince <dan.prince@rackspace.com>
Date: Fri, 11 Mar 2011 14:33:12 -0500
Subject: Add config for osapi_extensions_path. Update the ExtensionManager so
 that it loads extensions in the osapi_extensions_path.

---
 nova/api/openstack/__init__.py                 |  9 ++++----
 nova/api/openstack/extensions.py               | 32 +++++++++++++++++++++++++-
 nova/flags.py                                  |  2 ++
 nova/tests/api/openstack/extensions/widgets.py | 27 ++++++++++++++++++++++
 nova/tests/api/openstack/test_extensions.py    | 19 +++++++++++++++
 5 files changed, 84 insertions(+), 5 deletions(-)
 create mode 100644 nova/tests/api/openstack/extensions/widgets.py

(limited to 'nova')

diff --git a/nova/api/openstack/__init__.py b/nova/api/openstack/__init__.py
index 28e2a1691..8f6076511 100644
--- a/nova/api/openstack/__init__.py
+++ b/nova/api/openstack/__init__.py
@@ -69,7 +69,7 @@ class APIRouter(wsgi.Router):
         """Simple paste factory, :class:`nova.wsgi.Router` doesn't have one"""
         return cls()
 
-    def __init__(self, ext_manager=None):
+    def __init__(self, ext_mgr=None):
         mapper = routes.Mapper()
 
         server_members = {'action': 'POST'}
@@ -112,9 +112,10 @@ class APIRouter(wsgi.Router):
                         collection={'detail': 'GET'},
                         controller=shared_ip_groups.Controller())
 
-        if ext_manager is None:
-            ext_manager = extensions.ExtensionManager()
-        for resource in ext_manager.get_resources():
+        if ext_mgr is None:
+            ext_mgr = extensions.ExtensionManager(FLAGS.osapi_extensions_path)
+        for resource in ext_mgr.get_resources():
+            print resource
             resource.add_routes(mapper)
 
         super(APIRouter, self).__init__(mapper)
diff --git a/nova/api/openstack/extensions.py b/nova/api/openstack/extensions.py
index 1c539c500..24846d9cd 100644
--- a/nova/api/openstack/extensions.py
+++ b/nova/api/openstack/extensions.py
@@ -15,15 +15,45 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+import imp
+import os
+import sys
+
+
 class ExtensionManager(object):
 
+    def __init__(self, path):
+
+        self.path = path
+        self.extensions = []
+        self._load_extensions()
+
     def get_resources(self):
         """
         returns a list of ExtensionResource objects
         """
-        return []
+        resources = []
+        for ext in self.extensions:
+            resources.append(ext.get_resources())
+        return resources
+
+    def _load_extensions(self):
+        if not os.path.exists(self.path):
+            return
+
+        for f in os.listdir(self.path):
+            mod_name, file_ext = os.path.splitext(os.path.split(f)[-1])
+            ext_path = os.path.join(self.path, f)
+            if file_ext.lower() == '.py':
+                mod = imp.load_source(mod_name, ext_path)
+                self.extensions.append(getattr(mod, 'get_extension')())
+
 
 class ExtensionResource(object):
+    """
+    Example ExtensionResource object. All ExtensionResource objects should
+    adhere to this interface.
+    """
 
     def add_routes(self, mapper):
         pass
diff --git a/nova/flags.py b/nova/flags.py
index 9123e9ac7..63e4cb5b6 100644
--- a/nova/flags.py
+++ b/nova/flags.py
@@ -298,6 +298,8 @@ DEFINE_string('ec2_dmz_host', '$my_ip', 'internal ip of api server')
 DEFINE_integer('ec2_port', 8773, 'cloud controller port')
 DEFINE_string('ec2_scheme', 'http', 'prefix for ec2')
 DEFINE_string('ec2_path', '/services/Cloud', 'suffix for ec2')
+DEFINE_string('osapi_extensions_path', '/var/lib/nova/extensions',
+               'default directory for nova extensions')
 DEFINE_string('osapi_host', '$my_ip', 'ip of api server')
 DEFINE_string('osapi_scheme', 'http', 'prefix for openstack')
 DEFINE_integer('osapi_port', 8774, 'OpenStack API port')
diff --git a/nova/tests/api/openstack/extensions/widgets.py b/nova/tests/api/openstack/extensions/widgets.py
new file mode 100644
index 000000000..bc0947223
--- /dev/null
+++ b/nova/tests/api/openstack/extensions/widgets.py
@@ -0,0 +1,27 @@
+from nova import wsgi
+
+class WidgetController(wsgi.Controller):
+
+    def index(self, req):
+        return "Buy more widgets!"
+
+class WidgetExtensionResource(object):
+
+    def __init__(self):
+        pass
+
+    def add_routes(self, mapper):
+        mapper.resource('widget', 'widgets', controller=WidgetController())
+
+
+class WidgetExtension(object):
+
+    def __init__(self):
+        pass
+
+    def get_resources(self):
+        return WidgetExtensionResource()
+
+
+def get_extension():
+    return WidgetExtension()
diff --git a/nova/tests/api/openstack/test_extensions.py b/nova/tests/api/openstack/test_extensions.py
index f5332c84a..ff41d6d99 100644
--- a/nova/tests/api/openstack/test_extensions.py
+++ b/nova/tests/api/openstack/test_extensions.py
@@ -16,12 +16,16 @@
 #    under the License.
 
 import unittest
+import os.path
 
 import webob
 
+from nova import flags
 from nova.api import openstack
 import nova.wsgi
 
+FLAGS = flags.FLAGS
+
 class StubController(nova.wsgi.Controller):
 
     def __init__(self, body):
@@ -81,3 +85,18 @@ class ExtensionTest(unittest.TestCase):
         self.assertEqual(response_body, response.body)
 
 
+class ExtensionManagerTest(unittest.TestCase):
+
+    def setUp(self):
+        FLAGS.osapi_extensions_path = os.path.join(os.path.dirname(__file__),
+                                                    "extensions")
+
+    def test_get_resources(self):
+        router = openstack.APIRouter()
+        request = webob.Request.blank("/widgets")
+        response = request.get_response(router)
+        self.assertEqual(200, response.status_int)
+        self.assertEqual("Buy more widgets!", response.body)
+
+
+
-- 
cgit 


From d03b169e2343fc13f37324f0136835ae54f85569 Mon Sep 17 00:00:00 2001
From: Naveed Massjouni <naveedm9@gmail.com>
Date: Fri, 11 Mar 2011 16:04:54 -0500
Subject: Added support for ips resource: /servers/1/ips Refactored
 implmentation of how the servers response model is generated.

---
 nova/api/openstack/servers.py | 85 +++++++++++++++++++++++++------------------
 nova/context.py               |  2 +-
 2 files changed, 50 insertions(+), 37 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index bd317f995..b486dfebb 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -39,9 +39,41 @@ LOG = logging.getLogger('server')
 FLAGS = flags.FLAGS
 
 
-def _translate_detail_keys(req, inst):
+def _translate_keys(req, inst):
+    """ Coerces into dictionary format, excluding all model attributes
+    save for id and name """
+    return dict(server=dict(id=inst['id'], name=inst['display_name']))
+
+
+def _build_addresses_10(inst):
+    private_ips = utils.get_from_path(inst, 'fixed_ip/address')
+    public_ips = utils.get_from_path(inst, 'fixed_ip/floating_ips/address')
+    return dict(public=public_ips, private=private_ips)
+
+
+def _build_addresses_11(inst):
+    private_ips = utils.get_from_path(inst, 'fixed_ip/address')
+    private_ips = [dict(version=4, addr=a) for a in private_ips]
+    public_ips = utils.get_from_path(inst, 'fixed_ip/floating_ips/address')
+    public_ips = [dict(version=4, addr=a) for a in public_ips]
+    return dict(public=public_ips, private=private_ips)
+
+
+def addresses_builder(req):
+    version = req.environ['nova.context'].version
+    if version == '1.1':
+        return _build_addresses_11
+    else:
+        return _build_addresses_10
+
+
+def build_server(req, inst, is_detail):
     """ Coerces into dictionary format, mapping everything to Rackspace-like
     attributes for return"""
+
+    if not is_detail:
+        return dict(server=dict(id=inst['id'], name=inst['display_name']))
+
     power_mapping = {
         None: 'build',
         power_state.NOSTATE: 'build',
@@ -63,7 +95,7 @@ def _translate_detail_keys(req, inst):
         inst_dict[k] = inst[v]
 
     inst_dict['status'] = power_mapping[inst_dict['status']]
-    inst_dict['addresses'] = _addresses_generator(version)(inst)
+    inst_dict['addresses'] = addresses_builder(req)(inst)
 
     # Return the metadata as a dictionary
     metadata = {}
@@ -78,33 +110,6 @@ def _translate_detail_keys(req, inst):
     return dict(server=inst_dict)
 
 
-def _translate_keys(req, inst):
-    """ Coerces into dictionary format, excluding all model attributes
-    save for id and name """
-    return dict(server=dict(id=inst['id'], name=inst['display_name']))
-
-
-def _addresses_generator(version):
-
-    def _gen_addresses_1_0(inst):
-        private_ips = utils.get_from_path(inst, 'fixed_ip/address')
-        public_ips = utils.get_from_path(inst, 'fixed_ip/floating_ips/address')
-        return dict(public=public_ips, private=private_ips)
-
-    def _gen_addresses_1_1(inst):
-        private_ips = utils.get_from_path(inst, 'fixed_ip/address')
-        private_ips = [dict(version=4, addr=a) for a in private_ips]
-        public_ips = utils.get_from_path(inst, 'fixed_ip/floating_ips/address')
-        public_ips = [dict(version=4, addr=a) for a in public_ips]
-        return dict(public=public_ips, private=private_ips)
-
-    dispatch_table = {
-        '1.0': _gen_addresses_1_0,
-        '1.1': _gen_addresses_1_1,
-    }
-
-    return dispatch_table[version]
-
 class Controller(wsgi.Controller):
     """ The Server API controller for the OpenStack API """
 
@@ -119,29 +124,37 @@ class Controller(wsgi.Controller):
         self._image_service = utils.import_object(FLAGS.image_service)
         super(Controller, self).__init__()
 
+    def ips(self, req, id):
+        try:
+            instance = self.compute_api.get(req.environ['nova.context'], id)
+            return addresses_builder(req)(instance)
+        except exception.NotFound:
+            return faults.Fault(exc.HTTPNotFound())
+
     def index(self, req):
         """ Returns a list of server names and ids for a given user """
-        return self._items(req, entity_maker=_translate_keys)
+        return self._items(req, is_detail=False)
 
     def detail(self, req):
         """ Returns a list of server details for a given user """
-        return self._items(req, entity_maker=_translate_detail_keys)
+        return self._items(req, is_detail=True)
 
-    def _items(self, req, entity_maker):
+    def _items(self, req, is_detail):
         """Returns a list of servers for a given user.
 
-        entity_maker - either _translate_detail_keys or _translate_keys
+        builder - the response model builder
         """
         instance_list = self.compute_api.get_all(req.environ['nova.context'])
         limited_list = common.limited(instance_list, req)
-        res = [entity_maker(req, inst)['server'] for inst in limited_list]
+        res = [build_server(req, inst, is_detail)['server']
+                for inst in limited_list]
         return dict(servers=res)
 
     def show(self, req, id):
         """ Returns server details by server id """
         try:
             instance = self.compute_api.get(req.environ['nova.context'], id)
-            return _translate_detail_keys(req, instance)
+            return build_server(req, instance, is_detail=True)
         except exception.NotFound:
             return faults.Fault(exc.HTTPNotFound())
 
@@ -193,7 +206,7 @@ class Controller(wsgi.Controller):
             metadata=metadata,
             onset_files=env.get('onset_files', []))
 
-        server = _translate_keys(req, instances[0])
+        server = build_server(req, instances[0], is_detail=False)
         password = "%s%s" % (server['server']['name'][:4],
                              utils.generate_password(12))
         server['server']['adminPass'] = password
diff --git a/nova/context.py b/nova/context.py
index 677bd2e7e..0f3eb9ae4 100644
--- a/nova/context.py
+++ b/nova/context.py
@@ -30,7 +30,7 @@ from nova import utils
 class RequestContext(object):
     def __init__(self, user, project, is_admin=None, read_deleted=False,
                  remote_address=None, timestamp=None, request_id=None,
-                 version='1.1'):
+                 version=None):
         if hasattr(user, 'id'):
             self._user = user
             self.user_id = user.id
-- 
cgit 


From 6cd90a95d632d45d1c906d412e3240f730e88b95 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Fri, 11 Mar 2011 15:35:55 -0600
Subject: New migration

---
 .../versions/010_add_flavors_to_migrations.py      | 44 ++++++++++++++++++++++
 nova/db/sqlalchemy/models.py                       |  2 +
 nova/tests/test_compute.py                         |  2 -
 3 files changed, 46 insertions(+), 2 deletions(-)
 create mode 100644 nova/db/sqlalchemy/migrate_repo/versions/010_add_flavors_to_migrations.py

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/migrate_repo/versions/010_add_flavors_to_migrations.py b/nova/db/sqlalchemy/migrate_repo/versions/010_add_flavors_to_migrations.py
new file mode 100644
index 000000000..412caedd0
--- /dev/null
+++ b/nova/db/sqlalchemy/migrate_repo/versions/010_add_flavors_to_migrations.py
@@ -0,0 +1,44 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 OpenStack LLC.
+# 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.from sqlalchemy import *
+
+from sqlalchemy import *
+from migrate import *
+
+from nova import log as logging
+
+
+meta = MetaData()
+
+migrations = Table('migrations', meta,
+        Column('id', Integer(), primary_key=True, nullable=False),
+        )
+
+#
+# Tables to alter
+#
+#
+
+old_flavor_id = Column('old_flavor_id', Integer())
+new_flavor_id = Column('new_flavor_id', Integer())
+
+
+def upgrade(migrate_engine):
+    # Upgrade operations go here. Don't create your own engine;
+    # bind migrate_engine to your metadata
+    meta.bind = migrate_engine
+    migrations.create_column(old_flavor_id)
+    migrations.create_column(new_flavor_id)
diff --git a/nova/db/sqlalchemy/models.py b/nova/db/sqlalchemy/models.py
index 6ef284e65..73cd8a4cc 100644
--- a/nova/db/sqlalchemy/models.py
+++ b/nova/db/sqlalchemy/models.py
@@ -396,6 +396,8 @@ class Migration(BASE, NovaBase):
     source_compute = Column(String(255))
     dest_compute = Column(String(255))
     dest_host = Column(String(255))
+    old_flavor_id = Column(Integer())
+    new_flavor_id = Column(Integer())
     instance_id = Column(Integer, ForeignKey('instances.id'), nullable=True)
     #TODO(_cerberus_): enum
     status = Column(String(255))
diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index 643b2e93a..3d25a8997 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -299,5 +299,3 @@ class ComputeTestCase(test.TestCase):
         self.assertRaises(exception.Error, self.compute.prep_resize,
                 self.context, instance_id)
         self.compute.terminate_instance(self.context, instance_id)
-        type = instance_types.get_by_flavor_id("1")
-        self.assertEqual(type, 'm1.tiny')
-- 
cgit 


From be9734b03bce871d32e21da2ba341dfa42aa020a Mon Sep 17 00:00:00 2001
From: Brian Lamar <brian.lamar@rackspace.com>
Date: Fri, 11 Mar 2011 17:19:14 -0500
Subject: Fixed lp732866 by catching relevant `exception.NotFound` exception.
 Tests did not uncover this vulnerability due to "incorrect" FakeAuthManager.
 I say "incorrect" because potentially different implementations (LDAP or
 Database driven) of AuthManager might return different errors from
 `get_user_from_access_key`.

Also, removed all references to 'bacon', 'ham', 'herp', and 'derp' and replaced them with hopefully more helpful terms.
---
 nova/api/openstack/auth.py            |  6 +++-
 nova/tests/api/openstack/fakes.py     |  5 +++-
 nova/tests/api/openstack/test_auth.py | 56 +++++++++++++++++++++--------------
 3 files changed, 43 insertions(+), 24 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/auth.py b/nova/api/openstack/auth.py
index 4c6b58eff..f3a9bdeca 100644
--- a/nova/api/openstack/auth.py
+++ b/nova/api/openstack/auth.py
@@ -135,7 +135,11 @@ class AuthMiddleware(wsgi.Middleware):
         req - wsgi.Request object
         """
         ctxt = context.get_admin_context()
-        user = self.auth.get_user_from_access_key(key)
+
+        try:
+            user = self.auth.get_user_from_access_key(key)
+        except exception.NotFound:
+            user = None
 
         if user and user.name == username:
             token_hash = hashlib.sha1('%s%s%f' % (username, key,
diff --git a/nova/tests/api/openstack/fakes.py b/nova/tests/api/openstack/fakes.py
index e50d11a3d..7cb974bb2 100644
--- a/nova/tests/api/openstack/fakes.py
+++ b/nova/tests/api/openstack/fakes.py
@@ -321,7 +321,10 @@ class FakeAuthManager(object):
                        (user.id == p.project_manager_id)]
 
     def get_user_from_access_key(self, key):
-        return FakeAuthManager.auth_data.get(key, None)
+        try:
+            return FakeAuthManager.auth_data[key]
+        except KeyError:
+            raise exc.NotFound
 
 
 class FakeRateLimiter(object):
diff --git a/nova/tests/api/openstack/test_auth.py b/nova/tests/api/openstack/test_auth.py
index aaaa4e415..d1b3c0e10 100644
--- a/nova/tests/api/openstack/test_auth.py
+++ b/nova/tests/api/openstack/test_auth.py
@@ -51,11 +51,12 @@ class Test(test.TestCase):
 
     def test_authorize_user(self):
         f = fakes.FakeAuthManager()
-        f.add_user('derp', nova.auth.manager.User(1, 'herp', None, None, None))
+        f.add_user('user1_key', 
+            nova.auth.manager.User(1, 'user1', None, None, None))
 
         req = webob.Request.blank('/v1.0/')
-        req.headers['X-Auth-User'] = 'herp'
-        req.headers['X-Auth-Key'] = 'derp'
+        req.headers['X-Auth-User'] = 'user1'
+        req.headers['X-Auth-Key'] = 'user1_key'
         result = req.get_response(fakes.wsgi_app())
         self.assertEqual(result.status, '204 No Content')
         self.assertEqual(len(result.headers['X-Auth-Token']), 40)
@@ -65,13 +66,13 @@ class Test(test.TestCase):
 
     def test_authorize_token(self):
         f = fakes.FakeAuthManager()
-        u = nova.auth.manager.User(1, 'herp', None, None, None)
-        f.add_user('derp', u)
-        f.create_project('test', u)
+        u = nova.auth.manager.User(1, 'user1', None, None, None)
+        f.add_user('user1_key', u)
+        f.create_project('user1_project', u)
 
         req = webob.Request.blank('/v1.0/', {'HTTP_HOST': 'foo'})
-        req.headers['X-Auth-User'] = 'herp'
-        req.headers['X-Auth-Key'] = 'derp'
+        req.headers['X-Auth-User'] = 'user1'
+        req.headers['X-Auth-Key'] = 'user1_key'
         result = req.get_response(fakes.wsgi_app())
         self.assertEqual(result.status, '204 No Content')
         self.assertEqual(len(result.headers['X-Auth-Token']), 40)
@@ -92,7 +93,7 @@ class Test(test.TestCase):
 
     def test_token_expiry(self):
         self.destroy_called = False
-        token_hash = 'bacon'
+        token_hash = 'token_hash'
 
         def destroy_token_mock(meh, context, token):
             self.destroy_called = True
@@ -109,15 +110,26 @@ class Test(test.TestCase):
             bad_token)
 
         req = webob.Request.blank('/v1.0/')
-        req.headers['X-Auth-Token'] = 'bacon'
+        req.headers['X-Auth-Token'] = 'token_hash'
         result = req.get_response(fakes.wsgi_app())
         self.assertEqual(result.status, '401 Unauthorized')
         self.assertEqual(self.destroy_called, True)
 
-    def test_bad_user(self):
+    def test_bad_user_bad_key(self):
+        req = webob.Request.blank('/v1.0/')
+        req.headers['X-Auth-User'] = 'unknown_user'
+        req.headers['X-Auth-Key'] = 'unknown_user_key'
+        result = req.get_response(fakes.wsgi_app())
+        self.assertEqual(result.status, '401 Unauthorized')
+
+    def test_bad_user_good_key(self):
+        f = fakes.FakeAuthManager()
+        u = nova.auth.manager.User(1, 'user1', None, None, None)
+        f.add_user('user1_key', u)
+
         req = webob.Request.blank('/v1.0/')
-        req.headers['X-Auth-User'] = 'herp'
-        req.headers['X-Auth-Key'] = 'derp'
+        req.headers['X-Auth-User'] = 'unknown_user'
+        req.headers['X-Auth-Key'] = 'user1_key'
         result = req.get_response(fakes.wsgi_app())
         self.assertEqual(result.status, '401 Unauthorized')
 
@@ -128,7 +140,7 @@ class Test(test.TestCase):
 
     def test_bad_token(self):
         req = webob.Request.blank('/v1.0/')
-        req.headers['X-Auth-Token'] = 'baconbaconbacon'
+        req.headers['X-Auth-Token'] = 'unknown_token'
         result = req.get_response(fakes.wsgi_app())
         self.assertEqual(result.status, '401 Unauthorized')
 
@@ -137,11 +149,11 @@ class TestFunctional(test.TestCase):
     def test_token_expiry(self):
         ctx = context.get_admin_context()
         tok = db.auth_token_create(ctx, dict(
-                token_hash='bacon',
+                token_hash='test_token_hash',
                 cdn_management_url='',
                 server_management_url='',
                 storage_url='',
-                user_id='ham',
+                user_id='user1',
                 ))
 
         db.auth_token_update(ctx, tok.token_hash, dict(
@@ -149,13 +161,13 @@ class TestFunctional(test.TestCase):
                 ))
 
         req = webob.Request.blank('/v1.0/')
-        req.headers['X-Auth-Token'] = 'bacon'
+        req.headers['X-Auth-Token'] = 'test_token_hash'
         result = req.get_response(fakes.wsgi_app())
         self.assertEqual(result.status, '401 Unauthorized')
 
     def test_token_doesnotexist(self):
         req = webob.Request.blank('/v1.0/')
-        req.headers['X-Auth-Token'] = 'ham'
+        req.headers['X-Auth-Token'] = 'nonexistant_token_hash'
         result = req.get_response(fakes.wsgi_app())
         self.assertEqual(result.status, '401 Unauthorized')
 
@@ -178,13 +190,13 @@ class TestLimiter(test.TestCase):
 
     def test_authorize_token(self):
         f = fakes.FakeAuthManager()
-        u = nova.auth.manager.User(1, 'herp', None, None, None)
-        f.add_user('derp', u)
+        u = nova.auth.manager.User(1, 'user1', None, None, None)
+        f.add_user('user1_key', u)
         f.create_project('test', u)
 
         req = webob.Request.blank('/v1.0/')
-        req.headers['X-Auth-User'] = 'herp'
-        req.headers['X-Auth-Key'] = 'derp'
+        req.headers['X-Auth-User'] = 'user1'
+        req.headers['X-Auth-Key'] = 'user1_key'
         result = req.get_response(fakes.wsgi_app())
         self.assertEqual(len(result.headers['X-Auth-Token']), 40)
 
-- 
cgit 


From 2ac7fa75c02c885fc9d4dfacba8318aadbdbfceb Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
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')

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 <soren@linux2go.dk>
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')

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 5d0ca375e082c702b218c26f24d8009650a319a3 Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Fri, 11 Mar 2011 14:36:31 -0800
Subject: Beginning of cleanup of FakeAuthManager

---
 nova/tests/api/openstack/fakes.py         | 41 +++++++++++++++++--------------
 nova/tests/api/openstack/test_accounts.py |  4 +--
 nova/tests/api/openstack/test_auth.py     | 14 +++++------
 nova/tests/api/openstack/test_users.py    | 14 +++++------
 4 files changed, 38 insertions(+), 35 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/fakes.py b/nova/tests/api/openstack/fakes.py
index e50d11a3d..52ac80e3f 100644
--- a/nova/tests/api/openstack/fakes.py
+++ b/nova/tests/api/openstack/fakes.py
@@ -228,12 +228,14 @@ class FakeAuthDatabase(object):
 
 
 class FakeAuthManager(object):
-    auth_data = {}
+    #NOTE(justinsb): Accessing static variables through instances is FUBAR
+    #NOTE(justinsb): This should also be private!
+    auth_data = []
     projects = {}
 
     @classmethod
     def clear_fakes(cls):
-        cls.auth_data = {}
+        cls.auth_data = []
         cls.projects = {}
 
     @classmethod
@@ -246,34 +248,40 @@ class FakeAuthManager(object):
                                              'test',
                                               []))
 
-    def add_user(self, key, user):
-        FakeAuthManager.auth_data[key] = user
+    def add_user(self, user):
+        FakeAuthManager.auth_data.append(user)
 
     def get_users(self):
-        return FakeAuthManager.auth_data.values()
+        return FakeAuthManager.auth_data
 
     def get_user(self, uid):
-        for k, v in FakeAuthManager.auth_data.iteritems():
-            if v.id == uid:
-                return v
+        for u in FakeAuthManager.auth_data:
+            if u.id == uid:
+                return u
+        return None
+
+    def get_user_from_access_key(self, key):
+        for u in FakeAuthManager.auth_data:
+            if u.access == key:
+                return u
         return None
 
     def delete_user(self, uid):
-        for k, v in FakeAuthManager.auth_data.items():
-            if v.id == uid:
-                del FakeAuthManager.auth_data[k]
+        for u in FakeAuthManager.auth_data:
+            if u.id == uid:
+                FakeAuthManager.auth_data.remove(u)
         return None
 
     def create_user(self, name, access=None, secret=None, admin=False):
         u = User(name, name, access, secret, admin)
-        FakeAuthManager.auth_data[access] = u
+        FakeAuthManager.auth_data.append(u)
         return u
 
     def modify_user(self, user_id, access=None, secret=None, admin=None):
         user = None
-        for k, v in FakeAuthManager.auth_data.iteritems():
-            if v.id == user_id:
-                user = v
+        for u in FakeAuthManager.auth_data:
+            if u.id == user_id:
+                user = u
         if user:
             user.access = access
             user.secret = secret
@@ -320,9 +328,6 @@ class FakeAuthManager(object):
                     if (user.id in p.member_ids) or
                        (user.id == p.project_manager_id)]
 
-    def get_user_from_access_key(self, key):
-        return FakeAuthManager.auth_data.get(key, None)
-
 
 class FakeRateLimiter(object):
     def __init__(self, application):
diff --git a/nova/tests/api/openstack/test_accounts.py b/nova/tests/api/openstack/test_accounts.py
index 60edce769..1bf49b33b 100644
--- a/nova/tests/api/openstack/test_accounts.py
+++ b/nova/tests/api/openstack/test_accounts.py
@@ -59,8 +59,8 @@ class AccountsTest(test.TestCase):
         fakemgr = fakes.FakeAuthManager()
         joeuser = User('guy1', 'guy1', 'acc1', 'fortytwo!', False)
         superuser = User('guy2', 'guy2', 'acc2', 'swordfish', True)
-        fakemgr.add_user(joeuser.access, joeuser)
-        fakemgr.add_user(superuser.access, superuser)
+        fakemgr.add_user(joeuser)
+        fakemgr.add_user(superuser)
         fakemgr.create_project('test1', joeuser)
         fakemgr.create_project('test2', superuser)
 
diff --git a/nova/tests/api/openstack/test_auth.py b/nova/tests/api/openstack/test_auth.py
index aaaa4e415..84222f0f1 100644
--- a/nova/tests/api/openstack/test_auth.py
+++ b/nova/tests/api/openstack/test_auth.py
@@ -39,7 +39,7 @@ class Test(test.TestCase):
         self.stubs.Set(nova.api.openstack.auth.AuthMiddleware,
             '__init__', fakes.fake_auth_init)
         self.stubs.Set(context, 'RequestContext', fakes.FakeRequestContext)
-        fakes.FakeAuthManager.auth_data = {}
+        fakes.FakeAuthManager.clear_fakes()
         fakes.FakeAuthDatabase.data = {}
         fakes.stub_out_rate_limiting(self.stubs)
         fakes.stub_out_networking(self.stubs)
@@ -51,7 +51,7 @@ class Test(test.TestCase):
 
     def test_authorize_user(self):
         f = fakes.FakeAuthManager()
-        f.add_user('derp', nova.auth.manager.User(1, 'herp', None, None, None))
+        f.add_user(nova.auth.manager.User(1, 'herp', 'derp', None, None))
 
         req = webob.Request.blank('/v1.0/')
         req.headers['X-Auth-User'] = 'herp'
@@ -65,8 +65,8 @@ class Test(test.TestCase):
 
     def test_authorize_token(self):
         f = fakes.FakeAuthManager()
-        u = nova.auth.manager.User(1, 'herp', None, None, None)
-        f.add_user('derp', u)
+        u = nova.auth.manager.User(1, 'herp', 'derp', None, None)
+        f.add_user(u)
         f.create_project('test', u)
 
         req = webob.Request.blank('/v1.0/', {'HTTP_HOST': 'foo'})
@@ -167,7 +167,7 @@ class TestLimiter(test.TestCase):
         self.stubs.Set(nova.api.openstack.auth.AuthMiddleware,
             '__init__', fakes.fake_auth_init)
         self.stubs.Set(context, 'RequestContext', fakes.FakeRequestContext)
-        fakes.FakeAuthManager.auth_data = {}
+        fakes.FakeAuthManager.clear_fakes()
         fakes.FakeAuthDatabase.data = {}
         fakes.stub_out_networking(self.stubs)
 
@@ -178,8 +178,8 @@ class TestLimiter(test.TestCase):
 
     def test_authorize_token(self):
         f = fakes.FakeAuthManager()
-        u = nova.auth.manager.User(1, 'herp', None, None, None)
-        f.add_user('derp', u)
+        u = nova.auth.manager.User(1, 'herp', 'derp', None, None)
+        f.add_user(u)
         f.create_project('test', u)
 
         req = webob.Request.blank('/v1.0/')
diff --git a/nova/tests/api/openstack/test_users.py b/nova/tests/api/openstack/test_users.py
index 2dda4319b..a62db7efc 100644
--- a/nova/tests/api/openstack/test_users.py
+++ b/nova/tests/api/openstack/test_users.py
@@ -47,7 +47,7 @@ class UsersTest(test.TestCase):
                        fake_init)
         self.stubs.Set(nova.api.openstack.users.Controller, '_check_admin',
                        fake_admin_check)
-        fakes.FakeAuthManager.auth_data = {}
+        fakes.FakeAuthManager.clear_fakes()
         fakes.FakeAuthManager.projects = dict(testacct=Project('testacct',
                                                                'testacct',
                                                                'guy1',
@@ -61,10 +61,8 @@ class UsersTest(test.TestCase):
         self.allow_admin = FLAGS.allow_admin_api
         FLAGS.allow_admin_api = True
         fakemgr = fakes.FakeAuthManager()
-        fakemgr.add_user('acc1', User('guy1', 'guy1', 'acc1',
-                                      'fortytwo!', False))
-        fakemgr.add_user('acc2', User('guy2', 'guy2', 'acc2',
-                                      'swordfish', True))
+        fakemgr.add_user(User('guy1', 'guy1', 'acc1', 'fortytwo!', False))
+        fakemgr.add_user(User('guy2', 'guy2', 'acc2', 'swordfish', True))
 
     def tearDown(self):
         self.stubs.UnsetAll()
@@ -95,7 +93,7 @@ class UsersTest(test.TestCase):
         req.method = 'DELETE'
         res = req.get_response(fakes.wsgi_app())
         self.assertTrue('guy1' not in [u.id for u in
-                        fakes.FakeAuthManager.auth_data.values()])
+                        fakes.FakeAuthManager.auth_data])
         self.assertEqual(res.status_int, 200)
 
     def test_user_create(self):
@@ -118,8 +116,8 @@ class UsersTest(test.TestCase):
         self.assertEqual(res_dict['user']['secret'], 'invasionIsInNormandy')
         self.assertEqual(res_dict['user']['admin'], True)
         self.assertTrue('test_guy' in [u.id for u in
-                        fakes.FakeAuthManager.auth_data.values()])
-        self.assertEqual(len(fakes.FakeAuthManager.auth_data.values()), 3)
+                        fakes.FakeAuthManager.auth_data])
+        self.assertEqual(len(fakes.FakeAuthManager.auth_data), 3)
 
     def test_user_update(self):
         body = dict(user=dict(name='guy2',
-- 
cgit 


From 909b72faa77ba0a2bc787309b95fdfae9bb9ca01 Mon Sep 17 00:00:00 2001
From: Brian Lamar <brian.lamar@rackspace.com>
Date: Fri, 11 Mar 2011 17:41:10 -0500
Subject: Removed EOL whitespace in accordance with PEP-8.

---
 nova/tests/api/openstack/test_auth.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/test_auth.py b/nova/tests/api/openstack/test_auth.py
index d1b3c0e10..0448ed701 100644
--- a/nova/tests/api/openstack/test_auth.py
+++ b/nova/tests/api/openstack/test_auth.py
@@ -51,7 +51,7 @@ class Test(test.TestCase):
 
     def test_authorize_user(self):
         f = fakes.FakeAuthManager()
-        f.add_user('user1_key', 
+        f.add_user('user1_key',
             nova.auth.manager.User(1, 'user1', None, None, None))
 
         req = webob.Request.blank('/v1.0/')
-- 
cgit 


From b3f5a4d5a8e513fe65a3b1dde9b36fd1388afb67 Mon Sep 17 00:00:00 2001
From: "Kevin L. Mitchell" <kevin.mitchell@rackspace.com>
Date: Fri, 11 Mar 2011 22:55:56 +0000
Subject: Remove vish comment

---
 nova/db/sqlalchemy/api.py | 2 --
 1 file changed, 2 deletions(-)

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 08bc8fe2f..71b85d659 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -578,8 +578,6 @@ def fixed_ip_disassociate(context, address):
 @require_admin_context
 def fixed_ip_disassociate_all_by_timeout(_context, host, time):
     session = get_session()
-    # NOTE(vish): The nested select is because sqlite doesn't support
-    #             JOINs in UPDATEs.
     inner_q = session.query(models.Network.id).\
                       filter_by(host=host).\
                       subquery()
-- 
cgit 


From da76b3d67b2c2e864025c4ba201b63e1dee2ff1f Mon Sep 17 00:00:00 2001
From: Josh Kearney <josh@jk0.org>
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')

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 <josh@jk0.org>
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')

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 <josh@jk0.org>
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')

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 29e59a96602265c5b5746865db94a3f00b8b5cf5 Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Fri, 11 Mar 2011 15:21:31 -0800
Subject: Change capitalization of Openstack to OpenStack

---
 nova/tests/integrated/api/client.py | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/integrated/api/client.py b/nova/tests/integrated/api/client.py
index da8d87e07..245eb8c69 100644
--- a/nova/tests/integrated/api/client.py
+++ b/nova/tests/integrated/api/client.py
@@ -24,7 +24,7 @@ from nova import log as logging
 LOG = logging.getLogger('nova.tests.api')
 
 
-class OpenstackApiException(Exception):
+class OpenStackApiException(Exception):
     def __init__(self, message=None, response=None):
         self.response = response
         if not message:
@@ -37,22 +37,22 @@ class OpenstackApiException(Exception):
             message = _('%(message)s\nStatus Code: %(_status)s\n'
                         'Body: %(_body)s') % locals()
 
-        super(OpenstackApiException, self).__init__(message)
+        super(OpenStackApiException, self).__init__(message)
 
 
-class OpenstackApiAuthenticationException(OpenstackApiException):
+class OpenStackApiAuthenticationException(OpenStackApiException):
     def __init__(self, response=None, message=None):
         if not message:
             message = _("Authentication error")
-        super(OpenstackApiAuthenticationException, self).__init__(message,
+        super(OpenStackApiAuthenticationException, self).__init__(message,
                                                                   response)
 
 
-class OpenstackApiNotFoundException(OpenstackApiException):
+class OpenStackApiNotFoundException(OpenStackApiException):
     def __init__(self, response=None, message=None):
         if not message:
             message = _("Item not found")
-        super(OpenstackApiNotFoundException, self).__init__(message, response)
+        super(OpenStackApiNotFoundException, self).__init__(message, response)
 
 
 class TestOpenStackClient(object):
@@ -82,7 +82,7 @@ class TestOpenStackClient(object):
             conn = httplib.HTTPSConnection(hostname,
                                            port=port)
         else:
-            raise OpenstackApiException("Unknown scheme: %s" % url)
+            raise OpenStackApiException("Unknown scheme: %s" % url)
 
         relative_url = parsed_url.path
         if parsed_url.query:
@@ -111,7 +111,7 @@ class TestOpenStackClient(object):
         # Until bug732866 is fixed, we can't check this properly...
         #if http_status == 401:
         if http_status != 204:
-            raise OpenstackApiAuthenticationException(response=response)
+            raise OpenStackApiAuthenticationException(response=response)
 
         auth_headers = {}
         for k, v in response.getheaders():
@@ -138,9 +138,9 @@ class TestOpenStackClient(object):
         if check_response_status:
             if not http_status in check_response_status:
                 if http_status == 404:
-                    raise OpenstackApiNotFoundException(response=response)
+                    raise OpenStackApiNotFoundException(response=response)
                 else:
-                    raise OpenstackApiException(
+                    raise OpenStackApiException(
                                         message=_("Unexpected status code"),
                                         response=response)
 
-- 
cgit 


From 1c4afe23157233b7081872ccbc6ea5fa1ff0015a Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Fri, 11 Mar 2011 17:30:51 -0600
Subject: Some unit tests

---
 nova/compute/api.py        |  9 ++++++---
 nova/tests/test_compute.py | 24 ++++++++++++++++++++++++
 2 files changed, 30 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/api.py b/nova/compute/api.py
index 1393c01d5..0dc2bb3d3 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -460,10 +460,13 @@ class API(base.Base):
     def resize(self, context, instance_id, flavor_id):
         """Resize a running instance."""
         instance = self.db.instance_get(context, instance_id)
-        current_instance_type = self.db.instance_type_get_by_flavor_id(
-            context, instance['flavor_id'])
+        current_instance_type = self.db.instance_type_get_by_name(
+            context, instance['instance_type'])
+        
         new_instance_type = self.db.instance_type_get_by_flavor_id(
-            context, flavor_id)
+                context, flavor_id)
+        if not new_instance_type:
+            raise exception.ApiError(_("Requested flavor does not exist"))
 
         if current_instance_type.memory_mb > new_instance_typ.memory_mb:
             raise exception.ApiError(_("Invalid flavor: cannot downsize"
diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index 3d25a8997..c53284216 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -287,6 +287,30 @@ class ComputeTestCase(test.TestCase):
                 migration_ref['id'])
         self.compute.terminate_instance(context, instance_id)
 
+    def test_resize_invalid_flavor_fails(self):
+        """Ensure invalid flavors raise"""
+        instance_id = self._create_instance()
+        context = self.context.elevated()
+        self.compute.run_instance(self.context, instance_id)
+
+        self.assertRaises(exception.ApiError, self.compute_api.resize,
+                context, instance_id, 200)
+
+        self.compute.terminate_instance(context, instance_id)
+
+    def test_resize_down_fails(self):
+        """Ensure invalid flavors raise"""
+        instance_id = self._create_instance()
+        context = self.context.elevated()
+        self.compute.run_instance(self.context, instance_id)
+        db.instance_update(self.context, instance_id, 
+                {'instance_type': 'm1.large'})
+
+        self.assertRaises(exception.ApiError, self.compute_api.resize,
+                context, instance_id, 1)
+
+        self.compute.terminate_instance(context, instance_id)
+
     def test_get_by_flavor_id(self):
         type = instance_types.get_by_flavor_id(1)
         self.assertEqual(type, 'm1.tiny')
-- 
cgit 


From f9706b5080786a4d3e530f3e8bdb69147e9f5086 Mon Sep 17 00:00:00 2001
From: Josh Kearney <josh@jk0.org>
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')

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 <josh@jk0.org>
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')

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 <josh@jk0.org>
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')

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 <josh@jk0.org>
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')

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 87f7356e98dbb4d01305785ed8209f44b525ff2c Mon Sep 17 00:00:00 2001
From: Naveed Massjouni <naveedm9@gmail.com>
Date: Fri, 11 Mar 2011 19:21:34 -0500
Subject: Removed _translate_keys() functions since it is no longer used. Moved
 private top level functions to bottom of module.

---
 nova/api/openstack/servers.py | 148 ++++++++++++++++++++----------------------
 1 file changed, 71 insertions(+), 77 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index b486dfebb..940c2c47e 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -34,82 +34,9 @@ import nova.api.openstack
 
 
 LOG = logging.getLogger('server')
-
-
 FLAGS = flags.FLAGS
 
 
-def _translate_keys(req, inst):
-    """ Coerces into dictionary format, excluding all model attributes
-    save for id and name """
-    return dict(server=dict(id=inst['id'], name=inst['display_name']))
-
-
-def _build_addresses_10(inst):
-    private_ips = utils.get_from_path(inst, 'fixed_ip/address')
-    public_ips = utils.get_from_path(inst, 'fixed_ip/floating_ips/address')
-    return dict(public=public_ips, private=private_ips)
-
-
-def _build_addresses_11(inst):
-    private_ips = utils.get_from_path(inst, 'fixed_ip/address')
-    private_ips = [dict(version=4, addr=a) for a in private_ips]
-    public_ips = utils.get_from_path(inst, 'fixed_ip/floating_ips/address')
-    public_ips = [dict(version=4, addr=a) for a in public_ips]
-    return dict(public=public_ips, private=private_ips)
-
-
-def addresses_builder(req):
-    version = req.environ['nova.context'].version
-    if version == '1.1':
-        return _build_addresses_11
-    else:
-        return _build_addresses_10
-
-
-def build_server(req, inst, is_detail):
-    """ Coerces into dictionary format, mapping everything to Rackspace-like
-    attributes for return"""
-
-    if not is_detail:
-        return dict(server=dict(id=inst['id'], name=inst['display_name']))
-
-    power_mapping = {
-        None: 'build',
-        power_state.NOSTATE: 'build',
-        power_state.RUNNING: 'active',
-        power_state.BLOCKED: 'active',
-        power_state.SUSPENDED: 'suspended',
-        power_state.PAUSED: 'paused',
-        power_state.SHUTDOWN: 'active',
-        power_state.SHUTOFF: 'active',
-        power_state.CRASHED: 'error',
-        power_state.FAILED: 'error'}
-    inst_dict = {}
-    version = req.environ['nova.context'].version
-
-    mapped_keys = dict(status='state', imageId='image_id',
-        flavorId='instance_type', name='display_name', id='id')
-
-    for k, v in mapped_keys.iteritems():
-        inst_dict[k] = inst[v]
-
-    inst_dict['status'] = power_mapping[inst_dict['status']]
-    inst_dict['addresses'] = addresses_builder(req)(inst)
-
-    # Return the metadata as a dictionary
-    metadata = {}
-    for item in inst['metadata']:
-        metadata[item['key']] = item['value']
-    inst_dict['metadata'] = metadata
-
-    inst_dict['hostId'] = ''
-    if inst['host']:
-        inst_dict['hostId'] = hashlib.sha224(inst['host']).hexdigest()
-
-    return dict(server=inst_dict)
-
-
 class Controller(wsgi.Controller):
     """ The Server API controller for the OpenStack API """
 
@@ -127,7 +54,7 @@ class Controller(wsgi.Controller):
     def ips(self, req, id):
         try:
             instance = self.compute_api.get(req.environ['nova.context'], id)
-            return addresses_builder(req)(instance)
+            return _addresses_builder(req)(instance)
         except exception.NotFound:
             return faults.Fault(exc.HTTPNotFound())
 
@@ -146,7 +73,7 @@ class Controller(wsgi.Controller):
         """
         instance_list = self.compute_api.get_all(req.environ['nova.context'])
         limited_list = common.limited(instance_list, req)
-        res = [build_server(req, inst, is_detail)['server']
+        res = [_build_server(req, inst, is_detail)['server']
                 for inst in limited_list]
         return dict(servers=res)
 
@@ -154,7 +81,7 @@ class Controller(wsgi.Controller):
         """ Returns server details by server id """
         try:
             instance = self.compute_api.get(req.environ['nova.context'], id)
-            return build_server(req, instance, is_detail=True)
+            return _build_server(req, instance, is_detail=True)
         except exception.NotFound:
             return faults.Fault(exc.HTTPNotFound())
 
@@ -206,7 +133,7 @@ class Controller(wsgi.Controller):
             metadata=metadata,
             onset_files=env.get('onset_files', []))
 
-        server = build_server(req, instances[0], is_detail=False)
+        server = _build_server(req, instances[0], is_detail=False)
         password = "%s%s" % (server['server']['name'][:4],
                              utils.generate_password(12))
         server['server']['adminPass'] = password
@@ -503,3 +430,70 @@ class Controller(wsgi.Controller):
                 _("Ramdisk not found for image %(image_id)s") % locals())
 
         return kernel_id, ramdisk_id
+
+
+def _build_server(req, inst, is_detail):
+    """ Coerces into dictionary format, mapping everything to Rackspace-like
+    attributes for return"""
+
+    if not is_detail:
+        return dict(server=dict(id=inst['id'], name=inst['display_name']))
+
+    power_mapping = {
+        None: 'build',
+        power_state.NOSTATE: 'build',
+        power_state.RUNNING: 'active',
+        power_state.BLOCKED: 'active',
+        power_state.SUSPENDED: 'suspended',
+        power_state.PAUSED: 'paused',
+        power_state.SHUTDOWN: 'active',
+        power_state.SHUTOFF: 'active',
+        power_state.CRASHED: 'error',
+        power_state.FAILED: 'error'}
+    inst_dict = {}
+    version = req.environ['nova.context'].version
+
+    mapped_keys = dict(status='state', imageId='image_id',
+        flavorId='instance_type', name='display_name', id='id')
+
+    for k, v in mapped_keys.iteritems():
+        inst_dict[k] = inst[v]
+
+    inst_dict['status'] = power_mapping[inst_dict['status']]
+    inst_dict['addresses'] = _addresses_builder(req)(inst)
+
+    # Return the metadata as a dictionary
+    metadata = {}
+    for item in inst['metadata']:
+        metadata[item['key']] = item['value']
+    inst_dict['metadata'] = metadata
+
+    inst_dict['hostId'] = ''
+    if inst['host']:
+        inst_dict['hostId'] = hashlib.sha224(inst['host']).hexdigest()
+
+    return dict(server=inst_dict)
+
+
+def _addresses_builder(req):
+    version = req.environ['nova.context'].version
+    if version == '1.1':
+        return _build_addresses_11
+    else:
+        return _build_addresses_10
+
+
+def _build_addresses_10(inst):
+    private_ips = utils.get_from_path(inst, 'fixed_ip/address')
+    public_ips = utils.get_from_path(inst, 'fixed_ip/floating_ips/address')
+    return dict(public=public_ips, private=private_ips)
+
+
+def _build_addresses_11(inst):
+    private_ips = utils.get_from_path(inst, 'fixed_ip/address')
+    private_ips = [dict(version=4, addr=a) for a in private_ips]
+    public_ips = utils.get_from_path(inst, 'fixed_ip/floating_ips/address')
+    public_ips = [dict(version=4, addr=a) for a in public_ips]
+    return dict(public=public_ips, private=private_ips)
+
+
-- 
cgit 


From 2bfa7b29c7882da559041cea771b9243555828fa Mon Sep 17 00:00:00 2001
From: Dan Prince <dan.prince@rackspace.com>
Date: Sun, 13 Mar 2011 13:51:42 -0400
Subject: The extension name is constructed from the camel cased module_name +
 'Extension'.

---
 nova/api/openstack/extensions.py               |  9 ++++++++-
 nova/tests/api/openstack/extensions/widgets.py | 14 +++++---------
 2 files changed, 13 insertions(+), 10 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/extensions.py b/nova/api/openstack/extensions.py
index 24846d9cd..13789863b 100644
--- a/nova/api/openstack/extensions.py
+++ b/nova/api/openstack/extensions.py
@@ -38,6 +38,12 @@ class ExtensionManager(object):
         return resources
 
     def _load_extensions(self):
+        """
+        Load extensions from the configured path. The extension name is
+        constructed from the camel cased module_name + 'Extension'. If your
+        extension module was named widgets.py the extension class within that
+        module should be 'WidgetsExtension'.
+        """
         if not os.path.exists(self.path):
             return
 
@@ -46,7 +52,8 @@ class ExtensionManager(object):
             ext_path = os.path.join(self.path, f)
             if file_ext.lower() == '.py':
                 mod = imp.load_source(mod_name, ext_path)
-                self.extensions.append(getattr(mod, 'get_extension')())
+                ext_name = mod_name[0].upper() + mod_name[1:] + 'Extension'
+                self.extensions.append(getattr(mod, ext_name)())
 
 
 class ExtensionResource(object):
diff --git a/nova/tests/api/openstack/extensions/widgets.py b/nova/tests/api/openstack/extensions/widgets.py
index bc0947223..e03fc7776 100644
--- a/nova/tests/api/openstack/extensions/widgets.py
+++ b/nova/tests/api/openstack/extensions/widgets.py
@@ -1,27 +1,23 @@
 from nova import wsgi
 
-class WidgetController(wsgi.Controller):
+class WidgetsController(wsgi.Controller):
 
     def index(self, req):
         return "Buy more widgets!"
 
-class WidgetExtensionResource(object):
+class WidgetsExtensionResource(object):
 
     def __init__(self):
         pass
 
     def add_routes(self, mapper):
-        mapper.resource('widget', 'widgets', controller=WidgetController())
+        mapper.resource('widget', 'widgets', controller=WidgetsController())
 
 
-class WidgetExtension(object):
+class WidgetsExtension(object):
 
     def __init__(self):
         pass
 
     def get_resources(self):
-        return WidgetExtensionResource()
-
-
-def get_extension():
-    return WidgetExtension()
+        return WidgetsExtensionResource()
-- 
cgit 


From 4f2d48eeffc79333afae829ea31f7eae0549b40a Mon Sep 17 00:00:00 2001
From: Salvatore Orlando <salvatore.orlando@eu.citrix.com>
Date: Sun, 13 Mar 2011 23:35:30 +0000
Subject: Removed excess LOG.debug line

---
 nova/tests/test_xenapi.py | 1 -
 1 file changed, 1 deletion(-)

(limited to 'nova')

diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index 85d804ebd..def37b377 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -268,7 +268,6 @@ class XenAPIVMTestCase(test.TestCase):
         mem_kib = long(instance_type['memory_mb']) << 10
         mem_bytes = str(mem_kib << 10)
         vcpus = instance_type['vcpus']
-        LOG.debug("VM:%s", self.vm)
         self.assertEquals(self.vm_info['max_mem'], mem_kib)
         self.assertEquals(self.vm_info['mem'], mem_kib)
         self.assertEquals(self.vm['memory_static_max'], mem_bytes)
-- 
cgit 


From 9164b8d224ae6629cdac00248b98fad762bdfc10 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Mon, 14 Mar 2011 10:46:26 +0100
Subject: Make utils.execute not overwrite std{in,out,err} args to Popen on
 retries. Make utils.execute reject unknown kwargs.

Add a couple of unit tests for utils.execute.
---
 nova/tests/test_utils.py | 76 ++++++++++++++++++++++++++++++++++++++++++++++++
 nova/utils.py            | 25 +++++++++-------
 2 files changed, 91 insertions(+), 10 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/test_utils.py b/nova/tests/test_utils.py
index 34a407f1a..51cd57c76 100644
--- a/nova/tests/test_utils.py
+++ b/nova/tests/test_utils.py
@@ -14,11 +14,87 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+import os
+import tempfile
+
 from nova import test
 from nova import utils
 from nova import exception
 
 
+class ExecuteTestCase(test.TestCase):
+    def test_retry_on_failure(self):
+        fd, tmpfilename = tempfile.mkstemp()
+        _, tmpfilename2 = tempfile.mkstemp()
+        try:
+            fp = os.fdopen(fd, 'w+')
+            fp.write('''#!/bin/sh
+# If stdin fails to get passed during one of the runs, make a note.
+if ! grep -q foo
+then
+    echo 'failure' > "$1"
+fi
+# If stdin has failed to get passed during this or a previous run, exit early.
+if grep failure "$1"
+then
+    exit 1
+fi
+runs="$(cat $1)"
+if [ -z "$runs" ]
+then
+    runs=0
+fi
+runs=$(($runs + 1))
+echo $runs > "$1"
+exit 1
+''')
+            fp.close()
+            os.chmod(tmpfilename, 0755)
+            self.assertRaises(exception.ProcessExecutionError,
+                              utils.execute,
+                              tmpfilename, tmpfilename2, attempts=10,
+                              process_input='foo',
+                              delay_on_retry=False)
+            fp = open(tmpfilename2, 'r+')
+            runs = fp.read()
+            fp.close()
+            self.assertNotEquals(runs.strip(), 'failure', 'stdin did not '
+                                                          'always get passed '
+                                                          'correctly')
+            runs = int(runs.strip())
+            self.assertEquals(runs, 10, 'Ran %d times instead of 10.' % (runs,))
+        finally:
+            os.unlink(tmpfilename)
+            os.unlink(tmpfilename2)
+
+    def test_unknown_kwargs_raises_error(self):
+        self.assertRaises(exception.Error,
+                          utils.execute,
+                          '/bin/true', this_is_not_a_valid_kwarg=True)
+
+    def test_no_retry_on_success(self):
+        fd, tmpfilename = tempfile.mkstemp()
+        _, tmpfilename2 = tempfile.mkstemp()
+        try:
+            fp = os.fdopen(fd, 'w+')
+            fp.write('''#!/bin/sh
+# If we've already run, bail out.
+grep -q foo "$1" && exit 1
+# Mark that we've run before.
+echo foo > "$1"
+# Check that stdin gets passed correctly.
+grep foo
+''')
+            fp.close()
+            os.chmod(tmpfilename, 0755)
+            utils.execute(tmpfilename,
+                          tmpfilename2,
+                          process_input='foo',
+                          attempts=2)
+        finally:
+            os.unlink(tmpfilename)
+            os.unlink(tmpfilename2)
+
 class GetFromPathTestCase(test.TestCase):
     def test_tolerates_nones(self):
         f = utils.get_from_path
diff --git a/nova/utils.py b/nova/utils.py
index 87e726394..2a98411ea 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -133,13 +133,14 @@ def fetchfile(url, target):
 
 
 def execute(*cmd, **kwargs):
-    process_input = kwargs.get('process_input', None)
-    addl_env = kwargs.get('addl_env', None)
-    check_exit_code = kwargs.get('check_exit_code', 0)
-    stdin = kwargs.get('stdin', subprocess.PIPE)
-    stdout = kwargs.get('stdout', subprocess.PIPE)
-    stderr = kwargs.get('stderr', subprocess.PIPE)
-    attempts = kwargs.get('attempts', 1)
+    process_input = kwargs.pop('process_input', None)
+    addl_env = kwargs.pop('addl_env', None)
+    check_exit_code = kwargs.pop('check_exit_code', 0)
+    delay_on_retry = kwargs.pop('delay_on_retry', True)
+    attempts = kwargs.pop('attempts', 1)
+    if len(kwargs):
+        raise exception.Error(_('Got unknown keyword args '
+                                'to utils.execute: %r') % kwargs)
     cmd = map(str, cmd)
 
     while attempts > 0:
@@ -149,8 +150,11 @@ def execute(*cmd, **kwargs):
             env = os.environ.copy()
             if addl_env:
                 env.update(addl_env)
-            obj = subprocess.Popen(cmd, stdin=stdin,
-                    stdout=stdout, stderr=stderr, env=env)
+            obj = subprocess.Popen(cmd,
+                                   stdin=subprocess.PIPE,
+                                   stdout=subprocess.PIPE,
+                                   stderr=subprocess.PIPE,
+                                   env=env)
             result = None
             if process_input != None:
                 result = obj.communicate(process_input)
@@ -176,7 +180,8 @@ def execute(*cmd, **kwargs):
                 raise
             else:
                 LOG.debug(_("%r failed. Retrying."), cmd)
-                greenthread.sleep(random.randint(20, 200) / 100.0)
+                if delay_on_retry:
+                    greenthread.sleep(random.randint(20, 200) / 100.0)
 
 
 def ssh_execute(ssh, cmd, process_input=None,
-- 
cgit 


From c8fc7ed48be84e3b39ab88c8c103fbe52b6718e1 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Mon, 14 Mar 2011 14:06:10 +0100
Subject: Add a unit test

---
 nova/network/linux_net.py  | 17 +++++++++++------
 nova/tests/test_network.py | 27 +++++++++++++++++++++++++++
 2 files changed, 38 insertions(+), 6 deletions(-)

(limited to 'nova')

diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index 0bcc36081..f55662a7a 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -18,7 +18,7 @@ Implements vlans, bridges, and iptables rules using linux utilities.
 """
 
 import os
-import time
+import calendar
 
 from nova import db
 from nova import exception
@@ -380,12 +380,17 @@ interface %s
 def _host_lease(fixed_ip_ref):
     """Return a host string for an address in leasefile format"""
     instance_ref = fixed_ip_ref['instance']
-    timestamp = time.mktime(instance_ref['updated_at'].timetuple())
+    if instance_ref['updated_at']:
+        timestamp = instance_ref['updated_at']
+    else:
+        timestamp = instance_ref['created_at']
+
+    seconds_since_epoch = calendar.timegm(timestamp.utctimetuple())
 
-    return "%d %s %s %s" % (timestamp + FLAGS.dhcp_lease_time,
-                            instance_ref['mac_address'],
-                            instance_ref['hostname'],
-                            fixed_ip_ref['address'])
+    return "%d %s %s %s *" % (seconds_since_epoch + FLAGS.dhcp_lease_time,
+                              instance_ref['mac_address'],
+                              fixed_ip_ref['address'],
+                              instance_ref['hostname'] or '*')
 
 
 def _host_dhcp(fixed_ip_ref):
diff --git a/nova/tests/test_network.py b/nova/tests/test_network.py
index ce1c77210..b7a76be85 100644
--- a/nova/tests/test_network.py
+++ b/nova/tests/test_network.py
@@ -20,6 +20,7 @@ Unit Tests for network code
 """
 import IPy
 import os
+import time
 
 from nova import context
 from nova import db
@@ -29,6 +30,7 @@ from nova import log as logging
 from nova import test
 from nova import utils
 from nova.auth import manager
+from nova.network import linux_net
 
 FLAGS = flags.FLAGS
 LOG = logging.getLogger('nova.tests.network')
@@ -321,6 +323,31 @@ class NetworkTestCase(test.TestCase):
                                                   network['id'])
         self.assertEqual(ip_count, num_available_ips)
 
+    def test_dhcp_lease_output(self):
+        admin_ctxt = context.get_admin_context()
+        address = self._create_address(0, self.instance_id)
+        lease_ip(address)
+        network_ref = db.network_get_by_instance(admin_ctxt, self.instance_id)
+        leases = linux_net.get_dhcp_leases(context.get_admin_context(),
+                                           network_ref['id'])
+        for line in leases.split('\n'):
+            seconds, mac, ip, hostname, client_id = line.split(' ')
+            self.assertTrue(int(seconds) > time.time(), 'Lease expires in '
+                                                        'the past')
+            octets = mac.split(':')
+            self.assertEqual(len(octets), 6, "Wrong number of octets "
+                                             "in %s" % (max,))
+            for octet in octets:
+                self.assertEqual(len(octet), 2, "Oddly sized octet: %s"
+                                                                    % (octet,))
+                # This will throw an exception if the octet is invalid
+                int(octet, 16)
+
+            # And this will raise an exception in case of an invalid IP
+            IPy.IP(ip)
+
+        release_ip(address)
+
 
 def is_allocated_in_project(address, project_id):
     """Returns true if address is in specified project"""
-- 
cgit 


From af5e752e8eb21d0e9192d9acd9e75586bdec3685 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Mon, 14 Mar 2011 11:55:55 -0500
Subject: Compute test

---
 nova/tests/test_compute.py | 25 +++++++++++++++++++++++--
 1 file changed, 23 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index c53284216..47e0f66fb 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -76,6 +76,20 @@ class ComputeTestCase(test.TestCase):
         inst.update(params)
         return db.instance_create(self.context, inst)['id']
 
+    def _create_instance_type(self, params={}):
+        """Create a test instance"""
+        inst = {}
+        inst['name'] = 'm1.small'
+        inst['memory_mb'] = '1024'
+        inst['vcpus'] = '1'
+        inst['local_gb'] = '20'
+        inst['flavorid'] = '1'
+        inst['swap'] = '2048'
+        inst['rxtx_quota'] = 100
+        inst['rxtx_cap'] = 200
+        inst.update(params)
+        return db.instance_type_create(self.context, inst)['id']
+
     def _create_group(self):
         values = {'name': 'testgroup',
                   'description': 'testgroup',
@@ -301,10 +315,17 @@ class ComputeTestCase(test.TestCase):
     def test_resize_down_fails(self):
         """Ensure invalid flavors raise"""
         instance_id = self._create_instance()
+
+        small_inst_type_id = self._create_instance_type(dict(flavorid=1,
+                memory_mb=512))
+        big_inst_type_id = self._create_instance_type(dict(flavorid=2,
+                name='m1.wowzers', memory_mb=8192))
+
         context = self.context.elevated()
         self.compute.run_instance(self.context, instance_id)
-        db.instance_update(self.context, instance_id, 
-                {'instance_type': 'm1.large'})
+        db.instance_update(self.context, instance_id,
+                {'instance_type': 'm1.wowzers',
+                 'memory_gb': 8192})
 
         self.assertRaises(exception.ApiError, self.compute_api.resize,
                 context, instance_id, 1)
-- 
cgit 


From 1f763599d733de1ded1074dee828237256eda01d Mon Sep 17 00:00:00 2001
From: "matt.dietz@rackspace.com" <>
Date: Mon, 14 Mar 2011 16:59:46 +0000
Subject: Migration moved again

---
 .../versions/010_add_flavors_to_migrations.py      | 44 ----------------------
 .../versions/011_add_flavors_to_migrations.py      | 44 ++++++++++++++++++++++
 2 files changed, 44 insertions(+), 44 deletions(-)
 delete mode 100644 nova/db/sqlalchemy/migrate_repo/versions/010_add_flavors_to_migrations.py
 create mode 100644 nova/db/sqlalchemy/migrate_repo/versions/011_add_flavors_to_migrations.py

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/migrate_repo/versions/010_add_flavors_to_migrations.py b/nova/db/sqlalchemy/migrate_repo/versions/010_add_flavors_to_migrations.py
deleted file mode 100644
index 412caedd0..000000000
--- a/nova/db/sqlalchemy/migrate_repo/versions/010_add_flavors_to_migrations.py
+++ /dev/null
@@ -1,44 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 OpenStack LLC.
-# 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.from sqlalchemy import *
-
-from sqlalchemy import *
-from migrate import *
-
-from nova import log as logging
-
-
-meta = MetaData()
-
-migrations = Table('migrations', meta,
-        Column('id', Integer(), primary_key=True, nullable=False),
-        )
-
-#
-# Tables to alter
-#
-#
-
-old_flavor_id = Column('old_flavor_id', Integer())
-new_flavor_id = Column('new_flavor_id', Integer())
-
-
-def upgrade(migrate_engine):
-    # Upgrade operations go here. Don't create your own engine;
-    # bind migrate_engine to your metadata
-    meta.bind = migrate_engine
-    migrations.create_column(old_flavor_id)
-    migrations.create_column(new_flavor_id)
diff --git a/nova/db/sqlalchemy/migrate_repo/versions/011_add_flavors_to_migrations.py b/nova/db/sqlalchemy/migrate_repo/versions/011_add_flavors_to_migrations.py
new file mode 100644
index 000000000..412caedd0
--- /dev/null
+++ b/nova/db/sqlalchemy/migrate_repo/versions/011_add_flavors_to_migrations.py
@@ -0,0 +1,44 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 OpenStack LLC.
+# 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.from sqlalchemy import *
+
+from sqlalchemy import *
+from migrate import *
+
+from nova import log as logging
+
+
+meta = MetaData()
+
+migrations = Table('migrations', meta,
+        Column('id', Integer(), primary_key=True, nullable=False),
+        )
+
+#
+# Tables to alter
+#
+#
+
+old_flavor_id = Column('old_flavor_id', Integer())
+new_flavor_id = Column('new_flavor_id', Integer())
+
+
+def upgrade(migrate_engine):
+    # Upgrade operations go here. Don't create your own engine;
+    # bind migrate_engine to your metadata
+    meta.bind = migrate_engine
+    migrations.create_column(old_flavor_id)
+    migrations.create_column(new_flavor_id)
-- 
cgit 


From 1ebae577150ce64d81d102c2e162acfe5a72528b Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Mon, 14 Mar 2011 12:07:27 -0500
Subject: Test changes

---
 nova/compute/api.py        |  2 +-
 nova/tests/test_compute.py | 15 ++++++++++++---
 2 files changed, 13 insertions(+), 4 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/api.py b/nova/compute/api.py
index 3920f2af8..9d238c7d0 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -482,7 +482,7 @@ class API(base.Base):
                     {"method": "prep_resize",
                      "args": {"topic": FLAGS.compute_topic,
                               "instance_id": instance_id,
-                              "instance_type": new_instance_type}})
+                              "flavor_id": flavor_id}})
 
     def pause(self, context, instance_id):
         """Pause the given instance."""
diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index 47e0f66fb..265421837 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -292,14 +292,18 @@ class ComputeTestCase(test.TestCase):
         """Ensure instance can be migrated/resized"""
         instance_id = self._create_instance()
         context = self.context.elevated()
+        small_inst_type_id = self._create_instance_type(dict(flavorid=1,
+                memory_mb=512, name='m1.small'))
+
         self.compute.run_instance(self.context, instance_id)
         db.instance_update(self.context, instance_id, {'host': 'foo'})
-        self.compute.prep_resize(context, instance_id)
+        self.compute.prep_resize(context, instance_id, 1)
         migration_ref = db.migration_get_by_instance_and_status(context,
                 instance_id, 'pre-migrating')
         self.compute.resize_instance(context, instance_id,
                 migration_ref['id'])
         self.compute.terminate_instance(context, instance_id)
+        self.db.instance_type_purge(context, 'm1.small')
 
     def test_resize_invalid_flavor_fails(self):
         """Ensure invalid flavors raise"""
@@ -317,7 +321,7 @@ class ComputeTestCase(test.TestCase):
         instance_id = self._create_instance()
 
         small_inst_type_id = self._create_instance_type(dict(flavorid=1,
-                memory_mb=512))
+                memory_mb=512, name='m1.small'))
         big_inst_type_id = self._create_instance_type(dict(flavorid=2,
                 name='m1.wowzers', memory_mb=8192))
 
@@ -331,6 +335,8 @@ class ComputeTestCase(test.TestCase):
                 context, instance_id, 1)
 
         self.compute.terminate_instance(context, instance_id)
+        self.db.instance_type_purge(context, 'm1.small')
+        self.db.instance_type_purge(context, 'm1.wowzers')
 
     def test_get_by_flavor_id(self):
         type = instance_types.get_by_flavor_id(1)
@@ -340,7 +346,10 @@ class ComputeTestCase(test.TestCase):
         """Ensure instance fails to migrate when source and destination are
         the same host"""
         instance_id = self._create_instance()
+        small_inst_type_id = self._create_instance_type(dict(flavorid=1,
+                memory_mb=512, name='m1.small'))
         self.compute.run_instance(self.context, instance_id)
         self.assertRaises(exception.Error, self.compute.prep_resize,
-                self.context, instance_id)
+                self.context, instance_id, 1)
         self.compute.terminate_instance(self.context, instance_id)
+        self.db.instance_type_purge(context, 'm1.small')
-- 
cgit 


From e509cd70e7a2e8a430b2b24af50adcf1ad763564 Mon Sep 17 00:00:00 2001
From: "matt.dietz@rackspace.com" <>
Date: Mon, 14 Mar 2011 17:24:39 +0000
Subject: Test fixes and some typos

---
 nova/compute/api.py        |  4 ++--
 nova/compute/manager.py    |  2 +-
 nova/db/sqlalchemy/api.py  |  4 ++--
 nova/tests/test_compute.py | 23 +++++------------------
 4 files changed, 10 insertions(+), 23 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/api.py b/nova/compute/api.py
index 9d238c7d0..0e9bf2424 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -468,13 +468,13 @@ class API(base.Base):
         instance = self.db.instance_get(context, instance_id)
         current_instance_type = self.db.instance_type_get_by_name(
             context, instance['instance_type'])
-        
+
         new_instance_type = self.db.instance_type_get_by_flavor_id(
                 context, flavor_id)
         if not new_instance_type:
             raise exception.ApiError(_("Requested flavor does not exist"))
 
-        if current_instance_type.memory_mb > new_instance_typ.memory_mb:
+        if current_instance_type['memory_mb'] > new_instance_type['memory_mb']:
             raise exception.ApiError(_("Invalid flavor: cannot downsize"
                     "instances"))
 
diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index f73e81345..57d175ec7 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -479,7 +479,7 @@ class ComputeManager(manager.Manager):
                  'source_compute': instance_ref['host'],
                  'dest_compute': FLAGS.host,
                  'dest_host':   self.driver.get_host_ip_addr(),
-                 'old_flavor_id': instance_type['flavor_id'],
+                 'old_flavor_id': instance_type['flavorid'],
                  'new_flavor_id': flavor_id,
                  'status':      'pre-migrating'})
 
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 8b541757a..50267e21f 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -2185,8 +2185,8 @@ def instance_type_create(_context, values):
         instance_type_ref = models.InstanceTypes()
         instance_type_ref.update(values)
         instance_type_ref.save()
-    except:
-        raise exception.DBError
+    except Exception, e:
+        raise exception.DBError(e)
     return instance_type_ref
 
 
diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index 265421837..a6defd644 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -78,6 +78,7 @@ class ComputeTestCase(test.TestCase):
 
     def _create_instance_type(self, params={}):
         """Create a test instance"""
+        context = self.context.elevated()
         inst = {}
         inst['name'] = 'm1.small'
         inst['memory_mb'] = '1024'
@@ -88,7 +89,7 @@ class ComputeTestCase(test.TestCase):
         inst['rxtx_quota'] = 100
         inst['rxtx_cap'] = 200
         inst.update(params)
-        return db.instance_type_create(self.context, inst)['id']
+        return db.instance_type_create(context, inst)['id']
 
     def _create_group(self):
         values = {'name': 'testgroup',
@@ -292,8 +293,6 @@ class ComputeTestCase(test.TestCase):
         """Ensure instance can be migrated/resized"""
         instance_id = self._create_instance()
         context = self.context.elevated()
-        small_inst_type_id = self._create_instance_type(dict(flavorid=1,
-                memory_mb=512, name='m1.small'))
 
         self.compute.run_instance(self.context, instance_id)
         db.instance_update(self.context, instance_id, {'host': 'foo'})
@@ -303,7 +302,6 @@ class ComputeTestCase(test.TestCase):
         self.compute.resize_instance(context, instance_id,
                 migration_ref['id'])
         self.compute.terminate_instance(context, instance_id)
-        self.db.instance_type_purge(context, 'm1.small')
 
     def test_resize_invalid_flavor_fails(self):
         """Ensure invalid flavors raise"""
@@ -311,32 +309,24 @@ class ComputeTestCase(test.TestCase):
         context = self.context.elevated()
         self.compute.run_instance(self.context, instance_id)
 
-        self.assertRaises(exception.ApiError, self.compute_api.resize,
+        self.assertRaises(exception.NotFound, self.compute_api.resize,
                 context, instance_id, 200)
 
         self.compute.terminate_instance(context, instance_id)
 
     def test_resize_down_fails(self):
         """Ensure invalid flavors raise"""
+        context = self.context.elevated()
         instance_id = self._create_instance()
 
-        small_inst_type_id = self._create_instance_type(dict(flavorid=1,
-                memory_mb=512, name='m1.small'))
-        big_inst_type_id = self._create_instance_type(dict(flavorid=2,
-                name='m1.wowzers', memory_mb=8192))
-
-        context = self.context.elevated()
         self.compute.run_instance(self.context, instance_id)
         db.instance_update(self.context, instance_id,
-                {'instance_type': 'm1.wowzers',
-                 'memory_gb': 8192})
+                {'instance_type': 'm1.xlarge'})
 
         self.assertRaises(exception.ApiError, self.compute_api.resize,
                 context, instance_id, 1)
 
         self.compute.terminate_instance(context, instance_id)
-        self.db.instance_type_purge(context, 'm1.small')
-        self.db.instance_type_purge(context, 'm1.wowzers')
 
     def test_get_by_flavor_id(self):
         type = instance_types.get_by_flavor_id(1)
@@ -346,10 +336,7 @@ class ComputeTestCase(test.TestCase):
         """Ensure instance fails to migrate when source and destination are
         the same host"""
         instance_id = self._create_instance()
-        small_inst_type_id = self._create_instance_type(dict(flavorid=1,
-                memory_mb=512, name='m1.small'))
         self.compute.run_instance(self.context, instance_id)
         self.assertRaises(exception.Error, self.compute.prep_resize,
                 self.context, instance_id, 1)
         self.compute.terminate_instance(self.context, instance_id)
-        self.db.instance_type_purge(context, 'm1.small')
-- 
cgit 


From 266ea0bdd1da014a3cf23c7003f7fc932f447d35 Mon Sep 17 00:00:00 2001
From: Naveed Massjouni <naveedm9@gmail.com>
Date: Mon, 14 Mar 2011 15:02:59 -0400
Subject: Create v1_0 and v1_1 packages for the openstack api. Added a servers
 module to each. Added tests to validate the structure of ip addresses for a
 1.1 request.

---
 nova/api/openstack/servers.py            | 28 +++++++---------------------
 nova/api/openstack/v1_0/__init__.py      |  0
 nova/api/openstack/v1_0/servers.py       |  6 ++++++
 nova/api/openstack/v1_1/__init__.py      |  0
 nova/api/openstack/v1_1/servers.py       |  8 ++++++++
 nova/tests/api/openstack/fakes.py        |  1 +
 nova/tests/api/openstack/test_servers.py | 23 +++++++++++++++++++++++
 7 files changed, 45 insertions(+), 21 deletions(-)
 create mode 100644 nova/api/openstack/v1_0/__init__.py
 create mode 100644 nova/api/openstack/v1_0/servers.py
 create mode 100644 nova/api/openstack/v1_1/__init__.py
 create mode 100644 nova/api/openstack/v1_1/servers.py

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 940c2c47e..0d36546d7 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -27,6 +27,8 @@ from nova import wsgi
 from nova import utils
 from nova.api.openstack import common
 from nova.api.openstack import faults
+from nova.api.openstack.v1_0 import servers as v1_0
+from nova.api.openstack.v1_1 import servers as v1_1
 from nova.auth import manager as auth_manager
 from nova.compute import instance_types
 from nova.compute import power_state
@@ -54,7 +56,7 @@ class Controller(wsgi.Controller):
     def ips(self, req, id):
         try:
             instance = self.compute_api.get(req.environ['nova.context'], id)
-            return _addresses_builder(req)(instance)
+            return _get_addresses_builder(req)(instance)
         except exception.NotFound:
             return faults.Fault(exc.HTTPNotFound())
 
@@ -460,7 +462,7 @@ def _build_server(req, inst, is_detail):
         inst_dict[k] = inst[v]
 
     inst_dict['status'] = power_mapping[inst_dict['status']]
-    inst_dict['addresses'] = _addresses_builder(req)(inst)
+    inst_dict['addresses'] = _get_addresses_builder(req)(inst)
 
     # Return the metadata as a dictionary
     metadata = {}
@@ -475,25 +477,9 @@ def _build_server(req, inst, is_detail):
     return dict(server=inst_dict)
 
 
-def _addresses_builder(req):
+def _get_addresses_builder(req):
     version = req.environ['nova.context'].version
     if version == '1.1':
-        return _build_addresses_11
+        return v1_1.build_addresses
     else:
-        return _build_addresses_10
-
-
-def _build_addresses_10(inst):
-    private_ips = utils.get_from_path(inst, 'fixed_ip/address')
-    public_ips = utils.get_from_path(inst, 'fixed_ip/floating_ips/address')
-    return dict(public=public_ips, private=private_ips)
-
-
-def _build_addresses_11(inst):
-    private_ips = utils.get_from_path(inst, 'fixed_ip/address')
-    private_ips = [dict(version=4, addr=a) for a in private_ips]
-    public_ips = utils.get_from_path(inst, 'fixed_ip/floating_ips/address')
-    public_ips = [dict(version=4, addr=a) for a in public_ips]
-    return dict(public=public_ips, private=private_ips)
-
-
+        return v1_0.build_addresses
diff --git a/nova/api/openstack/v1_0/__init__.py b/nova/api/openstack/v1_0/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/nova/api/openstack/v1_0/servers.py b/nova/api/openstack/v1_0/servers.py
new file mode 100644
index 000000000..d332b1378
--- /dev/null
+++ b/nova/api/openstack/v1_0/servers.py
@@ -0,0 +1,6 @@
+from nova import utils
+
+def build_addresses(inst):
+    private_ips = utils.get_from_path(inst, 'fixed_ip/address')
+    public_ips = utils.get_from_path(inst, 'fixed_ip/floating_ips/address')
+    return dict(public=public_ips, private=private_ips)
diff --git a/nova/api/openstack/v1_1/__init__.py b/nova/api/openstack/v1_1/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/nova/api/openstack/v1_1/servers.py b/nova/api/openstack/v1_1/servers.py
new file mode 100644
index 000000000..012fc3e5c
--- /dev/null
+++ b/nova/api/openstack/v1_1/servers.py
@@ -0,0 +1,8 @@
+from nova import utils
+
+def build_addresses(inst):
+    private_ips = utils.get_from_path(inst, 'fixed_ip/address')
+    private_ips = [dict(version=4, addr=a) for a in private_ips]
+    public_ips = utils.get_from_path(inst, 'fixed_ip/floating_ips/address')
+    public_ips = [dict(version=4, addr=a) for a in public_ips]
+    return dict(public=public_ips, private=private_ips)
diff --git a/nova/tests/api/openstack/fakes.py b/nova/tests/api/openstack/fakes.py
index 8ec1629f4..7af62c57f 100644
--- a/nova/tests/api/openstack/fakes.py
+++ b/nova/tests/api/openstack/fakes.py
@@ -81,6 +81,7 @@ def wsgi_app(inner_application=None):
     api = openstack.FaultWrapper(auth.AuthMiddleware(
               ratelimiting.RateLimitingMiddleware(inner_application)))
     mapper['/v1.0'] = api
+    mapper['/v1.1'] = api
     mapper['/'] = openstack.FaultWrapper(openstack.Versions())
     return mapper
 
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index c1e05b18a..a2bd875a4 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -21,6 +21,7 @@ import json
 import stubout
 import webob
 
+from nova import context
 from nova import db
 from nova import flags
 from nova import test
@@ -176,6 +177,28 @@ class ServersTest(test.TestCase):
         self.assertEqual(len(addresses["private"]), 1)
         self.assertEqual(addresses["private"][0], private)
 
+    def test_get_server_by_id_with_addresses_v1_1(self):
+        class FakeRequestContext(object):
+            def __init__(self, user, project, *args, **kwargs):
+                self.user_id = 1
+                self.project_id = 1
+                self.version = '1.1'
+        self.stubs.Set(context, 'RequestContext', FakeRequestContext)
+        private = "192.168.0.3"
+        public = ["1.2.3.4"]
+        new_return_server = return_server_with_addresses(private, public)
+        self.stubs.Set(nova.db.api, 'instance_get', new_return_server)
+        req = webob.Request.blank('/v1.1/servers/1')
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+        self.assertEqual(res_dict['server']['id'], '1')
+        self.assertEqual(res_dict['server']['name'], 'server1')
+        addresses = res_dict['server']['addresses']
+        self.assertEqual(len(addresses["public"]), len(public))
+        self.assertEqual(addresses["public"][0], {"version": 4, "addr": public[0]})
+        self.assertEqual(len(addresses["private"]), 1)
+        self.assertEqual(addresses["private"][0], {"version": 4, "addr": private})
+
     def test_get_server_list(self):
         req = webob.Request.blank('/v1.0/servers')
         res = req.get_response(fakes.wsgi_app())
-- 
cgit 


From 7fe5052f9e8dbaebce45b44a545be9707f6480a6 Mon Sep 17 00:00:00 2001
From: Rick Harris <rick.harris@rackspace.com>
Date: Mon, 14 Mar 2011 20:38:05 +0000
Subject: Adding instance_id as Glance image_property

---
 nova/compute/api.py                     |  2 +-
 nova/image/glance.py                    | 58 ++++++++++++++++++++++++++++++---
 nova/test.py                            | 31 ++++++++++++++++++
 nova/tests/api/openstack/fakes.py       | 19 +++++++++--
 nova/tests/api/openstack/test_images.py | 41 +++++++++++++++++++++++
 5 files changed, 144 insertions(+), 7 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/api.py b/nova/compute/api.py
index 61f8b2a6a..b65590ac8 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -420,7 +420,7 @@ class API(base.Base):
 
         :retval: A dict containing image metadata
         """
-        data = {'name': name, 'is_public': False}
+        data = {'name': name, 'is_public': False, 'instance_id': instance_id}
         image_meta = self.image_service.create(context, data)
         params = {'image_id': image_meta['id']}
         self._cast_compute_message('snapshot_instance', context, instance_id,
diff --git a/nova/image/glance.py b/nova/image/glance.py
index 15fca69b8..8e6ecbc43 100644
--- a/nova/image/glance.py
+++ b/nova/image/glance.py
@@ -36,6 +36,7 @@ GlanceClient = utils.import_class('glance.client.Client')
 
 class GlanceImageService(service.BaseImageService):
     """Provides storage and retrieval of disk image objects within Glance."""
+    IMAGE_PROPERTIES = ['instance_id', 'os_type']
 
     def __init__(self):
         self.client = GlanceClient(FLAGS.glance_host, FLAGS.glance_port)
@@ -57,10 +58,12 @@ class GlanceImageService(service.BaseImageService):
         Returns a dict containing image data for the given opaque image id.
         """
         try:
-            image = self.client.get_image_meta(image_id)
+            metadata = self.client.get_image_meta(image_id)
         except glance_exception.NotFound:
             raise exception.NotFound
-        return image
+
+        meta = self._depropertify_metadata_from_glance(metadata)
+        return meta
 
     def show_by_name(self, context, name):
         """
@@ -88,7 +91,9 @@ class GlanceImageService(service.BaseImageService):
             raise exception.NotFound
         for chunk in image_chunks:
             data.write(chunk)
-        return metadata
+
+        meta = self._depropertify_metadata_from_glance(metadata)
+        return meta
 
     def create(self, context, metadata, data=None):
         """
@@ -97,7 +102,12 @@ class GlanceImageService(service.BaseImageService):
         :raises AlreadyExists if the image already exist.
 
         """
-        return self.client.add_image(metadata, data)
+        LOG.debug(_("Creating image in Glance. Metdata passed in %s"),
+                  metadata)
+
+        meta = self._propertify_metadata_for_glance(metadata)
+        LOG.debug(_("Metadata after formatting for Glance %s"), meta)
+        return self.client.add_image(meta, data)
 
     def update(self, context, image_id, metadata, data=None):
         """Replace the contents of the given image with the new data.
@@ -129,3 +139,43 @@ class GlanceImageService(service.BaseImageService):
         Clears out all images
         """
         pass
+
+    @classmethod
+    def _propertify_metadata_for_glance(cls, metadata):
+        """Return a metadata dict suitable for passing to Glance.
+
+        The ImageService exposes metadata as a flat-dict; however, Glance
+        distinguishes between two different types of metadata:
+
+            1. First-class attributes: These are columns on the image table
+               and represent metadata that is common to all images on all IAAS
+               providers.
+
+            2. Properties: These are entries in the image_properties table and
+               represent image/IAAS-provider specific metadata.
+
+        To reconcile this difference, this function accepts a flat-dict of
+        metadata, figures out which attributes are stored as image properties
+        in Glance, and then adds those to a `properties` dict nested within
+        the metadata.
+        """
+        new_metadata = metadata.copy()
+        properties = {}
+        for property_ in cls.IMAGE_PROPERTIES:
+            if property_ in new_metadata:
+                value = new_metadata.pop(property_)
+                properties[property_] = value
+        new_metadata['properties'] = properties
+        return new_metadata
+
+    @classmethod
+    def _depropertify_metadata_from_glance(cls, metadata):
+        """Return a metadata dict suitable for returning from ImageService
+        """
+        new_metadata = metadata.copy()
+        properties = new_metadata.pop('properties')
+        for property_ in cls.IMAGE_PROPERTIES:
+            if property_ in properties and property_ not in new_metadata:
+                value = properties[property_]
+                new_metadata[property_] = value
+        return new_metadata
diff --git a/nova/test.py b/nova/test.py
index d8a47464f..c41551bf3 100644
--- a/nova/test.py
+++ b/nova/test.py
@@ -150,3 +150,34 @@ class TestCase(unittest.TestCase):
 
         _wrapped.func_name = self.originalAttach.func_name
         rpc.Consumer.attach_to_eventlet = _wrapped
+
+    # Useful assertions
+    def assertDictMatch(self, d1, d2):
+        """Assert two dicts are equivalent.
+
+        This is a 'deep' match in the sense that it handles nested
+        dictionaries appropriately.
+        """
+        def raise_assertion(msg):
+            d1str = str(d1)
+            d2str = str(d2)
+            base_msg = ("Dictionaries do not match. %(msg)s d1: %(d1str)s "
+                        "d2: %(d2str)s" % locals())
+            raise AssertionError(base_msg)
+
+        d1keys = set(d1.keys())
+        d2keys = set(d2.keys())
+        if d1keys != d2keys:
+            d1only = d1keys - d2keys
+            d2only = d2keys - d1keys
+            raise_assertion("Keys in d1 and not d2: %(d1only)s. "
+                            "Keys in d2 and not d1: %(d2only)s" % locals())
+
+        for key in d1keys:
+            d1value = d1[key]
+            d2value = d2[key]
+            if hasattr(d1value, 'keys') and hasattr(d2value, 'keys'):
+                self.assertDictMatch(d1value, d2value)
+            elif d1value != d2value:
+                raise_assertion("d1['%(key)s']=%(d1value)s != "
+                                "d2['%(key)s']=%(d2value)s" % locals())
diff --git a/nova/tests/api/openstack/fakes.py b/nova/tests/api/openstack/fakes.py
index e50d11a3d..1c7d926ba 100644
--- a/nova/tests/api/openstack/fakes.py
+++ b/nova/tests/api/openstack/fakes.py
@@ -132,6 +132,19 @@ def stub_out_compute_api_snapshot(stubs):
     stubs.Set(nova.compute.API, 'snapshot', snapshot)
 
 
+def stub_out_glance_add_image(stubs, sent_to_glance):
+    """
+    We return the metadata sent to glance by modifying the sent_to_glance dict
+    in place.
+    """
+    orig_add_image = glance_client.Client.add_image
+    def fake_add_image(context, metadata, data=None):
+        sent_to_glance['metadata'] = metadata
+        sent_to_glance['data'] = data
+        return orig_add_image(metadata, data)
+    stubs.Set(glance_client.Client, 'add_image', fake_add_image)
+
+
 def stub_out_glance(stubs, initial_fixtures=None):
 
     class FakeGlanceClient:
@@ -153,8 +166,10 @@ def stub_out_glance(stubs, initial_fixtures=None):
             raise glance_exc.NotFound
 
         def fake_add_image(self, image_meta, data=None):
-            id = ''.join(random.choice(string.letters) for _ in range(20))
-            image_meta['id'] = id
+            if 'id' not in image_meta:
+                image_id = ''.join(random.choice(string.letters)
+                                   for _ in range(20))
+                image_meta['id'] = image_id
             self.fixtures.append(image_meta)
             return image_meta
 
diff --git a/nova/tests/api/openstack/test_images.py b/nova/tests/api/openstack/test_images.py
index 76f758929..0e6d538f9 100644
--- a/nova/tests/api/openstack/test_images.py
+++ b/nova/tests/api/openstack/test_images.py
@@ -28,6 +28,7 @@ import tempfile
 import stubout
 import webob
 
+from glance import client as glance_client
 from nova import context
 from nova import exception
 from nova import flags
@@ -166,11 +167,51 @@ class GlanceImageServiceTest(test.TestCase,
         self.service = utils.import_object(service_class)
         self.context = context.RequestContext(None, None)
         self.service.delete_all()
+        self.sent_to_glance = {}
+        fakes.stub_out_glance_add_image(self.stubs, self.sent_to_glance)
 
     def tearDown(self):
         self.stubs.UnsetAll()
         super(GlanceImageServiceTest, self).tearDown()
 
+    def test_create_propertified_images_with_instance_id(self):
+        """
+        Some attributes are passed to Glance as image-properties (ex.
+        instance_id).
+
+        This tests asserts that the ImageService exposes them as if they were
+        first-class attribrutes, but that they are passed to Glance as image
+        properties.
+        """
+        fixture = {'id': 123, 'instance_id': 42, 'name': 'test image'}
+        image_id = self.service.create(self.context, fixture)['id']
+
+        expected = {'id': 123,
+                    'name': 'test image',
+                    'properties': {'instance_id': 42}}
+        self.assertDictMatch(self.sent_to_glance['metadata'], expected)
+
+        # The ImageService shouldn't leak the fact that the instance_id
+        # happens to be stored as a property in Glance
+        expected = {'id': 123, 'instance_id': 42, 'name': 'test image'}
+        image_meta = self.service.show(self.context, image_id)
+        self.assertDictMatch(image_meta, expected)
+
+    def test_create_propertified_images_without_instance_id(self):
+        """
+        Some attributes are passed to Glance as image-properties (ex.
+        instance_id).
+
+        This tests asserts that the ImageService exposes them as if they were
+        first-class attribrutes, but that they are passed to Glance as image
+        properties.
+        """
+        fixture = {'id': 123, 'name': 'test image'}
+        image_id = self.service.create(self.context, fixture)['id']
+
+        expected = {'id': 123, 'name': 'test image', 'properties': {}}
+        self.assertDictMatch(self.sent_to_glance['metadata'], expected)
+
 
 class ImageControllerWithGlanceServiceTest(test.TestCase):
 
-- 
cgit 


From 229c5bc3324d5df39ca959d71a540a806bc5ad3e Mon Sep 17 00:00:00 2001
From: Dan Prince <dan.prince@rackspace.com>
Date: Mon, 14 Mar 2011 16:58:03 -0400
Subject: Implement action extensions.

---
 nova/api/openstack/__init__.py                 |   1 -
 nova/api/openstack/extensions.py               | 106 +++++++++++++++++++++++++
 nova/tests/api/openstack/extensions/widgets.py |  22 +++++
 nova/tests/api/openstack/test_extensions.py    |  44 +++++++++-
 4 files changed, 170 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/__init__.py b/nova/api/openstack/__init__.py
index 9b7b76a91..8a458eea1 100644
--- a/nova/api/openstack/__init__.py
+++ b/nova/api/openstack/__init__.py
@@ -124,7 +124,6 @@ class APIRouter(wsgi.Router):
         if ext_mgr is None:
             ext_mgr = extensions.ExtensionManager(FLAGS.osapi_extensions_path)
         for resource in ext_mgr.get_resources():
-            print resource
             resource.add_routes(mapper)
 
         super(APIRouter, self).__init__(mapper)
diff --git a/nova/api/openstack/extensions.py b/nova/api/openstack/extensions.py
index 13789863b..e41de3120 100644
--- a/nova/api/openstack/extensions.py
+++ b/nova/api/openstack/extensions.py
@@ -18,11 +18,101 @@
 import imp
 import os
 import sys
+import routes
+import webob.dec
+import webob.exc
+
+from nova import flags
+from nova import log as logging
+from nova import wsgi
+
+
+LOG = logging.getLogger('extensions')
+
+
+FLAGS = flags.FLAGS
+
+
+class ExtensionActionController(wsgi.Controller):
+
+    def __init__(self, application, action_name, handler):
+
+        self.application = application
+        self.action_name = action_name
+        self.handler = handler
+
+    def action(self, req, id):
+
+        input_dict = self._deserialize(req.body, req.get_content_type())
+        if self.action_name in input_dict:
+            return self.handler(input_dict, req, id)
+        # no action handler found (bump to downstream application)
+        res = self.application
+        return res
+
+
+class ExtensionMiddleware(wsgi.Middleware):
+    """
+    Extensions middleware that intercepts configured routes for extensions.
+    """
+    @classmethod
+    def factory(cls, global_config, **local_config):
+        """ paste factory """
+        def _factory(app):
+            return cls(app, **local_config)
+        return _factory
+
+    def __init__(self, application, ext_mgr=None):
+        mapper = routes.Mapper()
+
+        if ext_mgr is None:
+            ext_mgr = ExtensionManager(FLAGS.osapi_extensions_path)
+
+        # create custom mapper connections for extended actions
+        for action in ext_mgr.get_actions():
+            controller = ExtensionActionController(application, action.name,
+                                                    action.handler)
+            mapper.connect("/%s/{id}/action.:(format)" % action.collection,
+                            action='action',
+                            controller=controller,
+                            conditions=dict(method=['POST']))
+            mapper.connect("/%s/{id}/action" % action.collection,
+                            action='action',
+                            controller=controller,
+                            conditions=dict(method=['POST']))
+
+        self._router = routes.middleware.RoutesMiddleware(self._dispatch,
+                                                          mapper)
+
+        super(ExtensionMiddleware, self).__init__(application)
+
+    @webob.dec.wsgify(RequestClass=wsgi.Request)
+    def __call__(self, req):
+        """
+        Route the incoming request with router.
+        """
+        req.environ['extended.app'] = self.application
+        return self._router
+
+    @staticmethod
+    @webob.dec.wsgify(RequestClass=wsgi.Request)
+    def _dispatch(req):
+        """
+        Called by self._router after matching the incoming request to a route
+        and putting the information into req.environ.  Either returns the
+        routed WSGI app's response or defers to the extended application.
+        """
+        match = req.environ['wsgiorg.routing_args'][1]
+        if not match:
+            return req.environ['extended.app']
+        app = match['controller']
+        return app
 
 
 class ExtensionManager(object):
 
     def __init__(self, path):
+        LOG.audit(_('Initializing extension manager.'))
 
         self.path = path
         self.extensions = []
@@ -37,6 +127,12 @@ class ExtensionManager(object):
             resources.append(ext.get_resources())
         return resources
 
+    def get_actions(self):
+        actions = []
+        for ext in self.extensions:
+            actions.extend(ext.get_actions())
+        return actions
+
     def _load_extensions(self):
         """
         Load extensions from the configured path. The extension name is
@@ -48,6 +144,7 @@ class ExtensionManager(object):
             return
 
         for f in os.listdir(self.path):
+            LOG.audit(_('Loading extension file: %s'), f)
             mod_name, file_ext = os.path.splitext(os.path.split(f)[-1])
             ext_path = os.path.join(self.path, f)
             if file_ext.lower() == '.py':
@@ -56,6 +153,15 @@ class ExtensionManager(object):
                 self.extensions.append(getattr(mod, ext_name)())
 
 
+class ExtensionAction(object):
+
+    def __init__(self, member, collection, name, handler):
+        self.member = member
+        self.collection = collection
+        self.name = name
+        self.handler = handler
+
+
 class ExtensionResource(object):
     """
     Example ExtensionResource object. All ExtensionResource objects should
diff --git a/nova/tests/api/openstack/extensions/widgets.py b/nova/tests/api/openstack/extensions/widgets.py
index e03fc7776..6839d2bb2 100644
--- a/nova/tests/api/openstack/extensions/widgets.py
+++ b/nova/tests/api/openstack/extensions/widgets.py
@@ -1,10 +1,14 @@
 from nova import wsgi
 
+from nova.api.openstack import extensions
+
+
 class WidgetsController(wsgi.Controller):
 
     def index(self, req):
         return "Buy more widgets!"
 
+
 class WidgetsExtensionResource(object):
 
     def __init__(self):
@@ -21,3 +25,21 @@ class WidgetsExtension(object):
 
     def get_resources(self):
         return WidgetsExtensionResource()
+
+    def get_actions(self):
+        actions = []
+        actions.append(extensions.ExtensionAction('server', 'servers',
+                                                    'add_widget',
+                                                    self._add_widget))
+        actions.append(extensions.ExtensionAction('server', 'servers',
+                                                    'delete_widget',
+                                                    self._delete_widget))
+        return actions
+
+    def _add_widget(self, input_dict, req, id):
+
+        return "Widget Added."
+
+    def _delete_widget(self, input_dict, req, id):
+
+        return "Widget Deleted."
diff --git a/nova/tests/api/openstack/test_extensions.py b/nova/tests/api/openstack/test_extensions.py
index ff41d6d99..f8d217e9c 100644
--- a/nova/tests/api/openstack/test_extensions.py
+++ b/nova/tests/api/openstack/test_extensions.py
@@ -15,10 +15,10 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+import json
 import unittest
-import os.path
-
 import webob
+import os.path
 
 from nova import flags
 from nova.api import openstack
@@ -26,6 +26,7 @@ import nova.wsgi
 
 FLAGS = flags.FLAGS
 
+
 class StubController(nova.wsgi.Controller):
 
     def __init__(self, body):
@@ -34,6 +35,7 @@ class StubController(nova.wsgi.Controller):
     def index(self, req):
         return self.body
 
+
 class StubExtensionManager(object):
 
     def __init__(self, resources):
@@ -42,6 +44,7 @@ class StubExtensionManager(object):
     def get_resources(self):
         return self.resources
 
+
 class WidgetExtensionResource(object):
 
     def __init__(self, name, collection, wsgi_app):
@@ -52,6 +55,7 @@ class WidgetExtensionResource(object):
     def add_routes(self, mapper):
         mapper.resource(self.name, self.collection, controller=self.wsgi_app)
 
+
 class ExtensionTest(unittest.TestCase):
 
     def test_no_extension_present(self):
@@ -99,4 +103,40 @@ class ExtensionManagerTest(unittest.TestCase):
         self.assertEqual("Buy more widgets!", response.body)
 
 
+class ExtendedActionTest(unittest.TestCase):
 
+    def setUp(self):
+        FLAGS.osapi_extensions_path = os.path.join(os.path.dirname(__file__),
+                                                    "extensions")
+
+    def test_extended_action(self):
+        app = openstack.APIRouter()
+        ext_midware = openstack.extensions.ExtensionMiddleware(app)
+        body = dict(add_widget=dict(name="test"))
+        request = webob.Request.blank("/servers/1/action")
+        request.method = 'POST'
+        request.content_type = 'application/json'
+        request.body = json.dumps(body)
+        response = request.get_response(ext_midware)
+        self.assertEqual(200, response.status_int)
+        self.assertEqual("Widget Added.", response.body)
+
+    def test_invalid_action_body(self):
+        app = openstack.APIRouter()
+        ext_midware = openstack.extensions.ExtensionMiddleware(app)
+        body = dict(blah=dict(name="test"))  # Doesn't exist
+        request = webob.Request.blank("/servers/1/action")
+        request.method = 'POST'
+        request.content_type = 'application/json'
+        request.body = json.dumps(body)
+        response = request.get_response(ext_midware)
+        self.assertEqual(501, response.status_int)
+
+    def test_invalid_action(self):
+        app = openstack.APIRouter()
+        ext_midware = openstack.extensions.ExtensionMiddleware(app)
+        request = webob.Request.blank("/asdf/1/action")
+        request.method = 'POST'
+        request.content_type = 'application/json'
+        response = request.get_response(ext_midware)
+        self.assertEqual(404, response.status_int)
-- 
cgit 


From ce57cff740bc7f821bdbb0dd1367c037b6fa1c01 Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
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')

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 <soren@linux2go.dk>
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')

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 <justin@fathomdb.com>
Date: Mon, 14 Mar 2011 14:17:58 -0700
Subject: Initial implementation of refresh instance states

---
 nova/compute/driver.py      | 38 ++++++++++++++++++++++++++++++
 nova/compute/manager.py     | 56 ++++++++++++++++++++++++++++++++++++++++++++-
 nova/compute/power_state.py | 16 +++++++++----
 nova/utils.py               |  9 ++++++++
 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 +++++-
 10 files changed, 194 insertions(+), 19 deletions(-)
 create mode 100644 nova/compute/driver.py

(limited to 'nova')

diff --git a/nova/compute/driver.py b/nova/compute/driver.py
new file mode 100644
index 000000000..bda82c60a
--- /dev/null
+++ b/nova/compute/driver.py
@@ -0,0 +1,38 @@
+# 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):
+    def list_instances_detail(self):
+        """Return a list of InstanceInfo for all registered VMs"""
+        raise NotImplementedError()
diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 0cab10fc3..057371d40 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -2,6 +2,7 @@
 
 # Copyright 2010 United States Government as represented by the
 # Administrator of the National Aeronautics and Space Administration.
+# Copyright 2011 Justin Santa Barbara
 # All Rights Reserved.
 #
 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
@@ -51,6 +52,7 @@ from nova import manager
 from nova import rpc
 from nova import utils
 from nova.compute import power_state
+from nova.compute import driver
 
 FLAGS = flags.FLAGS
 flags.DEFINE_string('instances_path', '$state_path/instances',
@@ -115,7 +117,9 @@ class ComputeManager(manager.Manager):
         #             and redocument the module docstring
         if not compute_driver:
             compute_driver = FLAGS.compute_driver
-        self.driver = utils.import_object(compute_driver)
+        self.driver = utils.check_instance(utils.import_object(
+                                                            compute_driver),
+                                           driver.ComputeDriver)
         self.network_manager = utils.import_object(FLAGS.network_manager)
         self.volume_manager = utils.import_object(FLAGS.volume_manager)
         super(ComputeManager, self).__init__(*args, **kwargs)
@@ -974,3 +978,53 @@ class ComputeManager(manager.Manager):
 
         for volume in instance_ref['volumes']:
             self.db.volume_update(ctxt, volume['id'], {'status': 'in-use'})
+
+    def periodic_tasks(self, context=None):
+        """Tasks to be run at a periodic interval."""
+        super(ComputeManager, self).periodic_tasks(context)
+        try:
+            self._poll_instance_states(context)
+        except Exception as ex:
+            LOG.warning(_("Error during instance poll: %s"),
+                        unicode(ex))
+
+    def _poll_instance_states(self, context):
+        vm_instances = self.driver.list_instances_detail(context)
+        vm_instances = dict((vm.name, vm) for vm in vm_instances)
+
+        # Keep a list of VMs not in the DB, cross them off as we find them
+        vms_not_found_in_db = [vm.name for vm in vm_instances]
+
+        db_instances = self.db.instance_get_all_by_host(context, self.host)
+        for db_instance in db_instances:
+            name = db_instance['name']
+            vm_instance = vm_instances.get(name)
+            if vm_instance is None:
+                LOG.info(_("Found instance '%(name)' in DB but no VM. "
+                           "Shutting off.") % locals())
+                vm_state = power_state.SHUTOFF
+            else:
+                vm_state = vm_instance.state
+                vms_not_found_in_db.remove(name)
+
+            db_state = db_instance['state']
+            if vm_state != db_state:
+                LOG.info(_("DB/VM state mismatch. Changing state from "
+                           "%(db_state) to %(vm_state)") % locals())
+                self.db.instance_set_state(context,
+                                           db_instance['id'],
+                                           vm_state)
+
+            if vm_state == power_state.SHUTOFF:
+                # TODO(soren): This is what the compute manager does when you
+                # terminate an instance. At some point I figure we'll have a
+                # "terminated" state and some sort of cleanup job that runs
+                # occasionally, cleaning them out.
+                self.db.instance_destroy(context, db_instance['id'])
+
+        # Are there VMs not in the DB?
+        for vm_not_found_in_db in vms_not_found_in_db:
+            name = vm_not_found_in_db
+            #TODO(justinsb): What to do here?  Adopt it?  Shut it down?
+            LOG.warning(_("Found VM not in DB: %(name).  Ignoring")
+                        % locals())
diff --git a/nova/compute/power_state.py b/nova/compute/power_state.py
index adfc2dff0..145362f97 100644
--- a/nova/compute/power_state.py
+++ b/nova/compute/power_state.py
@@ -2,6 +2,7 @@
 
 # Copyright 2010 United States Government as represented by the
 # Administrator of the National Aeronautics and Space Administration.
+# Copyright 2011 Justin Santa Barbara
 # All Rights Reserved.
 # Copyright (c) 2010 Citrix Systems, Inc.
 #
@@ -19,6 +20,7 @@
 
 """The various power states that a VM can be in."""
 
+#NOTE(justinsb): These are the virDomainState values from libvirt
 NOSTATE = 0x00
 RUNNING = 0x01
 BLOCKED = 0x02
@@ -29,9 +31,8 @@ CRASHED = 0x06
 SUSPENDED = 0x07
 FAILED = 0x08
 
-
-def name(code):
-    d = {
+#TODO(justinsb): Power state really needs to be a proper class...
+_STATE_MAP = {
         NOSTATE: 'pending',
         RUNNING: 'running',
         BLOCKED: 'blocked',
@@ -41,4 +42,11 @@ def name(code):
         CRASHED: 'crashed',
         SUSPENDED: 'suspended',
         FAILED: 'failed to spawn'}
-    return d[code]
+
+
+def name(code):
+    return _STATE_MAP[code]
+
+
+def valid_states():
+    return _STATE_MAP.values()
diff --git a/nova/utils.py b/nova/utils.py
index 87e726394..e93f489be 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -585,3 +585,12 @@ def get_from_path(items, path):
         return results
     else:
         return get_from_path(results, remainder)
+
+
+def check_instance(obj, cls):
+    """Checks that obj is of type cls, and lets PyLint infer types"""
+    if isinstance(obj, cls):
+        return obj
+    raise Exception(_("Expected object of type: %s") % (str(cls)))
+    #TODO(justinsb): Can we make this better??
+    return cls()  # Ugly PyLint hack
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 <josh.kearney@rackspace.com>
Date: Mon, 14 Mar 2011 16:21:33 -0500
Subject: PEP8 cleanup

---
 nova/tests/db/fakes.py       |  4 ++--
 nova/tests/test_xenapi.py    | 11 +++++------
 nova/virt/xenapi/vm_utils.py |  3 +--
 3 files changed, 8 insertions(+), 10 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/db/fakes.py b/nova/tests/db/fakes.py
index 142f6b1c6..5e9a3aa3b 100644
--- a/nova/tests/db/fakes.py
+++ b/nova/tests/db/fakes.py
@@ -77,8 +77,8 @@ def stub_out_db_instance_api(stubs):
             'mac_address': values['mac_address'],
             'vcpus': type_data['vcpus'],
             'local_gb': type_data['local_gb'],
-            'os_type': values['os_type']
-            }
+            'os_type': values['os_type']}
+
         return FakeModel(base_options)
 
     def fake_network_get_by_instance(context, instance_id):
diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index cd125a301..8b0affd5c 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -78,8 +78,7 @@ class XenAPIVolumeTestCase(test.TestCase):
                   'ramdisk_id': 3,
                   'instance_type': 'm1.large',
                   'mac_address': 'aa:bb:cc:dd:ee:ff',
-                  'os_type': 'linux'
-                  }
+                  'os_type': 'linux'}
 
     def _create_volume(self, size='0'):
         """Create a volume object."""
@@ -315,8 +314,8 @@ class XenAPIVMTestCase(test.TestCase):
                   'ramdisk_id': ramdisk_id,
                   'instance_type': instance_type,
                   'mac_address': 'aa:bb:cc:dd:ee:ff',
-                  'os_type': os_type
-                  }
+                  'os_type': os_type}
+
         conn = xenapi_conn.get_connection(False)
         instance = db.instance_create(values)
         conn.spawn(instance)
@@ -440,8 +439,8 @@ class XenAPIMigrateInstance(test.TestCase):
                   'ramdisk_id': None,
                   'instance_type': 'm1.large',
                   'mac_address': 'aa:bb:cc:dd:ee:ff',
-                  'os_type': 'linux'
-                  }
+                  'os_type': 'linux'}
+
         stubs.stub_out_migration_methods(self.stubs)
         glance_stubs.stubout_glance_client(self.stubs,
                                            glance_stubs.FakeGlance)
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 7c6aa5eb302637dde0d800f7155235858bbabbeb Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Mon, 14 Mar 2011 14:32:15 -0700
Subject: Removed duplicated test, renamed same-named (but non-identical) tests

---
 nova/tests/test_compute.py | 15 ++-------------
 1 file changed, 2 insertions(+), 13 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index e486050be..14559d1dc 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -115,7 +115,7 @@ class ComputeTestCase(test.TestCase):
             finally:
                 db.instance_destroy(self.context, ref[0]['id'])
 
-    def test_create_instance_associates_security_groups(self):
+    def test_create_instance_associates_security_groups_1(self):
         """Make sure create associates security groups"""
         group = self._create_group()
         instance_ref = models.Instance()
@@ -124,18 +124,7 @@ class ComputeTestCase(test.TestCase):
         instance_ref['hostname'] = 'i-00000001'
         return instance_ref
 
-    def test_create_instance_defaults_display_name(self):
-        """Verify that an instance cannot be created without a display_name."""
-        cases = [dict(), dict(display_name=None)]
-        for instance in cases:
-            ref = self.compute_api.create(self.context,
-                FLAGS.default_instance_type, None, **instance)
-            try:
-                self.assertNotEqual(ref[0]['display_name'], None)
-            finally:
-                db.instance_destroy(self.context, ref[0]['id'])
-
-    def test_create_instance_associates_security_groups(self):
+    def test_create_instance_associates_security_groups_2(self):
         """Make sure create associates security groups"""
         group = self._create_group()
         ref = self.compute_api.create(
-- 
cgit 


From 5a0d4fbc24e897e4aa861819fd2f861e7dedcb6b Mon Sep 17 00:00:00 2001
From: Trey Morris <trey.morris@rackspace.com>
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')

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 <justin@fathomdb.com>
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')

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 <trey.morris@rackspace.com>
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')

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 <tushar.vitthal.patil@gmail.com>
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')

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 <justin@fathomdb.com>
Date: Mon, 14 Mar 2011 15:11:14 -0700
Subject: Added test and fixed up code so that it works

---
 nova/compute/manager.py    | 16 +++++++++++-----
 nova/tests/test_compute.py | 21 +++++++++++++++++++++
 nova/virt/fake.py          |  6 +++++-
 3 files changed, 37 insertions(+), 6 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 057371d40..a7727a239 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -981,26 +981,32 @@ class ComputeManager(manager.Manager):
 
     def periodic_tasks(self, context=None):
         """Tasks to be run at a periodic interval."""
-        super(ComputeManager, self).periodic_tasks(context)
+        error_list = super(ComputeManager, self).periodic_tasks(context)
+        if error_list is None:
+            error_list = []
+
         try:
             self._poll_instance_states(context)
         except Exception as ex:
             LOG.warning(_("Error during instance poll: %s"),
                         unicode(ex))
+            error_list.append(ex)
+        return error_list
 
     def _poll_instance_states(self, context):
-        vm_instances = self.driver.list_instances_detail(context)
+        vm_instances = self.driver.list_instances_detail()
         vm_instances = dict((vm.name, vm) for vm in vm_instances)
 
         # Keep a list of VMs not in the DB, cross them off as we find them
         vms_not_found_in_db = [vm.name for vm in vm_instances]
 
         db_instances = self.db.instance_get_all_by_host(context, self.host)
+
         for db_instance in db_instances:
             name = db_instance['name']
             vm_instance = vm_instances.get(name)
             if vm_instance is None:
-                LOG.info(_("Found instance '%(name)' in DB but no VM. "
+                LOG.info(_("Found instance '%(name)s' in DB but no VM. "
                            "Shutting off.") % locals())
                 vm_state = power_state.SHUTOFF
             else:
@@ -1010,7 +1016,7 @@ class ComputeManager(manager.Manager):
             db_state = db_instance['state']
             if vm_state != db_state:
                 LOG.info(_("DB/VM state mismatch. Changing state from "
-                           "%(db_state) to %(vm_state)") % locals())
+                           "'%(db_state)s' to '%(vm_state)s'") % locals())
                 self.db.instance_set_state(context,
                                            db_instance['id'],
                                            vm_state)
@@ -1026,5 +1032,5 @@ class ComputeManager(manager.Manager):
         for vm_not_found_in_db in vms_not_found_in_db:
             name = vm_not_found_in_db
             #TODO(justinsb): What to do here?  Adopt it?  Shut it down?
-            LOG.warning(_("Found VM not in DB: %(name).  Ignoring")
+            LOG.warning(_("Found VM not in DB: '%(name)s'.  Ignoring")
                         % locals())
diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index e486050be..b9d0aa0b6 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -595,3 +595,24 @@ class ComputeTestCase(test.TestCase):
         db.instance_destroy(c, instance_id)
         db.volume_destroy(c, v_ref['id'])
         db.floating_ip_destroy(c, flo_addr)
+
+    def test_run_kill_vm(self):
+        """Detect when a vm is terminated behind the scenes"""
+        instance_id = self._create_instance()
+
+        self.compute.run_instance(self.context, instance_id)
+
+        instances = db.instance_get_all(context.get_admin_context())
+        LOG.info(_("Running instances: %s"), instances)
+        self.assertEqual(len(instances), 1)
+
+        instance_name = instances[0].name
+        self.compute.driver.test_remove_vm(instance_name)
+
+        # Force the compute manager to do its periodic poll
+        error_list = self.compute.periodic_tasks(context.get_admin_context())
+        self.assertFalse(error_list)
+
+        instances = db.instance_get_all(context.get_admin_context())
+        LOG.info(_("After force-killing instances: %s"), instances)
+        self.assertEqual(len(instances), 0)
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 567e3bc3a7e66896482d83420190a7c4a8df1e5a Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Mon, 14 Mar 2011 15:17:00 -0700
Subject: So the first of those tests doesn't pass.  Removing as it looks like
 it was meant to be deleted.

---
 nova/tests/test_compute.py | 11 +----------
 1 file changed, 1 insertion(+), 10 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index 14559d1dc..3651f4cef 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -115,16 +115,7 @@ class ComputeTestCase(test.TestCase):
             finally:
                 db.instance_destroy(self.context, ref[0]['id'])
 
-    def test_create_instance_associates_security_groups_1(self):
-        """Make sure create associates security groups"""
-        group = self._create_group()
-        instance_ref = models.Instance()
-        instance_ref['id'] = 1
-        instance_ref['volumes'] = [{'id': 1}, {'id': 2}]
-        instance_ref['hostname'] = 'i-00000001'
-        return instance_ref
-
-    def test_create_instance_associates_security_groups_2(self):
+    def test_create_instance_associates_security_groups(self):
         """Make sure create associates security groups"""
         group = self._create_group()
         ref = self.compute_api.create(
-- 
cgit 


From 9f135cc4d6069a0b882c8e848d3b6cb292002d10 Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
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')

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 9dce9ee5fe5a1df018b9a606a3ea35b2dbfc987e Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Mon, 14 Mar 2011 15:37:29 -0700
Subject: Clarified message when a VM is not running but still in DB

---
 nova/compute/manager.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index a7727a239..019bb3c89 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -1007,7 +1007,7 @@ class ComputeManager(manager.Manager):
             vm_instance = vm_instances.get(name)
             if vm_instance is None:
                 LOG.info(_("Found instance '%(name)s' in DB but no VM. "
-                           "Shutting off.") % locals())
+                           "Setting state to shutoff.") % locals())
                 vm_state = power_state.SHUTOFF
             else:
                 vm_state = vm_instance.state
-- 
cgit 


From a56a973e9d839df5bcd956126300afd7df4c2fe9 Mon Sep 17 00:00:00 2001
From: Rick Harris <rick.harris@rackspace.com>
Date: Tue, 15 Mar 2011 00:37:13 +0000
Subject: Fixing API per spec, to get unit-tests to pass

---
 nova/api/openstack/images.py            | 118 +++++++++++++++++++++++++++++---
 nova/image/glance.py                    |  20 +++---
 nova/test.py                            |  26 +++++++
 nova/tests/api/openstack/fakes.py       |  13 ++--
 nova/tests/api/openstack/test_images.py |  93 +++++++++++++------------
 5 files changed, 204 insertions(+), 66 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/images.py b/nova/api/openstack/images.py
index 98f0dd96b..7b3800429 100644
--- a/nova/api/openstack/images.py
+++ b/nova/api/openstack/images.py
@@ -15,10 +15,13 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+import datetime
+
 from webob import exc
 
 from nova import compute
 from nova import flags
+from nova import log
 from nova import utils
 from nova import wsgi
 import nova.api.openstack
@@ -27,6 +30,8 @@ from nova.api.openstack import faults
 import nova.image.service
 
 
+LOG = log.getLogger('nova.api.openstack.images')
+
 FLAGS = flags.FLAGS
 
 
@@ -84,8 +89,6 @@ def _translate_status(item):
         # S3ImageService
         pass
 
-    return item
-
 
 def _filter_keys(item, keys):
     """
@@ -104,6 +107,89 @@ def _convert_image_id_to_hash(image):
         image['id'] = image_id
 
 
+def _translate_s3_like_images(image_metadata):
+    """Work-around for leaky S3ImageService abstraction"""
+    api_metadata = image_metadata.copy()
+    _convert_image_id_to_hash(api_metadata)
+    api_metadata = _translate_keys(api_metadata)
+    _translate_status(api_metadata)
+    return api_metadata
+
+
+def _translate_metadata_for_api_detail(image_metadata):
+    """Translate from ImageService to OpenStack API style attribute names
+
+    This involves 3 steps:
+
+        1. Translating required keys
+
+        2. Translating optional keys (ex. progress, serverId)
+
+        3. Formatting values according to API spec (for example dates must
+           look like "2010-08-10T12:00:00Z")
+    """
+    service_metadata = image_metadata.copy()
+    api_metadata = {}
+
+    # 1. Translate required keys
+    required_image_service2api = {
+        'id': 'id',
+        'name': 'name',
+        'updated_at': 'updated',
+        'created_at': 'created',
+        'status': 'status'}
+    for service_attr, api_attr in required_image_service2api.items():
+        api_metadata[api_attr] = service_metadata[service_attr]
+
+    # 2. Translate optional keys
+    optional_image_service2api = {'instance_id': 'serverId'}
+    for service_attr, api_attr in optional_image_service2api.items():
+        if service_attr in service_metadata:
+            api_metadata[api_attr] = service_metadata[service_attr]
+
+    # 2a. Progress special case
+    # TODO(sirp): ImageService doesn't have a notion of progress yet, so for
+    # now just fake it
+    if service_metadata['status'] == 'saving':
+        api_metadata['progress'] = 0
+
+    # 3. Format values
+
+    # 3a. Format Image Status (API requires uppercase)
+    status_service2api = {'queued': 'QUEUED',
+                          'preparing': 'PREPARING',
+                          'saving': 'SAVING',
+                          'active': 'ACTIVE',
+                          'killed': 'FAILED'}
+    api_metadata['status'] = status_service2api[api_metadata['status']]
+
+    # 3b. Format timestamps
+    def _format_timestamp(dt_str):
+        """Return a timestamp formatted for OpenStack API
+
+        NOTE(sirp):
+
+        ImageService (specifically GlanceImageService) is currently
+        returning timestamps as strings. This should probably be datetime
+        objects. In the mean time, we work around this by using strptime() to
+        create datetime objects.
+        """
+        if dt_str is None:
+            return None
+
+        service_timestamp_fmt = "%Y-%m-%dT%H:%M:%S"
+        api_timestamp_fmt = "%Y-%m-%dT%H:%M:%SZ"
+        dt = datetime.datetime.strptime(dt_str, service_timestamp_fmt)
+        return dt.strftime(api_timestamp_fmt)
+
+    for ts_attr in ('created', 'updated'):
+        if ts_attr in api_metadata:
+            formatted_timestamp = _format_timestamp(api_metadata[ts_attr])
+            api_metadata[ts_attr] = formatted_timestamp
+
+    return api_metadata
+
+
 class Controller(wsgi.Controller):
 
     _serialization_metadata = {
@@ -125,16 +211,28 @@ class Controller(wsgi.Controller):
     def detail(self, req):
         """Return all public images in detail"""
         try:
-            items = self._service.detail(req.environ['nova.context'])
+            service_image_metas = self._service.detail(
+                req.environ['nova.context'])
         except NotImplementedError:
-            items = self._service.index(req.environ['nova.context'])
-        for image in items:
-            _convert_image_id_to_hash(image)
+            service_image_metas = self._service.index(
+                req.environ['nova.context'])
 
-        items = common.limited(items, req)
-        items = [_translate_keys(item) for item in items]
-        items = [_translate_status(item) for item in items]
-        return dict(images=items)
+        service_image_metas = common.limited(service_image_metas, req)
+
+        # FIXME(sirp): The S3ImageService appears to be leaking implementation
+        # details, including its internal attribute names, and internal
+        # `status` values. Working around it for now.
+        s3_like_image = (service_image_metas and
+                         ('imageId' in service_image_metas[0]))
+        if s3_like_image:
+            translate = _translate_s3_like_images
+        else:
+            translate = _translate_metadata_for_api_detail
+
+        api_image_metas = [translate(service_image_meta)
+                           for service_image_meta in service_image_metas]
+
+        return dict(images=api_image_metas)
 
     def show(self, req, id):
         """Return data about the given image id"""
diff --git a/nova/image/glance.py b/nova/image/glance.py
index 8e6ecbc43..63a3faa0f 100644
--- a/nova/image/glance.py
+++ b/nova/image/glance.py
@@ -22,12 +22,12 @@ from glance.common import exception as glance_exception
 
 from nova import exception
 from nova import flags
-from nova import log as logging
+from nova import log
 from nova import utils
 from nova.image import service
 
 
-LOG = logging.getLogger('nova.image.glance')
+LOG = log.getLogger('nova.image.glance')
 
 FLAGS = flags.FLAGS
 
@@ -51,7 +51,10 @@ class GlanceImageService(service.BaseImageService):
         """
         Calls out to Glance for a list of detailed image information
         """
-        return self.client.get_images_detailed()
+        image_metas = self.client.get_images_detailed()
+        return image_metas
+        return [self._depropertify_metadata_from_glance(image_meta)
+                for image_meta in image_metas]
 
     def show(self, context, image_id):
         """
@@ -173,9 +176,10 @@ class GlanceImageService(service.BaseImageService):
         """Return a metadata dict suitable for returning from ImageService
         """
         new_metadata = metadata.copy()
-        properties = new_metadata.pop('properties')
-        for property_ in cls.IMAGE_PROPERTIES:
-            if property_ in properties and property_ not in new_metadata:
-                value = properties[property_]
-                new_metadata[property_] = value
+        if 'properties' in new_metadata:
+            properties = new_metadata.pop('properties')
+            for property_ in cls.IMAGE_PROPERTIES:
+                if property_ in properties and property_ not in new_metadata:
+                    value = properties[property_]
+                    new_metadata[property_] = value
         return new_metadata
diff --git a/nova/test.py b/nova/test.py
index c41551bf3..e0fef6101 100644
--- a/nova/test.py
+++ b/nova/test.py
@@ -157,6 +157,12 @@ class TestCase(unittest.TestCase):
 
         This is a 'deep' match in the sense that it handles nested
         dictionaries appropriately.
+
+        NOTE:
+
+            If you don't care (or don't know) a given value, you can specify
+            the string DONTCARE as the value. This will cause that dict-item
+            to be skipped.
         """
         def raise_assertion(msg):
             d1str = str(d1)
@@ -178,6 +184,26 @@ class TestCase(unittest.TestCase):
             d2value = d2[key]
             if hasattr(d1value, 'keys') and hasattr(d2value, 'keys'):
                 self.assertDictMatch(d1value, d2value)
+            elif 'DONTCARE' in (d1value, d2value):
+                continue
             elif d1value != d2value:
                 raise_assertion("d1['%(key)s']=%(d1value)s != "
                                 "d2['%(key)s']=%(d2value)s" % locals())
+
+    def assertDictListMatch(self, L1, L2):
+        """Assert a list of dicts are equivalent"""
+        def raise_assertion(msg):
+            L1str = str(L1)
+            L2str = str(L2)
+            base_msg = ("List of dictionaries do not match: %(msg)s "
+                        "L1: %(L1str)s L2: %(L2str)s" % locals())
+            raise AssertionError(base_msg)
+
+        L1count = len(L1)
+        L2count = len(L2)
+        if L1count != L2count:
+            raise_assertion("Length mismatch: len(L1)=%(L1count)d != "
+                            "len(L2)=%(L2count)d" % locals())
+
+        for d1, d2 in zip(L1, L2):
+            self.assertDictMatch(d1, d2)
diff --git a/nova/tests/api/openstack/fakes.py b/nova/tests/api/openstack/fakes.py
index 1c7d926ba..ef38b93ca 100644
--- a/nova/tests/api/openstack/fakes.py
+++ b/nova/tests/api/openstack/fakes.py
@@ -138,10 +138,12 @@ def stub_out_glance_add_image(stubs, sent_to_glance):
     in place.
     """
     orig_add_image = glance_client.Client.add_image
+
     def fake_add_image(context, metadata, data=None):
         sent_to_glance['metadata'] = metadata
         sent_to_glance['data'] = data
         return orig_add_image(metadata, data)
+
     stubs.Set(glance_client.Client, 'add_image', fake_add_image)
 
 
@@ -166,10 +168,13 @@ def stub_out_glance(stubs, initial_fixtures=None):
             raise glance_exc.NotFound
 
         def fake_add_image(self, image_meta, data=None):
-            if 'id' not in image_meta:
-                image_id = ''.join(random.choice(string.letters)
-                                   for _ in range(20))
-                image_meta['id'] = image_id
+            if 'id' in image_meta:
+                raise Exception(
+                    _("Cannot set id attribute for Glance image: %s")
+                    % image_meta)
+            image_id = ''.join(random.choice(string.letters)
+                               for _ in range(20))
+            image_meta['id'] = image_id
             self.fixtures.append(image_meta)
             return image_meta
 
diff --git a/nova/tests/api/openstack/test_images.py b/nova/tests/api/openstack/test_images.py
index 0e6d538f9..9b4b5832a 100644
--- a/nova/tests/api/openstack/test_images.py
+++ b/nova/tests/api/openstack/test_images.py
@@ -156,7 +156,7 @@ class LocalImageServiceTest(test.TestCase,
 class GlanceImageServiceTest(test.TestCase,
                              BaseImageServiceTests):
 
-    """Tests the local image service"""
+    """Tests the Glance image service"""
 
     def setUp(self):
         super(GlanceImageServiceTest, self).setUp()
@@ -183,20 +183,23 @@ class GlanceImageServiceTest(test.TestCase,
         first-class attribrutes, but that they are passed to Glance as image
         properties.
         """
-        fixture = {'id': 123, 'instance_id': 42, 'name': 'test image'}
+        fixture = {'instance_id': 42, 'name': 'test image'}
         image_id = self.service.create(self.context, fixture)['id']
 
-        expected = {'id': 123,
+        expected = {'id': image_id,
                     'name': 'test image',
                     'properties': {'instance_id': 42}}
         self.assertDictMatch(self.sent_to_glance['metadata'], expected)
 
         # The ImageService shouldn't leak the fact that the instance_id
         # happens to be stored as a property in Glance
-        expected = {'id': 123, 'instance_id': 42, 'name': 'test image'}
+        expected = {'id': image_id, 'instance_id': 42, 'name': 'test image'}
         image_meta = self.service.show(self.context, image_id)
         self.assertDictMatch(image_meta, expected)
 
+        #image_metas = self.service.detail(self.context)
+        #self.assertDictMatch(image_metas[0], expected)
+
     def test_create_propertified_images_without_instance_id(self):
         """
         Some attributes are passed to Glance as image-properties (ex.
@@ -206,10 +209,10 @@ class GlanceImageServiceTest(test.TestCase,
         first-class attribrutes, but that they are passed to Glance as image
         properties.
         """
-        fixture = {'id': 123, 'name': 'test image'}
+        fixture = {'name': 'test image'}
         image_id = self.service.create(self.context, fixture)['id']
 
-        expected = {'id': 123, 'name': 'test image', 'properties': {}}
+        expected = {'id': image_id, 'name': 'test image', 'properties': {}}
         self.assertDictMatch(self.sent_to_glance['metadata'], expected)
 
 
@@ -217,29 +220,39 @@ class ImageControllerWithGlanceServiceTest(test.TestCase):
 
     """Test of the OpenStack API /images application controller"""
 
-    # Registered images at start of each test.
+    # FIXME(sirp): The ImageService and API use two different formats for
+    # timestamps. Ultimately, the ImageService should probably use datetime
+    # objects
+    NOW_SERVICE_STR = "2010-10-11T10:30:22"
+    NOW_API_STR = "2010-10-11T10:30:22Z"
 
     IMAGE_FIXTURES = [
-        {'id': '23g2ogk23k4hhkk4k42l',
-         'imageId': '23g2ogk23k4hhkk4k42l',
+        {'id': 123,
          'name': 'public image #1',
-         'created_at': str(datetime.datetime.utcnow()),
-         'updated_at': str(datetime.datetime.utcnow()),
+         'created_at': NOW_SERVICE_STR,
+         'updated_at': NOW_SERVICE_STR,
          'deleted_at': None,
          'deleted': False,
          'is_public': True,
-         'status': 'available',
-         'image_type': 'kernel'},
-        {'id': 'slkduhfas73kkaskgdas',
-         'imageId': 'slkduhfas73kkaskgdas',
+         'status': 'saving'},
+        {'id': 124,
          'name': 'public image #2',
-         'created_at': str(datetime.datetime.utcnow()),
-         'updated_at': str(datetime.datetime.utcnow()),
+         'created_at': NOW_SERVICE_STR,
+         'updated_at': NOW_SERVICE_STR,
+         'deleted_at': None,
+         'deleted': False,
+         'is_public': True,
+         'status': 'active',
+         'instance_id': 42},
+        {'id': 125,
+         'name': 'public image #3',
+         'created_at': NOW_SERVICE_STR,
+         'updated_at': NOW_SERVICE_STR,
          'deleted_at': None,
          'deleted': False,
          'is_public': True,
-         'status': 'available',
-         'image_type': 'ramdisk'}]
+         'status': 'killed',
+         'instance_id': 42}]
 
     def setUp(self):
         super(ImageControllerWithGlanceServiceTest, self).setUp()
@@ -262,34 +275,26 @@ class ImageControllerWithGlanceServiceTest(test.TestCase):
     def test_get_image_index(self):
         req = webob.Request.blank('/v1.0/images')
         res = req.get_response(fakes.wsgi_app())
-        res_dict = json.loads(res.body)
+        image_metas = json.loads(res.body)['images']
 
-        fixture_index = [dict(id=f['id'], name=f['name']) for f
-                         in self.IMAGE_FIXTURES]
+        expected = [{'id': 123, 'name': 'public image #1'},
+                    {'id': 124, 'name': 'public image #2'},
+                    {'id': 125, 'name': 'public image #3'}]
 
-        for image in res_dict['images']:
-            self.assertEquals(1, fixture_index.count(image),
-                              "image %s not in fixture index!" % str(image))
+        self.assertDictListMatch(image_metas, expected)
 
     def test_get_image_details(self):
         req = webob.Request.blank('/v1.0/images/detail')
         res = req.get_response(fakes.wsgi_app())
-        res_dict = json.loads(res.body)
-
-        def _is_equivalent_subset(x, y):
-            if set(x) <= set(y):
-                for k, v in x.iteritems():
-                    if x[k] != y[k]:
-                        if x[k] == 'active' and y[k] == 'available':
-                            continue
-                        return False
-                return True
-            return False
-
-        for image in res_dict['images']:
-            for image_fixture in self.IMAGE_FIXTURES:
-                if _is_equivalent_subset(image, image_fixture):
-                    break
-            else:
-                self.assertEquals(1, 2, "image %s not in fixtures!" %
-                                                            str(image))
+        image_metas = json.loads(res.body)['images']
+
+        expected = [
+            {'id': 123, 'name': 'public image #1', 'updated': self.NOW_API_STR,
+             'created': self.NOW_API_STR, 'status': 'SAVING', 'progress': 0},
+            {'id': 124, 'name': 'public image #2', 'updated': self.NOW_API_STR,
+             'created': self.NOW_API_STR, 'status': 'ACTIVE', 'serverId': 42},
+            {'id': 125, 'name': 'public image #3', 'updated': self.NOW_API_STR,
+             'created': self.NOW_API_STR, 'status': 'FAILED', 'serverId': 42},
+        ]
+
+        self.assertDictListMatch(image_metas, expected)
-- 
cgit 


From b5a6e343bb6a15e652b3a6924e1809a04a0eb421 Mon Sep 17 00:00:00 2001
From: Rick Harris <rick.harris@rackspace.com>
Date: Tue, 15 Mar 2011 01:14:58 +0000
Subject: Moving fixtures to a factory

---
 nova/tests/api/openstack/test_images.py | 109 +++++++++++++++++++++-----------
 1 file changed, 71 insertions(+), 38 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/test_images.py b/nova/tests/api/openstack/test_images.py
index 9b4b5832a..47cb7e74c 100644
--- a/nova/tests/api/openstack/test_images.py
+++ b/nova/tests/api/openstack/test_images.py
@@ -226,34 +226,6 @@ class ImageControllerWithGlanceServiceTest(test.TestCase):
     NOW_SERVICE_STR = "2010-10-11T10:30:22"
     NOW_API_STR = "2010-10-11T10:30:22Z"
 
-    IMAGE_FIXTURES = [
-        {'id': 123,
-         'name': 'public image #1',
-         'created_at': NOW_SERVICE_STR,
-         'updated_at': NOW_SERVICE_STR,
-         'deleted_at': None,
-         'deleted': False,
-         'is_public': True,
-         'status': 'saving'},
-        {'id': 124,
-         'name': 'public image #2',
-         'created_at': NOW_SERVICE_STR,
-         'updated_at': NOW_SERVICE_STR,
-         'deleted_at': None,
-         'deleted': False,
-         'is_public': True,
-         'status': 'active',
-         'instance_id': 42},
-        {'id': 125,
-         'name': 'public image #3',
-         'created_at': NOW_SERVICE_STR,
-         'updated_at': NOW_SERVICE_STR,
-         'deleted_at': None,
-         'deleted': False,
-         'is_public': True,
-         'status': 'killed',
-         'instance_id': 42}]
-
     def setUp(self):
         super(ImageControllerWithGlanceServiceTest, self).setUp()
         self.orig_image_service = FLAGS.image_service
@@ -265,7 +237,8 @@ class ImageControllerWithGlanceServiceTest(test.TestCase):
         fakes.stub_out_rate_limiting(self.stubs)
         fakes.stub_out_auth(self.stubs)
         fakes.stub_out_key_pair_funcs(self.stubs)
-        fakes.stub_out_glance(self.stubs, initial_fixtures=self.IMAGE_FIXTURES)
+        fixtures = self._make_image_fixtures()
+        fakes.stub_out_glance(self.stubs, initial_fixtures=fixtures)
 
     def tearDown(self):
         self.stubs.UnsetAll()
@@ -277,9 +250,11 @@ class ImageControllerWithGlanceServiceTest(test.TestCase):
         res = req.get_response(fakes.wsgi_app())
         image_metas = json.loads(res.body)['images']
 
-        expected = [{'id': 123, 'name': 'public image #1'},
-                    {'id': 124, 'name': 'public image #2'},
-                    {'id': 125, 'name': 'public image #3'}]
+        expected = [{'id': 123, 'name': 'public image'},
+                    {'id': 124, 'name': 'queued backup'},
+                    {'id': 125, 'name': 'saving backup'},
+                    {'id': 126, 'name': 'active backup'},
+                    {'id': 127, 'name': 'killed backup'}]
 
         self.assertDictListMatch(image_metas, expected)
 
@@ -289,12 +264,70 @@ class ImageControllerWithGlanceServiceTest(test.TestCase):
         image_metas = json.loads(res.body)['images']
 
         expected = [
-            {'id': 123, 'name': 'public image #1', 'updated': self.NOW_API_STR,
-             'created': self.NOW_API_STR, 'status': 'SAVING', 'progress': 0},
-            {'id': 124, 'name': 'public image #2', 'updated': self.NOW_API_STR,
-             'created': self.NOW_API_STR, 'status': 'ACTIVE', 'serverId': 42},
-            {'id': 125, 'name': 'public image #3', 'updated': self.NOW_API_STR,
-             'created': self.NOW_API_STR, 'status': 'FAILED', 'serverId': 42},
+            {'id': 123, 'name': 'public image', 'updated': self.NOW_API_STR,
+             'created': self.NOW_API_STR, 'status': 'ACTIVE'},
+            {'id': 124, 'name': 'queued backup', 'serverId': 42,
+             'updated': self.NOW_API_STR, 'created': self.NOW_API_STR,
+             'status': 'QUEUED'},
+            {'id': 125, 'name': 'saving backup', 'serverId': 42,
+             'updated': self.NOW_API_STR, 'created': self.NOW_API_STR,
+             'status': 'SAVING', 'progress': 0},
+            {'id': 126, 'name': 'active backup', 'serverId': 42,
+             'updated': self.NOW_API_STR, 'created': self.NOW_API_STR,
+             'status': 'ACTIVE'},
+            {'id': 127, 'name': 'killed backup', 'serverId': 42,
+             'updated': self.NOW_API_STR, 'created': self.NOW_API_STR,
+             'status': 'FAILED'}
         ]
 
         self.assertDictListMatch(image_metas, expected)
+
+    @classmethod
+    def _make_image_fixtures(cls):
+        """
+        """
+        fixtures = []
+        public_image = {'id': 123,
+                        'name': 'public image',
+                        'is_public': True,
+                        'status': 'active'}
+        fixtures.append(public_image)
+
+        queued_backup = {'id': 124,
+                         'name': 'queued backup',
+                         'is_public': False,
+                         'status': 'queued',
+                         'instance_id': 42}
+        fixtures.append(queued_backup)
+
+        saving_backup = {'id': 125,
+                         'name': 'saving backup',
+                         'is_public': False,
+                         'status': 'saving',
+                         'instance_id': 42,
+                         'progress': 0}
+        fixtures.append(saving_backup)
+
+        active_backup = {'id': 126,
+                         'name': 'active backup',
+                         'is_public': False,
+                         'status': 'active',
+                         'instance_id': 42}
+        fixtures.append(active_backup)
+
+        killed_backup = {'id': 127,
+                         'name': 'killed backup',
+                         'is_public': False,
+                         'status': 'killed',
+                         'instance_id': 42}
+        fixtures.append(killed_backup)
+
+        base_attrs = {'created_at': cls.NOW_SERVICE_STR,
+                      'updated_at': cls.NOW_SERVICE_STR,
+                      'deleted_at': None,
+                      'deleted': False}
+
+        for fixture in fixtures:
+            fixture.update(base_attrs)
+
+        return fixtures
-- 
cgit 


From f0141b1616e1b1fc9e52e33b37cc3a1091c57587 Mon Sep 17 00:00:00 2001
From: Dan Prince <dan.prince@rackspace.com>
Date: Mon, 14 Mar 2011 22:24:34 -0400
Subject: Moved extended resource code into the extensions.py module.

---
 nova/api/openstack/__init__.py                 |  6 ---
 nova/api/openstack/extensions.py               | 29 +++++++----
 nova/tests/api/openstack/extensions/widgets.py | 15 ++----
 nova/tests/api/openstack/test_extensions.py    | 66 +++++++++++++-------------
 4 files changed, 59 insertions(+), 57 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/__init__.py b/nova/api/openstack/__init__.py
index 8a458eea1..ff91c77cf 100644
--- a/nova/api/openstack/__init__.py
+++ b/nova/api/openstack/__init__.py
@@ -31,7 +31,6 @@ from nova.api.openstack import accounts
 from nova.api.openstack import faults
 from nova.api.openstack import backup_schedules
 from nova.api.openstack import consoles
-from nova.api.openstack import extensions
 from nova.api.openstack import flavors
 from nova.api.openstack import images
 from nova.api.openstack import servers
@@ -121,11 +120,6 @@ class APIRouter(wsgi.Router):
                         collection={'detail': 'GET'},
                         controller=shared_ip_groups.Controller())
 
-        if ext_mgr is None:
-            ext_mgr = extensions.ExtensionManager(FLAGS.osapi_extensions_path)
-        for resource in ext_mgr.get_resources():
-            resource.add_routes(mapper)
-
         super(APIRouter, self).__init__(mapper)
 
 
diff --git a/nova/api/openstack/extensions.py b/nova/api/openstack/extensions.py
index e41de3120..f32471051 100644
--- a/nova/api/openstack/extensions.py
+++ b/nova/api/openstack/extensions.py
@@ -68,7 +68,15 @@ class ExtensionMiddleware(wsgi.Middleware):
         if ext_mgr is None:
             ext_mgr = ExtensionManager(FLAGS.osapi_extensions_path)
 
-        # create custom mapper connections for extended actions
+        # extended resources
+        for resource in ext_mgr.get_resources():
+            mapper.resource(resource.member, resource.collection,
+                            controller=resource.controller,
+                            collection=resource.collection_actions,
+                            member=resource.member_actions,
+                            parent_resource=resource.parent)
+
+        # extended actions
         for action in ext_mgr.get_actions():
             controller = ExtensionActionController(application, action.name,
                                                     action.handler)
@@ -124,10 +132,13 @@ class ExtensionManager(object):
         """
         resources = []
         for ext in self.extensions:
-            resources.append(ext.get_resources())
+            resources.extend(ext.get_resources())
         return resources
 
     def get_actions(self):
+        """
+        returns a list of ExtensionAction objects
+        """
         actions = []
         for ext in self.extensions:
             actions.extend(ext.get_actions())
@@ -163,10 +174,12 @@ class ExtensionAction(object):
 
 
 class ExtensionResource(object):
-    """
-    Example ExtensionResource object. All ExtensionResource objects should
-    adhere to this interface.
-    """
 
-    def add_routes(self, mapper):
-        pass
+    def __init__(self, member, collection, controller,
+                 parent=None, collection_actions={}, member_actions={}):
+        self.member = member
+        self.collection = collection
+        self.controller = controller
+        self.parent = parent
+        self.collection_actions = collection_actions
+        self.member_actions = member_actions
diff --git a/nova/tests/api/openstack/extensions/widgets.py b/nova/tests/api/openstack/extensions/widgets.py
index 6839d2bb2..d5a2d95d9 100644
--- a/nova/tests/api/openstack/extensions/widgets.py
+++ b/nova/tests/api/openstack/extensions/widgets.py
@@ -9,22 +9,17 @@ class WidgetsController(wsgi.Controller):
         return "Buy more widgets!"
 
 
-class WidgetsExtensionResource(object):
-
-    def __init__(self):
-        pass
-
-    def add_routes(self, mapper):
-        mapper.resource('widget', 'widgets', controller=WidgetsController())
-
-
 class WidgetsExtension(object):
 
     def __init__(self):
         pass
 
     def get_resources(self):
-        return WidgetsExtensionResource()
+        resources = []
+        widgets = extensions.ExtensionResource('widget', 'widgets',
+                                               WidgetsController())
+        resources.append(widgets)
+        return resources
 
     def get_actions(self):
         actions = []
diff --git a/nova/tests/api/openstack/test_extensions.py b/nova/tests/api/openstack/test_extensions.py
index f8d217e9c..080760c14 100644
--- a/nova/tests/api/openstack/test_extensions.py
+++ b/nova/tests/api/openstack/test_extensions.py
@@ -22,6 +22,7 @@ import os.path
 
 from nova import flags
 from nova.api import openstack
+from nova.api.openstack import extensions
 import nova.wsgi
 
 FLAGS = flags.FLAGS
@@ -38,53 +39,51 @@ class StubController(nova.wsgi.Controller):
 
 class StubExtensionManager(object):
 
-    def __init__(self, resources):
-        self.resources = resources
+    def __init__(self, resource):
+        self.resource = resource
 
     def get_resources(self):
-        return self.resources
+        resources = []
+        if self.resource:
+            resources.append(self.resource)
+        return resources
 
+    def get_actions(self):
+        actions = []
+        return actions
 
-class WidgetExtensionResource(object):
 
-    def __init__(self, name, collection, wsgi_app):
-        self.name = name
-        self.collection = collection
-        self.wsgi_app = wsgi_app
-
-    def add_routes(self, mapper):
-        mapper.resource(self.name, self.collection, controller=self.wsgi_app)
-
-
-class ExtensionTest(unittest.TestCase):
+class ExtensionResourceTest(unittest.TestCase):
 
     def test_no_extension_present(self):
-        manager = StubExtensionManager([])
-        router = openstack.APIRouter(manager)
+        manager = StubExtensionManager(None)
+        app = openstack.APIRouter()
+        ext_midware = extensions.ExtensionMiddleware(app, manager)
         request = webob.Request.blank("/widgets")
-        response = request.get_response(router)
+        response = request.get_response(ext_midware)
         self.assertEqual(404, response.status_int)
 
     def test_get_resources(self):
         response_body = "Buy more widgets!"
-        response = webob.Response()
-        response.body = response_body
-        resource1 = WidgetExtensionResource("widget", "widgets", response)
-        manager = StubExtensionManager([resource1])
-        router = openstack.APIRouter(manager)
+        widgets = extensions.ExtensionResource('widget', 'widgets',
+                                               StubController(response_body))
+        manager = StubExtensionManager(widgets)
+        app = openstack.APIRouter()
+        ext_midware = extensions.ExtensionMiddleware(app, manager)
         request = webob.Request.blank("/widgets")
-        response = request.get_response(router)
+        response = request.get_response(ext_midware)
         self.assertEqual(200, response.status_int)
         self.assertEqual(response_body, response.body)
 
     def test_get_resources_with_controller(self):
         response_body = "Buy more widgets!"
-        controller = StubController(response_body)
-        resource1 = WidgetExtensionResource("widget", "widgets", controller)
-        manager = StubExtensionManager([resource1])
-        router = openstack.APIRouter(manager)
+        widgets = extensions.ExtensionResource('widget', 'widgets',
+                                               StubController(response_body))
+        manager = StubExtensionManager(widgets)
+        app = openstack.APIRouter()
+        ext_midware = extensions.ExtensionMiddleware(app, manager)
         request = webob.Request.blank("/widgets")
-        response = request.get_response(router)
+        response = request.get_response(ext_midware)
         self.assertEqual(200, response.status_int)
         self.assertEqual(response_body, response.body)
 
@@ -96,9 +95,10 @@ class ExtensionManagerTest(unittest.TestCase):
                                                     "extensions")
 
     def test_get_resources(self):
-        router = openstack.APIRouter()
+        app = openstack.APIRouter()
+        ext_midware = extensions.ExtensionMiddleware(app)
         request = webob.Request.blank("/widgets")
-        response = request.get_response(router)
+        response = request.get_response(ext_midware)
         self.assertEqual(200, response.status_int)
         self.assertEqual("Buy more widgets!", response.body)
 
@@ -111,7 +111,7 @@ class ExtendedActionTest(unittest.TestCase):
 
     def test_extended_action(self):
         app = openstack.APIRouter()
-        ext_midware = openstack.extensions.ExtensionMiddleware(app)
+        ext_midware = extensions.ExtensionMiddleware(app)
         body = dict(add_widget=dict(name="test"))
         request = webob.Request.blank("/servers/1/action")
         request.method = 'POST'
@@ -123,7 +123,7 @@ class ExtendedActionTest(unittest.TestCase):
 
     def test_invalid_action_body(self):
         app = openstack.APIRouter()
-        ext_midware = openstack.extensions.ExtensionMiddleware(app)
+        ext_midware = extensions.ExtensionMiddleware(app)
         body = dict(blah=dict(name="test"))  # Doesn't exist
         request = webob.Request.blank("/servers/1/action")
         request.method = 'POST'
@@ -134,7 +134,7 @@ class ExtendedActionTest(unittest.TestCase):
 
     def test_invalid_action(self):
         app = openstack.APIRouter()
-        ext_midware = openstack.extensions.ExtensionMiddleware(app)
+        ext_midware = extensions.ExtensionMiddleware(app)
         request = webob.Request.blank("/asdf/1/action")
         request.method = 'POST'
         request.content_type = 'application/json'
-- 
cgit 


From a4e94971b696681a5ced189d8f4263c8f77cc531 Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Mon, 14 Mar 2011 19:57:30 -0700
Subject: Make key_pair optional with OpenStack API

---
 nova/api/openstack/servers.py | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index dc28a0782..47ed254ec 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -146,10 +146,14 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPUnprocessableEntity())
 
         context = req.environ['nova.context']
+
+        key_name = None
+        key_data = None
         key_pairs = auth_manager.AuthManager.get_key_pairs(context)
-        if not key_pairs:
-            raise exception.NotFound(_("No keypairs defined"))
-        key_pair = key_pairs[0]
+        if key_pairs:
+            key_pair = key_pairs[0]
+            key_name = key_pair['name']
+            key_data = key_pair['public_key']
 
         image_id = common.get_image_id_from_image_hash(self._image_service,
             context, env['server']['imageId'])
@@ -174,8 +178,8 @@ class Controller(wsgi.Controller):
             ramdisk_id=ramdisk_id,
             display_name=env['server']['name'],
             display_description=env['server']['name'],
-            key_name=key_pair['name'],
-            key_data=key_pair['public_key'],
+            key_name=key_name,
+            key_data=key_data,
             metadata=metadata,
             onset_files=env.get('onset_files', []))
 
-- 
cgit 


From d5b9391e2911ba2210a045a2af380dfc85d16919 Mon Sep 17 00:00:00 2001
From: Naveed Massjouni <naveedm9@gmail.com>
Date: Mon, 14 Mar 2011 23:14:59 -0400
Subject: Added a views package and a views.servers module. For representing
 the response object before it is serialized.

---
 nova/api/openstack/servers.py            | 65 +++++----------------------
 nova/api/openstack/v1_0/__init__.py      |  0
 nova/api/openstack/v1_0/servers.py       |  6 ---
 nova/api/openstack/v1_1/__init__.py      |  0
 nova/api/openstack/v1_1/servers.py       |  8 ----
 nova/api/openstack/views/__init__.py     |  0
 nova/api/openstack/views/servers.py      | 76 ++++++++++++++++++++++++++++++++
 nova/tests/api/openstack/test_servers.py |  6 ++-
 8 files changed, 90 insertions(+), 71 deletions(-)
 delete mode 100644 nova/api/openstack/v1_0/__init__.py
 delete mode 100644 nova/api/openstack/v1_0/servers.py
 delete mode 100644 nova/api/openstack/v1_1/__init__.py
 delete mode 100644 nova/api/openstack/v1_1/servers.py
 create mode 100644 nova/api/openstack/views/__init__.py
 create mode 100644 nova/api/openstack/views/servers.py

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 0d36546d7..ea8321e8d 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -27,8 +27,7 @@ from nova import wsgi
 from nova import utils
 from nova.api.openstack import common
 from nova.api.openstack import faults
-from nova.api.openstack.v1_0 import servers as v1_0
-from nova.api.openstack.v1_1 import servers as v1_1
+from nova.api.openstack.views.servers import get_view_builder
 from nova.auth import manager as auth_manager
 from nova.compute import instance_types
 from nova.compute import power_state
@@ -56,7 +55,8 @@ class Controller(wsgi.Controller):
     def ips(self, req, id):
         try:
             instance = self.compute_api.get(req.environ['nova.context'], id)
-            return _get_addresses_builder(req)(instance)
+            builder = get_view_builder(req)
+            return builder._build_addresses(instance)
         except exception.NotFound:
             return faults.Fault(exc.HTTPNotFound())
 
@@ -75,15 +75,17 @@ class Controller(wsgi.Controller):
         """
         instance_list = self.compute_api.get_all(req.environ['nova.context'])
         limited_list = common.limited(instance_list, req)
-        res = [_build_server(req, inst, is_detail)['server']
+        builder = get_view_builder(req)
+        servers = [builder.build(inst, is_detail)['server']
                 for inst in limited_list]
-        return dict(servers=res)
+        return dict(servers=servers)
 
     def show(self, req, id):
         """ Returns server details by server id """
         try:
             instance = self.compute_api.get(req.environ['nova.context'], id)
-            return _build_server(req, instance, is_detail=True)
+            builder = get_view_builder(req)
+            return builder.build(instance, is_detail=True)
         except exception.NotFound:
             return faults.Fault(exc.HTTPNotFound())
 
@@ -135,7 +137,8 @@ class Controller(wsgi.Controller):
             metadata=metadata,
             onset_files=env.get('onset_files', []))
 
-        server = _build_server(req, instances[0], is_detail=False)
+        builder = get_view_builder(req)
+        server = builder.build(instances[0], is_detail=False)
         password = "%s%s" % (server['server']['name'][:4],
                              utils.generate_password(12))
         server['server']['adminPass'] = password
@@ -434,52 +437,4 @@ class Controller(wsgi.Controller):
         return kernel_id, ramdisk_id
 
 
-def _build_server(req, inst, is_detail):
-    """ Coerces into dictionary format, mapping everything to Rackspace-like
-    attributes for return"""
 
-    if not is_detail:
-        return dict(server=dict(id=inst['id'], name=inst['display_name']))
-
-    power_mapping = {
-        None: 'build',
-        power_state.NOSTATE: 'build',
-        power_state.RUNNING: 'active',
-        power_state.BLOCKED: 'active',
-        power_state.SUSPENDED: 'suspended',
-        power_state.PAUSED: 'paused',
-        power_state.SHUTDOWN: 'active',
-        power_state.SHUTOFF: 'active',
-        power_state.CRASHED: 'error',
-        power_state.FAILED: 'error'}
-    inst_dict = {}
-    version = req.environ['nova.context'].version
-
-    mapped_keys = dict(status='state', imageId='image_id',
-        flavorId='instance_type', name='display_name', id='id')
-
-    for k, v in mapped_keys.iteritems():
-        inst_dict[k] = inst[v]
-
-    inst_dict['status'] = power_mapping[inst_dict['status']]
-    inst_dict['addresses'] = _get_addresses_builder(req)(inst)
-
-    # Return the metadata as a dictionary
-    metadata = {}
-    for item in inst['metadata']:
-        metadata[item['key']] = item['value']
-    inst_dict['metadata'] = metadata
-
-    inst_dict['hostId'] = ''
-    if inst['host']:
-        inst_dict['hostId'] = hashlib.sha224(inst['host']).hexdigest()
-
-    return dict(server=inst_dict)
-
-
-def _get_addresses_builder(req):
-    version = req.environ['nova.context'].version
-    if version == '1.1':
-        return v1_1.build_addresses
-    else:
-        return v1_0.build_addresses
diff --git a/nova/api/openstack/v1_0/__init__.py b/nova/api/openstack/v1_0/__init__.py
deleted file mode 100644
index e69de29bb..000000000
diff --git a/nova/api/openstack/v1_0/servers.py b/nova/api/openstack/v1_0/servers.py
deleted file mode 100644
index d332b1378..000000000
--- a/nova/api/openstack/v1_0/servers.py
+++ /dev/null
@@ -1,6 +0,0 @@
-from nova import utils
-
-def build_addresses(inst):
-    private_ips = utils.get_from_path(inst, 'fixed_ip/address')
-    public_ips = utils.get_from_path(inst, 'fixed_ip/floating_ips/address')
-    return dict(public=public_ips, private=private_ips)
diff --git a/nova/api/openstack/v1_1/__init__.py b/nova/api/openstack/v1_1/__init__.py
deleted file mode 100644
index e69de29bb..000000000
diff --git a/nova/api/openstack/v1_1/servers.py b/nova/api/openstack/v1_1/servers.py
deleted file mode 100644
index 012fc3e5c..000000000
--- a/nova/api/openstack/v1_1/servers.py
+++ /dev/null
@@ -1,8 +0,0 @@
-from nova import utils
-
-def build_addresses(inst):
-    private_ips = utils.get_from_path(inst, 'fixed_ip/address')
-    private_ips = [dict(version=4, addr=a) for a in private_ips]
-    public_ips = utils.get_from_path(inst, 'fixed_ip/floating_ips/address')
-    public_ips = [dict(version=4, addr=a) for a in public_ips]
-    return dict(public=public_ips, private=private_ips)
diff --git a/nova/api/openstack/views/__init__.py b/nova/api/openstack/views/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/nova/api/openstack/views/servers.py b/nova/api/openstack/views/servers.py
new file mode 100644
index 000000000..120cae4d4
--- /dev/null
+++ b/nova/api/openstack/views/servers.py
@@ -0,0 +1,76 @@
+import hashlib
+from nova.compute import power_state
+from nova import utils
+
+def get_view_builder(req):
+    '''
+    A factory method that returns the correct builder based on the version of
+    the api requested.
+    '''
+    version = req.environ['nova.context'].version
+    if version == '1.1':
+        return DataViewBuilder_1_1()
+    else:
+        return DataViewBuilder_1_0()
+
+
+class DataViewBuilder(object):
+    ''' Models a server response as a python dictionary. '''
+
+    def build(self, inst, is_detail):
+        """ Coerces into dictionary format, mapping everything to Rackspace-like
+        attributes for return"""
+
+        if not is_detail:
+            return dict(server=dict(id=inst['id'], name=inst['display_name']))
+
+        power_mapping = {
+            None: 'build',
+            power_state.NOSTATE: 'build',
+            power_state.RUNNING: 'active',
+            power_state.BLOCKED: 'active',
+            power_state.SUSPENDED: 'suspended',
+            power_state.PAUSED: 'paused',
+            power_state.SHUTDOWN: 'active',
+            power_state.SHUTOFF: 'active',
+            power_state.CRASHED: 'error',
+            power_state.FAILED: 'error'}
+        inst_dict = {}
+
+        mapped_keys = dict(status='state', imageId='image_id',
+            flavorId='instance_type', name='display_name', id='id')
+
+        for k, v in mapped_keys.iteritems():
+            inst_dict[k] = inst[v]
+
+        inst_dict['status'] = power_mapping[inst_dict['status']]
+        inst_dict['addresses'] = self._build_addresses(inst)
+
+        # Return the metadata as a dictionary
+        metadata = {}
+        for item in inst['metadata']:
+            metadata[item['key']] = item['value']
+        inst_dict['metadata'] = metadata
+
+        inst_dict['hostId'] = ''
+        if inst['host']:
+            inst_dict['hostId'] = hashlib.sha224(inst['host']).hexdigest()
+
+        return dict(server=inst_dict)
+
+
+class DataViewBuilder_1_0(DataViewBuilder):
+    def _build_addresses(self, inst):
+        private_ips = utils.get_from_path(inst, 'fixed_ip/address')
+        public_ips = utils.get_from_path(inst, 'fixed_ip/floating_ips/address')
+        return dict(public=public_ips, private=private_ips)
+
+
+class DataViewBuilder_1_1(DataViewBuilder):
+    def _build_addresses(self, inst):
+        private_ips = utils.get_from_path(inst, 'fixed_ip/address')
+        private_ips = [dict(version=4, addr=a) for a in private_ips]
+        public_ips = utils.get_from_path(inst, 'fixed_ip/floating_ips/address')
+        public_ips = [dict(version=4, addr=a) for a in public_ips]
+        return dict(public=public_ips, private=private_ips)
+
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index a2bd875a4..b2446f194 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -195,9 +195,11 @@ class ServersTest(test.TestCase):
         self.assertEqual(res_dict['server']['name'], 'server1')
         addresses = res_dict['server']['addresses']
         self.assertEqual(len(addresses["public"]), len(public))
-        self.assertEqual(addresses["public"][0], {"version": 4, "addr": public[0]})
+        self.assertEqual(addresses["public"][0],
+            {"version": 4, "addr": public[0]})
         self.assertEqual(len(addresses["private"]), 1)
-        self.assertEqual(addresses["private"][0], {"version": 4, "addr": private})
+        self.assertEqual(addresses["private"][0],
+            {"version": 4, "addr": private})
 
     def test_get_server_list(self):
         req = webob.Request.blank('/v1.0/servers')
-- 
cgit 


From da605eb84f7d5de741225ff936447db01690a04f Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Mon, 14 Mar 2011 20:48:33 -0700
Subject: Don't generate insecure passwords where it's easy to use urandom
 instead

---
 nova/console/manager.py |  2 +-
 nova/console/xvp.py     |  4 ----
 nova/utils.py           | 15 ++++++++++-----
 3 files changed, 11 insertions(+), 10 deletions(-)

(limited to 'nova')

diff --git a/nova/console/manager.py b/nova/console/manager.py
index 57c75cf4f..bfa571ea9 100644
--- a/nova/console/manager.py
+++ b/nova/console/manager.py
@@ -69,7 +69,7 @@ class ConsoleProxyManager(manager.Manager):
         except exception.NotFound:
             logging.debug(_("Adding console"))
             if not password:
-                password = self.driver.generate_password()
+                password = utils.generate_password(8)
             if not port:
                 port = self.driver.get_port(context)
             console_data = {'instance_name': name,
diff --git a/nova/console/xvp.py b/nova/console/xvp.py
index 68d8c8565..0cedfbb13 100644
--- a/nova/console/xvp.py
+++ b/nova/console/xvp.py
@@ -91,10 +91,6 @@ class XVPConsoleProxy(object):
         """Trim password to length, and encode"""
         return self._xvp_encrypt(password)
 
-    def generate_password(self, length=8):
-        """Returns random console password"""
-        return os.urandom(length * 2).encode('base64')[:length]
-
     def _rebuild_xvp_conf(self, context):
         logging.debug(_("Rebuilding xvp conf"))
         pools = [pool for pool in
diff --git a/nova/utils.py b/nova/utils.py
index 87e726394..9c8b27d56 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -263,12 +263,17 @@ def generate_mac():
 
 
 def generate_password(length=20):
-    """Generate a random sequence of letters and digits
-    to be used as a password. Note that this is not intended
-    to represent the ultimate in security.
+    """Generate a random alphanumeric password, avoiding 'confusing' O,0,I,1.
+
+    Believed to be reasonably secure (with a reasonable password length!)
     """
-    chrs = string.letters + string.digits
-    return "".join([random.choice(chrs) for i in xrange(length)])
+    # 26 letters, 10 digits = 36
+    # Remove O, 0, I, 1 => 32 digits
+    # 32 digits means we're just using the low 5 bit of each byte
+    chrs = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789"
+
+    random_bytes = os.urandom(length)
+    return "".join([chrs[ord(random_bytes[i]) % 32] for i in xrange(length)])
 
 
 def last_octet(address):
-- 
cgit 


From c70e3777a488a63062c030e9949e9c16f2269f9c Mon Sep 17 00:00:00 2001
From: Brian Waldon <brian.waldon@rackspace.com>
Date: Mon, 14 Mar 2011 23:55:44 -0400
Subject: moving addresses views to new module; removing 'Data' from
 'DataViewBuilder'

---
 nova/api/openstack/views/servers.py | 39 ++++++++++++++++++++-----------------
 1 file changed, 21 insertions(+), 18 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/views/servers.py b/nova/api/openstack/views/servers.py
index 120cae4d4..3ccfd8dba 100644
--- a/nova/api/openstack/views/servers.py
+++ b/nova/api/openstack/views/servers.py
@@ -1,29 +1,40 @@
 import hashlib
 from nova.compute import power_state
+from nova.api.openstack.views import addresses as addresses_view
 from nova import utils
 
+
 def get_view_builder(req):
     '''
     A factory method that returns the correct builder based on the version of
     the api requested.
     '''
     version = req.environ['nova.context'].version
+    addresses_builder = addresses_view.get_view_builder(req)
     if version == '1.1':
-        return DataViewBuilder_1_1()
+        return ViewBuilder_1_1(addresses_builder)
     else:
-        return DataViewBuilder_1_0()
+        return ViewBuilder_1_0(addresses_builder)
+
 
+class ViewBuilder(object):
+    ''' Models a server response as a python dictionary.'''
 
-class DataViewBuilder(object):
-    ''' Models a server response as a python dictionary. '''
+    def __init__(self, addresses_builder):
+        self.addresses_builder = addresses_builder
 
     def build(self, inst, is_detail):
         """ Coerces into dictionary format, mapping everything to Rackspace-like
         attributes for return"""
+        if is_detail:
+            return self._build_detail(inst)
+        else:
+            return self._build_simple(inst)
 
-        if not is_detail:
+    def _build_simple(self, inst):
             return dict(server=dict(id=inst['id'], name=inst['display_name']))
 
+    def _build_detail(self, inst):
         power_mapping = {
             None: 'build',
             power_state.NOSTATE: 'build',
@@ -44,7 +55,7 @@ class DataViewBuilder(object):
             inst_dict[k] = inst[v]
 
         inst_dict['status'] = power_mapping[inst_dict['status']]
-        inst_dict['addresses'] = self._build_addresses(inst)
+        inst_dict['addresses'] = self.addresses_builder.build(inst)
 
         # Return the metadata as a dictionary
         metadata = {}
@@ -59,18 +70,10 @@ class DataViewBuilder(object):
         return dict(server=inst_dict)
 
 
-class DataViewBuilder_1_0(DataViewBuilder):
-    def _build_addresses(self, inst):
-        private_ips = utils.get_from_path(inst, 'fixed_ip/address')
-        public_ips = utils.get_from_path(inst, 'fixed_ip/floating_ips/address')
-        return dict(public=public_ips, private=private_ips)
+class ViewBuilder_1_0(ViewBuilder):
+    pass
 
 
-class DataViewBuilder_1_1(DataViewBuilder):
-    def _build_addresses(self, inst):
-        private_ips = utils.get_from_path(inst, 'fixed_ip/address')
-        private_ips = [dict(version=4, addr=a) for a in private_ips]
-        public_ips = utils.get_from_path(inst, 'fixed_ip/floating_ips/address')
-        public_ips = [dict(version=4, addr=a) for a in public_ips]
-        return dict(public=public_ips, private=private_ips)
+class ViewBuilder_1_1(ViewBuilder):
+    pass
 
-- 
cgit 


From 3d0cde272e3227978c5875c811c93e1e3df692ed Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Mon, 14 Mar 2011 21:01:48 -0700
Subject: Clarify the logic in using 32 symbols

---
 nova/utils.py | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/utils.py b/nova/utils.py
index 9c8b27d56..0510c3cbe 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -267,9 +267,10 @@ def generate_password(length=20):
 
     Believed to be reasonably secure (with a reasonable password length!)
     """
-    # 26 letters, 10 digits = 36
-    # Remove O, 0, I, 1 => 32 digits
-    # 32 digits means we're just using the low 5 bit of each byte
+    # 26 letters, 10 digits = 36 choices
+    # Remove O, 0, I, 1 => 32 choices
+    # 32 choices means we're just using the low 5 bit of each byte,
+    # so there's no bias introduced by using a modulo
     chrs = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789"
 
     random_bytes = os.urandom(length)
-- 
cgit 


From 3cf224b9e676b88d1990b13476095be6ec156e5d Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Mon, 14 Mar 2011 21:28:42 -0700
Subject: Fixed problem with metadata creation (backported fix)

---
 nova/db/sqlalchemy/api.py | 9 +++++++++
 1 file changed, 9 insertions(+)

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 56998ce05..d4dd82227 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -746,6 +746,15 @@ def instance_create(context, values):
     context - request context object
     values - dict containing column values.
     """
+    metadata = values.get('metadata')
+    metadata_refs = []
+    if metadata:
+        for metadata_item in metadata:
+            metadata_ref = models.InstanceMetadata()
+            metadata_ref.update(metadata_item)
+            metadata_refs.append(metadata_ref)
+    values['metadata'] = metadata_refs
+
     instance_ref = models.Instance()
     instance_ref.update(values)
 
-- 
cgit 


From 18cd549ba8d7aa4c688a7f7a5e940acbaaa03acc Mon Sep 17 00:00:00 2001
From: Brian Waldon <brian.waldon@rackspace.com>
Date: Tue, 15 Mar 2011 00:49:20 -0400
Subject: adding flavors and images barebones view code; adding flavorRef and
 imageRef to v1.1 servers

---
 nova/api/openstack/servers.py            | 13 +++++-----
 nova/api/openstack/views/servers.py      | 42 ++++++++++++++++++++++++++++----
 nova/tests/api/openstack/test_servers.py | 32 +++++++++++++++++++++---
 3 files changed, 72 insertions(+), 15 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index ea8321e8d..7bb7250ba 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -27,7 +27,8 @@ from nova import wsgi
 from nova import utils
 from nova.api.openstack import common
 from nova.api.openstack import faults
-from nova.api.openstack.views.servers import get_view_builder
+from nova.api.openstack.views import servers as servers_views
+from nova.api.openstack.views import addresses as addresses_views
 from nova.auth import manager as auth_manager
 from nova.compute import instance_types
 from nova.compute import power_state
@@ -55,8 +56,8 @@ class Controller(wsgi.Controller):
     def ips(self, req, id):
         try:
             instance = self.compute_api.get(req.environ['nova.context'], id)
-            builder = get_view_builder(req)
-            return builder._build_addresses(instance)
+            builder = addresses_views.get_view_builder(req)
+            return builder.build(instance)
         except exception.NotFound:
             return faults.Fault(exc.HTTPNotFound())
 
@@ -75,7 +76,7 @@ class Controller(wsgi.Controller):
         """
         instance_list = self.compute_api.get_all(req.environ['nova.context'])
         limited_list = common.limited(instance_list, req)
-        builder = get_view_builder(req)
+        builder = servers_views.get_view_builder(req)
         servers = [builder.build(inst, is_detail)['server']
                 for inst in limited_list]
         return dict(servers=servers)
@@ -84,7 +85,7 @@ class Controller(wsgi.Controller):
         """ Returns server details by server id """
         try:
             instance = self.compute_api.get(req.environ['nova.context'], id)
-            builder = get_view_builder(req)
+            builder = servers_views.get_view_builder(req)
             return builder.build(instance, is_detail=True)
         except exception.NotFound:
             return faults.Fault(exc.HTTPNotFound())
@@ -137,7 +138,7 @@ class Controller(wsgi.Controller):
             metadata=metadata,
             onset_files=env.get('onset_files', []))
 
-        builder = get_view_builder(req)
+        builder = servers_views.get_view_builder(req)
         server = builder.build(instances[0], is_detail=False)
         password = "%s%s" % (server['server']['name'][:4],
                              utils.generate_password(12))
diff --git a/nova/api/openstack/views/servers.py b/nova/api/openstack/views/servers.py
index 3ccfd8dba..950662747 100644
--- a/nova/api/openstack/views/servers.py
+++ b/nova/api/openstack/views/servers.py
@@ -1,6 +1,8 @@
 import hashlib
 from nova.compute import power_state
 from nova.api.openstack.views import addresses as addresses_view
+from nova.api.openstack.views import flavors as flavors_view
+from nova.api.openstack.views import images as images_view
 from nova import utils
 
 
@@ -12,7 +14,9 @@ def get_view_builder(req):
     version = req.environ['nova.context'].version
     addresses_builder = addresses_view.get_view_builder(req)
     if version == '1.1':
-        return ViewBuilder_1_1(addresses_builder)
+        flavor_builder = flavors_view.get_view_builder(req)
+        image_builder = images_view.get_view_builder(req)
+        return ViewBuilder_1_1(addresses_builder, flavor_builder, image_builder)
     else:
         return ViewBuilder_1_0(addresses_builder)
 
@@ -48,8 +52,10 @@ class ViewBuilder(object):
             power_state.FAILED: 'error'}
         inst_dict = {}
 
-        mapped_keys = dict(status='state', imageId='image_id',
-            flavorId='instance_type', name='display_name', id='id')
+        #mapped_keys = dict(status='state', imageId='image_id',
+        #    flavorId='instance_type', name='display_name', id='id')
+
+        mapped_keys = dict(status='state', name='display_name', id='id')
 
         for k, v in mapped_keys.iteritems():
             inst_dict[k] = inst[v]
@@ -67,13 +73,39 @@ class ViewBuilder(object):
         if inst['host']:
             inst_dict['hostId'] = hashlib.sha224(inst['host']).hexdigest()
 
+        inst_dict = self._decorate_response(inst_dict, inst)
+
         return dict(server=inst_dict)
 
+    def _build_image_data(self, response, inst):
+        raise NotImplementedError()
+
 
 class ViewBuilder_1_0(ViewBuilder):
-    pass
+    def _decorate_response(self, response, inst):
+        response["imageId"] = inst["image_id"]
+        response["flavorId"] = inst["instance_type"]
+        return response
 
 
 class ViewBuilder_1_1(ViewBuilder):
-    pass
+    def __init__(self, addresses_builder, flavor_builder, image_builder):
+        ViewBuilder.__init__(self, addresses_builder)
+        self.flavor_builder = flavor_builder
+        self.image_builder = image_builder
+
+    def _decorate_response(self, response, inst):
+        response = self._build_image_ref(response, inst)
+        response = self._build_flavor_ref(response, inst)
+        return response
+
+    def _build_image_ref(self, response, inst):
+        image_id = inst["image_id"]
+        response["imageRef"] = self.image_builder.generate_href(image_id)
+        return response
+
+    def _build_flavor_ref(self, response, inst):
+        flavor_id = inst["instance_type"]
+        response["flavorRef"]= self.flavor_builder.generate_href(flavor_id)
+        return response
 
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index b2446f194..b42cecfbb 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -79,7 +79,7 @@ def stub_instance(id, user_id=1, private_address=None, public_addresses=None):
         "admin_pass": "",
         "user_id": user_id,
         "project_id": "",
-        "image_id": 10,
+        "image_id": "10",
         "kernel_id": "",
         "ramdisk_id": "",
         "launch_index": 0,
@@ -92,7 +92,7 @@ def stub_instance(id, user_id=1, private_address=None, public_addresses=None):
         "local_gb": 0,
         "hostname": "",
         "host": None,
-        "instance_type": "",
+        "instance_type": "1",
         "user_data": "",
         "reservation_id": "",
         "mac_address": "",
@@ -353,7 +353,7 @@ class ServersTest(test.TestCase):
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status, '404 Not Found')
 
-    def test_get_all_server_details(self):
+    def test_get_all_server_details_v1_0(self):
         req = webob.Request.blank('/v1.0/servers/detail')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
@@ -363,7 +363,31 @@ class ServersTest(test.TestCase):
             self.assertEqual(s['id'], i)
             self.assertEqual(s['hostId'], '')
             self.assertEqual(s['name'], 'server%d' % i)
-            self.assertEqual(s['imageId'], 10)
+            self.assertEqual(s['imageId'], '10')
+            self.assertEqual(s['flavorId'], '1')
+            self.assertEqual(s['metadata']['seq'], i)
+            i += 1
+
+    def test_get_all_server_details_v1_1(self):
+        class FakeRequestContext(object):
+            def __init__(self, user, project, *args, **kwargs):
+                self.user_id = 1
+                self.project_id = 1
+                self.version = '1.1'
+                self.is_admin = True
+
+        self.stubs.Set(context, 'RequestContext', FakeRequestContext)
+        req = webob.Request.blank('/v1.1/servers/detail')
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+
+        i = 0
+        for s in res_dict['servers']:
+            self.assertEqual(s['id'], i)
+            self.assertEqual(s['hostId'], '')
+            self.assertEqual(s['name'], 'server%d' % i)
+            self.assertEqual(s['imageRef'], 'http://localhost/v1.1/images/10')
+            self.assertEqual(s['flavorRef'], 'http://localhost/v1.1/flavors/1')
             self.assertEqual(s['metadata']['seq'], i)
             i += 1
 
-- 
cgit 


From 354f5e61c4bfb32ad8c2bc3389678f19db5fdb56 Mon Sep 17 00:00:00 2001
From: Brian Waldon <brian.waldon@rackspace.com>
Date: Tue, 15 Mar 2011 00:55:52 -0400
Subject: pep8 fixes

---
 nova/api/openstack/servers.py       |  3 ---
 nova/api/openstack/views/servers.py | 12 +++++++-----
 2 files changed, 7 insertions(+), 8 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 7bb7250ba..de67cbc4a 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -436,6 +436,3 @@ class Controller(wsgi.Controller):
                 _("Ramdisk not found for image %(image_id)s") % locals())
 
         return kernel_id, ramdisk_id
-
-
-
diff --git a/nova/api/openstack/views/servers.py b/nova/api/openstack/views/servers.py
index 950662747..15ac9964c 100644
--- a/nova/api/openstack/views/servers.py
+++ b/nova/api/openstack/views/servers.py
@@ -16,7 +16,8 @@ def get_view_builder(req):
     if version == '1.1':
         flavor_builder = flavors_view.get_view_builder(req)
         image_builder = images_view.get_view_builder(req)
-        return ViewBuilder_1_1(addresses_builder, flavor_builder, image_builder)
+        return ViewBuilder_1_1(addresses_builder, flavor_builder,
+                               image_builder)
     else:
         return ViewBuilder_1_0(addresses_builder)
 
@@ -28,8 +29,10 @@ class ViewBuilder(object):
         self.addresses_builder = addresses_builder
 
     def build(self, inst, is_detail):
-        """ Coerces into dictionary format, mapping everything to Rackspace-like
-        attributes for return"""
+        """
+        Coerces into dictionary format, mapping everything to
+        Rackspace-like attributes for return
+        """
         if is_detail:
             return self._build_detail(inst)
         else:
@@ -106,6 +109,5 @@ class ViewBuilder_1_1(ViewBuilder):
 
     def _build_flavor_ref(self, response, inst):
         flavor_id = inst["instance_type"]
-        response["flavorRef"]= self.flavor_builder.generate_href(flavor_id)
+        response["flavorRef"] = self.flavor_builder.generate_href(flavor_id)
         return response
-
-- 
cgit 


From 2b20306fcaddcb6b9bc57fb55b17230d709cd1ce Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Mon, 14 Mar 2011 22:23:38 -0700
Subject: Derive unit test from standard nova.test.TestCase

---
 nova/tests/integrated/test_login.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/tests/integrated/test_login.py b/nova/tests/integrated/test_login.py
index e362f92d6..5fa558bdf 100644
--- a/nova/tests/integrated/test_login.py
+++ b/nova/tests/integrated/test_login.py
@@ -18,6 +18,7 @@
 import unittest
 
 from nova import flags
+from nova import test
 from nova.log import logging
 from nova.tests.integrated import integrated_helpers
 from nova.tests.integrated.api import client
@@ -29,7 +30,7 @@ FLAGS = flags.FLAGS
 FLAGS.verbose = True
 
 
-class LoginTest(unittest.TestCase):
+class LoginTest(test.TestCase):
     def setUp(self):
         super(LoginTest, self).setUp()
         context = integrated_helpers.IntegratedUnitTestContext.startup()
@@ -73,5 +74,6 @@ class LoginTest(unittest.TestCase):
         self.assertRaises(client.OpenstackApiAuthenticationException,
                           bad_credentials_api.get_flavors)
 
+
 if __name__ == "__main__":
     unittest.main()
-- 
cgit 


From db8beffc9acd90c748512c1fa9c127d39756232c Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Mon, 14 Mar 2011 22:36:30 -0700
Subject: Reapplied rename of Openstack -> OpenStack.  Easier to do it by hand
 than to ask Bazaar to do it.

---
 nova/tests/integrated/api/client.py | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/integrated/api/client.py b/nova/tests/integrated/api/client.py
index 6fba2930a..568e8c17e 100644
--- a/nova/tests/integrated/api/client.py
+++ b/nova/tests/integrated/api/client.py
@@ -24,7 +24,7 @@ from nova import log as logging
 LOG = logging.getLogger('nova.tests.api')
 
 
-class OpenstackApiException(Exception):
+class OpenStackApiException(Exception):
     def __init__(self, message=None, response=None):
         self.response = response
         if not message:
@@ -37,22 +37,22 @@ class OpenstackApiException(Exception):
             message = _('%(message)s\nStatus Code: %(_status)s\n'
                         'Body: %(_body)s') % locals()
 
-        super(OpenstackApiException, self).__init__(message)
+        super(OpenStackApiException, self).__init__(message)
 
 
-class OpenstackApiAuthenticationException(OpenstackApiException):
+class OpenStackApiAuthenticationException(OpenStackApiException):
     def __init__(self, response=None, message=None):
         if not message:
             message = _("Authentication error")
-        super(OpenstackApiAuthenticationException, self).__init__(message,
+        super(OpenStackApiAuthenticationException, self).__init__(message,
                                                                   response)
 
 
-class OpenstackApiNotFoundException(OpenstackApiException):
+class OpenStackApiNotFoundException(OpenStackApiException):
     def __init__(self, response=None, message=None):
         if not message:
             message = _("Item not found")
-        super(OpenstackApiNotFoundException, self).__init__(message, response)
+        super(OpenStackApiNotFoundException, self).__init__(message, response)
 
 
 class TestOpenStackClient(object):
@@ -82,7 +82,7 @@ class TestOpenStackClient(object):
             conn = httplib.HTTPSConnection(hostname,
                                            port=port)
         else:
-            raise OpenstackApiException("Unknown scheme: %s" % url)
+            raise OpenStackApiException("Unknown scheme: %s" % url)
 
         relative_url = parsed_url.path
         if parsed_url.query:
@@ -112,7 +112,7 @@ class TestOpenStackClient(object):
         # bug732866
         #if http_status == 401:
         if http_status != 204:
-            raise OpenstackApiAuthenticationException(response=response)
+            raise OpenStackApiAuthenticationException(response=response)
 
         auth_headers = {}
         for k, v in response.getheaders():
@@ -139,9 +139,9 @@ class TestOpenStackClient(object):
         if check_response_status:
             if not http_status in check_response_status:
                 if http_status == 404:
-                    raise OpenstackApiNotFoundException(response=response)
+                    raise OpenStackApiNotFoundException(response=response)
                 else:
-                    raise OpenstackApiException(
+                    raise OpenStackApiException(
                                         message=_("Unexpected status code"),
                                         response=response)
 
-- 
cgit 


From ad6f82909060cd4d1d99a1b1a9f33aa2788d8c94 Mon Sep 17 00:00:00 2001
From: Rick Harris <rick.harris@rackspace.com>
Date: Tue, 15 Mar 2011 05:37:08 +0000
Subject: serverId returned as int per spec

---
 nova/api/openstack/images.py            |  4 +--
 nova/image/glance.py                    | 63 +++++++++++++++++++++------------
 nova/tests/api/openstack/test_images.py | 39 ++++++++++----------
 3 files changed, 64 insertions(+), 42 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/images.py b/nova/api/openstack/images.py
index 7b3800429..0c56b5f0d 100644
--- a/nova/api/openstack/images.py
+++ b/nova/api/openstack/images.py
@@ -116,7 +116,7 @@ def _translate_s3_like_images(image_metadata):
     return api_metadata
 
 
-def _translate_metadata_for_api_detail(image_metadata):
+def _translate_from_image_service_to_api(image_metadata):
     """Translate from ImageService to OpenStack API style attribute names
 
     This involves 3 steps:
@@ -227,7 +227,7 @@ class Controller(wsgi.Controller):
         if s3_like_image:
             translate = _translate_s3_like_images
         else:
-            translate = _translate_metadata_for_api_detail
+            translate = _translate_from_image_service_to_api
 
         api_image_metas = [translate(service_image_meta)
                            for service_image_meta in service_image_metas]
diff --git a/nova/image/glance.py b/nova/image/glance.py
index 63a3faa0f..ae831e270 100644
--- a/nova/image/glance.py
+++ b/nova/image/glance.py
@@ -52,9 +52,8 @@ class GlanceImageService(service.BaseImageService):
         Calls out to Glance for a list of detailed image information
         """
         image_metas = self.client.get_images_detailed()
-        return image_metas
-        return [self._depropertify_metadata_from_glance(image_meta)
-                for image_meta in image_metas]
+        translate = self._translate_from_glance_to_image_service
+        return [translate(image_meta) for image_meta in image_metas]
 
     def show(self, context, image_id):
         """
@@ -65,7 +64,7 @@ class GlanceImageService(service.BaseImageService):
         except glance_exception.NotFound:
             raise exception.NotFound
 
-        meta = self._depropertify_metadata_from_glance(metadata)
+        meta = self._translate_from_glance_to_image_service(metadata)
         return meta
 
     def show_by_name(self, context, name):
@@ -95,7 +94,7 @@ class GlanceImageService(service.BaseImageService):
         for chunk in image_chunks:
             data.write(chunk)
 
-        meta = self._depropertify_metadata_from_glance(metadata)
+        meta = self._translate_from_glance_to_image_service(metadata)
         return meta
 
     def create(self, context, metadata, data=None):
@@ -107,8 +106,7 @@ class GlanceImageService(service.BaseImageService):
         """
         LOG.debug(_("Creating image in Glance. Metdata passed in %s"),
                   metadata)
-
-        meta = self._propertify_metadata_for_glance(metadata)
+        meta = self._translate_from_image_service_to_glance(metadata)
         LOG.debug(_("Metadata after formatting for Glance %s"), meta)
         return self.client.add_image(meta, data)
 
@@ -144,7 +142,7 @@ class GlanceImageService(service.BaseImageService):
         pass
 
     @classmethod
-    def _propertify_metadata_for_glance(cls, metadata):
+    def _translate_from_image_service_to_glance(cls, metadata):
         """Return a metadata dict suitable for passing to Glance.
 
         The ImageService exposes metadata as a flat-dict; however, Glance
@@ -161,25 +159,46 @@ class GlanceImageService(service.BaseImageService):
         metadata, figures out which attributes are stored as image properties
         in Glance, and then adds those to a `properties` dict nested within
         the metadata.
+
         """
-        new_metadata = metadata.copy()
+        glance_metadata = metadata.copy()
         properties = {}
         for property_ in cls.IMAGE_PROPERTIES:
-            if property_ in new_metadata:
-                value = new_metadata.pop(property_)
-                properties[property_] = value
-        new_metadata['properties'] = properties
-        return new_metadata
+            if property_ in glance_metadata:
+                value = glance_metadata.pop(property_)
+                properties[property_] = str(value)
+        glance_metadata['properties'] = properties
+        return glance_metadata
 
     @classmethod
-    def _depropertify_metadata_from_glance(cls, metadata):
-        """Return a metadata dict suitable for returning from ImageService
+    def _translate_from_glance_to_image_service(cls, metadata):
+        """Convert Glance-style image metadata to ImageService-style
+
+        The steps in involved are:
+
+            1. Extracting Glance properties and making them ImageService
+               attributes
+
+            2. Converting any strings to appropriate values
         """
-        new_metadata = metadata.copy()
-        if 'properties' in new_metadata:
-            properties = new_metadata.pop('properties')
+        service_metadata = metadata.copy()
+
+        # 1. Extract properties
+        if 'properties' in service_metadata:
+            properties = service_metadata.pop('properties')
             for property_ in cls.IMAGE_PROPERTIES:
-                if property_ in properties and property_ not in new_metadata:
+                if ((property_ in properties) and
+                    (property_ not in service_metadata)):
                     value = properties[property_]
-                    new_metadata[property_] = value
-        return new_metadata
+                    service_metadata[property_] = value
+
+        # 2. Convert values
+        try:
+            service_metadata['instance_id'] = int(
+                service_metadata['instance_id'])
+        except KeyError:
+            pass  # instance_id is not required
+        except TypeError:
+            pass  # instance_id can be None
+
+        return service_metadata
diff --git a/nova/tests/api/openstack/test_images.py b/nova/tests/api/openstack/test_images.py
index 47cb7e74c..4604b331e 100644
--- a/nova/tests/api/openstack/test_images.py
+++ b/nova/tests/api/openstack/test_images.py
@@ -156,7 +156,17 @@ class LocalImageServiceTest(test.TestCase,
 class GlanceImageServiceTest(test.TestCase,
                              BaseImageServiceTests):
 
-    """Tests the Glance image service"""
+    """Tests the Glance image service, in particular that metadata translation
+    works properly.
+
+    At a high level, the translations involved are:
+
+        1. Glance -> ImageService - This is needed so we can support
+           multple ImageServices (Glance, Local, etc)
+
+        2. ImageService -> API - This is needed so we can support multple
+           APIs (OpenStack, EC2)
+    """
 
     def setUp(self):
         super(GlanceImageServiceTest, self).setUp()
@@ -174,21 +184,17 @@ class GlanceImageServiceTest(test.TestCase,
         self.stubs.UnsetAll()
         super(GlanceImageServiceTest, self).tearDown()
 
-    def test_create_propertified_images_with_instance_id(self):
+    def test_create_with_instance_id(self):
         """
-        Some attributes are passed to Glance as image-properties (ex.
-        instance_id).
-
-        This tests asserts that the ImageService exposes them as if they were
-        first-class attribrutes, but that they are passed to Glance as image
-        properties.
+        Ensure that a instance_id is stored in Glance as a image property
+        string and then converted back to an instance_id integer attribute.
         """
         fixture = {'instance_id': 42, 'name': 'test image'}
         image_id = self.service.create(self.context, fixture)['id']
 
         expected = {'id': image_id,
                     'name': 'test image',
-                    'properties': {'instance_id': 42}}
+                    'properties': {'instance_id': '42'}}
         self.assertDictMatch(self.sent_to_glance['metadata'], expected)
 
         # The ImageService shouldn't leak the fact that the instance_id
@@ -197,17 +203,14 @@ class GlanceImageServiceTest(test.TestCase,
         image_meta = self.service.show(self.context, image_id)
         self.assertDictMatch(image_meta, expected)
 
-        #image_metas = self.service.detail(self.context)
-        #self.assertDictMatch(image_metas[0], expected)
+        image_metas = self.service.detail(self.context)
+        self.assertDictMatch(image_metas[0], expected)
 
-    def test_create_propertified_images_without_instance_id(self):
+    def test_create_without_instance_id(self):
         """
-        Some attributes are passed to Glance as image-properties (ex.
-        instance_id).
-
-        This tests asserts that the ImageService exposes them as if they were
-        first-class attribrutes, but that they are passed to Glance as image
-        properties.
+        Ensure we can create an image without having to specify an
+        instance_id. Public images are an example of an image not tied to an
+        instance.
         """
         fixture = {'name': 'test image'}
         image_id = self.service.create(self.context, fixture)['id']
-- 
cgit 


From e0563f49792441af106c52e662bdada3c7997feb Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Mon, 14 Mar 2011 22:43:21 -0700
Subject: Reapplied rename to another file.

---
 nova/tests/integrated/test_login.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/integrated/test_login.py b/nova/tests/integrated/test_login.py
index 5fa558bdf..501f8c919 100644
--- a/nova/tests/integrated/test_login.py
+++ b/nova/tests/integrated/test_login.py
@@ -53,7 +53,7 @@ class LoginTest(test.TestCase):
                                                          "notso_password",
                                                          self.user.auth_url)
 
-        self.assertRaises(client.OpenstackApiAuthenticationException,
+        self.assertRaises(client.OpenStackApiAuthenticationException,
                           bad_credentials_api.get_flavors)
 
     def test_bad_login_username(self):
@@ -62,7 +62,7 @@ class LoginTest(test.TestCase):
                                                          self.user.secret,
                                                          self.user.auth_url)
 
-        self.assertRaises(client.OpenstackApiAuthenticationException,
+        self.assertRaises(client.OpenStackApiAuthenticationException,
                           bad_credentials_api.get_flavors)
 
     def test_bad_login_both_bad(self):
@@ -71,7 +71,7 @@ class LoginTest(test.TestCase):
                                                          "notso_password",
                                                          self.user.auth_url)
 
-        self.assertRaises(client.OpenstackApiAuthenticationException,
+        self.assertRaises(client.OpenStackApiAuthenticationException,
                           bad_credentials_api.get_flavors)
 
 
-- 
cgit 


From 8a41046dc7cafb19afb6719866b11681daaa9082 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
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')

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 e161b00349a7478ac9f51f087c9f16cd345bc2d2 Mon Sep 17 00:00:00 2001
From: Brian Waldon <brian.waldon@rackspace.com>
Date: Tue, 15 Mar 2011 13:23:42 -0400
Subject: adding missing view modules; modifying a couple of servers tests to
 use enumerate

---
 nova/api/openstack/views/addresses.py    | 38 +++++++++++++++++++++++++++++++
 nova/api/openstack/views/flavors.py      | 39 ++++++++++++++++++++++++++++++++
 nova/api/openstack/views/images.py       | 39 ++++++++++++++++++++++++++++++++
 nova/tests/api/openstack/test_servers.py |  8 ++-----
 4 files changed, 118 insertions(+), 6 deletions(-)
 create mode 100644 nova/api/openstack/views/addresses.py
 create mode 100644 nova/api/openstack/views/flavors.py
 create mode 100644 nova/api/openstack/views/images.py

(limited to 'nova')

diff --git a/nova/api/openstack/views/addresses.py b/nova/api/openstack/views/addresses.py
new file mode 100644
index 000000000..d764e5229
--- /dev/null
+++ b/nova/api/openstack/views/addresses.py
@@ -0,0 +1,38 @@
+import hashlib
+from nova.compute import power_state
+from nova import utils
+
+
+def get_view_builder(req):
+    '''
+    A factory method that returns the correct builder based on the version of
+    the api requested.
+    '''
+    version = req.environ['nova.context'].version
+    if version == '1.1':
+        return ViewBuilder_1_1()
+    else:
+        return ViewBuilder_1_0()
+
+
+class ViewBuilder(object):
+    ''' Models a server addresses response as a python dictionary.'''
+
+    def build(self, inst):
+        raise NotImplementedError()
+
+
+class ViewBuilder_1_0(ViewBuilder):
+    def build(self, inst):
+        private_ips = utils.get_from_path(inst, 'fixed_ip/address')
+        public_ips = utils.get_from_path(inst, 'fixed_ip/floating_ips/address')
+        return dict(public=public_ips, private=private_ips)
+
+
+class ViewBuilder_1_1(ViewBuilder):
+    def build(self, inst):
+        private_ips = utils.get_from_path(inst, 'fixed_ip/address')
+        private_ips = [dict(version=4, addr=a) for a in private_ips]
+        public_ips = utils.get_from_path(inst, 'fixed_ip/floating_ips/address')
+        public_ips = [dict(version=4, addr=a) for a in public_ips]
+        return dict(public=public_ips, private=private_ips)
diff --git a/nova/api/openstack/views/flavors.py b/nova/api/openstack/views/flavors.py
new file mode 100644
index 000000000..c6b6c10bb
--- /dev/null
+++ b/nova/api/openstack/views/flavors.py
@@ -0,0 +1,39 @@
+
+
+def get_view_builder(req):
+    '''
+    A factory method that returns the correct builder based on the version of
+    the api requested.
+    '''
+    version = req.environ['nova.context'].version
+    base_url = req.application_url
+    if version == '1.1':
+        return ViewBuilder_1_1(base_url)
+    else:
+        return ViewBuilder_1_0()
+
+
+class ViewBuilder(object):
+    def __init__(self):
+        pass
+
+    def build(self, flavor_obj):
+        raise NotImplementedError()
+
+    def _decorate_response(self, response, flavor_obj):
+        return response
+
+
+class ViewBuilder_1_1(ViewBuilder):
+    def __init__(self, base_url):
+        self.base_url = base_url
+
+    def _decorate_response(self, response, flavor_obj):
+        raise NotImplementedError()
+
+    def generate_href(self, flavor_id):
+        return "{0}/flavors/{1}".format(self.base_url, flavor_id)
+
+
+class ViewBuilder_1_0(ViewBuilder):
+    pass
diff --git a/nova/api/openstack/views/images.py b/nova/api/openstack/views/images.py
new file mode 100644
index 000000000..c80713250
--- /dev/null
+++ b/nova/api/openstack/views/images.py
@@ -0,0 +1,39 @@
+
+
+def get_view_builder(req):
+    '''
+    A factory method that returns the correct builder based on the version of
+    the api requested.
+    '''
+    version = req.environ['nova.context'].version
+    base_url = req.application_url
+    if version == '1.1':
+        return ViewBuilder_1_1(base_url)
+    else:
+        return ViewBuilder_1_0()
+
+
+class ViewBuilder(object):
+    def __init__(self):
+        pass
+
+    def build(self, image_obj):
+        raise NotImplementedError()
+
+    def _decorate_response(self, response, image_obj):
+        return response
+
+
+class ViewBuilder_1_1(ViewBuilder):
+    def __init__(self, base_url):
+        self.base_url = base_url
+
+    def _decorate_response(self, response, image_obj):
+        raise NotImplementedError()
+
+    def generate_href(self, image_id):
+        return "{0}/images/{1}".format(self.base_url, image_id)
+
+
+class ViewBuilder_1_0(ViewBuilder):
+    pass
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index b42cecfbb..ad2fa2497 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -358,15 +358,13 @@ class ServersTest(test.TestCase):
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
 
-        i = 0
-        for s in res_dict['servers']:
+        for i,s in enumerate(res_dict['servers']):
             self.assertEqual(s['id'], i)
             self.assertEqual(s['hostId'], '')
             self.assertEqual(s['name'], 'server%d' % i)
             self.assertEqual(s['imageId'], '10')
             self.assertEqual(s['flavorId'], '1')
             self.assertEqual(s['metadata']['seq'], i)
-            i += 1
 
     def test_get_all_server_details_v1_1(self):
         class FakeRequestContext(object):
@@ -381,15 +379,13 @@ class ServersTest(test.TestCase):
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
 
-        i = 0
-        for s in res_dict['servers']:
+        for i,s in enumerate(res_dict['servers']):
             self.assertEqual(s['id'], i)
             self.assertEqual(s['hostId'], '')
             self.assertEqual(s['name'], 'server%d' % i)
             self.assertEqual(s['imageRef'], 'http://localhost/v1.1/images/10')
             self.assertEqual(s['flavorRef'], 'http://localhost/v1.1/flavors/1')
             self.assertEqual(s['metadata']['seq'], i)
-            i += 1
 
     def test_get_all_server_details_with_host(self):
         '''
-- 
cgit 


From 56ff68056254610c4f0eb5cd5c5432a68ed30b2f Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Tue, 15 Mar 2011 10:42:32 -0700
Subject: Support testing the OpenStack API without key_pairs

---
 nova/tests/api/openstack/fakes.py        | 11 +++++++++--
 nova/tests/api/openstack/test_servers.py |  9 ++++++++-
 2 files changed, 17 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/fakes.py b/nova/tests/api/openstack/fakes.py
index e50d11a3d..ccc853360 100644
--- a/nova/tests/api/openstack/fakes.py
+++ b/nova/tests/api/openstack/fakes.py
@@ -85,10 +85,17 @@ def wsgi_app(inner_application=None):
     return mapper
 
 
-def stub_out_key_pair_funcs(stubs):
+def stub_out_key_pair_funcs(stubs, have_key_pair=True):
     def key_pair(context, user_id):
         return [dict(name='key', public_key='public_key')]
-    stubs.Set(nova.db, 'key_pair_get_all_by_user', key_pair)
+
+    def no_key_pair(context, user_id):
+        return []
+
+    if have_key_pair:
+        stubs.Set(nova.db, 'key_pair_get_all_by_user', key_pair)
+    else:
+        stubs.Set(nova.db, 'key_pair_get_all_by_user', no_key_pair)
 
 
 def stub_out_image_service(stubs):
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 5d7a208e9..40026a615 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -216,7 +216,7 @@ class ServersTest(test.TestCase):
         servers = json.loads(res.body)['servers']
         self.assertEqual([s['id'] for s in servers], [1, 2])
 
-    def test_create_instance(self):
+    def _test_create_instance_helper(self, with_key_pair):
         def instance_create(context, inst):
             return {'id': '1', 'display_name': 'server_test'}
 
@@ -271,6 +271,13 @@ class ServersTest(test.TestCase):
 
         self.assertEqual(res.status_int, 200)
 
+    def test_create_instance(self):
+        self._test_create_instance_helper(True)
+
+    def test_create_instance_no_key_pair(self):
+        fakes.stub_out_key_pair_funcs(self.stubs, False)
+        self._test_create_instance_helper(False)
+
     def test_update_no_body(self):
         req = webob.Request.blank('/v1.0/servers/1')
         req.method = 'PUT'
-- 
cgit 


From 22aad6700124411aceed0b2bd3953cbbc48b6130 Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Tue, 15 Mar 2011 11:24:07 -0700
Subject: Use random.SystemRandom for easy secure randoms, configurable symbol
 set by default including mixed-case

---
 nova/utils.py | 26 ++++++++++++++++----------
 1 file changed, 16 insertions(+), 10 deletions(-)

(limited to 'nova')

diff --git a/nova/utils.py b/nova/utils.py
index 0510c3cbe..199ee8701 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -262,19 +262,25 @@ def generate_mac():
     return ':'.join(map(lambda x: "%02x" % x, mac))
 
 
-def generate_password(length=20):
-    """Generate a random alphanumeric password, avoiding 'confusing' O,0,I,1.
+# Default symbols to use for passwords. Avoids visually confusing characters.
+# ~6 bits per symbol
+DEFAULT_PASSWORD_SYMBOLS = ("23456789"  # Removed: 0,1
+                            "ABCDEFGHJKLMNPQRSTUVWXYZ"  # Removed: I, O
+                            "abcdefghijkmnopqrstuvwxyz")  # Removed: l
+
+
+# ~5 bits per symbol
+EASIER_PASSWORD_SYMBOLS = ("23456789"  # Removed: 0, 1
+                           "ABCDEFGHJKLMNPQRSTUVWXYZ")  # Removed: I, O
+
+
+def generate_password(length=20, symbols=DEFAULT_PASSWORD_SYMBOLS):
+    """Generate a random password from the supplied symbols.
 
     Believed to be reasonably secure (with a reasonable password length!)
     """
-    # 26 letters, 10 digits = 36 choices
-    # Remove O, 0, I, 1 => 32 choices
-    # 32 choices means we're just using the low 5 bit of each byte,
-    # so there's no bias introduced by using a modulo
-    chrs = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789"
-
-    random_bytes = os.urandom(length)
-    return "".join([chrs[ord(random_bytes[i]) % 32] for i in xrange(length)])
+    r = random.SystemRandom()
+    return "".join([r.choice(symbols) for _i in xrange(length)])
 
 
 def last_octet(address):
-- 
cgit 


From 937c135ec0c8b557b22ad30c400c75c713f660e1 Mon Sep 17 00:00:00 2001
From: Naveed Massjouni <naveedm9@gmail.com>
Date: Tue, 15 Mar 2011 14:31:48 -0400
Subject: Code clean up. Removing _decorate_response methods. Replaced them
 with more explicit methods, _build_image, and _build_flavor.

---
 nova/api/openstack/views/flavors.py |  6 ------
 nova/api/openstack/views/images.py  |  6 ------
 nova/api/openstack/views/servers.py | 30 ++++++++++++++++--------------
 3 files changed, 16 insertions(+), 26 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/views/flavors.py b/nova/api/openstack/views/flavors.py
index c6b6c10bb..dfcc2644c 100644
--- a/nova/api/openstack/views/flavors.py
+++ b/nova/api/openstack/views/flavors.py
@@ -20,17 +20,11 @@ class ViewBuilder(object):
     def build(self, flavor_obj):
         raise NotImplementedError()
 
-    def _decorate_response(self, response, flavor_obj):
-        return response
-
 
 class ViewBuilder_1_1(ViewBuilder):
     def __init__(self, base_url):
         self.base_url = base_url
 
-    def _decorate_response(self, response, flavor_obj):
-        raise NotImplementedError()
-
     def generate_href(self, flavor_id):
         return "{0}/flavors/{1}".format(self.base_url, flavor_id)
 
diff --git a/nova/api/openstack/views/images.py b/nova/api/openstack/views/images.py
index c80713250..cd61ed656 100644
--- a/nova/api/openstack/views/images.py
+++ b/nova/api/openstack/views/images.py
@@ -20,17 +20,11 @@ class ViewBuilder(object):
     def build(self, image_obj):
         raise NotImplementedError()
 
-    def _decorate_response(self, response, image_obj):
-        return response
-
 
 class ViewBuilder_1_1(ViewBuilder):
     def __init__(self, base_url):
         self.base_url = base_url
 
-    def _decorate_response(self, response, image_obj):
-        raise NotImplementedError()
-
     def generate_href(self, image_id):
         return "{0}/images/{1}".format(self.base_url, image_id)
 
diff --git a/nova/api/openstack/views/servers.py b/nova/api/openstack/views/servers.py
index 15ac9964c..708c74b4e 100644
--- a/nova/api/openstack/views/servers.py
+++ b/nova/api/openstack/views/servers.py
@@ -23,7 +23,10 @@ def get_view_builder(req):
 
 
 class ViewBuilder(object):
-    ''' Models a server response as a python dictionary.'''
+    '''
+    Models a server response as a python dictionary.
+    Abstract methods: _build_image, _build_flavor
+    '''
 
     def __init__(self, addresses_builder):
         self.addresses_builder = addresses_builder
@@ -76,19 +79,24 @@ class ViewBuilder(object):
         if inst['host']:
             inst_dict['hostId'] = hashlib.sha224(inst['host']).hexdigest()
 
-        inst_dict = self._decorate_response(inst_dict, inst)
+        self._build_image(inst_dict, inst)
+        self._build_flavor(inst_dict, inst)
 
         return dict(server=inst_dict)
 
-    def _build_image_data(self, response, inst):
+    def _build_image(self, response, inst):
+        raise NotImplementedError()
+
+    def _build_flavor(self, response, inst):
         raise NotImplementedError()
 
 
 class ViewBuilder_1_0(ViewBuilder):
-    def _decorate_response(self, response, inst):
+    def _build_image(self, response, inst):
         response["imageId"] = inst["image_id"]
+
+    def _build_flavor(self, response, inst):
         response["flavorId"] = inst["instance_type"]
-        return response
 
 
 class ViewBuilder_1_1(ViewBuilder):
@@ -97,17 +105,11 @@ class ViewBuilder_1_1(ViewBuilder):
         self.flavor_builder = flavor_builder
         self.image_builder = image_builder
 
-    def _decorate_response(self, response, inst):
-        response = self._build_image_ref(response, inst)
-        response = self._build_flavor_ref(response, inst)
-        return response
-
-    def _build_image_ref(self, response, inst):
+    def _build_image(self, response, inst):
         image_id = inst["image_id"]
         response["imageRef"] = self.image_builder.generate_href(image_id)
-        return response
 
-    def _build_flavor_ref(self, response, inst):
+    def _build_flavor(self, response, inst):
         flavor_id = inst["instance_type"]
         response["flavorRef"] = self.flavor_builder.generate_href(flavor_id)
-        return response
+
-- 
cgit 


From 1d69d499124317aa1a9cf7d4bc54db2ff0bc3be9 Mon Sep 17 00:00:00 2001
From: Mark Washenberger <mark.washenberger@rackspace.com>
Date: Tue, 15 Mar 2011 14:33:45 -0400
Subject: refactor onset_files quota checking

---
 nova/compute/api.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/api.py b/nova/compute/api.py
index b6ef889f6..c11059a28 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -86,6 +86,8 @@ class API(base.Base):
 
         Raises a QuotaError if any limit is exceeded
         """
+        if onset_files is None:
+            return
         limit = quota.allowed_onset_files(context)
         if len(onset_files) > limit:
             raise quota.QuotaError(code="OnsetFileLimitExceeded")
@@ -96,7 +98,6 @@ class API(base.Base):
                 raise quota.QuotaError(code="OnsetFilePathLimitExceeded")
             if len(content) > content_limit:
                 raise quota.QuotaError(code="OnsetFileContentLimitExceeded")
-        return onset_files
 
     def create(self, context, instance_type,
                image_id, kernel_id=None, ramdisk_id=None,
@@ -142,8 +143,7 @@ class API(base.Base):
                 LOG.warn(msg)
                 raise quota.QuotaError(msg, "MetadataLimitExceeded")
 
-        if onset_files is not None:
-            onset_files = self._check_onset_file_quota(context, onset_files)
+        self._check_onset_file_quota(context, onset_files)
 
         image = self.image_service.show(context, image_id)
 
-- 
cgit 


From cc25d277755f0e103ff09144d1d490536ab9acec Mon Sep 17 00:00:00 2001
From: Brian Waldon <brian.waldon@rackspace.com>
Date: Tue, 15 Mar 2011 15:56:54 -0400
Subject: modifying paste config to support v1.1; adding v1.1 entry in versions
 resource ( GET /)

---
 nova/api/openstack/__init__.py | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/__init__.py b/nova/api/openstack/__init__.py
index ce3cff337..0244bc93c 100644
--- a/nova/api/openstack/__init__.py
+++ b/nova/api/openstack/__init__.py
@@ -128,8 +128,11 @@ class Versions(wsgi.Application):
     def __call__(self, req):
         """Respond to a request for all OpenStack API versions."""
         response = {
-                "versions": [
-                    dict(status="CURRENT", id="v1.0")]}
+            "versions": [
+                dict(status="DEPRECATED", id="v1.0"),
+                dict(status="CURRENT", id="v1.1"),
+            ],
+        }
         metadata = {
             "application/xml": {
                 "attributes": dict(version=["status", "id"])}}
-- 
cgit 


From 4b49df7e7232dfd3e187faac52b9eb72773be360 Mon Sep 17 00:00:00 2001
From: Brian Lamar <brian.lamar@rackspace.com>
Date: Tue, 15 Mar 2011 16:49:19 -0400
Subject: Major cosmetic changes to limits, but little-to-no functional
 changes. MUCH better testability now, no more relying on system time to tick
 by for limit testing.

---
 nova/api/openstack/__init__.py                |   6 +
 nova/api/openstack/faults.py                  |  21 ++
 nova/api/openstack/limits.py                  | 342 ++++++++++++++++++++
 nova/tests/api/openstack/__init__.py          |   2 +-
 nova/tests/api/openstack/fakes.py             |  10 +-
 nova/tests/api/openstack/test_adminapi.py     |   1 -
 nova/tests/api/openstack/test_ratelimiting.py | 443 +++++++++++++++++---------
 7 files changed, 668 insertions(+), 157 deletions(-)
 create mode 100644 nova/api/openstack/limits.py

(limited to 'nova')

diff --git a/nova/api/openstack/__init__.py b/nova/api/openstack/__init__.py
index ce3cff337..db2dff8d5 100644
--- a/nova/api/openstack/__init__.py
+++ b/nova/api/openstack/__init__.py
@@ -33,6 +33,7 @@ from nova.api.openstack import backup_schedules
 from nova.api.openstack import consoles
 from nova.api.openstack import flavors
 from nova.api.openstack import images
+from nova.api.openstack import limits
 from nova.api.openstack import servers
 from nova.api.openstack import shared_ip_groups
 from nova.api.openstack import users
@@ -114,12 +115,17 @@ class APIRouter(wsgi.Router):
 
         mapper.resource("image", "images", controller=images.Controller(),
                         collection={'detail': 'GET'})
+
         mapper.resource("flavor", "flavors", controller=flavors.Controller(),
                         collection={'detail': 'GET'})
+
         mapper.resource("shared_ip_group", "shared_ip_groups",
                         collection={'detail': 'GET'},
                         controller=shared_ip_groups.Controller())
 
+        _limits = limits.LimitsController()
+        mapper.resource("limit", "limits", controller=_limits)
+
         super(APIRouter, self).__init__(mapper)
 
 
diff --git a/nova/api/openstack/faults.py b/nova/api/openstack/faults.py
index 2fd733299..6ed9322de 100644
--- a/nova/api/openstack/faults.py
+++ b/nova/api/openstack/faults.py
@@ -61,3 +61,24 @@ class Fault(webob.exc.HTTPException):
         content_type = req.best_match_content_type()
         self.wrapped_exc.body = serializer.serialize(fault_data, content_type)
         return self.wrapped_exc
+
+
+class OverLimitFault(webob.exc.HTTPException):
+    """
+    Rate-limited request response.
+    """
+
+    wrapped_exc = webob.exc.HTTPForbidden()
+
+    def __init__(self, message, details, retry_time):
+        """
+        Initialize new `OverLimitFault` with relevant information.
+        """
+        self.message = message
+        self.details = details
+        self.retry_time = retry_time
+
+    @webob.dec.wsgify(RequestClass=wsgi.Request)
+    def __call__(self, request):
+        """Currently just return the wrapped exception."""
+        return self.wrapped_exc
diff --git a/nova/api/openstack/limits.py b/nova/api/openstack/limits.py
new file mode 100644
index 000000000..4f64cab3c
--- /dev/null
+++ b/nova/api/openstack/limits.py
@@ -0,0 +1,342 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 OpenStack LLC.
+# 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.import datetime
+
+"""
+Module dedicated functions/classes dealing with rate limiting requests.
+"""
+
+import copy
+import httplib
+import json
+import math
+import re
+import time
+import urllib
+import webob.exc
+
+from collections import defaultdict
+
+from webob.dec import wsgify
+
+from nova import wsgi
+from nova.api.openstack import faults
+from nova.wsgi import Controller
+from nova.wsgi import Middleware
+
+
+# Convenience constants for the limits dictionary passed to Limiter().
+PER_SECOND = 1
+PER_MINUTE = 60
+PER_HOUR = 60 * 60
+PER_DAY = 60 * 60 * 24
+
+
+class LimitsController(Controller):
+    """
+    Controller for accessing limits in the OpenStack API.
+    """
+
+    def index(self, req):
+        """
+        Return all global and rate limit information.
+        """
+        abs_limits = {}
+        rate_limits = req.environ.get("nova.limits", {})
+
+        return {
+            "limits" : {
+                "rate" : rate_limits,
+                "absolute" : abs_limits,
+            },
+        }
+        
+
+class Limit(object):
+    """
+    Stores information about a limit for HTTP requets.
+    """
+
+    UNITS = {
+        1 : "SECOND",
+        60 : "MINUTE",
+        60 * 60 : "HOUR",
+        60 * 60 * 24 : "DAY",
+    }
+
+    def __init__(self, verb, uri, regex, value, unit):
+        """
+        Initialize a new `Limit`.
+
+        @param verb: HTTP verb (POST, PUT, etc.)
+        @param uri: Human-readable URI
+        @param regex: Regular expression format for this limit
+        @param value: Integer number of requests which can be made
+        @param unit: Unit of measure for the value parameter
+        """
+        self.verb = verb
+        self.uri = uri
+        self.regex = regex
+        self.value = int(value)
+        self.unit = unit
+        self.remaining = int(value)
+
+        if value <= 0:
+            raise ValueError("Limit value must be > 0")
+
+        self.last_request = None
+        self.next_request = None
+
+        self.water_level = 0
+        self.capacity = float(self.unit)
+        self.request_value = float(self.capacity) / float(self.value)
+
+    def __call__(self, verb, url):
+        """
+        Represents a call to this limit from a relevant request.
+
+        @param verb: string http verb (POST, GET, etc.)
+        @param url: string URL
+        """
+        if self.verb != verb or not re.match(self.regex, url):
+            return
+
+        now = self._get_time()
+
+        if self.last_request is None:
+            self.last_request = now
+
+        leak_value = now - self.last_request
+
+        self.water_level -= leak_value
+        self.water_level = max(self.water_level, 0)
+        self.water_level += self.request_value
+
+        difference = self.water_level - self.capacity
+
+        self.last_request = now
+
+        if difference > 0:
+            self.water_level -= self.request_value
+            self.next_request = now + difference
+            return difference
+
+        cap = self.capacity
+        water = self.water_level
+        val = self.value
+ 
+        self.remaining = math.floor((cap - water) / cap * val)
+        print "Remaining:", self.remaining
+        self.next_request = now
+
+    def _get_time(self):
+        """Retrieve the current time. Broken out for testability."""
+        return time.time() 
+
+    def display_unit(self):
+        """Display the string name of the unit."""
+        return self.UNITS.get(self.unit, "UNKNOWN")
+
+    def display(self):
+        """Return a useful representation of this class."""
+        return {
+            "verb" : self.verb,
+            "uri" : self.uri,
+            "regex" : self.regex,
+            "value" : self.value,
+            "remaining" : int(self.remaining),
+            "unit" : self.display_unit(),
+            "resetTime" : int(self.next_request or self._get_time()),
+        }
+
+
+
+# "Limit" format is a dictionary with the HTTP verb, human-readable URI,
+# a regular-expression to match, value and unit of measure (PER_DAY, etc.)
+
+DEFAULT_LIMITS = [
+    Limit("POST", "*", ".*", 10, PER_MINUTE),
+    Limit("POST", "*/servers", "^/servers", 50, PER_DAY),
+    Limit("PUT", "*", ".*", 10, PER_MINUTE),
+    Limit("GET", "*changes-since*", ".*changes-since.*", 3, PER_MINUTE),
+    Limit("DELETE", "*", ".*", 100, PER_MINUTE),
+]
+
+
+class RateLimitingMiddleware(Middleware):
+    """
+    Rate-limits requests passing through this middleware. All limit information
+    is stored in memory for this implementation.
+    """
+
+    def __init__(self, application, limits=None):
+        """
+        Initialize new `RateLimitingMiddleware`, which wraps the given WSGI
+        application and sets up the given limits.
+
+        @param application: WSGI application to wrap
+        @param limits: List of dictionaries describing limits
+        """
+        Middleware.__init__(self, application)
+        self._limiter = Limiter(limits or DEFAULT_LIMITS)
+
+    @wsgify(RequestClass=wsgi.Request)
+    def __call__(self, req):
+        """
+        Represents a single call through this middleware. We should record the
+        request if we have a limit relevant to it. If no limit is relevant to
+        the request, ignore it.
+
+        If the request should be rate limited, return a fault telling the user
+        they are over the limit and need to retry later.
+        """
+        verb = req.method
+        url = req.url
+        username = req.environ["nova.context"].user_id
+
+        delay = self._limiter.check_for_delay(verb, url, username)
+
+        if delay:
+            msg = "This request was rate-limited."
+            details = "Error details."
+            retry = time.time() + delay
+            return faults.OverLimitFault(msg, details, retry)
+
+        req.environ["nova.limits"] = self._limiter.get_limits(username)
+
+        return self.application
+
+
+class Limiter(object):
+    """
+    Rate-limit checking class which handles limits in memory.
+    """
+
+    def __init__(self, limits):
+        """
+        Initialize the new `Limiter`.
+
+        @param limits: List of `Limit` objects
+        """
+        self.limits = copy.deepcopy(limits)
+        self.levels = defaultdict(lambda: copy.deepcopy(limits))
+
+    def get_limits(self, username=None):
+        """
+        Return the limits for a given user.
+        """
+        return [limit.display() for limit in self.levels[username]]
+
+    def check_for_delay(self, verb, url, username=None):
+        """
+        Check the given verb/user/user triplet for limit.
+        """
+        def _get_delay_list():
+            """Yield limit delays."""
+            for limit in self.levels[username]:
+                delay = limit(verb, url)
+                if delay:
+                    yield delay
+
+        delays = list(_get_delay_list())
+
+        if delays:
+            delays.sort()
+            return delays[0]
+
+
+class WsgiLimiter(object):
+    """
+    Rate-limit checking from a WSGI application. Uses an in-memory `Limiter`.
+
+    To use:
+        POST /<username> with JSON data such as:
+        {
+            "verb" : GET,
+            "path" : "/servers"
+        }
+
+    and receive a 204 No Content, or a 403 Forbidden with an X-Wait-Seconds
+    header containing the number of seconds to wait before the action would
+    succeed.
+    """
+
+    def __init__(self, limits=None):
+        """
+        Initialize the new `WsgiLimiter`.
+
+        @param limits: List of `Limit` objects
+        """
+        self._limiter = Limiter(limits or DEFAULT_LIMITS)
+
+    @wsgify(RequestClass=wsgi.Request)
+    def __call__(self, request):
+        """
+        Handles a call to this application. Returns 204 if the request is
+        acceptable to the limiter, else a 403 is returned with a relevant
+        header indicating when the request *will* succeed.
+        """
+        if request.method != "POST":
+            raise webob.exc.HTTPMethodNotAllowed()
+
+        try:
+            info = dict(json.loads(request.body))
+        except ValueError:
+            raise webob.exc.HTTPBadRequest()
+
+        username = request.path_info_pop()
+        verb = info.get("verb")
+        path = info.get("path")
+
+        delay = self._limiter.check_for_delay(verb, path, username)
+
+        if delay:
+            headers = {"X-Wait-Seconds": "%.2f" % delay}
+            return webob.exc.HTTPForbidden(headers=headers)
+        else:
+            return webob.exc.HTTPNoContent()
+
+
+class WsgiLimiterProxy(object):
+    """
+    Rate-limit requests based on answers from a remote source.
+    """
+
+    def __init__(self, limiter_address):
+        """
+        Initialize the new `WsgiLimiterProxy`.
+
+        @param limiter_address: IP/port combination of where to request limit
+        """
+        self.limiter_address = limiter_address
+
+    def check_for_delay(self, verb, path, username=None):
+        body = json.dumps({"verb":verb,"path":path})
+        headers = {"Content-Type" : "application/json"}
+
+        conn = httplib.HTTPConnection(self.limiter_address)
+        
+        if username:
+            conn.request("POST", "/%s" % (username), body, headers)
+        else:
+            conn.request("POST", "/", body, headers)
+
+        resp = conn.getresponse()
+
+        if 200 >= resp.status < 300:
+            return None
+
+        return resp.getheader("X-Wait-Seconds")
diff --git a/nova/tests/api/openstack/__init__.py b/nova/tests/api/openstack/__init__.py
index e18120285..bac7181f7 100644
--- a/nova/tests/api/openstack/__init__.py
+++ b/nova/tests/api/openstack/__init__.py
@@ -20,7 +20,7 @@ from nova import test
 
 from nova import context
 from nova import flags
-from nova.api.openstack.ratelimiting import RateLimitingMiddleware
+from nova.api.openstack.limits import RateLimitingMiddleware
 from nova.api.openstack.common import limited
 from nova.tests.api.openstack import fakes
 from webob import Request
diff --git a/nova/tests/api/openstack/fakes.py b/nova/tests/api/openstack/fakes.py
index 7cb974bb2..ae95c0648 100644
--- a/nova/tests/api/openstack/fakes.py
+++ b/nova/tests/api/openstack/fakes.py
@@ -34,7 +34,7 @@ from nova import utils
 import nova.api.openstack.auth
 from nova.api import openstack
 from nova.api.openstack import auth
-from nova.api.openstack import ratelimiting
+from nova.api.openstack import limits
 from nova.auth.manager import User, Project
 from nova.image import glance
 from nova.image import local
@@ -79,7 +79,7 @@ def wsgi_app(inner_application=None):
         inner_application = openstack.APIRouter()
     mapper = urlmap.URLMap()
     api = openstack.FaultWrapper(auth.AuthMiddleware(
-              ratelimiting.RateLimitingMiddleware(inner_application)))
+              limits.RateLimitingMiddleware(inner_application)))
     mapper['/v1.0'] = api
     mapper['/'] = openstack.FaultWrapper(openstack.Versions())
     return mapper
@@ -110,13 +110,13 @@ def stub_out_auth(stubs):
 
 def stub_out_rate_limiting(stubs):
     def fake_rate_init(self, app):
-        super(ratelimiting.RateLimitingMiddleware, self).__init__(app)
+        super(limits.RateLimitingMiddleware, self).__init__(app)
         self.application = app
 
-    stubs.Set(nova.api.openstack.ratelimiting.RateLimitingMiddleware,
+    stubs.Set(nova.api.openstack.limits.RateLimitingMiddleware,
         '__init__', fake_rate_init)
 
-    stubs.Set(nova.api.openstack.ratelimiting.RateLimitingMiddleware,
+    stubs.Set(nova.api.openstack.limits.RateLimitingMiddleware,
         '__call__', fake_wsgi)
 
 
diff --git a/nova/tests/api/openstack/test_adminapi.py b/nova/tests/api/openstack/test_adminapi.py
index 4568cb9f5..e87255b18 100644
--- a/nova/tests/api/openstack/test_adminapi.py
+++ b/nova/tests/api/openstack/test_adminapi.py
@@ -23,7 +23,6 @@ from paste import urlmap
 from nova import flags
 from nova import test
 from nova.api import openstack
-from nova.api.openstack import ratelimiting
 from nova.api.openstack import auth
 from nova.tests.api.openstack import fakes
 
diff --git a/nova/tests/api/openstack/test_ratelimiting.py b/nova/tests/api/openstack/test_ratelimiting.py
index 9ae90ee20..c88de2db7 100644
--- a/nova/tests/api/openstack/test_ratelimiting.py
+++ b/nova/tests/api/openstack/test_ratelimiting.py
@@ -1,178 +1,321 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 OpenStack LLC.
+# 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.
+
+"""
+Tests dealing with HTTP rate-limiting.
+"""
+
 import httplib
+import json
 import StringIO
+import stubout
 import time
 import webob
 
 from nova import test
-import nova.api.openstack.ratelimiting as ratelimiting
+from nova.api.openstack import limits
+from nova.api.openstack.limits import Limit
+
 
+TEST_LIMITS = [
+    Limit("GET", "/delayed", "^/delayed", 1, limits.PER_MINUTE),
+    Limit("POST", "*", ".*", 7, limits.PER_MINUTE),
+    Limit("POST", "/servers", "^/servers", 3, limits.PER_MINUTE),
+    Limit("PUT", "*", "", 10, limits.PER_MINUTE),
+    Limit("PUT", "/servers", "^/servers", 5, limits.PER_MINUTE),
+]
 
 class LimiterTest(test.TestCase):
+    """
+    Tests for the in-memory `limits.Limiter` class.
+    """
 
     def setUp(self):
-        super(LimiterTest, self).setUp()
-        self.limits = {
-                'a': (5, ratelimiting.PER_SECOND),
-                'b': (5, ratelimiting.PER_MINUTE),
-                'c': (5, ratelimiting.PER_HOUR),
-                'd': (1, ratelimiting.PER_SECOND),
-                'e': (100, ratelimiting.PER_SECOND)}
-        self.rl = ratelimiting.Limiter(self.limits)
-
-    def exhaust(self, action, times_until_exhausted, **kwargs):
-        for i in range(times_until_exhausted):
-            when = self.rl.perform(action, **kwargs)
-            self.assertEqual(when, None)
-        num, period = self.limits[action]
-        delay = period * 1.0 / num
-        # Verify that we are now thoroughly delayed
-        for i in range(10):
-            when = self.rl.perform(action, **kwargs)
-            self.assertAlmostEqual(when, delay, 2)
-
-    def test_second(self):
-        self.exhaust('a', 5)
-        time.sleep(0.2)
-        self.exhaust('a', 1)
-        time.sleep(1)
-        self.exhaust('a', 5)
-
-    def test_minute(self):
-        self.exhaust('b', 5)
-
-    def test_one_per_period(self):
-        def allow_once_and_deny_once():
-            when = self.rl.perform('d')
-            self.assertEqual(when, None)
-            when = self.rl.perform('d')
-            self.assertAlmostEqual(when, 1, 2)
-            return when
-        time.sleep(allow_once_and_deny_once())
-        time.sleep(allow_once_and_deny_once())
-        allow_once_and_deny_once()
-
-    def test_we_can_go_indefinitely_if_we_spread_out_requests(self):
-        for i in range(200):
-            when = self.rl.perform('e')
-            self.assertEqual(when, None)
-            time.sleep(0.01)
-
-    def test_users_get_separate_buckets(self):
-        self.exhaust('c', 5, username='alice')
-        self.exhaust('c', 5, username='bob')
-        self.exhaust('c', 5, username='chuck')
-        self.exhaust('c', 0, username='chuck')
-        self.exhaust('c', 0, username='bob')
-        self.exhaust('c', 0, username='alice')
-
-
-class FakeLimiter(object):
-    """Fake Limiter class that you can tell how to behave."""
-
-    def __init__(self, test):
-        self._action = self._username = self._delay = None
-        self.test = test
-
-    def mock(self, action, username, delay):
-        self._action = action
-        self._username = username
-        self._delay = delay
-
-    def perform(self, action, username):
-        self.test.assertEqual(action, self._action)
-        self.test.assertEqual(username, self._username)
-        return self._delay
-
-
-class WSGIAppTest(test.TestCase):
+        """Run before each test."""
+        test.TestCase.setUp(self)
+        self.time = 0.0
+        self.stubs = stubout.StubOutForTesting()
+        self.stubs.Set(limits.Limit, "_get_time", self._get_time)
+        self.limiter = limits.Limiter(TEST_LIMITS)
+
+    def tearDown(self):
+        """Run after each test."""
+        self.stubs.UnsetAll()
+
+    def _get_time(self):
+        """Return the "time" according to this test suite."""
+        return self.time
+
+    def _check(self, num, verb, url, username=None):
+        """Check and yield results from checks."""
+        for x in xrange(num):
+            yield self.limiter.check_for_delay(verb, url, username)
+
+    def _check_sum(self, num, verb, url, username=None):
+        """Check and sum results from checks."""
+        results = self._check(num, verb, url, username)
+        return sum(filter(lambda x: x != None, results))
+
+    def test_no_delay_GET(self):
+        """
+        Simple test to ensure no delay on a single call for a limit verb we
+        didn"t set.
+        """
+        delay = self.limiter.check_for_delay("GET", "/anything")
+        self.assertEqual(delay, None)
+
+    def test_no_delay_PUT(self):
+        """
+        Simple test to ensure no delay on a single call for a known limit.
+        """
+        delay = self.limiter.check_for_delay("PUT", "/anything")
+        self.assertEqual(delay, None)
+
+    def test_delay_PUT(self):
+        """
+        Ensure the 11th PUT will result in a delay of 6.0 seconds until
+        the next request will be granced.
+        """
+        expected = [None] * 10 + [6.0]
+        results = list(self._check(11, "PUT", "/anything"))
+
+        self.assertEqual(expected, results)
+
+    def test_delay_POST(self):
+        """
+        Ensure the 8th POST will result in a delay of 6.0 seconds until
+        the next request will be granced.
+        """
+        expected = [None] * 7
+        results = list(self._check(7, "POST", "/anything"))
+        self.assertEqual(expected, results)
+
+        expected = 60.0 / 7.0
+        results = self._check_sum(1, "POST", "/anything")
+        self.failUnlessAlmostEqual(expected, results, 8)
+            
+    def test_delay_GET(self):
+        """
+        Ensure the 11th GET will result in NO delay.
+        """
+        expected = [None] * 11
+        results = list(self._check(11, "GET", "/anything"))
+
+        self.assertEqual(expected, results)
+
+    def test_delay_PUT_servers(self):
+        """
+        Ensure PUT on /servers limits at 5 requests, and PUT elsewhere is still
+        OK after 5 requests...but then after 11 total requests, PUT limiting
+        kicks in.
+        """
+        # First 6 requests on PUT /servers
+        expected = [None] * 5 + [12.0]
+        results = list(self._check(6, "PUT", "/servers"))
+        self.assertEqual(expected, results)
+
+        # Next 5 request on PUT /anything
+        expected = [None] * 4 + [6.0]
+        results = list(self._check(5, "PUT", "/anything"))
+        self.assertEqual(expected, results)
+
+    def test_delay_PUT_wait(self):
+        """
+        Ensure after hitting the limit and then waiting for the correct
+        amount of time, the limit will be lifted.
+        """
+        expected = [None] * 10 + [6.0]
+        results = list(self._check(11, "PUT", "/anything"))
+        self.assertEqual(expected, results)
+
+        # Advance time
+        self.time += 6.0
+        
+        expected = [None, 6.0]
+        results = list(self._check(2, "PUT", "/anything"))
+        self.assertEqual(expected, results)
+
+    def test_multiple_delays(self):
+        """
+        Ensure multiple requests still get a delay.
+        """
+        expected = [None] * 10 + [6.0] * 10
+        results = list(self._check(20, "PUT", "/anything"))
+        self.assertEqual(expected, results)
+
+        self.time += 1.0
+
+        expected = [5.0] * 10
+        results = list(self._check(10, "PUT", "/anything"))
+        self.assertEqual(expected, results)
+
+    def test_multiple_users(self):
+        """
+        Tests involving multiple users.
+        """
+        # User1
+        expected = [None] * 10 + [6.0] * 10
+        results = list(self._check(20, "PUT", "/anything", "user1"))
+        self.assertEqual(expected, results)
+
+        # User2
+        expected = [None] * 10 + [6.0] * 5
+        results = list(self._check(15, "PUT", "/anything", "user2"))
+        self.assertEqual(expected, results)
+
+        self.time += 1.0
+
+        # User1 again
+        expected = [5.0] * 10
+        results = list(self._check(10, "PUT", "/anything", "user1"))
+        self.assertEqual(expected, results)
+
+        self.time += 1.0
+
+        # User1 again
+        expected = [4.0] * 5
+        results = list(self._check(5, "PUT", "/anything", "user2"))
+        self.assertEqual(expected, results)
+        
+    
+class WsgiLimiterTest(test.TestCase):
+    """
+    Tests for `limits.WsgiLimiter` class.
+    """
 
     def setUp(self):
-        super(WSGIAppTest, self).setUp()
-        self.limiter = FakeLimiter(self)
-        self.app = ratelimiting.WSGIApp(self.limiter)
+        """Run before each test."""
+        test.TestCase.setUp(self)
+        self.time = 0.0
+        self.app = limits.WsgiLimiter(TEST_LIMITS)
+        self.app._limiter._get_time = self._get_time
 
-    def test_invalid_methods(self):
-        requests = []
-        for method in ['GET', 'PUT', 'DELETE']:
-            req = webob.Request.blank('/limits/michael/breakdance',
-                                      dict(REQUEST_METHOD=method))
-            requests.append(req)
-        for req in requests:
-            self.assertEqual(req.get_response(self.app).status_int, 405)
-
-    def test_invalid_urls(self):
-        requests = []
-        for prefix in ['limit', '', 'limiter2', 'limiter/limits', 'limiter/1']:
-            req = webob.Request.blank('/%s/michael/breakdance' % prefix,
-                                      dict(REQUEST_METHOD='POST'))
-        requests.append(req)
-        for req in requests:
-            self.assertEqual(req.get_response(self.app).status_int, 404)
-
-    def verify(self, url, username, action, delay=None):
+    def _get_time(self):
+        """Return the "time" according to this test suite."""
+        return self.time
+
+    def _request_data(self, verb, path):
+        """Get data decribing a limit request verb/path."""
+        return json.dumps({"verb":verb, "path":path})
+
+    def _request(self, verb, url, username=None):
         """Make sure that POSTing to the given url causes the given username
         to perform the given action.  Make the internal rate limiter return
         delay and make sure that the WSGI app returns the correct response.
         """
-        req = webob.Request.blank(url, dict(REQUEST_METHOD='POST'))
-        self.limiter.mock(action, username, delay)
-        resp = req.get_response(self.app)
-        if not delay:
-            self.assertEqual(resp.status_int, 200)
+        if username:
+            request = webob.Request.blank("/%s" % username)
         else:
-            self.assertEqual(resp.status_int, 403)
-            self.assertEqual(resp.headers['X-Wait-Seconds'], "%.2f" % delay)
+            request = webob.Request.blank("/")
+    
+        request.method = "POST"
+        request.body = self._request_data(verb, url)
+        response = request.get_response(self.app)
+
+        if "X-Wait-Seconds" in response.headers:
+            self.assertEqual(response.status_int, 403)
+            return response.headers["X-Wait-Seconds"]
+            
+        self.assertEqual(response.status_int, 204)
 
-    def test_good_urls(self):
-        self.verify('/limiter/michael/hoot', 'michael', 'hoot')
+    def test_invalid_methods(self):
+        """Only POSTs should work."""
+        requests = []
+        for method in ["GET", "PUT", "DELETE", "HEAD", "OPTIONS"]:
+            request = webob.Request.blank("/")
+            request.body = self._request_data("GET", "/something")
+            response = request.get_response(self.app)
+            self.assertEqual(response.status_int, 405)
+
+    def test_good_url(self):
+        delay = self._request("GET", "/something")
+        self.assertEqual(delay, None)
 
     def test_escaping(self):
-        self.verify('/limiter/michael/jump%20up', 'michael', 'jump up')
+        delay = self._request("GET", "/something/jump%20up")
+        self.assertEqual(delay, None)
 
     def test_response_to_delays(self):
-        self.verify('/limiter/michael/hoot', 'michael', 'hoot', 1)
-        self.verify('/limiter/michael/hoot', 'michael', 'hoot', 1.56)
-        self.verify('/limiter/michael/hoot', 'michael', 'hoot', 1000)
+        delay = self._request("GET", "/delayed")
+        self.assertEqual(delay, None)
+
+        delay = self._request("GET", "/delayed")
+        self.assertEqual(delay, '60.00')
+
+    def test_response_to_delays_usernames(self):
+        delay = self._request("GET", "/delayed", "user1")
+        self.assertEqual(delay, None)
+
+        delay = self._request("GET", "/delayed", "user2")
+        self.assertEqual(delay, None)
+
+        delay = self._request("GET", "/delayed", "user1")
+        self.assertEqual(delay, '60.00')
+
+        delay = self._request("GET", "/delayed", "user2")
+        self.assertEqual(delay, '60.00')
 
 
 class FakeHttplibSocket(object):
-    """a fake socket implementation for httplib.HTTPResponse, trivial"""
+    """
+    Fake `httplib.HTTPResponse` replacement.
+    """
 
     def __init__(self, response_string):
+        """Initialize new `FakeHttplibSocket`."""
         self._buffer = StringIO.StringIO(response_string)
 
     def makefile(self, _mode, _other):
-        """Returns the socket's internal buffer"""
+        """Returns the socket's internal buffer."""
         return self._buffer
 
 
 class FakeHttplibConnection(object):
-    """A fake httplib.HTTPConnection
-
-    Requests made via this connection actually get translated and routed into
-    our WSGI app, we then wait for the response and turn it back into
-    an httplib.HTTPResponse.
     """
-    def __init__(self, app, host, is_secure=False):
+    Fake `httplib.HTTPConnection`.
+    """
+
+    def __init__(self, app, host):
+        """
+        Initialize `FakeHttplibConnection`.
+        """
         self.app = app
         self.host = host
 
-    def request(self, method, path, data='', headers={}):
+    def request(self, method, path, body="", headers={}):
+        """
+        Requests made via this connection actually get translated and routed into
+        our WSGI app, we then wait for the response and turn it back into
+        an `httplib.HTTPResponse`.
+        """
         req = webob.Request.blank(path)
         req.method = method
-        req.body = data
         req.headers = headers
         req.host = self.host
-        # Call the WSGI app, get the HTTP response
+        req.body = body
+
         resp = str(req.get_response(self.app))
-        # For some reason, the response doesn't have "HTTP/1.0 " prepended; I
-        # guess that's a function the web server usually provides.
         resp = "HTTP/1.0 %s" % resp
         sock = FakeHttplibSocket(resp)
         self.http_response = httplib.HTTPResponse(sock)
         self.http_response.begin()
 
     def getresponse(self):
+        """Return our generated response from the request."""
         return self.http_response
 
 
@@ -208,36 +351,36 @@ def wire_HTTPConnection_to_WSGI(host, app):
     httplib.HTTPConnection = HTTPConnectionDecorator(httplib.HTTPConnection)
 
 
-class WSGIAppProxyTest(test.TestCase):
+class WsgiLimiterProxyTest(test.TestCase):
+    """
+    Tests for the `limits.WsgiLimiterProxy` class.
+    """
 
     def setUp(self):
-        """Our WSGIAppProxy is going to call across an HTTPConnection to a
-        WSGIApp running a limiter.  The proxy will send input, and the proxy
-        should receive that same input, pass it to the limiter who gives a
-        result, and send the expected result back.
-
-        The HTTPConnection isn't real -- it's monkeypatched to point straight
-        at the WSGIApp.  And the limiter isn't real -- it's a fake that
-        behaves the way we tell it to.
         """
-        super(WSGIAppProxyTest, self).setUp()
-        self.limiter = FakeLimiter(self)
-        app = ratelimiting.WSGIApp(self.limiter)
-        wire_HTTPConnection_to_WSGI('100.100.100.100:80', app)
-        self.proxy = ratelimiting.WSGIAppProxy('100.100.100.100:80')
+        Do some nifty HTTP/WSGI magic which allows for WSGI to be called
+        directly by something like the `httplib` library.
+        """
+        test.TestCase.setUp(self)
+        self.time = 0.0
+        self.app = limits.WsgiLimiter(TEST_LIMITS)
+        self.app._limiter._get_time = self._get_time
+        wire_HTTPConnection_to_WSGI("169.254.0.1:80", self.app)
+        self.proxy = limits.WsgiLimiterProxy("169.254.0.1:80")
+
+    def _get_time(self):
+        """Return the "time" according to this test suite."""
+        return self.time
 
     def test_200(self):
-        self.limiter.mock('conquer', 'caesar', None)
-        when = self.proxy.perform('conquer', 'caesar')
-        self.assertEqual(when, None)
+        """Successful request test."""
+        delay = self.proxy.check_for_delay("GET", "/anything")
+        self.assertEqual(delay, None)
 
     def test_403(self):
-        self.limiter.mock('grumble', 'proletariat', 1.5)
-        when = self.proxy.perform('grumble', 'proletariat')
-        self.assertEqual(when, 1.5)
-
-    def test_failure(self):
-        def shouldRaise():
-            self.limiter.mock('murder', 'brutus', None)
-            self.proxy.perform('stab', 'brutus')
-        self.assertRaises(AssertionError, shouldRaise)
+        """Forbidden request test."""
+        delay = self.proxy.check_for_delay("GET", "/delayed")
+        self.assertEqual(delay, None)
+
+        delay = self.proxy.check_for_delay("GET", "/delayed")
+        self.assertEqual(delay, '60.00')
-- 
cgit 


From f1acc3d199a1a92b531a3e74ed54a8b2fcdb999c Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Tue, 15 Mar 2011 13:52:03 -0700
Subject: Now that the fix for 732866, stop working around the bug

---
 nova/tests/integrated/api/client.py | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/integrated/api/client.py b/nova/tests/integrated/api/client.py
index 568e8c17e..fc7c344e7 100644
--- a/nova/tests/integrated/api/client.py
+++ b/nova/tests/integrated/api/client.py
@@ -108,10 +108,7 @@ class TestOpenStackClient(object):
         http_status = response.status
         LOG.debug(_("%(auth_uri)s => code %(http_status)s") % locals())
 
-        # Until bug732866 is fixed, we can't check this properly...
-        # bug732866
-        #if http_status == 401:
-        if http_status != 204:
+        if http_status == 401:
             raise OpenStackApiAuthenticationException(response=response)
 
         auth_headers = {}
-- 
cgit 


From 0eaf02efd5fef3f77fced9c1a71c32a6f14f293f Mon Sep 17 00:00:00 2001
From: Josh Kearney <josh@jk0.org>
Date: Tue, 15 Mar 2011 16:21:22 -0500
Subject: Add logging to lock check

---
 nova/utils.py | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'nova')

diff --git a/nova/utils.py b/nova/utils.py
index 87e726394..d6f9ba829 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -518,6 +518,9 @@ def synchronized(name):
     def wrap(f):
         @functools.wraps(f)
         def inner(*args, **kwargs):
+            LOG.debug(_("Attempting to grab %(lock)s for method "
+                        "%(method)s..." % {"lock": name,
+                                           "method": f.__name__}))
             lock = lockfile.FileLock(os.path.join(FLAGS.lock_path,
                                                   'nova-%s.lock' % name))
             with lock:
-- 
cgit 


From 1b477c2225816ea8f05595a8812932d516828e01 Mon Sep 17 00:00:00 2001
From: Brian Lamar <brian.lamar@rackspace.com>
Date: Tue, 15 Mar 2011 17:47:34 -0400
Subject: pep8 fixes

---
 nova/api/openstack/limits.py                  | 43 +++++++++++++--------------
 nova/tests/api/openstack/test_ratelimiting.py | 19 ++++++------
 2 files changed, 30 insertions(+), 32 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/limits.py b/nova/api/openstack/limits.py
index 4f64cab3c..b1e633330 100644
--- a/nova/api/openstack/limits.py
+++ b/nova/api/openstack/limits.py
@@ -58,12 +58,12 @@ class LimitsController(Controller):
         rate_limits = req.environ.get("nova.limits", {})
 
         return {
-            "limits" : {
-                "rate" : rate_limits,
-                "absolute" : abs_limits,
+            "limits": {
+                "rate": rate_limits,
+                "absolute": abs_limits,
             },
         }
-        
+
 
 class Limit(object):
     """
@@ -71,10 +71,10 @@ class Limit(object):
     """
 
     UNITS = {
-        1 : "SECOND",
-        60 : "MINUTE",
-        60 * 60 : "HOUR",
-        60 * 60 * 24 : "DAY",
+        1: "SECOND",
+        60: "MINUTE",
+        60 * 60: "HOUR",
+        60 * 60 * 24: "DAY",
     }
 
     def __init__(self, verb, uri, regex, value, unit):
@@ -137,14 +137,13 @@ class Limit(object):
         cap = self.capacity
         water = self.water_level
         val = self.value
- 
+
         self.remaining = math.floor((cap - water) / cap * val)
-        print "Remaining:", self.remaining
         self.next_request = now
 
     def _get_time(self):
         """Retrieve the current time. Broken out for testability."""
-        return time.time() 
+        return time.time()
 
     def display_unit(self):
         """Display the string name of the unit."""
@@ -153,17 +152,15 @@ class Limit(object):
     def display(self):
         """Return a useful representation of this class."""
         return {
-            "verb" : self.verb,
-            "uri" : self.uri,
-            "regex" : self.regex,
-            "value" : self.value,
-            "remaining" : int(self.remaining),
-            "unit" : self.display_unit(),
-            "resetTime" : int(self.next_request or self._get_time()),
+            "verb": self.verb,
+            "uri": self.uri,
+            "regex": self.regex,
+            "value": self.value,
+            "remaining": int(self.remaining),
+            "unit": self.display_unit(),
+            "resetTime": int(self.next_request or self._get_time()),
         }
 
-
-
 # "Limit" format is a dictionary with the HTTP verb, human-readable URI,
 # a regular-expression to match, value and unit of measure (PER_DAY, etc.)
 
@@ -324,11 +321,11 @@ class WsgiLimiterProxy(object):
         self.limiter_address = limiter_address
 
     def check_for_delay(self, verb, path, username=None):
-        body = json.dumps({"verb":verb,"path":path})
-        headers = {"Content-Type" : "application/json"}
+        body = json.dumps({"verb": verb, "path": path})
+        headers = {"Content-Type": "application/json"}
 
         conn = httplib.HTTPConnection(self.limiter_address)
-        
+
         if username:
             conn.request("POST", "/%s" % (username), body, headers)
         else:
diff --git a/nova/tests/api/openstack/test_ratelimiting.py b/nova/tests/api/openstack/test_ratelimiting.py
index c88de2db7..a706364b4 100644
--- a/nova/tests/api/openstack/test_ratelimiting.py
+++ b/nova/tests/api/openstack/test_ratelimiting.py
@@ -39,6 +39,7 @@ TEST_LIMITS = [
     Limit("PUT", "/servers", "^/servers", 5, limits.PER_MINUTE),
 ]
 
+
 class LimiterTest(test.TestCase):
     """
     Tests for the in-memory `limits.Limiter` class.
@@ -107,7 +108,7 @@ class LimiterTest(test.TestCase):
         expected = 60.0 / 7.0
         results = self._check_sum(1, "POST", "/anything")
         self.failUnlessAlmostEqual(expected, results, 8)
-            
+
     def test_delay_GET(self):
         """
         Ensure the 11th GET will result in NO delay.
@@ -144,7 +145,7 @@ class LimiterTest(test.TestCase):
 
         # Advance time
         self.time += 6.0
-        
+
         expected = [None, 6.0]
         results = list(self._check(2, "PUT", "/anything"))
         self.assertEqual(expected, results)
@@ -190,8 +191,8 @@ class LimiterTest(test.TestCase):
         expected = [4.0] * 5
         results = list(self._check(5, "PUT", "/anything", "user2"))
         self.assertEqual(expected, results)
-        
-    
+
+
 class WsgiLimiterTest(test.TestCase):
     """
     Tests for `limits.WsgiLimiter` class.
@@ -210,7 +211,7 @@ class WsgiLimiterTest(test.TestCase):
 
     def _request_data(self, verb, path):
         """Get data decribing a limit request verb/path."""
-        return json.dumps({"verb":verb, "path":path})
+        return json.dumps({"verb": verb, "path": path})
 
     def _request(self, verb, url, username=None):
         """Make sure that POSTing to the given url causes the given username
@@ -221,7 +222,7 @@ class WsgiLimiterTest(test.TestCase):
             request = webob.Request.blank("/%s" % username)
         else:
             request = webob.Request.blank("/")
-    
+
         request.method = "POST"
         request.body = self._request_data(verb, url)
         response = request.get_response(self.app)
@@ -229,7 +230,7 @@ class WsgiLimiterTest(test.TestCase):
         if "X-Wait-Seconds" in response.headers:
             self.assertEqual(response.status_int, 403)
             return response.headers["X-Wait-Seconds"]
-            
+
         self.assertEqual(response.status_int, 204)
 
     def test_invalid_methods(self):
@@ -298,8 +299,8 @@ class FakeHttplibConnection(object):
 
     def request(self, method, path, body="", headers={}):
         """
-        Requests made via this connection actually get translated and routed into
-        our WSGI app, we then wait for the response and turn it back into
+        Requests made via this connection actually get translated and routed
+        into our WSGI app, we then wait for the response and turn it back into
         an `httplib.HTTPResponse`.
         """
         req = webob.Request.blank(path)
-- 
cgit 


From e9ef6e04786a40d20f8022bec5d23d2e4503ce3a Mon Sep 17 00:00:00 2001
From: Mark Washenberger <mark.washenberger@rackspace.com>
Date: Tue, 15 Mar 2011 17:56:00 -0400
Subject: s/onset_files/injected_files/g

---
 nova/api/openstack/servers.py            | 16 ++++-----
 nova/compute/api.py                      | 22 ++++++------
 nova/compute/manager.py                  |  2 +-
 nova/db/sqlalchemy/models.py             |  2 +-
 nova/quota.py                            | 30 ++++++++--------
 nova/tests/api/openstack/test_servers.py | 48 ++++++++++++-------------
 nova/tests/test_quota.py                 | 60 ++++++++++++++++----------------
 nova/virt/xenapi/vmops.py                | 21 +++++------
 8 files changed, 101 insertions(+), 100 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index adb5c5f99..42fe13619 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -169,7 +169,7 @@ class Controller(wsgi.Controller):
                 metadata.append({'key': k, 'value': v})
 
         personality = env['server'].get('personality', [])
-        onset_files = self._get_onset_files(personality)
+        injected_files = self._get_injected_files(personality)
 
         try:
             instances = self.compute_api.create(
@@ -183,7 +183,7 @@ class Controller(wsgi.Controller):
                 key_name=key_pair['name'],
                 key_data=key_pair['public_key'],
                 metadata=metadata,
-                onset_files=onset_files)
+                injected_files=injected_files)
         except QuotaError as error:
             self._handle_quota_error(error)
 
@@ -207,15 +207,15 @@ class Controller(wsgi.Controller):
         else:
             return self._deserialize(request.body, request.get_content_type())
 
-    def _get_onset_files(self, personality):
+    def _get_injected_files(self, personality):
         """
-        Create a list of onset files from the personality attribute
+        Create a list of injected files from the personality attribute
 
-        At this time, onset_files must be formatted as a list of
+        At this time, injected_files must be formatted as a list of
         (file_path, file_content) pairs for compatibility with the
         underlying compute service.
         """
-        onset_files = []
+        injected_files = []
         for item in personality:
             try:
                 path = item['path']
@@ -230,8 +230,8 @@ class Controller(wsgi.Controller):
             except TypeError:
                 msg = 'Personality content for %s cannot be decoded' % path
                 raise exc.HTTPBadRequest(explanation=msg)
-            onset_files.append((path, contents))
-        return onset_files
+            injected_files.append((path, contents))
+        return injected_files
 
     def _handle_quota_errors(self, error):
         """
diff --git a/nova/compute/api.py b/nova/compute/api.py
index c11059a28..32577af82 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -80,20 +80,20 @@ class API(base.Base):
                         topic,
                         {"method": "get_network_topic", "args": {'fake': 1}})
 
-    def _check_onset_file_quota(self, context, onset_files):
+    def _check_injected_file_quota(self, context, injected_files):
         """
-        Enforce quota limits on onset files
+        Enforce quota limits on injected files
 
         Raises a QuotaError if any limit is exceeded
         """
-        if onset_files is None:
+        if injected_files is None:
             return
-        limit = quota.allowed_onset_files(context)
-        if len(onset_files) > limit:
+        limit = quota.allowed_injected_files(context)
+        if len(injected_files) > limit:
             raise quota.QuotaError(code="OnsetFileLimitExceeded")
-        path_limit = quota.allowed_onset_file_path_bytes(context)
-        content_limit = quota.allowed_onset_file_content_bytes(context)
-        for path, content in onset_files:
+        path_limit = quota.allowed_injected_file_path_bytes(context)
+        content_limit = quota.allowed_injected_file_content_bytes(context)
+        for path, content in injected_files:
             if len(path) > path_limit:
                 raise quota.QuotaError(code="OnsetFilePathLimitExceeded")
             if len(content) > content_limit:
@@ -105,7 +105,7 @@ class API(base.Base):
                display_name='', display_description='',
                key_name=None, key_data=None, security_group='default',
                availability_zone=None, user_data=None, metadata=[],
-               onset_files=None):
+               injected_files=None):
         """Create the number of instances requested if quota and
         other arguments check out ok."""
 
@@ -143,7 +143,7 @@ class API(base.Base):
                 LOG.warn(msg)
                 raise quota.QuotaError(msg, "MetadataLimitExceeded")
 
-        self._check_onset_file_quota(context, onset_files)
+        self._check_injected_file_quota(context, injected_files)
 
         image = self.image_service.show(context, image_id)
 
@@ -246,7 +246,7 @@ class API(base.Base):
                       "args": {"topic": FLAGS.compute_topic,
                                "instance_id": instance_id,
                                "availability_zone": availability_zone,
-                               "onset_files": onset_files}})
+                               "injected_files": injected_files}})
 
         for group_id in security_groups:
             self.trigger_security_group_members_refresh(elevated, group_id)
diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 6bb169fa5..92deca813 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -179,7 +179,7 @@ class ComputeManager(manager.Manager):
         """Launch a new instance with specified options."""
         context = context.elevated()
         instance_ref = self.db.instance_get(context, instance_id)
-        instance_ref.onset_files = kwargs.get('onset_files', [])
+        instance_ref.injected_files = kwargs.get('injected_files', [])
         if instance_ref['name'] in self.driver.list_instances():
             raise exception.Error(_("Instance has already been created"))
         LOG.audit(_("instance %s: starting..."), instance_id,
diff --git a/nova/db/sqlalchemy/models.py b/nova/db/sqlalchemy/models.py
index 162f6fded..1845e85eb 100644
--- a/nova/db/sqlalchemy/models.py
+++ b/nova/db/sqlalchemy/models.py
@@ -161,7 +161,7 @@ class Certificate(BASE, NovaBase):
 class Instance(BASE, NovaBase):
     """Represents a guest vm."""
     __tablename__ = 'instances'
-    onset_files = []
+    injected_files = []
 
     id = Column(Integer, primary_key=True, autoincrement=True)
 
diff --git a/nova/quota.py b/nova/quota.py
index e0fb97542..2b24c0b5b 100644
--- a/nova/quota.py
+++ b/nova/quota.py
@@ -37,12 +37,12 @@ flags.DEFINE_integer('quota_floating_ips', 10,
                      'number of floating ips allowed per project')
 flags.DEFINE_integer('quota_metadata_items', 128,
                      'number of metadata items allowed per instance')
-flags.DEFINE_integer('quota_max_onset_files', 5,
-                     'number of onset files allowed')
-flags.DEFINE_integer('quota_max_onset_file_content_bytes', 10 * 1024,
-                     'number of bytes allowed per onset file')
-flags.DEFINE_integer('quota_max_onset_file_path_bytes', 255,
-                     'number of bytes allowed per onset file path')
+flags.DEFINE_integer('quota_max_injected_files', 5,
+                     'number of injected files allowed')
+flags.DEFINE_integer('quota_max_injected_file_content_bytes', 10 * 1024,
+                     'number of bytes allowed per injected file')
+flags.DEFINE_integer('quota_max_injected_file_path_bytes', 255,
+                     'number of bytes allowed per injected file path')
 
 
 def get_quota(context, project_id):
@@ -113,19 +113,19 @@ def allowed_metadata_items(context, num_metadata_items):
     return min(num_metadata_items, num_allowed_metadata_items)
 
 
-def allowed_onset_files(context):
-    """Return the number of onset files allowed"""
-    return int(FLAGS.quota_max_onset_files)
+def allowed_injected_files(context):
+    """Return the number of injected files allowed"""
+    return FLAGS.quota_max_injected_files
 
 
-def allowed_onset_file_content_bytes(context):
-    """Return the number of bytes allowed per onset file content"""
-    return int(FLAGS.quota_max_onset_file_content_bytes)
+def allowed_injected_file_content_bytes(context):
+    """Return the number of bytes allowed per injected file content"""
+    return FLAGS.quota_max_injected_file_content_bytes
 
 
-def allowed_onset_file_path_bytes(context):
-    """Return the number of bytes allowed in an onset file path"""
-    return int(FLAGS.quota_max_onset_file_path_bytes)
+def allowed_injected_file_path_bytes(context):
+    """Return the number of bytes allowed in an injected file path"""
+    return FLAGS.quota_max_injected_file_path_bytes
 
 
 class QuotaError(exception.ApiError):
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 7027c7ea3..253b84be9 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -834,13 +834,13 @@ class TestServerInstanceCreation(test.TestCase):
         class MockComputeAPI(object):
 
             def __init__(self):
-                self.onset_files = None
+                self.injected_files = None
 
             def create(self, *args, **kwargs):
-                if 'onset_files' in kwargs:
-                    self.onset_files = kwargs['onset_files']
+                if 'injected_files' in kwargs:
+                    self.injected_files = kwargs['injected_files']
                 else:
-                    self.onset_files = None
+                    self.injected_files = None
                 return [{'id': '1234', 'display_name': 'fakeinstance'}]
 
             def set_admin_password(self, *args, **kwargs):
@@ -920,46 +920,46 @@ class TestServerInstanceCreation(test.TestCase):
         request = self._get_create_request_json(body_dict)
         compute_api, response = \
             self._run_create_instance_with_mock_compute_api(request)
-        return request, response, compute_api.onset_files
+        return request, response, compute_api.injected_files
 
     def _create_instance_with_personality_xml(self, personality):
         body_dict = self._create_personality_request_dict(personality)
         request = self._get_create_request_xml(body_dict)
         compute_api, response = \
             self._run_create_instance_with_mock_compute_api(request)
-        return request, response, compute_api.onset_files
+        return request, response, compute_api.injected_files
 
     def test_create_instance_with_no_personality(self):
-        request, response, onset_files = \
+        request, response, injected_files = \
                 self._create_instance_with_personality_json(personality=None)
         self.assertEquals(response.status_int, 200)
-        self.assertEquals(onset_files, [])
+        self.assertEquals(injected_files, [])
 
     def test_create_instance_with_no_personality_xml(self):
-        request, response, onset_files = \
+        request, response, injected_files = \
                 self._create_instance_with_personality_xml(personality=None)
         self.assertEquals(response.status_int, 200)
-        self.assertEquals(onset_files, [])
+        self.assertEquals(injected_files, [])
 
     def test_create_instance_with_personality(self):
         path = '/my/file/path'
         contents = '#!/bin/bash\necho "Hello, World!"\n'
         b64contents = base64.b64encode(contents)
         personality = [(path, b64contents)]
-        request, response, onset_files = \
+        request, response, injected_files = \
             self._create_instance_with_personality_json(personality)
         self.assertEquals(response.status_int, 200)
-        self.assertEquals(onset_files, [(path, contents)])
+        self.assertEquals(injected_files, [(path, contents)])
 
     def test_create_instance_with_personality_xml(self):
         path = '/my/file/path'
         contents = '#!/bin/bash\necho "Hello, World!"\n'
         b64contents = base64.b64encode(contents)
         personality = [(path, b64contents)]
-        request, response, onset_files = \
+        request, response, injected_files = \
             self._create_instance_with_personality_xml(personality)
         self.assertEquals(response.status_int, 200)
-        self.assertEquals(onset_files, [(path, contents)])
+        self.assertEquals(injected_files, [(path, contents)])
 
     def test_create_instance_with_personality_no_path(self):
         personality = [('/remove/this/path',
@@ -970,7 +970,7 @@ class TestServerInstanceCreation(test.TestCase):
         compute_api, response = \
             self._run_create_instance_with_mock_compute_api(request)
         self.assertEquals(response.status_int, 400)
-        self.assertEquals(compute_api.onset_files, None)
+        self.assertEquals(compute_api.injected_files, None)
 
     def _test_create_instance_with_personality_no_path_xml(self):
         personality = [('/remove/this/path',
@@ -981,7 +981,7 @@ class TestServerInstanceCreation(test.TestCase):
         compute_api, response = \
             self._run_create_instance_with_mock_compute_api(request)
         self.assertEquals(response.status_int, 400)
-        self.assertEquals(compute_api.onset_files, None)
+        self.assertEquals(compute_api.injected_files, None)
 
     def test_create_instance_with_personality_no_contents(self):
         personality = [('/test/path',
@@ -992,7 +992,7 @@ class TestServerInstanceCreation(test.TestCase):
         compute_api, response = \
             self._run_create_instance_with_mock_compute_api(request)
         self.assertEquals(response.status_int, 400)
-        self.assertEquals(compute_api.onset_files, None)
+        self.assertEquals(compute_api.injected_files, None)
 
     def test_create_instance_with_personality_not_a_list(self):
         personality = [('/test/path', base64.b64encode('test\ncontents\n'))]
@@ -1003,16 +1003,16 @@ class TestServerInstanceCreation(test.TestCase):
         compute_api, response = \
             self._run_create_instance_with_mock_compute_api(request)
         self.assertEquals(response.status_int, 400)
-        self.assertEquals(compute_api.onset_files, None)
+        self.assertEquals(compute_api.injected_files, None)
 
     def test_create_instance_with_personality_with_non_b64_content(self):
         path = '/my/file/path'
         contents = '#!/bin/bash\necho "Oh no!"\n'
         personality = [(path, contents)]
-        request, response, onset_files = \
+        request, response, injected_files = \
             self._create_instance_with_personality_json(personality)
         self.assertEquals(response.status_int, 400)
-        self.assertEquals(onset_files, None)
+        self.assertEquals(injected_files, None)
 
     def test_create_instance_with_three_personalities(self):
         files = [
@@ -1023,19 +1023,19 @@ class TestServerInstanceCreation(test.TestCase):
         personality = []
         for path, content in files:
             personality.append((path, base64.b64encode(content)))
-        request, response, onset_files = \
+        request, response, injected_files = \
             self._create_instance_with_personality_json(personality)
         self.assertEquals(response.status_int, 200)
-        self.assertEquals(onset_files, files)
+        self.assertEquals(injected_files, files)
 
     def test_create_instance_personality_empty_content(self):
         path = '/my/file/path'
         contents = ''
         personality = [(path, contents)]
-        request, response, onset_files = \
+        request, response, injected_files = \
             self._create_instance_with_personality_json(personality)
         self.assertEquals(response.status_int, 200)
-        self.assertEquals(onset_files, [(path, contents)])
+        self.assertEquals(injected_files, [(path, contents)])
 
     def test_create_instance_admin_pass_json(self):
         request, response, dummy = \
diff --git a/nova/tests/test_quota.py b/nova/tests/test_quota.py
index d94381aa2..c65bc459d 100644
--- a/nova/tests/test_quota.py
+++ b/nova/tests/test_quota.py
@@ -200,66 +200,66 @@ class QuotaTestCase(test.TestCase):
                                             image_id='fake',
                                             metadata=metadata)
 
-    def test_allowed_onset_files(self):
+    def test_allowed_injected_files(self):
         self.assertEqual(
-                quota.allowed_onset_files(self.context),
-                FLAGS.quota_max_onset_files)
+                quota.allowed_injected_files(self.context),
+                FLAGS.quota_max_injected_files)
 
-    def _create_with_onset_files(self, files):
+    def _create_with_injected_files(self, files):
         api = compute.API(image_service=self.StubImageService())
         api.create(self.context, min_count=1, max_count=1,
                 instance_type='m1.small', image_id='fake',
-                onset_files=files)
+                injected_files=files)
 
-    def test_no_onset_files(self):
+    def test_no_injected_files(self):
         api = compute.API(image_service=self.StubImageService())
         api.create(self.context, instance_type='m1.small', image_id='fake')
 
-    def test_max_onset_files(self):
+    def test_max_injected_files(self):
         files = []
-        for i in xrange(FLAGS.quota_max_onset_files):
+        for i in xrange(FLAGS.quota_max_injected_files):
             files.append(('/my/path%d' % i, 'config = test\n'))
-        self._create_with_onset_files(files)  # no QuotaError
+        self._create_with_injected_files(files)  # no QuotaError
 
-    def test_too_many_onset_files(self):
+    def test_too_many_injected_files(self):
         files = []
-        for i in xrange(FLAGS.quota_max_onset_files + 1):
+        for i in xrange(FLAGS.quota_max_injected_files + 1):
             files.append(('/my/path%d' % i, 'my\ncontent%d\n' % i))
         self.assertRaises(quota.QuotaError,
-                          self._create_with_onset_files, files)
+                          self._create_with_injected_files, files)
 
-    def test_allowed_onset_file_content_bytes(self):
+    def test_allowed_injected_file_content_bytes(self):
         self.assertEqual(
-                quota.allowed_onset_file_content_bytes(self.context),
-                FLAGS.quota_max_onset_file_content_bytes)
+                quota.allowed_injected_file_content_bytes(self.context),
+                FLAGS.quota_max_injected_file_content_bytes)
 
-    def test_max_onset_file_content_bytes(self):
-        max = FLAGS.quota_max_onset_file_content_bytes
+    def test_max_injected_file_content_bytes(self):
+        max = FLAGS.quota_max_injected_file_content_bytes
         content = ''.join(['a' for i in xrange(max)])
         files = [('/test/path', content)]
-        self._create_with_onset_files(files)  # no QuotaError
+        self._create_with_injected_files(files)  # no QuotaError
 
-    def test_too_many_onset_file_content_bytes(self):
-        max = FLAGS.quota_max_onset_file_content_bytes
+    def test_too_many_injected_file_content_bytes(self):
+        max = FLAGS.quota_max_injected_file_content_bytes
         content = ''.join(['a' for i in xrange(max + 1)])
         files = [('/test/path', content)]
         self.assertRaises(quota.QuotaError,
-                          self._create_with_onset_files, files)
+                          self._create_with_injected_files, files)
 
-    def test_allowed_onset_file_path_bytes(self):
+    def test_allowed_injected_file_path_bytes(self):
         self.assertEqual(
-                quota.allowed_onset_file_path_bytes(self.context),
-                FLAGS.quota_max_onset_file_path_bytes)
+                quota.allowed_injected_file_path_bytes(self.context),
+                FLAGS.quota_max_injected_file_path_bytes)
 
-    def test_max_onset_file_path_bytes(self):
-        max = FLAGS.quota_max_onset_file_path_bytes
+    def test_max_injected_file_path_bytes(self):
+        max = FLAGS.quota_max_injected_file_path_bytes
         path = ''.join(['a' for i in xrange(max)])
         files = [(path, 'config = quotatest')]
-        self._create_with_onset_files(files)  # no QuotaError
+        self._create_with_injected_files(files)  # no QuotaError
 
-    def test_too_many_onset_file_path_bytes(self):
-        max = FLAGS.quota_max_onset_file_path_bytes
+    def test_too_many_injected_file_path_bytes(self):
+        max = FLAGS.quota_max_injected_file_path_bytes
         path = ''.join(['a' for i in xrange(max + 1)])
         files = [(path, 'config = quotatest')]
         self.assertRaises(quota.QuotaError,
-                          self._create_with_onset_files, files)
+                          self._create_with_injected_files, files)
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 74068a7b504a95dc8e0339faa04c8c5520417f32 Mon Sep 17 00:00:00 2001
From: Naveed Massjouni <naveedm9@gmail.com>
Date: Tue, 15 Mar 2011 18:10:25 -0400
Subject: Per Eric Day's suggest, the verson is not store in the request
 environ instead of the nova.context.

---
 nova/api/openstack/auth.py               |  4 ++--
 nova/api/openstack/views/addresses.py    |  2 +-
 nova/api/openstack/views/flavors.py      |  2 +-
 nova/api/openstack/views/images.py       |  2 +-
 nova/api/openstack/views/servers.py      |  2 +-
 nova/context.py                          |  7 ++-----
 nova/tests/api/openstack/fakes.py        |  4 +++-
 nova/tests/api/openstack/test_servers.py | 16 ++--------------
 8 files changed, 13 insertions(+), 26 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/auth.py b/nova/api/openstack/auth.py
index e33a9faf5..c820a5963 100644
--- a/nova/api/openstack/auth.py
+++ b/nova/api/openstack/auth.py
@@ -68,9 +68,9 @@ class AuthMiddleware(wsgi.Middleware):
            not self.auth.is_project_member(user, account):
             return faults.Fault(webob.exc.HTTPUnauthorized())
 
+        req.environ['nova.context'] = context.RequestContext(user, account)
         version = req.path.split('/')[1].replace('v', '')
-        req.environ['nova.context'] = context.RequestContext(user, account,
-            version=version)
+        req.environ['version'] = version
         return self.application
 
     def has_authentication(self, req):
diff --git a/nova/api/openstack/views/addresses.py b/nova/api/openstack/views/addresses.py
index d764e5229..65c24dbd7 100644
--- a/nova/api/openstack/views/addresses.py
+++ b/nova/api/openstack/views/addresses.py
@@ -8,7 +8,7 @@ def get_view_builder(req):
     A factory method that returns the correct builder based on the version of
     the api requested.
     '''
-    version = req.environ['nova.context'].version
+    version = req.environ['version']
     if version == '1.1':
         return ViewBuilder_1_1()
     else:
diff --git a/nova/api/openstack/views/flavors.py b/nova/api/openstack/views/flavors.py
index dfcc2644c..f945f9f8f 100644
--- a/nova/api/openstack/views/flavors.py
+++ b/nova/api/openstack/views/flavors.py
@@ -5,7 +5,7 @@ def get_view_builder(req):
     A factory method that returns the correct builder based on the version of
     the api requested.
     '''
-    version = req.environ['nova.context'].version
+    version = req.environ['version']
     base_url = req.application_url
     if version == '1.1':
         return ViewBuilder_1_1(base_url)
diff --git a/nova/api/openstack/views/images.py b/nova/api/openstack/views/images.py
index cd61ed656..a59d4a557 100644
--- a/nova/api/openstack/views/images.py
+++ b/nova/api/openstack/views/images.py
@@ -5,7 +5,7 @@ def get_view_builder(req):
     A factory method that returns the correct builder based on the version of
     the api requested.
     '''
-    version = req.environ['nova.context'].version
+    version = req.environ['version']
     base_url = req.application_url
     if version == '1.1':
         return ViewBuilder_1_1(base_url)
diff --git a/nova/api/openstack/views/servers.py b/nova/api/openstack/views/servers.py
index 7ca2b2427..2549cc11c 100644
--- a/nova/api/openstack/views/servers.py
+++ b/nova/api/openstack/views/servers.py
@@ -11,7 +11,7 @@ def get_view_builder(req):
     A factory method that returns the correct builder based on the version of
     the api requested.
     '''
-    version = req.environ['nova.context'].version
+    version = req.environ['version']
     addresses_builder = addresses_view.get_view_builder(req)
     if version == '1.1':
         flavor_builder = flavors_view.get_view_builder(req)
diff --git a/nova/context.py b/nova/context.py
index 0f3eb9ae4..0256bf448 100644
--- a/nova/context.py
+++ b/nova/context.py
@@ -29,8 +29,7 @@ from nova import utils
 
 class RequestContext(object):
     def __init__(self, user, project, is_admin=None, read_deleted=False,
-                 remote_address=None, timestamp=None, request_id=None,
-                 version=None):
+                 remote_address=None, timestamp=None, request_id=None):
         if hasattr(user, 'id'):
             self._user = user
             self.user_id = user.id
@@ -61,7 +60,6 @@ class RequestContext(object):
             chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890-'
             request_id = ''.join([random.choice(chars) for x in xrange(20)])
         self.request_id = request_id
-        self.version = version
 
     @property
     def user(self):
@@ -95,8 +93,7 @@ class RequestContext(object):
                 'read_deleted': self.read_deleted,
                 'remote_address': self.remote_address,
                 'timestamp': utils.isotime(self.timestamp),
-                'request_id': self.request_id,
-                'version': self.version}
+                'request_id': self.request_id}
 
     @classmethod
     def from_dict(cls, values):
diff --git a/nova/tests/api/openstack/fakes.py b/nova/tests/api/openstack/fakes.py
index 9f8ee9b56..9c3b53ac7 100644
--- a/nova/tests/api/openstack/fakes.py
+++ b/nova/tests/api/openstack/fakes.py
@@ -68,7 +68,9 @@ def fake_auth_init(self, application):
 
 @webob.dec.wsgify
 def fake_wsgi(self, req):
-    req.environ['nova.context'] = context.RequestContext(1, 1, version='1.0')
+    req.environ['nova.context'] = context.RequestContext(1, 1)
+    if not req.environ.get('version'):
+        req.environ['version'] = '1.0'
     if req.body:
         req.environ['inst_dict'] = json.loads(req.body)
     return self.application
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index ac115ebf7..6b804d3b4 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -178,17 +178,12 @@ class ServersTest(test.TestCase):
         self.assertEqual(addresses["private"][0], private)
 
     def test_get_server_by_id_with_addresses_v1_1(self):
-        class FakeRequestContext(object):
-            def __init__(self, user, project, *args, **kwargs):
-                self.user_id = 1
-                self.project_id = 1
-                self.version = '1.1'
-        self.stubs.Set(context, 'RequestContext', FakeRequestContext)
         private = "192.168.0.3"
         public = ["1.2.3.4"]
         new_return_server = return_server_with_addresses(private, public)
         self.stubs.Set(nova.db.api, 'instance_get', new_return_server)
         req = webob.Request.blank('/v1.1/servers/1')
+        req.environ['version'] = '1.1'
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
         self.assertEqual(res_dict['server']['id'], '1')
@@ -367,15 +362,8 @@ class ServersTest(test.TestCase):
             self.assertEqual(s['metadata']['seq'], i)
 
     def test_get_all_server_details_v1_1(self):
-        class FakeRequestContext(object):
-            def __init__(self, user, project, *args, **kwargs):
-                self.user_id = 1
-                self.project_id = 1
-                self.version = '1.1'
-                self.is_admin = True
-
-        self.stubs.Set(context, 'RequestContext', FakeRequestContext)
         req = webob.Request.blank('/v1.1/servers/detail')
+        req.environ['version'] = '1.1'
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
 
-- 
cgit 


From 3cc78174e023b3f848b9c4b30468d356ee575ea6 Mon Sep 17 00:00:00 2001
From: Mark Washenberger <mark.washenberger@rackspace.com>
Date: Tue, 15 Mar 2011 18:11:54 -0400
Subject: internationalization

---
 nova/api/openstack/servers.py | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 42fe13619..f618c31a0 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -221,15 +221,16 @@ class Controller(wsgi.Controller):
                 path = item['path']
                 contents = item['contents']
             except KeyError as key:
-                expl = 'Bad personality format: missing %s' % key
+                expl = _('Bad personality format: missing %s') % key
                 raise exc.HTTPBadRequest(explanation=expl)
             except TypeError:
-                raise exc.HTTPBadRequest(explanation='Bad personality format')
+                expl = _('Bad personality format')
+                raise exc.HTTPBadRequest(explanation=expl)
             try:
                 contents = base64.b64decode(contents)
             except TypeError:
-                msg = 'Personality content for %s cannot be decoded' % path
-                raise exc.HTTPBadRequest(explanation=msg)
+                expl = _('Personality content for %s cannot be decoded') % path
+                raise exc.HTTPBadRequest(explanation=expl)
             injected_files.append((path, contents))
         return injected_files
 
@@ -238,13 +239,13 @@ class Controller(wsgi.Controller):
         Reraise quota errors as api-specific http exceptions
         """
         if error.code == "OnsetFileLimitExceeded":
-            expl = "Personality file limit exceeded"
+            expl = _("Personality file limit exceeded")
             raise exc.HTTPBadRequest(explanation=expl)
         if error.code == "OnsetFilePathLimitExceeded":
-            expl = "Personality file path too long"
+            expl = _("Personality file path too long")
             raise exc.HTTPBadRequest(explanation=expl)
         if error.code == "OnsetFileContentLimitExceeded":
-            expl = "Personality file content too long"
+            expl = _("Personality file content too long")
             raise exc.HTTPBadRequest(explanation=expl)
         # if the original error is okay, just reraise it
         raise error
-- 
cgit 


From 70769dbe239c979d97154b88a33cb34d377d1196 Mon Sep 17 00:00:00 2001
From: Mark Washenberger <mark.washenberger@rackspace.com>
Date: Tue, 15 Mar 2011 18:12:46 -0400
Subject: pep8

---
 nova/tests/api/openstack/test_servers.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 253b84be9..a92c0f590 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -806,7 +806,7 @@ ZSBwYXR0ZXJucyBiZWhpbmQgYWxsIGNsb3VkcywgYW5kIHlv\
 dSB3aWxsIGtub3csIHRvbywgd2hlbiB5b3UgbGlmdCB5b3Vy\
 c2VsZiBoaWdoIGVub3VnaCB0byBzZWUgYmV5b25kIGhvcml6\
 b25zLiINCg0KLVJpY2hhcmQgQmFjaA==""",
-                }
+                },
             ],
         }}
         request = self.deserializer.deserialize(serial_request)
-- 
cgit 


From 67c871a257c684de3cb0f1416b1b2b6e9a99fe23 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Tue, 15 Mar 2011 17:37:07 -0500
Subject: Moving the migration again

---
 .../versions/011_add_flavors_to_migrations.py      | 44 ----------------------
 .../versions/012_add_flavors_to_migrations.py      | 44 ++++++++++++++++++++++
 2 files changed, 44 insertions(+), 44 deletions(-)
 delete mode 100644 nova/db/sqlalchemy/migrate_repo/versions/011_add_flavors_to_migrations.py
 create mode 100644 nova/db/sqlalchemy/migrate_repo/versions/012_add_flavors_to_migrations.py

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/migrate_repo/versions/011_add_flavors_to_migrations.py b/nova/db/sqlalchemy/migrate_repo/versions/011_add_flavors_to_migrations.py
deleted file mode 100644
index 412caedd0..000000000
--- a/nova/db/sqlalchemy/migrate_repo/versions/011_add_flavors_to_migrations.py
+++ /dev/null
@@ -1,44 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 OpenStack LLC.
-# 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.from sqlalchemy import *
-
-from sqlalchemy import *
-from migrate import *
-
-from nova import log as logging
-
-
-meta = MetaData()
-
-migrations = Table('migrations', meta,
-        Column('id', Integer(), primary_key=True, nullable=False),
-        )
-
-#
-# Tables to alter
-#
-#
-
-old_flavor_id = Column('old_flavor_id', Integer())
-new_flavor_id = Column('new_flavor_id', Integer())
-
-
-def upgrade(migrate_engine):
-    # Upgrade operations go here. Don't create your own engine;
-    # bind migrate_engine to your metadata
-    meta.bind = migrate_engine
-    migrations.create_column(old_flavor_id)
-    migrations.create_column(new_flavor_id)
diff --git a/nova/db/sqlalchemy/migrate_repo/versions/012_add_flavors_to_migrations.py b/nova/db/sqlalchemy/migrate_repo/versions/012_add_flavors_to_migrations.py
new file mode 100644
index 000000000..412caedd0
--- /dev/null
+++ b/nova/db/sqlalchemy/migrate_repo/versions/012_add_flavors_to_migrations.py
@@ -0,0 +1,44 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 OpenStack LLC.
+# 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.from sqlalchemy import *
+
+from sqlalchemy import *
+from migrate import *
+
+from nova import log as logging
+
+
+meta = MetaData()
+
+migrations = Table('migrations', meta,
+        Column('id', Integer(), primary_key=True, nullable=False),
+        )
+
+#
+# Tables to alter
+#
+#
+
+old_flavor_id = Column('old_flavor_id', Integer())
+new_flavor_id = Column('new_flavor_id', Integer())
+
+
+def upgrade(migrate_engine):
+    # Upgrade operations go here. Don't create your own engine;
+    # bind migrate_engine to your metadata
+    meta.bind = migrate_engine
+    migrations.create_column(old_flavor_id)
+    migrations.create_column(new_flavor_id)
-- 
cgit 


From 6d984c3097252f9f97ef10e48be390fdf756b391 Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Tue, 15 Mar 2011 16:08:22 -0700
Subject: wrap errors getting image ids from local image store

---
 nova/image/local.py                     | 14 ++++++++++++--
 nova/tests/api/openstack/test_images.py |  7 +++++++
 2 files changed, 19 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/image/local.py b/nova/image/local.py
index c4ac3baaa..ef92a35b5 100644
--- a/nova/image/local.py
+++ b/nova/image/local.py
@@ -20,8 +20,9 @@ import os.path
 import random
 import shutil
 
-from nova import flags
 from nova import exception
+from nova import flags
+from nova import log as logging
 from nova.image import service
 
 
@@ -29,6 +30,8 @@ FLAGS = flags.FLAGS
 flags.DEFINE_string('images_path', '$state_path/images',
                     'path to decrypted images')
 
+LOG = logging.getLogger('nova.image.local')
+
 
 class LocalImageService(service.BaseImageService):
     """Image service storing images to local disk.
@@ -47,7 +50,14 @@ class LocalImageService(service.BaseImageService):
 
     def _ids(self):
         """The list of all image ids."""
-        return [int(i, 16) for i in os.listdir(self._path)]
+        images = []
+        for i in os.listdir(self._path):
+            try:
+                images.append(int(i, 16))
+            except:
+                LOG.debug(
+                    _("%s is not in correct directory naming format" % i))
+        return images
 
     def index(self, context):
         return [dict(image_id=i['id'], name=i.get('name'))
diff --git a/nova/tests/api/openstack/test_images.py b/nova/tests/api/openstack/test_images.py
index 76f758929..2c4918117 100644
--- a/nova/tests/api/openstack/test_images.py
+++ b/nova/tests/api/openstack/test_images.py
@@ -151,6 +151,13 @@ class LocalImageServiceTest(test.TestCase,
         self.stubs.UnsetAll()
         super(LocalImageServiceTest, self).tearDown()
 
+    def test_get_all_ids_with_incorrect_directory_formats(self):
+        # create some old-style image directories (starting with 'ami-')
+        for x in [1, 2, 3]:
+            tempfile.mkstemp(prefix='ami-', dir=self.tempdir)
+        found_images = self.service._ids()
+        self.assertEqual(True, isinstance(found_images, list))
+
 
 class GlanceImageServiceTest(test.TestCase,
                              BaseImageServiceTests):
-- 
cgit 


From e237b4a5653384688b16f7fd2c0708eaec4b9ec7 Mon Sep 17 00:00:00 2001
From: Mark Washenberger <mark.washenberger@rackspace.com>
Date: Tue, 15 Mar 2011 19:11:21 -0400
Subject: ignore differently-named nodes in personality and metadata parsing

---
 nova/api/openstack/servers.py            |  10 +-
 nova/tests/api/openstack/test_servers.py | 164 ++++++++++++++++++++++---------
 2 files changed, 126 insertions(+), 48 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index f618c31a0..ea88f1fdc 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -575,7 +575,7 @@ class ServerCreateRequestXMLDeserializer(object):
         if metadata_node is None:
             return None
         metadata = {}
-        for meta_node in metadata_node.childNodes:
+        for meta_node in self._find_children_named(metadata_node, "meta"):
             key = meta_node.getAttribute("key")
             metadata[key] = self._extract_text(meta_node)
         return metadata
@@ -587,7 +587,7 @@ class ServerCreateRequestXMLDeserializer(object):
         if personality_node is None:
             return None
         personality = []
-        for file_node in personality_node.childNodes:
+        for file_node in self._find_children_named(personality_node, "file"):
             item = {}
             if file_node.hasAttribute("path"):
                 item["path"] = file_node.getAttribute("path")
@@ -602,6 +602,12 @@ class ServerCreateRequestXMLDeserializer(object):
                 return node
         return None
 
+    def _find_children_named(self, parent, name):
+        """Return all of a nodes children who have the given name"""
+        for node in parent.childNodes:
+            if node.nodeName == name:
+                yield node
+
     def _extract_text(self, node):
         """Get the text field contained by the given node"""
         if len(node.childNodes) == 1:
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index a92c0f590..ed37cb705 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -610,7 +610,7 @@ class TestServerCreateRequestXMLDeserializer(unittest.TestCase):
 
     def test_minimal_request(self):
         serial_request = """
-<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"\
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"
  name="new-server-test" imageId="1" flavorId="1"/>"""
         request = self.deserializer.deserialize(serial_request)
         expected = {"server": {
@@ -622,8 +622,10 @@ class TestServerCreateRequestXMLDeserializer(unittest.TestCase):
 
     def test_request_with_empty_metadata(self):
         serial_request = """
-<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"\
- name="new-server-test" imageId="1" flavorId="1"><metadata/></server>"""
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"
+ name="new-server-test" imageId="1" flavorId="1">
+    <metadata/>
+</server>"""
         request = self.deserializer.deserialize(serial_request)
         expected = {"server": {
                 "name": "new-server-test",
@@ -635,8 +637,10 @@ class TestServerCreateRequestXMLDeserializer(unittest.TestCase):
 
     def test_request_with_empty_personality(self):
         serial_request = """
-<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"\
- name="new-server-test" imageId="1" flavorId="1"><personality/></server>"""
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"
+ name="new-server-test" imageId="1" flavorId="1">
+    <personality/>
+</server>"""
         request = self.deserializer.deserialize(serial_request)
         expected = {"server": {
                 "name": "new-server-test",
@@ -648,9 +652,11 @@ class TestServerCreateRequestXMLDeserializer(unittest.TestCase):
 
     def test_request_with_empty_metadata_and_personality(self):
         serial_request = """
-<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"\
- name="new-server-test" imageId="1" flavorId="1">\
-<metadata/><personality/></server>"""
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"
+ name="new-server-test" imageId="1" flavorId="1">
+    <metadata/>
+    <personality/>
+</server>"""
         request = self.deserializer.deserialize(serial_request)
         expected = {"server": {
                 "name": "new-server-test",
@@ -663,9 +669,11 @@ class TestServerCreateRequestXMLDeserializer(unittest.TestCase):
 
     def test_request_with_empty_metadata_and_personality_reversed(self):
         serial_request = """
-<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"\
- name="new-server-test" imageId="1" flavorId="1">\
-<personality/><metadata/></server>"""
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"
+ name="new-server-test" imageId="1" flavorId="1">
+    <personality/>
+    <metadata/>
+</server>"""
         request = self.deserializer.deserialize(serial_request)
         expected = {"server": {
                 "name": "new-server-test",
@@ -678,28 +686,47 @@ class TestServerCreateRequestXMLDeserializer(unittest.TestCase):
 
     def test_request_with_one_personality(self):
         serial_request = """
-<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"\
- name="new-server-test" imageId="1" flavorId="1">\
-<personality><file path="/etc/conf">aabbccdd</file></personality></server>"""
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"
+ name="new-server-test" imageId="1" flavorId="1">
+    <personality>
+        <file path="/etc/conf">aabbccdd</file>
+    </personality>
+</server>"""
         request = self.deserializer.deserialize(serial_request)
         expected = [{"path": "/etc/conf", "contents": "aabbccdd"}]
         self.assertEquals(request["server"]["personality"], expected)
 
     def test_request_with_two_personalities(self):
         serial_request = """
-<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"\
- name="new-server-test" imageId="1" flavorId="1">\
-<personality><file path="/etc/conf">aabbccdd</file>\
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"
+ name="new-server-test" imageId="1" flavorId="1">
+<personality><file path="/etc/conf">aabbccdd</file>
 <file path="/etc/sudoers">abcd</file></personality></server>"""
         request = self.deserializer.deserialize(serial_request)
         expected = [{"path": "/etc/conf", "contents": "aabbccdd"},
                     {"path": "/etc/sudoers", "contents": "abcd"}]
         self.assertEquals(request["server"]["personality"], expected)
 
+    def test_request_second_personality_node_ignored(self):
+        serial_request = """
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"
+ name="new-server-test" imageId="1" flavorId="1">
+    <personality>
+        <file path="/etc/conf">aabbccdd</file>
+    </personality>
+    <personality>
+        <file path="/etc/ignoreme">anything</file>
+    </personality>
+</server>"""
+        request = self.deserializer.deserialize(serial_request)
+        expected = [{"path": "/etc/conf", "contents": "aabbccdd"}]
+        self.assertEquals(request["server"]["personality"], expected)
+
+
     def test_request_with_one_personality_missing_path(self):
         serial_request = """
-<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"\
- name="new-server-test" imageId="1" flavorId="1">\
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"
+ name="new-server-test" imageId="1" flavorId="1">
 <personality><file>aabbccdd</file></personality></server>"""
         request = self.deserializer.deserialize(serial_request)
         expected = [{"contents": "aabbccdd"}]
@@ -707,8 +734,8 @@ class TestServerCreateRequestXMLDeserializer(unittest.TestCase):
 
     def test_request_with_one_personality_empty_contents(self):
         serial_request = """
-<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"\
- name="new-server-test" imageId="1" flavorId="1">\
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"
+ name="new-server-test" imageId="1" flavorId="1">
 <personality><file path="/etc/conf"></file></personality></server>"""
         request = self.deserializer.deserialize(serial_request)
         expected = [{"path": "/etc/conf", "contents": ""}]
@@ -716,8 +743,8 @@ class TestServerCreateRequestXMLDeserializer(unittest.TestCase):
 
     def test_request_with_one_personality_empty_contents_variation(self):
         serial_request = """
-<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"\
- name="new-server-test" imageId="1" flavorId="1">\
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"
+ name="new-server-test" imageId="1" flavorId="1">
 <personality><file path="/etc/conf"/></personality></server>"""
         request = self.deserializer.deserialize(serial_request)
         expected = [{"path": "/etc/conf", "contents": ""}]
@@ -725,57 +752,101 @@ class TestServerCreateRequestXMLDeserializer(unittest.TestCase):
 
     def test_request_with_one_metadata(self):
         serial_request = """
-<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"\
- name="new-server-test" imageId="1" flavorId="1">\
-<metadata><meta key="alpha">beta</meta></metadata></server>"""
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"
+ name="new-server-test" imageId="1" flavorId="1">
+    <metadata>
+        <meta key="alpha">beta</meta>
+    </metadata>
+</server>"""
         request = self.deserializer.deserialize(serial_request)
         expected = {"alpha": "beta"}
         self.assertEquals(request["server"]["metadata"], expected)
 
     def test_request_with_two_metadata(self):
         serial_request = """
-<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"\
- name="new-server-test" imageId="1" flavorId="1">\
-<metadata><meta key="alpha">beta</meta><meta key="foo">bar</meta>\
-</metadata></server>"""
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"
+ name="new-server-test" imageId="1" flavorId="1">
+    <metadata>
+        <meta key="alpha">beta</meta>
+        <meta key="foo">bar</meta>
+    </metadata>
+</server>"""
         request = self.deserializer.deserialize(serial_request)
         expected = {"alpha": "beta", "foo": "bar"}
         self.assertEquals(request["server"]["metadata"], expected)
 
     def test_request_with_metadata_missing_value(self):
         serial_request = """
-<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"\
- name="new-server-test" imageId="1" flavorId="1">\
-<metadata><meta key="alpha"></meta></metadata></server>"""
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"
+ name="new-server-test" imageId="1" flavorId="1">
+    <metadata>
+        <meta key="alpha"></meta>
+    </metadata>
+</server>"""
         request = self.deserializer.deserialize(serial_request)
         expected = {"alpha": ""}
         self.assertEquals(request["server"]["metadata"], expected)
 
+    def test_request_with_two_metadata_missing_value(self):
+        serial_request = """
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"
+ name="new-server-test" imageId="1" flavorId="1">
+    <metadata>
+        <meta key="alpha"/>
+        <meta key="delta"/>
+    </metadata>
+</server>"""
+        request = self.deserializer.deserialize(serial_request)
+        expected = {"alpha": "", "delta": ""}
+        self.assertEquals(request["server"]["metadata"], expected)
+
     def test_request_with_metadata_missing_key(self):
         serial_request = """
-<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"\
- name="new-server-test" imageId="1" flavorId="1">\
-<metadata><meta>beta</meta></metadata></server>"""
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"
+ name="new-server-test" imageId="1" flavorId="1">
+    <metadata>
+        <meta>beta</meta>
+    </metadata>
+</server>"""
         request = self.deserializer.deserialize(serial_request)
         expected = {"": "beta"}
         self.assertEquals(request["server"]["metadata"], expected)
 
+    def test_request_with_two_metadata_missing_key(self):
+        serial_request = """
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"
+ name="new-server-test" imageId="1" flavorId="1">
+    <metadata>
+        <meta>beta</meta>
+        <meta>gamma</meta>
+    </metadata>
+</server>"""
+        request = self.deserializer.deserialize(serial_request)
+        expected = {"":"gamma"}
+        self.assertEquals(request["server"]["metadata"], expected)
+
     def test_request_with_metadata_duplicate_key(self):
         serial_request = """
-<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"\
- name="new-server-test" imageId="1" flavorId="1">\
-<metadata><meta key="foo">bar</meta><meta key="foo">baz</meta>\
-</metadata></server>"""
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"
+ name="new-server-test" imageId="1" flavorId="1">
+    <metadata>
+        <meta key="foo">bar</meta>
+        <meta key="foo">baz</meta>
+    </metadata>
+</server>"""
         request = self.deserializer.deserialize(serial_request)
         expected = {"foo": "baz"}
         self.assertEquals(request["server"]["metadata"], expected)
 
     def test_canonical_request_from_docs(self):
         serial_request = """
-<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"\
- name="new-server-test" imageId="1" flavorId="1">\
-<metadata><meta key="My Server Name">Apache1</meta></metadata>\
-<personality><file path="/etc/banner.txt">\
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"
+ name="new-server-test" imageId="1" flavorId="1">
+    <metadata>
+        <meta key="My Server Name">Apache1</meta>
+    </metadata>
+    <personality>
+        <file path="/etc/banner.txt">\
 ICAgICAgDQoiQSBjbG91ZCBkb2VzIG5vdCBrbm93IHdoeSBp\
 dCBtb3ZlcyBpbiBqdXN0IHN1Y2ggYSBkaXJlY3Rpb24gYW5k\
 IGF0IHN1Y2ggYSBzcGVlZC4uLkl0IGZlZWxzIGFuIGltcHVs\
@@ -784,8 +855,9 @@ QnV0IHRoZSBza3kga25vd3MgdGhlIHJlYXNvbnMgYW5kIHRo\
 ZSBwYXR0ZXJucyBiZWhpbmQgYWxsIGNsb3VkcywgYW5kIHlv\
 dSB3aWxsIGtub3csIHRvbywgd2hlbiB5b3UgbGlmdCB5b3Vy\
 c2VsZiBoaWdoIGVub3VnaCB0byBzZWUgYmV5b25kIGhvcml6\
-b25zLiINCg0KLVJpY2hhcmQgQmFjaA==\
-</file></personality></server>"""
+b25zLiINCg0KLVJpY2hhcmQgQmFjaA==</file>
+    </personality>
+</server>"""
         expected = {"server": {
             "name": "new-server-test",
             "imageId": "1",
-- 
cgit 


From fc07caece79e379b6d6f2a3220806af9271e349b Mon Sep 17 00:00:00 2001
From: Mark Washenberger <mark.washenberger@rackspace.com>
Date: Tue, 15 Mar 2011 19:23:46 -0400
Subject: pep8

---
 nova/tests/api/openstack/test_servers.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index ed37cb705..9a6f2c052 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -722,7 +722,6 @@ class TestServerCreateRequestXMLDeserializer(unittest.TestCase):
         expected = [{"path": "/etc/conf", "contents": "aabbccdd"}]
         self.assertEquals(request["server"]["personality"], expected)
 
-
     def test_request_with_one_personality_missing_path(self):
         serial_request = """
 <server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"
@@ -822,7 +821,7 @@ class TestServerCreateRequestXMLDeserializer(unittest.TestCase):
     </metadata>
 </server>"""
         request = self.deserializer.deserialize(serial_request)
-        expected = {"":"gamma"}
+        expected = {"": "gamma"}
         self.assertEquals(request["server"]["metadata"], expected)
 
     def test_request_with_metadata_duplicate_key(self):
-- 
cgit 


From 74987666f89b4d15ffcf17b43b3752135ba08a65 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Tue, 15 Mar 2011 18:48:17 -0500
Subject: A few fixes

---
 nova/compute/manager.py   | 2 +-
 nova/virt/xenapi/vmops.py | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 39b28f6a9..307c91650 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -541,7 +541,7 @@ class ComputeManager(manager.Manager):
         #after they're supported
         instance_type = self.db.instance_type_get_by_flavor_id(context,
                 migration_ref['new_flavor_id'])
-        self.db.instance_update(context, instance_ref,
+        self.db.instance_update(context, instance_id,
                dict(memory_mb=instance_type['memory_mb'],
                     vcpus=instance_type['vcpus'],
                     local_gb=instance_type['local_gb']))
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 <matt.dietz@rackspace.com>
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')

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 bee1951ac78688e49939aee4e2285ef0ff89adb2 Mon Sep 17 00:00:00 2001
From: Naveed Massjouni <naveedm9@gmail.com>
Date: Tue, 15 Mar 2011 19:55:13 -0400
Subject: As suggested by Eric Day:  * changed request.environ version key to
 more descriptive 'api.version'  * removed python3 string formatting  * added
 licenses to headers on new files

---
 nova/api/openstack/auth.py               |  2 +-
 nova/api/openstack/common.py             |  3 +++
 nova/api/openstack/views/addresses.py    | 22 +++++++++++++++++++---
 nova/api/openstack/views/flavors.py      | 23 ++++++++++++++++++++---
 nova/api/openstack/views/images.py       | 23 ++++++++++++++++++++---
 nova/api/openstack/views/servers.py      | 20 +++++++++++++++++++-
 nova/tests/api/openstack/fakes.py        |  4 ++--
 nova/tests/api/openstack/test_servers.py |  4 ++--
 8 files changed, 86 insertions(+), 15 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/auth.py b/nova/api/openstack/auth.py
index c820a5963..7ae285019 100644
--- a/nova/api/openstack/auth.py
+++ b/nova/api/openstack/auth.py
@@ -70,7 +70,7 @@ class AuthMiddleware(wsgi.Middleware):
 
         req.environ['nova.context'] = context.RequestContext(user, account)
         version = req.path.split('/')[1].replace('v', '')
-        req.environ['version'] = version
+        req.environ['nova.api.openstack.version'] = version
         return self.application
 
     def has_authentication(self, req):
diff --git a/nova/api/openstack/common.py b/nova/api/openstack/common.py
index 74ac21024..d94969ff5 100644
--- a/nova/api/openstack/common.py
+++ b/nova/api/openstack/common.py
@@ -74,3 +74,6 @@ def get_image_id_from_image_hash(image_service, context, image_hash):
         if abs(hash(image_id)) == int(image_hash):
             return image_id
     raise exception.NotFound(image_hash)
+
+def get_api_version(req):
+    return req.environ.get('api.version')
diff --git a/nova/api/openstack/views/addresses.py b/nova/api/openstack/views/addresses.py
index 65c24dbd7..9d392aace 100644
--- a/nova/api/openstack/views/addresses.py
+++ b/nova/api/openstack/views/addresses.py
@@ -1,6 +1,22 @@
-import hashlib
-from nova.compute import power_state
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010-2011 OpenStack LLC.
+# 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.
+
 from nova import utils
+from nova.api.openstack import common
 
 
 def get_view_builder(req):
@@ -8,7 +24,7 @@ def get_view_builder(req):
     A factory method that returns the correct builder based on the version of
     the api requested.
     '''
-    version = req.environ['version']
+    version = common.get_api_version(req)
     if version == '1.1':
         return ViewBuilder_1_1()
     else:
diff --git a/nova/api/openstack/views/flavors.py b/nova/api/openstack/views/flavors.py
index f945f9f8f..aa3c2aeb2 100644
--- a/nova/api/openstack/views/flavors.py
+++ b/nova/api/openstack/views/flavors.py
@@ -1,11 +1,28 @@
-
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010-2011 OpenStack LLC.
+# 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.
+
+from nova.api.openstack import common
 
 def get_view_builder(req):
     '''
     A factory method that returns the correct builder based on the version of
     the api requested.
     '''
-    version = req.environ['version']
+    version = common.get_api_version(req)
     base_url = req.application_url
     if version == '1.1':
         return ViewBuilder_1_1(base_url)
@@ -26,7 +43,7 @@ class ViewBuilder_1_1(ViewBuilder):
         self.base_url = base_url
 
     def generate_href(self, flavor_id):
-        return "{0}/flavors/{1}".format(self.base_url, flavor_id)
+        return "%s/flavors/%s" % (self.base_url, flavor_id)
 
 
 class ViewBuilder_1_0(ViewBuilder):
diff --git a/nova/api/openstack/views/images.py b/nova/api/openstack/views/images.py
index a59d4a557..930b464b0 100644
--- a/nova/api/openstack/views/images.py
+++ b/nova/api/openstack/views/images.py
@@ -1,11 +1,28 @@
-
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010-2011 OpenStack LLC.
+# 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.
+
+from nova.api.openstack import common
 
 def get_view_builder(req):
     '''
     A factory method that returns the correct builder based on the version of
     the api requested.
     '''
-    version = req.environ['version']
+    version = common.get_api_version(req)
     base_url = req.application_url
     if version == '1.1':
         return ViewBuilder_1_1(base_url)
@@ -26,7 +43,7 @@ class ViewBuilder_1_1(ViewBuilder):
         self.base_url = base_url
 
     def generate_href(self, image_id):
-        return "{0}/images/{1}".format(self.base_url, image_id)
+        return "%s/images/%s" % (self.base_url, image_id)
 
 
 class ViewBuilder_1_0(ViewBuilder):
diff --git a/nova/api/openstack/views/servers.py b/nova/api/openstack/views/servers.py
index 2549cc11c..261acfed0 100644
--- a/nova/api/openstack/views/servers.py
+++ b/nova/api/openstack/views/servers.py
@@ -1,5 +1,23 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010-2011 OpenStack LLC.
+# 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.
+
 import hashlib
 from nova.compute import power_state
+from nova.api.openstack import common
 from nova.api.openstack.views import addresses as addresses_view
 from nova.api.openstack.views import flavors as flavors_view
 from nova.api.openstack.views import images as images_view
@@ -11,7 +29,7 @@ def get_view_builder(req):
     A factory method that returns the correct builder based on the version of
     the api requested.
     '''
-    version = req.environ['version']
+    version = common.get_api_version(req)
     addresses_builder = addresses_view.get_view_builder(req)
     if version == '1.1':
         flavor_builder = flavors_view.get_view_builder(req)
diff --git a/nova/tests/api/openstack/fakes.py b/nova/tests/api/openstack/fakes.py
index 9c3b53ac7..a3968b57b 100644
--- a/nova/tests/api/openstack/fakes.py
+++ b/nova/tests/api/openstack/fakes.py
@@ -69,8 +69,8 @@ def fake_auth_init(self, application):
 @webob.dec.wsgify
 def fake_wsgi(self, req):
     req.environ['nova.context'] = context.RequestContext(1, 1)
-    if not req.environ.get('version'):
-        req.environ['version'] = '1.0'
+    if not req.environ.get('api.version'):
+        req.environ['api.version'] = '1.0'
     if req.body:
         req.environ['inst_dict'] = json.loads(req.body)
     return self.application
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 6b804d3b4..27d174fe9 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -183,7 +183,7 @@ class ServersTest(test.TestCase):
         new_return_server = return_server_with_addresses(private, public)
         self.stubs.Set(nova.db.api, 'instance_get', new_return_server)
         req = webob.Request.blank('/v1.1/servers/1')
-        req.environ['version'] = '1.1'
+        req.environ['api.version'] = '1.1'
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
         self.assertEqual(res_dict['server']['id'], '1')
@@ -363,7 +363,7 @@ class ServersTest(test.TestCase):
 
     def test_get_all_server_details_v1_1(self):
         req = webob.Request.blank('/v1.1/servers/detail')
-        req.environ['version'] = '1.1'
+        req.environ['api.version'] = '1.1'
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
 
-- 
cgit 


From 9650e73db3e18f839f8abf7a47aebb6fbf8c9e36 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
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')

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 c42d79b58eccaebab14274adf09128d890e920f7 Mon Sep 17 00:00:00 2001
From: Brian Waldon <brian.waldon@rackspace.com>
Date: Tue, 15 Mar 2011 20:37:37 -0400
Subject: adding imageRef and flavorRef attributes to servers serialization
 metadata

---
 nova/api/openstack/servers.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index de67cbc4a..dc62882eb 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -46,7 +46,8 @@ class Controller(wsgi.Controller):
         'application/xml': {
             "attributes": {
                 "server": ["id", "imageId", "name", "flavorId", "hostId",
-                           "status", "progress", "adminPass"]}}}
+                           "status", "progress", "adminPass", "flavorRef",
+                           "imageRef"]}}}
 
     def __init__(self):
         self.compute_api = compute.API()
-- 
cgit 


From 5e45d0ba921566e98817cb9e62e383f84c30c5f6 Mon Sep 17 00:00:00 2001
From: Brian Lamar <brian.lamar@rackspace.com>
Date: Tue, 15 Mar 2011 20:51:17 -0400
Subject: Limits controller and testing with XML and JSON serialization.

---
 nova/api/openstack/limits.py                  |  42 ++-
 nova/tests/api/openstack/test_limits.py       | 524 ++++++++++++++++++++++++++
 nova/tests/api/openstack/test_ratelimiting.py | 387 -------------------
 nova/wsgi.py                                  |   1 +
 4 files changed, 556 insertions(+), 398 deletions(-)
 create mode 100644 nova/tests/api/openstack/test_limits.py
 delete mode 100644 nova/tests/api/openstack/test_ratelimiting.py

(limited to 'nova')

diff --git a/nova/api/openstack/limits.py b/nova/api/openstack/limits.py
index b1e633330..57e6bfcc2 100644
--- a/nova/api/openstack/limits.py
+++ b/nova/api/openstack/limits.py
@@ -50,12 +50,24 @@ class LimitsController(Controller):
     Controller for accessing limits in the OpenStack API.
     """
 
+    _serialization_metadata = {
+        "application/xml": {
+            "attributes": {
+                "limit": ["verb", "URI", "regex", "value", "unit",
+                    "resetTime", "remaining", "name"],
+            },
+            "plurals" : {
+                "rate" : "limit",
+            },
+        },
+    }
+
     def index(self, req):
         """
         Return all global and rate limit information.
         """
         abs_limits = {}
-        rate_limits = req.environ.get("nova.limits", {})
+        rate_limits = req.environ.get("nova.limits", [])
 
         return {
             "limits": {
@@ -92,6 +104,7 @@ class Limit(object):
         self.regex = regex
         self.value = int(value)
         self.unit = unit
+        self.unit_string = self.display_unit().lower()
         self.remaining = int(value)
 
         if value <= 0:
@@ -101,8 +114,10 @@ class Limit(object):
         self.next_request = None
 
         self.water_level = 0
-        self.capacity = float(self.unit)
+        self.capacity = self.unit
         self.request_value = float(self.capacity) / float(self.value)
+        self.error_message = _("Only %(value)s %(verb)s request(s) can be "\
+            "made to %(uri)s every %(unit_string)s." % self.__dict__)
 
     def __call__(self, verb, url):
         """
@@ -153,7 +168,7 @@ class Limit(object):
         """Return a useful representation of this class."""
         return {
             "verb": self.verb,
-            "uri": self.uri,
+            "URI": self.uri,
             "regex": self.regex,
             "value": self.value,
             "remaining": int(self.remaining),
@@ -204,13 +219,12 @@ class RateLimitingMiddleware(Middleware):
         url = req.url
         username = req.environ["nova.context"].user_id
 
-        delay = self._limiter.check_for_delay(verb, url, username)
+        delay, error = self._limiter.check_for_delay(verb, url, username)
 
         if delay:
             msg = "This request was rate-limited."
-            details = "Error details."
             retry = time.time() + delay
-            return faults.OverLimitFault(msg, details, retry)
+            return faults.OverLimitFault(msg, error, retry)
 
         req.environ["nova.limits"] = self._limiter.get_limits(username)
 
@@ -240,13 +254,15 @@ class Limiter(object):
     def check_for_delay(self, verb, url, username=None):
         """
         Check the given verb/user/user triplet for limit.
+
+        @return: Tuple of delay (in seconds) and error message (or None, None)
         """
         def _get_delay_list():
             """Yield limit delays."""
             for limit in self.levels[username]:
                 delay = limit(verb, url)
                 if delay:
-                    yield delay
+                    yield delay, limit.error_message
 
         delays = list(_get_delay_list())
 
@@ -254,6 +270,8 @@ class Limiter(object):
             delays.sort()
             return delays[0]
 
+        return None, None
+
 
 class WsgiLimiter(object):
     """
@@ -298,11 +316,11 @@ class WsgiLimiter(object):
         verb = info.get("verb")
         path = info.get("path")
 
-        delay = self._limiter.check_for_delay(verb, path, username)
+        delay, error = self._limiter.check_for_delay(verb, path, username)
 
         if delay:
             headers = {"X-Wait-Seconds": "%.2f" % delay}
-            return webob.exc.HTTPForbidden(headers=headers)
+            return webob.exc.HTTPForbidden(headers=headers, explanation=error)
         else:
             return webob.exc.HTTPNoContent()
 
@@ -333,7 +351,9 @@ class WsgiLimiterProxy(object):
 
         resp = conn.getresponse()
 
+        print resp
+
         if 200 >= resp.status < 300:
-            return None
+            return None, None
 
-        return resp.getheader("X-Wait-Seconds")
+        return resp.getheader("X-Wait-Seconds"), resp.read() or None
diff --git a/nova/tests/api/openstack/test_limits.py b/nova/tests/api/openstack/test_limits.py
new file mode 100644
index 000000000..cf4389c1d
--- /dev/null
+++ b/nova/tests/api/openstack/test_limits.py
@@ -0,0 +1,524 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 OpenStack LLC.
+# 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.
+
+"""
+Tests dealing with HTTP rate-limiting.
+"""
+
+import httplib
+import json
+import StringIO
+import stubout
+import time
+import webob
+
+from xml.dom.minidom import parseString
+
+from nova import test
+from nova.api.openstack import limits
+from nova.api.openstack.limits import Limit
+
+
+TEST_LIMITS = [
+    Limit("GET", "/delayed", "^/delayed", 1, limits.PER_MINUTE),
+    Limit("POST", "*", ".*", 7, limits.PER_MINUTE),
+    Limit("POST", "/servers", "^/servers", 3, limits.PER_MINUTE),
+    Limit("PUT", "*", "", 10, limits.PER_MINUTE),
+    Limit("PUT", "/servers", "^/servers", 5, limits.PER_MINUTE),
+]
+
+
+class LimitsControllerTest(test.TestCase):
+    """
+    Tests for `limits.LimitsController` class.
+    """
+
+    def setUp(self):
+        """Run before each test."""
+        test.TestCase.setUp(self)
+        self.time = 0.0
+        self.stubs = stubout.StubOutForTesting()
+        self.stubs.Set(limits.Limit, "_get_time", self._get_time)
+        self.controller = limits.LimitsController()
+
+    def tearDown(self):
+        """Run after each test."""
+        self.stubs.UnsetAll()
+        test.TestCase.tearDown(self)
+
+    def _get_time(self):
+        """Return the "time" according to this test suite."""
+        return self.time
+
+    def _get_index_request(self, accept_header="application/json"):
+        """Helper to set routing arguments."""
+        request = webob.Request.blank("/")
+        request.accept = accept_header
+        request.environ["wsgiorg.routing_args"] = (None, {
+            "action": "index",
+            "controller": "",
+        })
+        return request
+
+    def _populate_limits(self, request):
+        """Put limit info into a request."""
+        limits = [
+            Limit("GET", "*", ".*", 10, 60).display(),
+            Limit("POST", "*", ".*", 5, 60 * 60).display(),
+        ]
+        request.environ["nova.limits"] = limits
+        return request
+
+    def test_empty_index_json(self):
+        """Test getting empty limit details in JSON."""
+        request = self._get_index_request()
+        response = request.get_response(self.controller)
+        expected = {
+            "limits": {
+                "rate": [],
+                "absolute": {},
+            },
+        }
+        body = json.loads(response.body)
+        self.assertEqual(expected, body)
+
+    def test_index_json(self):
+        """Test getting limit details in JSON."""
+        request = self._get_index_request()
+        request = self._populate_limits(request)
+        response = request.get_response(self.controller)
+        expected = {
+            "limits": {
+                "rate": [{
+                    "regex": ".*",
+                    "resetTime": 0,
+                    "URI": "*",
+                    "value": 10,
+                    "verb": "GET",
+                    "remaining": 10,
+                    "unit": "MINUTE",
+                },
+                {
+                    "regex": ".*",
+                    "resetTime": 0,
+                    "URI": "*",
+                    "value": 5,
+                    "verb": "POST",
+                    "remaining": 5,
+                    "unit": "HOUR",
+                }],
+                "absolute": {},
+            },
+        }
+        body = json.loads(response.body)
+        self.assertEqual(expected, body)
+
+    def test_empty_index_xml(self):
+        """Test getting limit details in XML."""
+        request = self._get_index_request("application/xml")
+        response = request.get_response(self.controller)
+
+        expected = "<limits><rate/><absolute/></limits>"
+        body = response.body.replace("\n","").replace(" ", "")
+
+        self.assertEqual(expected, body)
+
+    def test_index_xml(self):
+        """Test getting limit details in XML."""
+        request = self._get_index_request("application/xml")
+        request = self._populate_limits(request)
+        response = request.get_response(self.controller)
+
+        expected = parseString("""
+            <limits>
+                <rate>
+                    <limit URI="*" regex=".*" remaining="10" resetTime="0" 
+                        unit="MINUTE" value="10" verb="GET"/>
+                    <limit URI="*" regex=".*" remaining="5" resetTime="0"
+                        unit="HOUR" value="5" verb="POST"/>
+                </rate>
+                <absolute/>
+            </limits>
+        """.replace("  ", ""))
+        body = parseString(response.body.replace("  ", ""))
+
+        self.assertEqual(expected.toxml(), body.toxml())
+
+
+class LimiterTest(test.TestCase):
+    """
+    Tests for the in-memory `limits.Limiter` class.
+    """
+
+    def setUp(self):
+        """Run before each test."""
+        test.TestCase.setUp(self)
+        self.time = 0.0
+        self.stubs = stubout.StubOutForTesting()
+        self.stubs.Set(limits.Limit, "_get_time", self._get_time)
+        self.limiter = limits.Limiter(TEST_LIMITS)
+
+    def tearDown(self):
+        """Run after each test."""
+        self.stubs.UnsetAll()
+        test.TestCase.tearDown(self)
+
+    def _get_time(self):
+        """Return the "time" according to this test suite."""
+        return self.time
+
+    def _check(self, num, verb, url, username=None):
+        """Check and yield results from checks."""
+        for x in xrange(num):
+            yield self.limiter.check_for_delay(verb, url, username)[0]
+
+    def _check_sum(self, num, verb, url, username=None):
+        """Check and sum results from checks."""
+        results = self._check(num, verb, url, username)
+        return sum(filter(lambda x: x != None, results))
+
+    def test_no_delay_GET(self):
+        """
+        Simple test to ensure no delay on a single call for a limit verb we
+        didn"t set.
+        """
+        delay = self.limiter.check_for_delay("GET", "/anything")
+        self.assertEqual(delay, (None, None))
+
+    def test_no_delay_PUT(self):
+        """
+        Simple test to ensure no delay on a single call for a known limit.
+        """
+        delay = self.limiter.check_for_delay("PUT", "/anything")
+        self.assertEqual(delay, (None, None))
+
+    def test_delay_PUT(self):
+        """
+        Ensure the 11th PUT will result in a delay of 6.0 seconds until
+        the next request will be granced.
+        """
+        expected = [None] * 10 + [6.0]
+        results = list(self._check(11, "PUT", "/anything"))
+
+        self.assertEqual(expected, results)
+
+    def test_delay_POST(self):
+        """
+        Ensure the 8th POST will result in a delay of 6.0 seconds until
+        the next request will be granced.
+        """
+        expected = [None] * 7
+        results = list(self._check(7, "POST", "/anything"))
+        self.assertEqual(expected, results)
+
+        expected = 60.0 / 7.0
+        results = self._check_sum(1, "POST", "/anything")
+        self.failUnlessAlmostEqual(expected, results, 8)
+
+    def test_delay_GET(self):
+        """
+        Ensure the 11th GET will result in NO delay.
+        """
+        expected = [None] * 11
+        results = list(self._check(11, "GET", "/anything"))
+
+        self.assertEqual(expected, results)
+
+    def test_delay_PUT_servers(self):
+        """
+        Ensure PUT on /servers limits at 5 requests, and PUT elsewhere is still
+        OK after 5 requests...but then after 11 total requests, PUT limiting
+        kicks in.
+        """
+        # First 6 requests on PUT /servers
+        expected = [None] * 5 + [12.0]
+        results = list(self._check(6, "PUT", "/servers"))
+        self.assertEqual(expected, results)
+
+        # Next 5 request on PUT /anything
+        expected = [None] * 4 + [6.0]
+        results = list(self._check(5, "PUT", "/anything"))
+        self.assertEqual(expected, results)
+
+    def test_delay_PUT_wait(self):
+        """
+        Ensure after hitting the limit and then waiting for the correct
+        amount of time, the limit will be lifted.
+        """
+        expected = [None] * 10 + [6.0]
+        results = list(self._check(11, "PUT", "/anything"))
+        self.assertEqual(expected, results)
+
+        # Advance time
+        self.time += 6.0
+
+        expected = [None, 6.0]
+        results = list(self._check(2, "PUT", "/anything"))
+        self.assertEqual(expected, results)
+
+    def test_multiple_delays(self):
+        """
+        Ensure multiple requests still get a delay.
+        """
+        expected = [None] * 10 + [6.0] * 10
+        results = list(self._check(20, "PUT", "/anything"))
+        self.assertEqual(expected, results)
+
+        self.time += 1.0
+
+        expected = [5.0] * 10
+        results = list(self._check(10, "PUT", "/anything"))
+        self.assertEqual(expected, results)
+
+    def test_multiple_users(self):
+        """
+        Tests involving multiple users.
+        """
+        # User1
+        expected = [None] * 10 + [6.0] * 10
+        results = list(self._check(20, "PUT", "/anything", "user1"))
+        self.assertEqual(expected, results)
+
+        # User2
+        expected = [None] * 10 + [6.0] * 5
+        results = list(self._check(15, "PUT", "/anything", "user2"))
+        self.assertEqual(expected, results)
+
+        self.time += 1.0
+
+        # User1 again
+        expected = [5.0] * 10
+        results = list(self._check(10, "PUT", "/anything", "user1"))
+        self.assertEqual(expected, results)
+
+        self.time += 1.0
+
+        # User1 again
+        expected = [4.0] * 5
+        results = list(self._check(5, "PUT", "/anything", "user2"))
+        self.assertEqual(expected, results)
+
+
+class WsgiLimiterTest(test.TestCase):
+    """
+    Tests for `limits.WsgiLimiter` class.
+    """
+
+    def setUp(self):
+        """Run before each test."""
+        test.TestCase.setUp(self)
+        self.time = 0.0
+        self.stubs = stubout.StubOutForTesting()
+        self.stubs.Set(limits.Limit, "_get_time", self._get_time)
+        self.app = limits.WsgiLimiter(TEST_LIMITS)
+
+    def tearDown(self):
+        """Run after each test."""
+        self.stubs.UnsetAll()
+        test.TestCase.tearDown(self)
+
+    def _get_time(self):
+        """Return the "time" according to this test suite."""
+        return self.time
+
+    def _request_data(self, verb, path):
+        """Get data decribing a limit request verb/path."""
+        return json.dumps({"verb": verb, "path": path})
+
+    def _request(self, verb, url, username=None):
+        """Make sure that POSTing to the given url causes the given username
+        to perform the given action.  Make the internal rate limiter return
+        delay and make sure that the WSGI app returns the correct response.
+        """
+        if username:
+            request = webob.Request.blank("/%s" % username)
+        else:
+            request = webob.Request.blank("/")
+
+        request.method = "POST"
+        request.body = self._request_data(verb, url)
+        response = request.get_response(self.app)
+
+        if "X-Wait-Seconds" in response.headers:
+            self.assertEqual(response.status_int, 403)
+            return response.headers["X-Wait-Seconds"]
+
+        self.assertEqual(response.status_int, 204)
+
+    def test_invalid_methods(self):
+        """Only POSTs should work."""
+        requests = []
+        for method in ["GET", "PUT", "DELETE", "HEAD", "OPTIONS"]:
+            request = webob.Request.blank("/")
+            request.body = self._request_data("GET", "/something")
+            response = request.get_response(self.app)
+            self.assertEqual(response.status_int, 405)
+
+    def test_good_url(self):
+        delay = self._request("GET", "/something")
+        self.assertEqual(delay, None)
+
+    def test_escaping(self):
+        delay = self._request("GET", "/something/jump%20up")
+        self.assertEqual(delay, None)
+
+    def test_response_to_delays(self):
+        delay = self._request("GET", "/delayed")
+        self.assertEqual(delay, None)
+
+        delay = self._request("GET", "/delayed")
+        self.assertEqual(delay, '60.00')
+
+    def test_response_to_delays_usernames(self):
+        delay = self._request("GET", "/delayed", "user1")
+        self.assertEqual(delay, None)
+
+        delay = self._request("GET", "/delayed", "user2")
+        self.assertEqual(delay, None)
+
+        delay = self._request("GET", "/delayed", "user1")
+        self.assertEqual(delay, '60.00')
+
+        delay = self._request("GET", "/delayed", "user2")
+        self.assertEqual(delay, '60.00')
+
+
+class FakeHttplibSocket(object):
+    """
+    Fake `httplib.HTTPResponse` replacement.
+    """
+
+    def __init__(self, response_string):
+        """Initialize new `FakeHttplibSocket`."""
+        self._buffer = StringIO.StringIO(response_string)
+
+    def makefile(self, _mode, _other):
+        """Returns the socket's internal buffer."""
+        return self._buffer
+
+
+class FakeHttplibConnection(object):
+    """
+    Fake `httplib.HTTPConnection`.
+    """
+
+    def __init__(self, app, host):
+        """
+        Initialize `FakeHttplibConnection`.
+        """
+        self.app = app
+        self.host = host
+
+    def request(self, method, path, body="", headers={}):
+        """
+        Requests made via this connection actually get translated and routed
+        into our WSGI app, we then wait for the response and turn it back into
+        an `httplib.HTTPResponse`.
+        """
+        req = webob.Request.blank(path)
+        req.method = method
+        req.headers = headers
+        req.host = self.host
+        req.body = body
+
+        resp = str(req.get_response(self.app))
+        resp = "HTTP/1.0 %s" % resp
+        sock = FakeHttplibSocket(resp)
+        self.http_response = httplib.HTTPResponse(sock)
+        self.http_response.begin()
+
+    def getresponse(self):
+        """Return our generated response from the request."""
+        return self.http_response
+
+
+def wire_HTTPConnection_to_WSGI(host, app):
+    """Monkeypatches HTTPConnection so that if you try to connect to host, you
+    are instead routed straight to the given WSGI app.
+
+    After calling this method, when any code calls
+
+    httplib.HTTPConnection(host)
+
+    the connection object will be a fake.  Its requests will be sent directly
+    to the given WSGI app rather than through a socket.
+
+    Code connecting to hosts other than host will not be affected.
+
+    This method may be called multiple times to map different hosts to
+    different apps.
+    """
+    class HTTPConnectionDecorator(object):
+        """Wraps the real HTTPConnection class so that when you instantiate
+        the class you might instead get a fake instance."""
+
+        def __init__(self, wrapped):
+            self.wrapped = wrapped
+
+        def __call__(self, connection_host, *args, **kwargs):
+            if connection_host == host:
+                return FakeHttplibConnection(app, host)
+            else:
+                return self.wrapped(connection_host, *args, **kwargs)
+
+    httplib.HTTPConnection = HTTPConnectionDecorator(httplib.HTTPConnection)
+
+
+class WsgiLimiterProxyTest(test.TestCase):
+    """
+    Tests for the `limits.WsgiLimiterProxy` class.
+    """
+
+    def setUp(self):
+        """
+        Do some nifty HTTP/WSGI magic which allows for WSGI to be called
+        directly by something like the `httplib` library.
+        """
+        test.TestCase.setUp(self)
+        self.time = 0.0
+        self.stubs = stubout.StubOutForTesting()
+        self.stubs.Set(limits.Limit, "_get_time", self._get_time)
+        self.app = limits.WsgiLimiter(TEST_LIMITS)
+        wire_HTTPConnection_to_WSGI("169.254.0.1:80", self.app)
+        self.proxy = limits.WsgiLimiterProxy("169.254.0.1:80")
+
+    def tearDown(self):
+        """Run after each test."""
+        self.stubs.UnsetAll()
+        test.TestCase.tearDown(self)
+
+    def _get_time(self):
+        """Return the "time" according to this test suite."""
+        return self.time
+
+    def test_200(self):
+        """Successful request test."""
+        delay = self.proxy.check_for_delay("GET", "/anything")
+        self.assertEqual(delay, (None, None))
+
+    def test_403(self):
+        """Forbidden request test."""
+        delay = self.proxy.check_for_delay("GET", "/delayed")
+        self.assertEqual(delay, (None, None))
+
+        delay, error = self.proxy.check_for_delay("GET", "/delayed")
+        error = error.strip()
+
+        expected = ("60.00", "403 Forbidden\n\nOnly 1 GET request(s) can be "\
+            "made to /delayed every minute.")
+
+        self.assertEqual((delay, error), expected) 
diff --git a/nova/tests/api/openstack/test_ratelimiting.py b/nova/tests/api/openstack/test_ratelimiting.py
deleted file mode 100644
index a706364b4..000000000
--- a/nova/tests/api/openstack/test_ratelimiting.py
+++ /dev/null
@@ -1,387 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 OpenStack LLC.
-# 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.
-
-"""
-Tests dealing with HTTP rate-limiting.
-"""
-
-import httplib
-import json
-import StringIO
-import stubout
-import time
-import webob
-
-from nova import test
-from nova.api.openstack import limits
-from nova.api.openstack.limits import Limit
-
-
-TEST_LIMITS = [
-    Limit("GET", "/delayed", "^/delayed", 1, limits.PER_MINUTE),
-    Limit("POST", "*", ".*", 7, limits.PER_MINUTE),
-    Limit("POST", "/servers", "^/servers", 3, limits.PER_MINUTE),
-    Limit("PUT", "*", "", 10, limits.PER_MINUTE),
-    Limit("PUT", "/servers", "^/servers", 5, limits.PER_MINUTE),
-]
-
-
-class LimiterTest(test.TestCase):
-    """
-    Tests for the in-memory `limits.Limiter` class.
-    """
-
-    def setUp(self):
-        """Run before each test."""
-        test.TestCase.setUp(self)
-        self.time = 0.0
-        self.stubs = stubout.StubOutForTesting()
-        self.stubs.Set(limits.Limit, "_get_time", self._get_time)
-        self.limiter = limits.Limiter(TEST_LIMITS)
-
-    def tearDown(self):
-        """Run after each test."""
-        self.stubs.UnsetAll()
-
-    def _get_time(self):
-        """Return the "time" according to this test suite."""
-        return self.time
-
-    def _check(self, num, verb, url, username=None):
-        """Check and yield results from checks."""
-        for x in xrange(num):
-            yield self.limiter.check_for_delay(verb, url, username)
-
-    def _check_sum(self, num, verb, url, username=None):
-        """Check and sum results from checks."""
-        results = self._check(num, verb, url, username)
-        return sum(filter(lambda x: x != None, results))
-
-    def test_no_delay_GET(self):
-        """
-        Simple test to ensure no delay on a single call for a limit verb we
-        didn"t set.
-        """
-        delay = self.limiter.check_for_delay("GET", "/anything")
-        self.assertEqual(delay, None)
-
-    def test_no_delay_PUT(self):
-        """
-        Simple test to ensure no delay on a single call for a known limit.
-        """
-        delay = self.limiter.check_for_delay("PUT", "/anything")
-        self.assertEqual(delay, None)
-
-    def test_delay_PUT(self):
-        """
-        Ensure the 11th PUT will result in a delay of 6.0 seconds until
-        the next request will be granced.
-        """
-        expected = [None] * 10 + [6.0]
-        results = list(self._check(11, "PUT", "/anything"))
-
-        self.assertEqual(expected, results)
-
-    def test_delay_POST(self):
-        """
-        Ensure the 8th POST will result in a delay of 6.0 seconds until
-        the next request will be granced.
-        """
-        expected = [None] * 7
-        results = list(self._check(7, "POST", "/anything"))
-        self.assertEqual(expected, results)
-
-        expected = 60.0 / 7.0
-        results = self._check_sum(1, "POST", "/anything")
-        self.failUnlessAlmostEqual(expected, results, 8)
-
-    def test_delay_GET(self):
-        """
-        Ensure the 11th GET will result in NO delay.
-        """
-        expected = [None] * 11
-        results = list(self._check(11, "GET", "/anything"))
-
-        self.assertEqual(expected, results)
-
-    def test_delay_PUT_servers(self):
-        """
-        Ensure PUT on /servers limits at 5 requests, and PUT elsewhere is still
-        OK after 5 requests...but then after 11 total requests, PUT limiting
-        kicks in.
-        """
-        # First 6 requests on PUT /servers
-        expected = [None] * 5 + [12.0]
-        results = list(self._check(6, "PUT", "/servers"))
-        self.assertEqual(expected, results)
-
-        # Next 5 request on PUT /anything
-        expected = [None] * 4 + [6.0]
-        results = list(self._check(5, "PUT", "/anything"))
-        self.assertEqual(expected, results)
-
-    def test_delay_PUT_wait(self):
-        """
-        Ensure after hitting the limit and then waiting for the correct
-        amount of time, the limit will be lifted.
-        """
-        expected = [None] * 10 + [6.0]
-        results = list(self._check(11, "PUT", "/anything"))
-        self.assertEqual(expected, results)
-
-        # Advance time
-        self.time += 6.0
-
-        expected = [None, 6.0]
-        results = list(self._check(2, "PUT", "/anything"))
-        self.assertEqual(expected, results)
-
-    def test_multiple_delays(self):
-        """
-        Ensure multiple requests still get a delay.
-        """
-        expected = [None] * 10 + [6.0] * 10
-        results = list(self._check(20, "PUT", "/anything"))
-        self.assertEqual(expected, results)
-
-        self.time += 1.0
-
-        expected = [5.0] * 10
-        results = list(self._check(10, "PUT", "/anything"))
-        self.assertEqual(expected, results)
-
-    def test_multiple_users(self):
-        """
-        Tests involving multiple users.
-        """
-        # User1
-        expected = [None] * 10 + [6.0] * 10
-        results = list(self._check(20, "PUT", "/anything", "user1"))
-        self.assertEqual(expected, results)
-
-        # User2
-        expected = [None] * 10 + [6.0] * 5
-        results = list(self._check(15, "PUT", "/anything", "user2"))
-        self.assertEqual(expected, results)
-
-        self.time += 1.0
-
-        # User1 again
-        expected = [5.0] * 10
-        results = list(self._check(10, "PUT", "/anything", "user1"))
-        self.assertEqual(expected, results)
-
-        self.time += 1.0
-
-        # User1 again
-        expected = [4.0] * 5
-        results = list(self._check(5, "PUT", "/anything", "user2"))
-        self.assertEqual(expected, results)
-
-
-class WsgiLimiterTest(test.TestCase):
-    """
-    Tests for `limits.WsgiLimiter` class.
-    """
-
-    def setUp(self):
-        """Run before each test."""
-        test.TestCase.setUp(self)
-        self.time = 0.0
-        self.app = limits.WsgiLimiter(TEST_LIMITS)
-        self.app._limiter._get_time = self._get_time
-
-    def _get_time(self):
-        """Return the "time" according to this test suite."""
-        return self.time
-
-    def _request_data(self, verb, path):
-        """Get data decribing a limit request verb/path."""
-        return json.dumps({"verb": verb, "path": path})
-
-    def _request(self, verb, url, username=None):
-        """Make sure that POSTing to the given url causes the given username
-        to perform the given action.  Make the internal rate limiter return
-        delay and make sure that the WSGI app returns the correct response.
-        """
-        if username:
-            request = webob.Request.blank("/%s" % username)
-        else:
-            request = webob.Request.blank("/")
-
-        request.method = "POST"
-        request.body = self._request_data(verb, url)
-        response = request.get_response(self.app)
-
-        if "X-Wait-Seconds" in response.headers:
-            self.assertEqual(response.status_int, 403)
-            return response.headers["X-Wait-Seconds"]
-
-        self.assertEqual(response.status_int, 204)
-
-    def test_invalid_methods(self):
-        """Only POSTs should work."""
-        requests = []
-        for method in ["GET", "PUT", "DELETE", "HEAD", "OPTIONS"]:
-            request = webob.Request.blank("/")
-            request.body = self._request_data("GET", "/something")
-            response = request.get_response(self.app)
-            self.assertEqual(response.status_int, 405)
-
-    def test_good_url(self):
-        delay = self._request("GET", "/something")
-        self.assertEqual(delay, None)
-
-    def test_escaping(self):
-        delay = self._request("GET", "/something/jump%20up")
-        self.assertEqual(delay, None)
-
-    def test_response_to_delays(self):
-        delay = self._request("GET", "/delayed")
-        self.assertEqual(delay, None)
-
-        delay = self._request("GET", "/delayed")
-        self.assertEqual(delay, '60.00')
-
-    def test_response_to_delays_usernames(self):
-        delay = self._request("GET", "/delayed", "user1")
-        self.assertEqual(delay, None)
-
-        delay = self._request("GET", "/delayed", "user2")
-        self.assertEqual(delay, None)
-
-        delay = self._request("GET", "/delayed", "user1")
-        self.assertEqual(delay, '60.00')
-
-        delay = self._request("GET", "/delayed", "user2")
-        self.assertEqual(delay, '60.00')
-
-
-class FakeHttplibSocket(object):
-    """
-    Fake `httplib.HTTPResponse` replacement.
-    """
-
-    def __init__(self, response_string):
-        """Initialize new `FakeHttplibSocket`."""
-        self._buffer = StringIO.StringIO(response_string)
-
-    def makefile(self, _mode, _other):
-        """Returns the socket's internal buffer."""
-        return self._buffer
-
-
-class FakeHttplibConnection(object):
-    """
-    Fake `httplib.HTTPConnection`.
-    """
-
-    def __init__(self, app, host):
-        """
-        Initialize `FakeHttplibConnection`.
-        """
-        self.app = app
-        self.host = host
-
-    def request(self, method, path, body="", headers={}):
-        """
-        Requests made via this connection actually get translated and routed
-        into our WSGI app, we then wait for the response and turn it back into
-        an `httplib.HTTPResponse`.
-        """
-        req = webob.Request.blank(path)
-        req.method = method
-        req.headers = headers
-        req.host = self.host
-        req.body = body
-
-        resp = str(req.get_response(self.app))
-        resp = "HTTP/1.0 %s" % resp
-        sock = FakeHttplibSocket(resp)
-        self.http_response = httplib.HTTPResponse(sock)
-        self.http_response.begin()
-
-    def getresponse(self):
-        """Return our generated response from the request."""
-        return self.http_response
-
-
-def wire_HTTPConnection_to_WSGI(host, app):
-    """Monkeypatches HTTPConnection so that if you try to connect to host, you
-    are instead routed straight to the given WSGI app.
-
-    After calling this method, when any code calls
-
-    httplib.HTTPConnection(host)
-
-    the connection object will be a fake.  Its requests will be sent directly
-    to the given WSGI app rather than through a socket.
-
-    Code connecting to hosts other than host will not be affected.
-
-    This method may be called multiple times to map different hosts to
-    different apps.
-    """
-    class HTTPConnectionDecorator(object):
-        """Wraps the real HTTPConnection class so that when you instantiate
-        the class you might instead get a fake instance."""
-
-        def __init__(self, wrapped):
-            self.wrapped = wrapped
-
-        def __call__(self, connection_host, *args, **kwargs):
-            if connection_host == host:
-                return FakeHttplibConnection(app, host)
-            else:
-                return self.wrapped(connection_host, *args, **kwargs)
-
-    httplib.HTTPConnection = HTTPConnectionDecorator(httplib.HTTPConnection)
-
-
-class WsgiLimiterProxyTest(test.TestCase):
-    """
-    Tests for the `limits.WsgiLimiterProxy` class.
-    """
-
-    def setUp(self):
-        """
-        Do some nifty HTTP/WSGI magic which allows for WSGI to be called
-        directly by something like the `httplib` library.
-        """
-        test.TestCase.setUp(self)
-        self.time = 0.0
-        self.app = limits.WsgiLimiter(TEST_LIMITS)
-        self.app._limiter._get_time = self._get_time
-        wire_HTTPConnection_to_WSGI("169.254.0.1:80", self.app)
-        self.proxy = limits.WsgiLimiterProxy("169.254.0.1:80")
-
-    def _get_time(self):
-        """Return the "time" according to this test suite."""
-        return self.time
-
-    def test_200(self):
-        """Successful request test."""
-        delay = self.proxy.check_for_delay("GET", "/anything")
-        self.assertEqual(delay, None)
-
-    def test_403(self):
-        """Forbidden request test."""
-        delay = self.proxy.check_for_delay("GET", "/delayed")
-        self.assertEqual(delay, None)
-
-        delay = self.proxy.check_for_delay("GET", "/delayed")
-        self.assertEqual(delay, '60.00')
diff --git a/nova/wsgi.py b/nova/wsgi.py
index ba0819466..21aabd556 100644
--- a/nova/wsgi.py
+++ b/nova/wsgi.py
@@ -482,6 +482,7 @@ class Serializer(object):
 
     def _to_xml_node(self, doc, metadata, nodename, data):
         """Recursive method to convert data members to XML nodes."""
+        print "to_xml_node(%s, %s, %s, %s)" % (doc, metadata, nodename, data)
         result = doc.createElement(nodename)
         if type(data) is list:
             singular = metadata.get('plurals', {}).get(nodename, None)
-- 
cgit 


From 5ba3e21875d3cf3b71082477311902891706eee4 Mon Sep 17 00:00:00 2001
From: Brian Lamar <brian.lamar@rackspace.com>
Date: Tue, 15 Mar 2011 21:09:26 -0400
Subject: Removed VIM specific stuff and changed copyright from 2010 to 2011.

---
 nova/api/openstack/limits.py            | 4 +---
 nova/tests/api/openstack/test_limits.py | 4 +---
 2 files changed, 2 insertions(+), 6 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/limits.py b/nova/api/openstack/limits.py
index 57e6bfcc2..3ecd46377 100644
--- a/nova/api/openstack/limits.py
+++ b/nova/api/openstack/limits.py
@@ -1,6 +1,4 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 OpenStack LLC.
+# Copyright 2011 OpenStack LLC.
 # All Rights Reserved.
 #
 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
diff --git a/nova/tests/api/openstack/test_limits.py b/nova/tests/api/openstack/test_limits.py
index cf4389c1d..40178e671 100644
--- a/nova/tests/api/openstack/test_limits.py
+++ b/nova/tests/api/openstack/test_limits.py
@@ -1,6 +1,4 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 OpenStack LLC.
+# Copyright 2011 OpenStack LLC.
 # All Rights Reserved.
 #
 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
-- 
cgit 


From 6911123fda88c9793a70ea4b03d0352c9c38f938 Mon Sep 17 00:00:00 2001
From: Naveed Massjouni <naveedm9@gmail.com>
Date: Tue, 15 Mar 2011 21:26:45 -0400
Subject: Adding newlines for pep8.

---
 nova/api/openstack/common.py        | 1 +
 nova/api/openstack/views/flavors.py | 1 +
 nova/api/openstack/views/images.py  | 1 +
 3 files changed, 3 insertions(+)

(limited to 'nova')

diff --git a/nova/api/openstack/common.py b/nova/api/openstack/common.py
index d94969ff5..d6679de01 100644
--- a/nova/api/openstack/common.py
+++ b/nova/api/openstack/common.py
@@ -75,5 +75,6 @@ def get_image_id_from_image_hash(image_service, context, image_hash):
             return image_id
     raise exception.NotFound(image_hash)
 
+
 def get_api_version(req):
     return req.environ.get('api.version')
diff --git a/nova/api/openstack/views/flavors.py b/nova/api/openstack/views/flavors.py
index aa3c2aeb2..dd2e75a7a 100644
--- a/nova/api/openstack/views/flavors.py
+++ b/nova/api/openstack/views/flavors.py
@@ -17,6 +17,7 @@
 
 from nova.api.openstack import common
 
+
 def get_view_builder(req):
     '''
     A factory method that returns the correct builder based on the version of
diff --git a/nova/api/openstack/views/images.py b/nova/api/openstack/views/images.py
index 930b464b0..2369a8f9d 100644
--- a/nova/api/openstack/views/images.py
+++ b/nova/api/openstack/views/images.py
@@ -17,6 +17,7 @@
 
 from nova.api.openstack import common
 
+
 def get_view_builder(req):
     '''
     A factory method that returns the correct builder based on the version of
-- 
cgit 


From f91d7925761f8204fdd46435ff57d74ae17483cf Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Tue, 15 Mar 2011 18:29:26 -0700
Subject: first pass openstack redirect working

---
 nova/api/openstack/servers.py |  1 +
 nova/compute/api.py           |  3 ++-
 nova/compute/manager.py       |  6 +++++-
 nova/exception.py             |  6 +++---
 nova/scheduler/api.py         | 13 +++++++++++--
 5 files changed, 22 insertions(+), 7 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 85999764f..ffcbe628c 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -343,6 +343,7 @@ class Controller(wsgi.Controller):
         """ Permit Admins to Pause the server. """
         ctxt = req.environ['nova.context']
         try:
+            LOG.debug(_("*** Compute.api::pause %s"), id)
             self.compute_api.pause(ctxt, id)
         except:
             readable = traceback.format_exc()
diff --git a/nova/compute/api.py b/nova/compute/api.py
index 8865a1654..1185b9964 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -347,7 +347,8 @@ class API(base.Base):
 
     def get(self, context, instance_id):
         """Get a single instance with the given ID."""
-        rv = self.db.instance_get(context, instance_id)
+        rv = self.scheduler_api.get_instance_or_reroute(context, instance_id)
+        #rv = self.db.instance_get(context, instance_id)
         return dict(rv.iteritems())
 
     def get_all(self, context, project_id=None, reservation_id=None,
diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index ebe1ce6f0..499b212e2 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -48,6 +48,7 @@ from nova import scheduler_manager
 from nova import rpc
 from nova import utils
 from nova.compute import power_state
+from nova.scheduler import api as scheduler_api
 
 FLAGS = flags.FLAGS
 flags.DEFINE_string('instances_path', '$state_path/instances',
@@ -521,7 +522,10 @@ class ComputeManager(scheduler_manager.SchedulerDependentManager):
     def pause_instance(self, context, instance_id):
         """Pause an instance on this server."""
         context = context.elevated()
-        instance_ref = self.db.instance_get(context, instance_id)
+        LOG.debug(_('*** instance %s: starting pause'), instance_id)
+        instance_ref = scheduler_api.get_instance_or_reroute(context,
+                                            instance_id)
+        #instance_ref = self.db.instance_get(context, instance_id)
         LOG.audit(_('instance %s: pausing'), instance_id, context=context)
         self.db.instance_set_state(context,
                                    instance_id,
diff --git a/nova/exception.py b/nova/exception.py
index ce8daf048..d0baa2e29 100644
--- a/nova/exception.py
+++ b/nova/exception.py
@@ -93,9 +93,9 @@ class TimeoutException(Error):
 
 
 class ZoneRouteException(Error):
-    def __init__(self, zone, *args, **kwargs):
-        self.zone = zone
-        super(ZoneRouteException, self).__init__(args, kwargs)
+    def __init__(self, zones, *args, **kwargs):
+        self.zones = zones
+        super(ZoneRouteException, self).__init__(*args, **kwargs)
 
 
 class DBError(Error):
diff --git a/nova/scheduler/api.py b/nova/scheduler/api.py
index 8f9806f77..c0e28a0a9 100644
--- a/nova/scheduler/api.py
+++ b/nova/scheduler/api.py
@@ -73,13 +73,22 @@ class API(object):
                       args=dict(service_name=service_name, host=host,
                                 capabilities=capabilities))
         return rpc.fanout_cast(context, 'scheduler', kwargs)
+        
+    @classmethod
+    def get_instance_or_reroute(cls, context, instance_id):
+        instance = db.instance_get(context, instance_id)
+        zones = db.zone_get_all(context)
+
+        LOG.debug("*** Firing ZoneRouteException")
+        # Throw a reroute Exception for the middleware to pick up. 
+        raise exception.ZoneRouteException(zones)
 
     @classmethod
-    def get_queue_for_instance(cls, context, service, instance_id)
+    def get_queue_for_instance(cls, context, service, instance_id):
         instance = db.instance_get(context, instance_id)
         zone = db.get_zone(instance.zone.id)
         if cls._is_current_zone(zone):
-            return db.queue_get_for(context, service, instance['host']):
+            return db.queue_get_for(context, service, instance['host'])
 
         # Throw a reroute Exception for the middleware to pick up. 
         raise exception.ZoneRouteException(zone)
-- 
cgit 


From 60c7ce60826becb1ebe7f75a0a0d28b2893d70c0 Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Tue, 15 Mar 2011 18:54:51 -0700
Subject: revised per code review

---
 nova/image/local.py                     | 11 +++++++----
 nova/tests/api/openstack/test_images.py |  9 +++++++--
 2 files changed, 14 insertions(+), 6 deletions(-)

(limited to 'nova')

diff --git a/nova/image/local.py b/nova/image/local.py
index ef92a35b5..c304a2212 100644
--- a/nova/image/local.py
+++ b/nova/image/local.py
@@ -51,12 +51,15 @@ class LocalImageService(service.BaseImageService):
     def _ids(self):
         """The list of all image ids."""
         images = []
-        for i in os.listdir(self._path):
+        for image_dir in os.listdir(self._path):
             try:
-                images.append(int(i, 16))
+                images.append(int(image_dir, 16))
+            except ValueError:
+                LOG.error(
+                    _("%s is not in correct directory naming format"\
+                       % image_dir))
             except:
-                LOG.debug(
-                    _("%s is not in correct directory naming format" % i))
+                raise
         return images
 
     def index(self, context):
diff --git a/nova/tests/api/openstack/test_images.py b/nova/tests/api/openstack/test_images.py
index 2c4918117..a674ccefe 100644
--- a/nova/tests/api/openstack/test_images.py
+++ b/nova/tests/api/openstack/test_images.py
@@ -22,6 +22,7 @@ and as a WSGI layer
 
 import json
 import datetime
+import os
 import shutil
 import tempfile
 
@@ -155,8 +156,12 @@ class LocalImageServiceTest(test.TestCase,
         # create some old-style image directories (starting with 'ami-')
         for x in [1, 2, 3]:
             tempfile.mkstemp(prefix='ami-', dir=self.tempdir)
-        found_images = self.service._ids()
-        self.assertEqual(True, isinstance(found_images, list))
+        # create some valid image directories names
+        for x in ["1485baed", "1a60f0ee",  "3123a73d"]:
+            os.makedirs(os.path.join(self.tempdir, x))
+        found_image_ids = self.service._ids()
+        self.assertEqual(True, isinstance(found_image_ids, list))
+        self.assertEqual(3, len(found_image_ids), len(found_image_ids))
 
 
 class GlanceImageServiceTest(test.TestCase,
-- 
cgit 


From 0053b776276e9cac617c812931c248be7e49fea2 Mon Sep 17 00:00:00 2001
From: Dan Prince <dan.prince@rackspace.com>
Date: Tue, 15 Mar 2011 23:00:09 -0400
Subject: Add ResponseExtensions.

---
 nova/api/openstack/extensions.py               | 144 ++++++++++++++++++++-----
 nova/tests/api/openstack/extensions/widgets.py |  26 +++--
 nova/tests/api/openstack/test_extensions.py    | 103 +++++++++++++-----
 3 files changed, 213 insertions(+), 60 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/extensions.py b/nova/api/openstack/extensions.py
index f32471051..8b8806c8a 100644
--- a/nova/api/openstack/extensions.py
+++ b/nova/api/openstack/extensions.py
@@ -33,24 +33,43 @@ LOG = logging.getLogger('extensions')
 FLAGS = flags.FLAGS
 
 
-class ExtensionActionController(wsgi.Controller):
+class ActionExtensionController(wsgi.Controller):
 
-    def __init__(self, application, action_name, handler):
+    def __init__(self, application):
 
         self.application = application
-        self.action_name = action_name
-        self.handler = handler
+        self.action_handlers = {}
+
+    def add_action(self, action_name, handler):
+        self.action_handlers[action_name] = handler
 
     def action(self, req, id):
 
         input_dict = self._deserialize(req.body, req.get_content_type())
-        if self.action_name in input_dict:
-            return self.handler(input_dict, req, id)
+        for action_name, handler in self.action_handlers.iteritems():
+            if action_name in input_dict:
+                return handler(input_dict, req, id)
         # no action handler found (bump to downstream application)
         res = self.application
         return res
 
 
+class ResponseExtensionController(wsgi.Controller):
+
+    def __init__(self, application):
+        self.application = application
+        self.handlers = []
+
+    def add_handler(self, handler):
+        self.handlers.append(handler)
+
+    def process(self, req, *args, **kwargs):
+        res = req.get_response(self.application)
+        # currently response handlers are un-ordered
+        for handler in self.handlers:
+            return handler(res)
+
+
 class ExtensionMiddleware(wsgi.Middleware):
     """
     Extensions middleware that intercepts configured routes for extensions.
@@ -62,33 +81,80 @@ class ExtensionMiddleware(wsgi.Middleware):
             return cls(app, **local_config)
         return _factory
 
+    def _actions_by_collection(self, application, ext_mgr):
+        """
+        Return a dict of ActionExtensionController objects by collection
+        """
+        action_controllers = {}
+        for action in ext_mgr.get_actions():
+            if not action.collection in action_controllers.keys():
+                controller = ActionExtensionController(application)
+                action_controllers[action.collection] = controller
+        return action_controllers
+
+    def _responses_by_collection(self, application, ext_mgr):
+        """
+        Return a dict of ResponseExtensionController objects by collection
+        """
+        response_ext_controllers = {}
+        for resp_ext in ext_mgr.get_response_extensions():
+            if not resp_ext.url_route in response_ext_controllers.keys():
+                controller = ResponseExtensionController(application)
+                response_ext_controllers[resp_ext.url_route] = controller
+        return response_ext_controllers
+
     def __init__(self, application, ext_mgr=None):
-        mapper = routes.Mapper()
 
         if ext_mgr is None:
             ext_mgr = ExtensionManager(FLAGS.osapi_extensions_path)
+        self.ext_mgr = ext_mgr
+
+        mapper = routes.Mapper()
 
         # extended resources
         for resource in ext_mgr.get_resources():
-            mapper.resource(resource.member, resource.collection,
+            LOG.debug(_('Extended resource: %s'),
+                        resource.collection)
+            mapper.resource(resource.collection, resource.collection,
                             controller=resource.controller,
                             collection=resource.collection_actions,
                             member=resource.member_actions,
                             parent_resource=resource.parent)
 
         # extended actions
+        action_controllers = self._actions_by_collection(application, ext_mgr)
         for action in ext_mgr.get_actions():
-            controller = ExtensionActionController(application, action.name,
-                                                    action.handler)
-            mapper.connect("/%s/{id}/action.:(format)" % action.collection,
+            LOG.debug(_('Extended collection/action: %s/%s'),
+                        action.collection,
+                        action.action_name)
+            controller = action_controllers[action.collection]
+            controller.add_action(action.action_name, action.handler)
+
+            mapper.connect("/%s/:(id)/action.:(format)" % action.collection,
                             action='action',
                             controller=controller,
                             conditions=dict(method=['POST']))
-            mapper.connect("/%s/{id}/action" % action.collection,
+            mapper.connect("/%s/:(id)/action" % action.collection,
                             action='action',
                             controller=controller,
                             conditions=dict(method=['POST']))
 
+        # extended responses
+        resp_controllers = self._responses_by_collection(application, ext_mgr)
+        for response_ext in ext_mgr.get_response_extensions():
+            LOG.debug(_('Extended response: %s'), response_ext.url_route)
+            controller = resp_controllers[response_ext.url_route]
+            controller.add_handler(response_ext.handler)
+            mapper.connect(response_ext.url_route + '.:(format)',
+                            action='process',
+                            controller=controller,
+                            conditions=response_ext.conditions)
+
+            mapper.connect(response_ext.url_route,
+                            action='process',
+                            controller=controller,
+                            conditions=response_ext.conditions)
+
         self._router = routes.middleware.RoutesMiddleware(self._dispatch,
                                                           mapper)
 
@@ -106,9 +172,8 @@ class ExtensionMiddleware(wsgi.Middleware):
     @webob.dec.wsgify(RequestClass=wsgi.Request)
     def _dispatch(req):
         """
-        Called by self._router after matching the incoming request to a route
-        and putting the information into req.environ.  Either returns the
-        routed WSGI app's response or defers to the extended application.
+        Returns the routed WSGI app's response or defers to the extended
+        application.
         """
         match = req.environ['wsgiorg.routing_args'][1]
         if not match:
@@ -128,7 +193,7 @@ class ExtensionManager(object):
 
     def get_resources(self):
         """
-        returns a list of ExtensionResource objects
+        returns a list of ResourceExtension objects
         """
         resources = []
         for ext in self.extensions:
@@ -137,13 +202,22 @@ class ExtensionManager(object):
 
     def get_actions(self):
         """
-        returns a list of ExtensionAction objects
+        returns a list of ActionExtension objects
         """
         actions = []
         for ext in self.extensions:
             actions.extend(ext.get_actions())
         return actions
 
+    def get_response_extensions(self):
+        """
+        returns a list of ResponseExtension objects
+        """
+        response_exts = []
+        for ext in self.extensions:
+            response_exts.extend(ext.get_response_extensions())
+        return response_exts
+
     def _load_extensions(self):
         """
         Load extensions from the configured path. The extension name is
@@ -160,24 +234,42 @@ class ExtensionManager(object):
             ext_path = os.path.join(self.path, f)
             if file_ext.lower() == '.py':
                 mod = imp.load_source(mod_name, ext_path)
-                ext_name = mod_name[0].upper() + mod_name[1:] + 'Extension'
+                ext_name = mod_name[0].upper() + mod_name[1:]
                 self.extensions.append(getattr(mod, ext_name)())
 
 
-class ExtensionAction(object):
+class ResponseExtension(object):
+    """
+    ResponseExtension objects can be used to add data to responses from
+    core nova OpenStack API controllers.
+    """
 
-    def __init__(self, member, collection, name, handler):
-        self.member = member
+    def __init__(self, url_route, method, handler):
+        self.url_route = url_route
+        self.conditions = dict(method=[method])
+        self.handler = handler
+
+
+class ActionExtension(object):
+    """
+    ActionExtension objects can be used to add custom actions to core nova
+    nova OpenStack API controllers.
+    """
+
+    def __init__(self, collection, action_name, handler):
         self.collection = collection
-        self.name = name
+        self.action_name = action_name
         self.handler = handler
 
 
-class ExtensionResource(object):
+class ResourceExtension(object):
+    """
+    ResourceExtension objects can be used to add add top level resources
+    to the OpenStack API in nova.
+    """
 
-    def __init__(self, member, collection, controller,
-                 parent=None, collection_actions={}, member_actions={}):
-        self.member = member
+    def __init__(self, collection, controller, parent=None,
+                 collection_actions={}, member_actions={}):
         self.collection = collection
         self.controller = controller
         self.parent = parent
diff --git a/nova/tests/api/openstack/extensions/widgets.py b/nova/tests/api/openstack/extensions/widgets.py
index d5a2d95d9..f463721f1 100644
--- a/nova/tests/api/openstack/extensions/widgets.py
+++ b/nova/tests/api/openstack/extensions/widgets.py
@@ -1,3 +1,5 @@
+import json
+
 from nova import wsgi
 
 from nova.api.openstack import extensions
@@ -9,28 +11,40 @@ class WidgetsController(wsgi.Controller):
         return "Buy more widgets!"
 
 
-class WidgetsExtension(object):
+class Widgets(object):
 
     def __init__(self):
         pass
 
     def get_resources(self):
         resources = []
-        widgets = extensions.ExtensionResource('widget', 'widgets',
+        widgets = extensions.ResourceExtension('widgets',
                                                WidgetsController())
         resources.append(widgets)
         return resources
 
     def get_actions(self):
         actions = []
-        actions.append(extensions.ExtensionAction('server', 'servers',
-                                                    'add_widget',
+        actions.append(extensions.ActionExtension('servers', 'add_widget',
                                                     self._add_widget))
-        actions.append(extensions.ExtensionAction('server', 'servers',
-                                                    'delete_widget',
+        actions.append(extensions.ActionExtension('servers', 'delete_widget',
                                                     self._delete_widget))
         return actions
 
+    def get_response_extensions(self):
+        response_exts = []
+
+        def _resp_handler(res):
+            # only handle JSON responses
+            data = json.loads(res.body)
+            data['flavor']['widgets'] = "Buy more widgets!"
+            return data
+
+        widgets = extensions.ResponseExtension('/v1.0/flavors/:(id)', 'GET',
+                                                _resp_handler)
+        response_exts.append(widgets)
+        return response_exts
+
     def _add_widget(self, input_dict, req, id):
 
         return "Widget Added."
diff --git a/nova/tests/api/openstack/test_extensions.py b/nova/tests/api/openstack/test_extensions.py
index 080760c14..8725c8f0e 100644
--- a/nova/tests/api/openstack/test_extensions.py
+++ b/nova/tests/api/openstack/test_extensions.py
@@ -16,13 +16,17 @@
 #    under the License.
 
 import json
+import stubout
 import unittest
 import webob
 import os.path
 
+from nova import context
 from nova import flags
 from nova.api import openstack
 from nova.api.openstack import extensions
+from nova.api.openstack import flavors
+from nova.tests.api.openstack import fakes
 import nova.wsgi
 
 FLAGS = flags.FLAGS
@@ -39,21 +43,31 @@ class StubController(nova.wsgi.Controller):
 
 class StubExtensionManager(object):
 
-    def __init__(self, resource):
-        self.resource = resource
+    def __init__(self, resource_ext=None, action_ext=None, response_ext=None):
+        self.resource_ext = resource_ext
+        self.action_ext = action_ext
+        self.response_ext = response_ext
 
     def get_resources(self):
-        resources = []
-        if self.resource:
-            resources.append(self.resource)
-        return resources
+        resource_exts = []
+        if self.resource_ext:
+            resource_exts.append(self.resource_ext)
+        return resource_exts
 
     def get_actions(self):
-        actions = []
-        return actions
+        action_exts = []
+        if self.action_ext:
+            action_exts.append(self.action_ext)
+        return action_exts
 
+    def get_response_extensions(self):
+        response_exts = []
+        if self.response_ext:
+            response_exts.append(self.response_ext)
+        return response_exts
 
-class ExtensionResourceTest(unittest.TestCase):
+
+class ResourceExtensionTest(unittest.TestCase):
 
     def test_no_extension_present(self):
         manager = StubExtensionManager(None)
@@ -65,7 +79,7 @@ class ExtensionResourceTest(unittest.TestCase):
 
     def test_get_resources(self):
         response_body = "Buy more widgets!"
-        widgets = extensions.ExtensionResource('widget', 'widgets',
+        widgets = extensions.ResourceExtension('widgets',
                                                StubController(response_body))
         manager = StubExtensionManager(widgets)
         app = openstack.APIRouter()
@@ -77,7 +91,7 @@ class ExtensionResourceTest(unittest.TestCase):
 
     def test_get_resources_with_controller(self):
         response_body = "Buy more widgets!"
-        widgets = extensions.ExtensionResource('widget', 'widgets',
+        widgets = extensions.ResourceExtension('widgets',
                                                StubController(response_body))
         manager = StubExtensionManager(widgets)
         app = openstack.APIRouter()
@@ -103,40 +117,73 @@ class ExtensionManagerTest(unittest.TestCase):
         self.assertEqual("Buy more widgets!", response.body)
 
 
-class ExtendedActionTest(unittest.TestCase):
+class ActionExtensionTest(unittest.TestCase):
 
     def setUp(self):
         FLAGS.osapi_extensions_path = os.path.join(os.path.dirname(__file__),
                                                     "extensions")
 
-    def test_extended_action(self):
+    def _send_server_action_request(self, url, body):
         app = openstack.APIRouter()
         ext_midware = extensions.ExtensionMiddleware(app)
-        body = dict(add_widget=dict(name="test"))
-        request = webob.Request.blank("/servers/1/action")
+        request = webob.Request.blank(url)
         request.method = 'POST'
         request.content_type = 'application/json'
         request.body = json.dumps(body)
         response = request.get_response(ext_midware)
+        return response
+
+    def test_extended_action(self):
+        body = dict(add_widget=dict(name="test"))
+        response = self._send_server_action_request("/servers/1/action", body)
         self.assertEqual(200, response.status_int)
         self.assertEqual("Widget Added.", response.body)
 
+        body = dict(delete_widget=dict(name="test"))
+        response = self._send_server_action_request("/servers/1/action", body)
+        self.assertEqual(200, response.status_int)
+        self.assertEqual("Widget Deleted.", response.body)
+
     def test_invalid_action_body(self):
-        app = openstack.APIRouter()
-        ext_midware = extensions.ExtensionMiddleware(app)
         body = dict(blah=dict(name="test"))  # Doesn't exist
-        request = webob.Request.blank("/servers/1/action")
-        request.method = 'POST'
-        request.content_type = 'application/json'
-        request.body = json.dumps(body)
-        response = request.get_response(ext_midware)
+        response = self._send_server_action_request("/servers/1/action", body)
         self.assertEqual(501, response.status_int)
 
     def test_invalid_action(self):
-        app = openstack.APIRouter()
-        ext_midware = extensions.ExtensionMiddleware(app)
-        request = webob.Request.blank("/asdf/1/action")
-        request.method = 'POST'
-        request.content_type = 'application/json'
-        response = request.get_response(ext_midware)
+        body = dict(blah=dict(name="test"))
+        response = self._send_server_action_request("/asdf/1/action", body)
         self.assertEqual(404, response.status_int)
+
+
+class ResponseExtensionTest(unittest.TestCase):
+
+    def setUp(self):
+        super(ResponseExtensionTest, self).setUp()
+        self.stubs = stubout.StubOutForTesting()
+        fakes.FakeAuthManager.reset_fake_data()
+        fakes.FakeAuthDatabase.data = {}
+        fakes.stub_out_networking(self.stubs)
+        fakes.stub_out_rate_limiting(self.stubs)
+        fakes.stub_out_auth(self.stubs)
+        self.context = context.get_admin_context()
+
+    def test_get_resources(self):
+
+        test_resp = "Buy more widgets!"
+
+        def _resp_handler(res):
+            # only handle JSON responses
+            data = json.loads(res.body)
+            data['flavor']['widgets'] = test_resp
+            return data
+
+        widgets = extensions.ResponseExtension('/v1.0/flavors/:(id)', 'GET',
+                                                _resp_handler)
+        manager = StubExtensionManager(None, None, widgets)
+        app = fakes.wsgi_app()
+        ext_midware = extensions.ExtensionMiddleware(app, manager)
+        request = webob.Request.blank("/v1.0/flavors/1")
+        response = request.get_response(ext_midware)
+        self.assertEqual(200, response.status_int)
+        response_data = json.loads(response.body)
+        self.assertEqual(test_resp, response_data['flavor']['widgets'])
-- 
cgit 


From be9a218e2e4b01fe19722fb0073731d8ae6a7eea Mon Sep 17 00:00:00 2001
From: Brian Lamar <brian.lamar@rackspace.com>
Date: Tue, 15 Mar 2011 23:13:05 -0400
Subject: Added tests back for RateLimitingMiddleware which now throw correctly
 serialized errors with correct error codes.

Removed some error printing, and simplified some other parts of the code with
suggestions from teammates.
---
 nova/api/openstack/faults.py            |  22 +++-
 nova/api/openstack/limits.py            |  25 ++---
 nova/tests/api/openstack/test_limits.py | 172 ++++++++++++++++++++++----------
 nova/wsgi.py                            |   1 -
 4 files changed, 148 insertions(+), 72 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/faults.py b/nova/api/openstack/faults.py
index 6ed9322de..d05c61fc7 100644
--- a/nova/api/openstack/faults.py
+++ b/nova/api/openstack/faults.py
@@ -68,17 +68,31 @@ class OverLimitFault(webob.exc.HTTPException):
     Rate-limited request response.
     """
 
-    wrapped_exc = webob.exc.HTTPForbidden()
+    _serialization_metadata = {
+        "application/xml": {
+            "attributes": {
+                "overLimitFault": "code"
+            }
+        }
+    }
 
     def __init__(self, message, details, retry_time):
         """
         Initialize new `OverLimitFault` with relevant information.
         """
-        self.message = message
-        self.details = details
-        self.retry_time = retry_time
+        self.wrapped_exc = webob.exc.HTTPForbidden()
+        self.content = {
+            "overLimitFault": {
+                "code": self.wrapped_exc.status_int,
+                "message": message,
+                "details": details,
+            },
+        }
 
     @webob.dec.wsgify(RequestClass=wsgi.Request)
     def __call__(self, request):
         """Currently just return the wrapped exception."""
+        serializer = wsgi.Serializer(self._serialization_metadata)
+        content_type = request.best_match_content_type()
+        self.wrapped_exc.body = serializer.serialize(self.content, content_type)
         return self.wrapped_exc
diff --git a/nova/api/openstack/limits.py b/nova/api/openstack/limits.py
index 3ecd46377..c4e04e9d9 100644
--- a/nova/api/openstack/limits.py
+++ b/nova/api/openstack/limits.py
@@ -54,8 +54,8 @@ class LimitsController(Controller):
                 "limit": ["verb", "URI", "regex", "value", "unit",
                     "resetTime", "remaining", "name"],
             },
-            "plurals" : {
-                "rate" : "limit",
+            "plurals": {
+                "rate": "limit",
             },
         },
     }
@@ -215,7 +215,12 @@ class RateLimitingMiddleware(Middleware):
         """
         verb = req.method
         url = req.url
-        username = req.environ["nova.context"].user_id
+        context = req.environ.get("nova.context")
+
+        if context:
+            username = context.user_id
+        else:
+            username = None
 
         delay, error = self._limiter.check_for_delay(verb, url, username)
 
@@ -255,14 +260,12 @@ class Limiter(object):
 
         @return: Tuple of delay (in seconds) and error message (or None, None)
         """
-        def _get_delay_list():
-            """Yield limit delays."""
-            for limit in self.levels[username]:
-                delay = limit(verb, url)
-                if delay:
-                    yield delay, limit.error_message
+        delays = []
 
-        delays = list(_get_delay_list())
+        for limit in self.levels[username]:
+            delay = limit(verb, url)
+            if delay:
+                delays.append((delay, limit.error_message))
 
         if delays:
             delays.sort()
@@ -349,8 +352,6 @@ class WsgiLimiterProxy(object):
 
         resp = conn.getresponse()
 
-        print resp
-
         if 200 >= resp.status < 300:
             return None, None
 
diff --git a/nova/tests/api/openstack/test_limits.py b/nova/tests/api/openstack/test_limits.py
index 40178e671..d1db93a59 100644
--- a/nova/tests/api/openstack/test_limits.py
+++ b/nova/tests/api/openstack/test_limits.py
@@ -22,11 +22,11 @@ import json
 import StringIO
 import stubout
 import time
+import unittest
 import webob
 
 from xml.dom.minidom import parseString
 
-from nova import test
 from nova.api.openstack import limits
 from nova.api.openstack.limits import Limit
 
@@ -40,28 +40,34 @@ TEST_LIMITS = [
 ]
 
 
-class LimitsControllerTest(test.TestCase):
-    """
-    Tests for `limits.LimitsController` class.
-    """
+class BaseLimitTestSuite(unittest.TestCase):
+    """Base test suite which provides relevant stubs and time abstraction."""
 
     def setUp(self):
         """Run before each test."""
-        test.TestCase.setUp(self)
         self.time = 0.0
         self.stubs = stubout.StubOutForTesting()
         self.stubs.Set(limits.Limit, "_get_time", self._get_time)
-        self.controller = limits.LimitsController()
 
     def tearDown(self):
         """Run after each test."""
         self.stubs.UnsetAll()
-        test.TestCase.tearDown(self)
 
     def _get_time(self):
         """Return the "time" according to this test suite."""
         return self.time
 
+
+class LimitsControllerTest(BaseLimitTestSuite):
+    """
+    Tests for `limits.LimitsController` class.
+    """
+
+    def setUp(self):
+        """Run before each test."""
+        BaseLimitTestSuite.setUp(self)
+        self.controller = limits.LimitsController()
+
     def _get_index_request(self, accept_header="application/json"):
         """Helper to set routing arguments."""
         request = webob.Request.blank("/")
@@ -74,11 +80,11 @@ class LimitsControllerTest(test.TestCase):
 
     def _populate_limits(self, request):
         """Put limit info into a request."""
-        limits = [
+        _limits = [
             Limit("GET", "*", ".*", 10, 60).display(),
             Limit("POST", "*", ".*", 5, 60 * 60).display(),
         ]
-        request.environ["nova.limits"] = limits
+        request.environ["nova.limits"] = _limits
         return request
 
     def test_empty_index_json(self):
@@ -131,7 +137,7 @@ class LimitsControllerTest(test.TestCase):
         response = request.get_response(self.controller)
 
         expected = "<limits><rate/><absolute/></limits>"
-        body = response.body.replace("\n","").replace(" ", "")
+        body = response.body.replace("\n", "").replace(" ", "")
 
         self.assertEqual(expected, body)
 
@@ -144,7 +150,7 @@ class LimitsControllerTest(test.TestCase):
         expected = parseString("""
             <limits>
                 <rate>
-                    <limit URI="*" regex=".*" remaining="10" resetTime="0" 
+                    <limit URI="*" regex=".*" remaining="10" resetTime="0"
                         unit="MINUTE" value="10" verb="GET"/>
                     <limit URI="*" regex=".*" remaining="5" resetTime="0"
                         unit="HOUR" value="5" verb="POST"/>
@@ -157,28 +163,108 @@ class LimitsControllerTest(test.TestCase):
         self.assertEqual(expected.toxml(), body.toxml())
 
 
-class LimiterTest(test.TestCase):
+class LimitMiddlewareTest(BaseLimitTestSuite):
+    """
+    Tests for the `limits.RateLimitingMiddleware` class.
+    """
+
+    @webob.dec.wsgify
+    def _empty_app(self, request):
+        """Do-nothing WSGI app."""
+        pass
+
+    def setUp(self):
+        """Prepare middleware for use through fake WSGI app."""
+        BaseLimitTestSuite.setUp(self)
+        _limits = [
+            Limit("GET", "*", ".*", 1, 60),
+        ]
+        self.app = limits.RateLimitingMiddleware(self._empty_app, _limits)
+
+    def test_good_request(self):
+        """Test successful GET request through middleware."""
+        request = webob.Request.blank("/")
+        response = request.get_response(self.app)
+        self.assertEqual(200, response.status_int)
+
+    def test_limited_request_json(self):
+        """Test a rate-limited (403) GET request through middleware."""
+        request = webob.Request.blank("/")
+        response = request.get_response(self.app)
+        self.assertEqual(200, response.status_int)
+
+        request = webob.Request.blank("/")
+        response = request.get_response(self.app)
+        self.assertEqual(response.status_int, 403)
+
+        body = json.loads(response.body)
+        expected = "Only 1 GET request(s) can be made to * every minute."
+        value = body["overLimitFault"]["details"].strip()
+        self.assertEqual(value, expected)
+
+    def test_limited_request_xml(self):
+        """Test a rate-limited (403) response as XML"""
+        request = webob.Request.blank("/")
+        response = request.get_response(self.app)
+        self.assertEqual(200, response.status_int)
+
+        request = webob.Request.blank("/")
+        request.accept = "application/xml"
+        response = request.get_response(self.app)
+        self.assertEqual(response.status_int, 403)
+
+        root = parseString(response.body).childNodes[0]
+        expected = "Only 1 GET request(s) can be made to * every minute."
+
+        details = root.getElementsByTagName("details")
+        self.assertEqual(details.length, 1)
+
+        value = details.item(0).firstChild.data.strip()
+        self.assertEqual(value, expected)
+
+
+class LimitTest(BaseLimitTestSuite):
+    """
+    Tests for the `limits.Limit` class.
+    """
+
+    def test_GET_no_delay(self):
+        """Test a limit handles 1 GET per second."""
+        limit = Limit("GET", "*", ".*", 1, 1)
+        delay = limit("GET", "/anything")
+        self.assertEqual(None, delay)
+        self.assertEqual(0, limit.next_request)
+        self.assertEqual(0, limit.last_request)
+
+    def test_GET_delay(self):
+        """Test two calls to 1 GET per second limit."""
+        limit = Limit("GET", "*", ".*", 1, 1)
+        delay = limit("GET", "/anything")
+        self.assertEqual(None, delay)
+
+        delay = limit("GET", "/anything")
+        self.assertEqual(1, delay)
+        self.assertEqual(1, limit.next_request)
+        self.assertEqual(0, limit.last_request)
+
+        self.time += 4
+
+        delay = limit("GET", "/anything")
+        self.assertEqual(None, delay)
+        self.assertEqual(4, limit.next_request)
+        self.assertEqual(4, limit.last_request)
+
+
+class LimiterTest(BaseLimitTestSuite):
     """
     Tests for the in-memory `limits.Limiter` class.
     """
 
     def setUp(self):
         """Run before each test."""
-        test.TestCase.setUp(self)
-        self.time = 0.0
-        self.stubs = stubout.StubOutForTesting()
-        self.stubs.Set(limits.Limit, "_get_time", self._get_time)
+        BaseLimitTestSuite.setUp(self)
         self.limiter = limits.Limiter(TEST_LIMITS)
 
-    def tearDown(self):
-        """Run after each test."""
-        self.stubs.UnsetAll()
-        test.TestCase.tearDown(self)
-
-    def _get_time(self):
-        """Return the "time" according to this test suite."""
-        return self.time
-
     def _check(self, num, verb, url, username=None):
         """Check and yield results from checks."""
         for x in xrange(num):
@@ -311,28 +397,16 @@ class LimiterTest(test.TestCase):
         self.assertEqual(expected, results)
 
 
-class WsgiLimiterTest(test.TestCase):
+class WsgiLimiterTest(BaseLimitTestSuite):
     """
     Tests for `limits.WsgiLimiter` class.
     """
 
     def setUp(self):
         """Run before each test."""
-        test.TestCase.setUp(self)
-        self.time = 0.0
-        self.stubs = stubout.StubOutForTesting()
-        self.stubs.Set(limits.Limit, "_get_time", self._get_time)
+        BaseLimitTestSuite.setUp(self)
         self.app = limits.WsgiLimiter(TEST_LIMITS)
 
-    def tearDown(self):
-        """Run after each test."""
-        self.stubs.UnsetAll()
-        test.TestCase.tearDown(self)
-
-    def _get_time(self):
-        """Return the "time" according to this test suite."""
-        return self.time
-
     def _request_data(self, verb, path):
         """Get data decribing a limit request verb/path."""
         return json.dumps({"verb": verb, "path": path})
@@ -476,7 +550,7 @@ def wire_HTTPConnection_to_WSGI(host, app):
     httplib.HTTPConnection = HTTPConnectionDecorator(httplib.HTTPConnection)
 
 
-class WsgiLimiterProxyTest(test.TestCase):
+class WsgiLimiterProxyTest(BaseLimitTestSuite):
     """
     Tests for the `limits.WsgiLimiterProxy` class.
     """
@@ -486,23 +560,11 @@ class WsgiLimiterProxyTest(test.TestCase):
         Do some nifty HTTP/WSGI magic which allows for WSGI to be called
         directly by something like the `httplib` library.
         """
-        test.TestCase.setUp(self)
-        self.time = 0.0
-        self.stubs = stubout.StubOutForTesting()
-        self.stubs.Set(limits.Limit, "_get_time", self._get_time)
+        BaseLimitTestSuite.setUp(self)
         self.app = limits.WsgiLimiter(TEST_LIMITS)
         wire_HTTPConnection_to_WSGI("169.254.0.1:80", self.app)
         self.proxy = limits.WsgiLimiterProxy("169.254.0.1:80")
 
-    def tearDown(self):
-        """Run after each test."""
-        self.stubs.UnsetAll()
-        test.TestCase.tearDown(self)
-
-    def _get_time(self):
-        """Return the "time" according to this test suite."""
-        return self.time
-
     def test_200(self):
         """Successful request test."""
         delay = self.proxy.check_for_delay("GET", "/anything")
@@ -519,4 +581,4 @@ class WsgiLimiterProxyTest(test.TestCase):
         expected = ("60.00", "403 Forbidden\n\nOnly 1 GET request(s) can be "\
             "made to /delayed every minute.")
 
-        self.assertEqual((delay, error), expected) 
+        self.assertEqual((delay, error), expected)
diff --git a/nova/wsgi.py b/nova/wsgi.py
index 21aabd556..ba0819466 100644
--- a/nova/wsgi.py
+++ b/nova/wsgi.py
@@ -482,7 +482,6 @@ class Serializer(object):
 
     def _to_xml_node(self, doc, metadata, nodename, data):
         """Recursive method to convert data members to XML nodes."""
-        print "to_xml_node(%s, %s, %s, %s)" % (doc, metadata, nodename, data)
         result = doc.createElement(nodename)
         if type(data) is list:
             singular = metadata.get('plurals', {}).get(nodename, None)
-- 
cgit 


From 7a61965908ebfc076ad3b1d9cdc5773ade50bf75 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Tue, 15 Mar 2011 20:30:27 -0700
Subject: response working

---
 nova/api/zone_redirect.py | 100 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 100 insertions(+)
 create mode 100644 nova/api/zone_redirect.py

(limited to 'nova')

diff --git a/nova/api/zone_redirect.py b/nova/api/zone_redirect.py
new file mode 100644
index 000000000..5e40a82dd
--- /dev/null
+++ b/nova/api/zone_redirect.py
@@ -0,0 +1,100 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 OpenStack LLC.
+# 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.import datetime
+
+"""Reroutes calls to child zones on ZoneRouteException's."""
+
+import httplib
+import re
+import webob
+import webob.dec
+import webob.exc
+import urlparse
+import urllib
+
+from nova import exception
+from nova import log as logging
+from nova import wsgi
+
+import novaclient.client as client
+
+try:
+    import json
+except ImportError:
+    import simplejson as json
+
+
+LOG = logging.getLogger('server')
+
+
+class ZoneRedirectMiddleware(wsgi.Middleware):
+    """Catches Zone Routing exceptions and delegates the call
+       to child zones."""
+
+    @webob.dec.wsgify
+    def __call__(self, req):
+        try:
+            return req.get_response(self.application)
+        except exception.ZoneRouteException as e:
+            if len(e.zones) == 0:
+                exc = webob.exc.HTTPInternalServerError(explanation=
+                                        _("No zones to reroute to."))
+                return faults.Fault(exc)
+
+            zone = e.zones[0]
+            # Todo(sandy): This only works for OpenStack API currently.
+            # Needs to be broken out into a driver. 
+            url = zone.api_url
+            LOG.info(_("Zone redirect to:[url:%(api_url)s, username:%(username)s]"
+                        % dict(api_url=zone.api_url, username=zone.username)))
+
+            LOG.info(_("Zone Initial Req: %s"), req)
+            nova = client.OpenStackClient(zone.username, zone.password,
+                                                zone.api_url)
+            nova.authenticate()
+            new_req = req.copy()
+            #m = re.search('(https?://.+)/(v\d+\.\d+)/', url)
+
+            scheme, netloc, path, query, frag = urlparse.urlsplit(new_req.path_qs)
+            query = urlparse.parse_qsl(query)
+            LOG.debug("**** QUERY=%s^%s^%s", path, query, frag)
+            query = [(key, value) for key, value in query if key != 'fresh']
+            query = urllib.urlencode(query)
+            url = urlparse.urlunsplit((scheme, netloc, path, query, frag))
+
+            m = re.search('/(v\d+\.\d+)/(.+)', url)
+            version = m.group(1)
+            resource = m.group(2)
+
+            LOG.info(_("New Request Data: %s"), new_req.body)
+            #LOG.info(_("New Request Headers: %s"), new_req.headers)
+            LOG.info(_("New Request Path: %s"), resource)
+            if req.method == 'GET':
+                response, body = nova.get(resource, body=new_req.body)
+            elif req.method == 'POST':
+                response, body = nova.post(resource, body=new_req.body)
+            elif req.method == 'PUT':
+                response, body = nova.put(resource, body=new_req.body)
+            elif req.method == 'DELETE':
+                response, body = nova.delete(resource, body=new_req.body)
+            #response, body = nova.request(req.path_qs, headers=new_req.headers, body=new_req.body)
+            LOG.info(_("Zone Response: %s / %s"), response, body)
+            res = webob.Response()
+            res.status = response['status']
+            res.content_type = response['content-type']
+            res.body = json.dumps(body)
+            LOG.info(_("Zone WebOb Response: %s"), res)
+            return res
-- 
cgit 


From 659cb8bd43e2091c61f44dacf21274a677ea3146 Mon Sep 17 00:00:00 2001
From: Brian Waldon <brian.waldon@rackspace.com>
Date: Tue, 15 Mar 2011 23:35:44 -0400
Subject: openstack api 1.0 flavors resource now implemented; adding flavors
 request value testing

---
 nova/api/openstack/flavors.py            | 12 ++++--
 nova/tests/api/openstack/test_flavors.py | 71 +++++++++++++++++++++++++++++++-
 2 files changed, 78 insertions(+), 5 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/flavors.py b/nova/api/openstack/flavors.py
index f3d040ba3..c99b945fb 100644
--- a/nova/api/openstack/flavors.py
+++ b/nova/api/openstack/flavors.py
@@ -22,6 +22,7 @@ from nova import context
 from nova.api.openstack import faults
 from nova.api.openstack import common
 from nova.compute import instance_types
+from nova.api.openstack.views import flavors as flavors_views
 from nova import wsgi
 import nova.api.openstack
 
@@ -47,13 +48,18 @@ class Controller(wsgi.Controller):
     def show(self, req, id):
         """Return data about the given flavor id."""
         ctxt = req.environ['nova.context']
-        values = db.instance_type_get_by_flavor_id(ctxt, id)
+        flavor = db.api.instance_type_get_by_flavor_id(ctxt, id)
+        values = {
+            "id": flavor["flavorid"],
+            "name": flavor["name"],
+            "ram": flavor["memory_mb"],
+            "disk": flavor["local_gb"],
+        }
         return dict(flavor=values)
-        raise faults.Fault(exc.HTTPNotFound())
 
     def _all_ids(self, req):
         """Return the list of all flavorids."""
         ctxt = req.environ['nova.context']
-        inst_types = db.instance_type_get_all(ctxt)
+        inst_types = db.api.instance_type_get_all(ctxt)
         flavor_ids = [inst_types[i]['flavorid'] for i in inst_types.keys()]
         return sorted(flavor_ids)
diff --git a/nova/tests/api/openstack/test_flavors.py b/nova/tests/api/openstack/test_flavors.py
index 8280a505f..8f53d14cc 100644
--- a/nova/tests/api/openstack/test_flavors.py
+++ b/nova/tests/api/openstack/test_flavors.py
@@ -15,17 +15,38 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+import json
 import stubout
 import webob
 
 from nova import test
 import nova.api
 from nova import context
-from nova import db
 from nova.api.openstack import flavors
+from nova import db
 from nova.tests.api.openstack import fakes
 
 
+def stub_flavor(flavorid, name, memory_mb="256", local_gb="10"):
+    return {
+        "flavorid": str(flavorid),
+        "name": name,
+        "memory_mb": memory_mb,
+        "local_gb": local_gb,
+    }
+
+
+def return_instance_type_by_flavor_id(context, flavorid):
+    return stub_flavor(flavorid, "flavor %s" % (flavorid,))
+
+def return_instance_types(context, num=2):
+    instance_types = {}
+    for i in xrange(1,num+1):
+        name = "flavor %s" % (i,)
+        instance_types[name] = stub_flavor(i, name)
+    return instance_types
+
+
 class FlavorsTest(test.TestCase):
     def setUp(self):
         super(FlavorsTest, self).setUp()
@@ -35,6 +56,10 @@ class FlavorsTest(test.TestCase):
         fakes.stub_out_networking(self.stubs)
         fakes.stub_out_rate_limiting(self.stubs)
         fakes.stub_out_auth(self.stubs)
+        self.stubs.Set(nova.db.api, "instance_type_get_all",
+                       return_instance_types)
+        self.stubs.Set(nova.db.api, "instance_type_get_by_flavor_id",
+                       return_instance_type_by_flavor_id)
         self.context = context.get_admin_context()
 
     def tearDown(self):
@@ -45,8 +70,50 @@ class FlavorsTest(test.TestCase):
         req = webob.Request.blank('/v1.0/flavors')
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 200)
+        flavors = json.loads(res.body)["flavors"]
+        expected = [
+            {
+                "id": "1",
+                "name": "flavor 1",
+            },
+            {
+                "id": "2",
+                "name": "flavor 2",
+            },
+        ]
+        self.assertEqual(flavors, expected)
+
+    def test_get_flavor_list_detail(self):
+        req = webob.Request.blank('/v1.0/flavors/detail')
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
+        flavors = json.loads(res.body)["flavors"]
+        expected = [
+            {
+                "id": "1",
+                "name": "flavor 1",
+                "ram": "256",
+                "disk": "10",
+            },
+            {
+                "id": "2",
+                "name": "flavor 2",
+                "ram": "256",
+                "disk": "10",
+            },
+        ]
+        self.assertEqual(flavors, expected)
+        
 
     def test_get_flavor_by_id(self):
-        req = webob.Request.blank('/v1.0/flavors/1')
+        req = webob.Request.blank('/v1.0/flavors/12')
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 200)
+        flavor = json.loads(res.body)["flavor"]
+        expected = {
+            "id": "12",
+            "name": "flavor 12",
+            "ram": "256",
+            "disk": "10",
+        }
+        self.assertEqual(flavor, expected)
-- 
cgit 


From 33419a2f84ea6bfbf6ff47fb1f01ef0c21389a54 Mon Sep 17 00:00:00 2001
From: Brian Waldon <brian.waldon@rackspace.com>
Date: Wed, 16 Mar 2011 00:22:34 -0400
Subject: pep8 fixes

---
 nova/tests/api/openstack/test_flavors.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/test_flavors.py b/nova/tests/api/openstack/test_flavors.py
index 8f53d14cc..4f504808c 100644
--- a/nova/tests/api/openstack/test_flavors.py
+++ b/nova/tests/api/openstack/test_flavors.py
@@ -39,9 +39,10 @@ def stub_flavor(flavorid, name, memory_mb="256", local_gb="10"):
 def return_instance_type_by_flavor_id(context, flavorid):
     return stub_flavor(flavorid, "flavor %s" % (flavorid,))
 
+
 def return_instance_types(context, num=2):
     instance_types = {}
-    for i in xrange(1,num+1):
+    for i in xrange(1, num + 1):
         name = "flavor %s" % (i,)
         instance_types[name] = stub_flavor(i, name)
     return instance_types
@@ -103,7 +104,6 @@ class FlavorsTest(test.TestCase):
             },
         ]
         self.assertEqual(flavors, expected)
-        
 
     def test_get_flavor_by_id(self):
         req = webob.Request.blank('/v1.0/flavors/12')
-- 
cgit 


From 78542ad1de6476a8962fa0c3b273c4a272410a83 Mon Sep 17 00:00:00 2001
From: Naveed Massjouni <naveedm9@gmail.com>
Date: Wed, 16 Mar 2011 00:38:47 -0400
Subject: req envirom param 'nova.api.openstack.version' should be
 'api.version'

---
 nova/api/openstack/auth.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/api/openstack/auth.py b/nova/api/openstack/auth.py
index 7ae285019..6f1cf5e63 100644
--- a/nova/api/openstack/auth.py
+++ b/nova/api/openstack/auth.py
@@ -70,7 +70,7 @@ class AuthMiddleware(wsgi.Middleware):
 
         req.environ['nova.context'] = context.RequestContext(user, account)
         version = req.path.split('/')[1].replace('v', '')
-        req.environ['nova.api.openstack.version'] = version
+        req.environ['api.version'] = version
         return self.application
 
     def has_authentication(self, req):
-- 
cgit 


From 20031162372329b40ca90b1bc39cebb4f187cace Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Tue, 15 Mar 2011 23:22:17 -0700
Subject: Use integer ids for (fake) users

---
 nova/tests/api/openstack/fakes.py         | 3 +--
 nova/tests/api/openstack/test_accounts.py | 4 ++--
 nova/tests/api/openstack/test_users.py    | 4 ++--
 3 files changed, 5 insertions(+), 6 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/fakes.py b/nova/tests/api/openstack/fakes.py
index 52ac80e3f..c2ae48ce4 100644
--- a/nova/tests/api/openstack/fakes.py
+++ b/nova/tests/api/openstack/fakes.py
@@ -240,8 +240,7 @@ class FakeAuthManager(object):
 
     @classmethod
     def reset_fake_data(cls):
-        cls.auth_data = dict(acc1=User('guy1', 'guy1', 'acc1',
-                                       'fortytwo!', False))
+        cls.auth_data = dict(acc1=User(1, 'guy1', 'acc1', 'fortytwo!', False))
         cls.projects = dict(testacct=Project('testacct',
                                              'testacct',
                                              'guy1',
diff --git a/nova/tests/api/openstack/test_accounts.py b/nova/tests/api/openstack/test_accounts.py
index 1bf49b33b..5cb08ffd2 100644
--- a/nova/tests/api/openstack/test_accounts.py
+++ b/nova/tests/api/openstack/test_accounts.py
@@ -57,8 +57,8 @@ class AccountsTest(test.TestCase):
         self.allow_admin = FLAGS.allow_admin_api
         FLAGS.allow_admin_api = True
         fakemgr = fakes.FakeAuthManager()
-        joeuser = User('guy1', 'guy1', 'acc1', 'fortytwo!', False)
-        superuser = User('guy2', 'guy2', 'acc2', 'swordfish', True)
+        joeuser = User(1, 'guy1', 'acc1', 'fortytwo!', False)
+        superuser = User(2, 'guy2', 'acc2', 'swordfish', True)
         fakemgr.add_user(joeuser)
         fakemgr.add_user(superuser)
         fakemgr.create_project('test1', joeuser)
diff --git a/nova/tests/api/openstack/test_users.py b/nova/tests/api/openstack/test_users.py
index a62db7efc..652aac936 100644
--- a/nova/tests/api/openstack/test_users.py
+++ b/nova/tests/api/openstack/test_users.py
@@ -61,8 +61,8 @@ class UsersTest(test.TestCase):
         self.allow_admin = FLAGS.allow_admin_api
         FLAGS.allow_admin_api = True
         fakemgr = fakes.FakeAuthManager()
-        fakemgr.add_user(User('guy1', 'guy1', 'acc1', 'fortytwo!', False))
-        fakemgr.add_user(User('guy2', 'guy2', 'acc2', 'swordfish', True))
+        fakemgr.add_user(User(1, 'guy1', 'acc1', 'fortytwo!', False))
+        fakemgr.add_user(User(2, 'guy2', 'acc2', 'swordfish', True))
 
     def tearDown(self):
         self.stubs.UnsetAll()
-- 
cgit 


From 016669543a1f6d4ffc281637ba98c6b6fe30be82 Mon Sep 17 00:00:00 2001
From: Thierry Carrez <thierry@openstack.org>
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')

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 <berendt@b1-systems.de>
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')

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. '<cpu>' 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 e2f8c143eab3b43acd9e3658a480f75f435e7d42 Mon Sep 17 00:00:00 2001
From: Koji Iida <iida.koji@lab.ntt.co.jp>
Date: Wed, 16 Mar 2011 19:51:06 +0900
Subject: Updating gateway_v6 in _on_set_network_host() is not required for
 FlatManager

---
 nova/network/manager.py | 5 -----
 1 file changed, 5 deletions(-)

(limited to 'nova')

diff --git a/nova/network/manager.py b/nova/network/manager.py
index c51eb9ad0..7e28e6da2 100644
--- a/nova/network/manager.py
+++ b/nova/network/manager.py
@@ -404,11 +404,6 @@ class FlatManager(NetworkManager):
         net = {}
         net['injected'] = FLAGS.flat_injected
         net['dns'] = FLAGS.flat_network_dns
-        if not FLAGS.fake_network:
-            if(FLAGS.use_ipv6):
-                net['gateway_v6'] = \
-                                 utils.get_my_linklocal(
-                                         FLAGS.flat_network_bridge)
         self.db.network_update(context, network_id, net)
 
     def allocate_floating_ip(self, context, project_id):
-- 
cgit 


From af2cae27930a3983c96a0b1705f828d65d4829cd Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
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')

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 8964cbecc10885bc6eff08544d62db1747fb14ef Mon Sep 17 00:00:00 2001
From: Koji Iida <iida.koji@lab.ntt.co.jp>
Date: Wed, 16 Mar 2011 20:24:20 +0900
Subject: pep8 clean

---
 nova/db/sqlalchemy/migrate_repo/versions/012_add_ipv6_flatmanager.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/migrate_repo/versions/012_add_ipv6_flatmanager.py b/nova/db/sqlalchemy/migrate_repo/versions/012_add_ipv6_flatmanager.py
index be1edc8f6..9f98f436f 100644
--- a/nova/db/sqlalchemy/migrate_repo/versions/012_add_ipv6_flatmanager.py
+++ b/nova/db/sqlalchemy/migrate_repo/versions/012_add_ipv6_flatmanager.py
@@ -83,8 +83,7 @@ networks = Table('networks', meta,
         Column(
         'label',
         String(length=255, convert_unicode=False, assert_unicode=None,
-               unicode_error=None, _warn_on_bytestring=False))
-        )
+               unicode_error=None, _warn_on_bytestring=False)))
 
 fixed_ips = Table('fixed_ips', meta,
         Column('created_at', DateTime(timezone=False)),
-- 
cgit 


From 2e81ce6bb5b1083220e7ae5c17113fd44465ddbf Mon Sep 17 00:00:00 2001
From: Koji Iida <iida.koji@lab.ntt.co.jp>
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')

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 ddeede35a5036aa3c80742fde69468aedbc74892 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Wed, 16 Mar 2011 06:09:00 -0700
Subject: Error codes handled properly now

---
 nova/api/zone_redirect.py | 94 ++++++++++++++++++++++++++---------------------
 1 file changed, 53 insertions(+), 41 deletions(-)

(limited to 'nova')

diff --git a/nova/api/zone_redirect.py b/nova/api/zone_redirect.py
index 5e40a82dd..ad47a6216 100644
--- a/nova/api/zone_redirect.py
+++ b/nova/api/zone_redirect.py
@@ -30,6 +30,7 @@ from nova import log as logging
 from nova import wsgi
 
 import novaclient.client as client
+import novaclient.exceptions as osexceptions
 
 try:
     import json
@@ -49,52 +50,63 @@ class ZoneRedirectMiddleware(wsgi.Middleware):
         try:
             return req.get_response(self.application)
         except exception.ZoneRouteException as e:
-            if len(e.zones) == 0:
+            if not e.zones:
                 exc = webob.exc.HTTPInternalServerError(explanation=
                                         _("No zones to reroute to."))
                 return faults.Fault(exc)
 
-            zone = e.zones[0]
             # Todo(sandy): This only works for OpenStack API currently.
             # Needs to be broken out into a driver. 
-            url = zone.api_url
-            LOG.info(_("Zone redirect to:[url:%(api_url)s, username:%(username)s]"
-                        % dict(api_url=zone.api_url, username=zone.username)))
-
-            LOG.info(_("Zone Initial Req: %s"), req)
-            nova = client.OpenStackClient(zone.username, zone.password,
-                                                zone.api_url)
-            nova.authenticate()
-            new_req = req.copy()
-            #m = re.search('(https?://.+)/(v\d+\.\d+)/', url)
-
-            scheme, netloc, path, query, frag = urlparse.urlsplit(new_req.path_qs)
-            query = urlparse.parse_qsl(query)
-            LOG.debug("**** QUERY=%s^%s^%s", path, query, frag)
-            query = [(key, value) for key, value in query if key != 'fresh']
-            query = urllib.urlencode(query)
-            url = urlparse.urlunsplit((scheme, netloc, path, query, frag))
-
-            m = re.search('/(v\d+\.\d+)/(.+)', url)
-            version = m.group(1)
-            resource = m.group(2)
-
-            LOG.info(_("New Request Data: %s"), new_req.body)
-            #LOG.info(_("New Request Headers: %s"), new_req.headers)
-            LOG.info(_("New Request Path: %s"), resource)
-            if req.method == 'GET':
-                response, body = nova.get(resource, body=new_req.body)
-            elif req.method == 'POST':
-                response, body = nova.post(resource, body=new_req.body)
-            elif req.method == 'PUT':
-                response, body = nova.put(resource, body=new_req.body)
-            elif req.method == 'DELETE':
-                response, body = nova.delete(resource, body=new_req.body)
-            #response, body = nova.request(req.path_qs, headers=new_req.headers, body=new_req.body)
-            LOG.info(_("Zone Response: %s / %s"), response, body)
+            for zone in e.zones:
+                url = zone.api_url
+                LOG.info(_("Zone redirect to:[url:%(api_url)s, "
+                                                "username:%(username)s]"
+                            % dict(api_url=zone.api_url,
+                                            username=zone.username)))
+
+                nova = client.OpenStackClient(zone.username, zone.password,
+                                                    zone.api_url)
+                nova.authenticate()
+                new_req = req.copy()
+
+                scheme, netloc, path, query, frag = \
+                                        urlparse.urlsplit(new_req.path_qs)
+                query = urlparse.parse_qsl(query)
+                query = [(key, value) for key, value in query if key != 'fresh']
+                query = urllib.urlencode(query)
+                url = urlparse.urlunsplit((scheme, netloc, path, query, frag))
+
+                m = re.search('/(v\d+\.\d+)/(.+)', url)
+                version = m.group(1)
+                resource = m.group(2)
+
+                #LOG.info(_("New Request Data: %s"), new_req.body)
+                #LOG.info(_("New Request Path: %s"), resource)
+                try:
+                    if req.method == 'GET':
+                        response, body = nova.get(resource, body=new_req.body)
+                    elif req.method == 'POST':
+                        response, body = nova.post(resource, body=new_req.body)
+                    elif req.method == 'PUT':
+                        response, body = nova.put(resource, body=new_req.body)
+                    elif req.method == 'DELETE':
+                        response, body = nova.delete(resource,
+                                                            body=new_req.body)
+                except osexceptions.OpenStackException, e:
+                    LOG.info(_("Zone returned error: %s ('%s', '%s')"),
+                                        e.code, e.message, e.details)
+                    continue
+
+                LOG.info(_("Zone Response: %s [%s]/ %s"), response,
+                                                        response.status, body)
+                if response.status == 200:
+                    res = webob.Response()
+                    res.status = response['status']
+                    res.content_type = response['content-type']
+                    res.body = json.dumps(body)
+                    return res
+
+            LOG.info(_("Returning 404 ..."))
             res = webob.Response()
-            res.status = response['status']
-            res.content_type = response['content-type']
-            res.body = json.dumps(body)
-            LOG.info(_("Zone WebOb Response: %s"), res)
+            res.status = "404"
             return res
-- 
cgit 


From 8dffae687e78a1fa2a8cf0d321d64ee95a35cc1f Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Wed, 16 Mar 2011 06:47:27 -0700
Subject: Checks locally before routing

---
 nova/api/zone_redirect.py | 34 +++++++++++++++-------------------
 nova/scheduler/api.py     | 11 ++++++++---
 2 files changed, 23 insertions(+), 22 deletions(-)

(limited to 'nova')

diff --git a/nova/api/zone_redirect.py b/nova/api/zone_redirect.py
index ad47a6216..fec1b1af3 100644
--- a/nova/api/zone_redirect.py
+++ b/nova/api/zone_redirect.py
@@ -57,9 +57,20 @@ class ZoneRedirectMiddleware(wsgi.Middleware):
 
             # Todo(sandy): This only works for OpenStack API currently.
             # Needs to be broken out into a driver. 
+            new_req = req.copy()
+
+            scheme, netloc, path, query, frag = \
+                                    urlparse.urlsplit(new_req.path_qs)
+            query = urlparse.parse_qsl(query)
+            query = [(key, value) for key, value in query if key != 'fresh']
+            query = urllib.urlencode(query)
+            url = urlparse.urlunsplit((scheme, netloc, path, query, frag))
+
+            m = re.search('/v\d+\.\d+/(.+)', url)
+            resource = m.group(1)
+
             for zone in e.zones:
-                url = zone.api_url
-                LOG.info(_("Zone redirect to:[url:%(api_url)s, "
+                LOG.debug(_("Zone redirect to:[url:%(api_url)s, "
                                                 "username:%(username)s]"
                             % dict(api_url=zone.api_url,
                                             username=zone.username)))
@@ -67,21 +78,6 @@ class ZoneRedirectMiddleware(wsgi.Middleware):
                 nova = client.OpenStackClient(zone.username, zone.password,
                                                     zone.api_url)
                 nova.authenticate()
-                new_req = req.copy()
-
-                scheme, netloc, path, query, frag = \
-                                        urlparse.urlsplit(new_req.path_qs)
-                query = urlparse.parse_qsl(query)
-                query = [(key, value) for key, value in query if key != 'fresh']
-                query = urllib.urlencode(query)
-                url = urlparse.urlunsplit((scheme, netloc, path, query, frag))
-
-                m = re.search('/(v\d+\.\d+)/(.+)', url)
-                version = m.group(1)
-                resource = m.group(2)
-
-                #LOG.info(_("New Request Data: %s"), new_req.body)
-                #LOG.info(_("New Request Path: %s"), resource)
                 try:
                     if req.method == 'GET':
                         response, body = nova.get(resource, body=new_req.body)
@@ -97,7 +93,7 @@ class ZoneRedirectMiddleware(wsgi.Middleware):
                                         e.code, e.message, e.details)
                     continue
 
-                LOG.info(_("Zone Response: %s [%s]/ %s"), response,
+                LOG.debug(_("Zone Response: %s [%s]/ %s"), response,
                                                         response.status, body)
                 if response.status == 200:
                     res = webob.Response()
@@ -106,7 +102,7 @@ class ZoneRedirectMiddleware(wsgi.Middleware):
                     res.body = json.dumps(body)
                     return res
 
-            LOG.info(_("Returning 404 ..."))
+            LOG.debug(_("Zone Redirect Middleware returning 404 ..."))
             res = webob.Response()
             res.status = "404"
             return res
diff --git a/nova/scheduler/api.py b/nova/scheduler/api.py
index c0e28a0a9..48da5bcfc 100644
--- a/nova/scheduler/api.py
+++ b/nova/scheduler/api.py
@@ -76,11 +76,16 @@ class API(object):
         
     @classmethod
     def get_instance_or_reroute(cls, context, instance_id):
-        instance = db.instance_get(context, instance_id)
-        zones = db.zone_get_all(context)
+        try:
+            instance = db.instance_get(context, instance_id)
+            return instance
+        except exception.InstanceNotFound, e:
+            LOG.debug(_("Instance %(instance_id)s not found locally: '%(e)s'" %
+                                                locals()))
 
-        LOG.debug("*** Firing ZoneRouteException")
         # Throw a reroute Exception for the middleware to pick up. 
+        LOG.debug("Firing ZoneRouteException")
+        zones = db.zone_get_all(context)
         raise exception.ZoneRouteException(zones)
 
     @classmethod
-- 
cgit 


From a586714557e38116b6b4f473aa21ac54ff0223e7 Mon Sep 17 00:00:00 2001
From: Brian Lamar <brian.lamar@rackspace.com>
Date: Wed, 16 Mar 2011 10:10:58 -0400
Subject: Added i18n to error message.

---
 nova/api/openstack/limits.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/api/openstack/limits.py b/nova/api/openstack/limits.py
index c4e04e9d9..1fe519f8a 100644
--- a/nova/api/openstack/limits.py
+++ b/nova/api/openstack/limits.py
@@ -225,7 +225,7 @@ class RateLimitingMiddleware(Middleware):
         delay, error = self._limiter.check_for_delay(verb, url, username)
 
         if delay:
-            msg = "This request was rate-limited."
+            msg = _("This request was rate-limited.")
             retry = time.time() + delay
             return faults.OverLimitFault(msg, error, retry)
 
-- 
cgit 


From d714df5ed4a6a1d4f1c0f7680c2fbb6a6abb81a5 Mon Sep 17 00:00:00 2001
From: Dan Prince <dan.prince@rackspace.com>
Date: Wed, 16 Mar 2011 11:02:22 -0400
Subject: Implement top level extensions.

---
 nova/api/openstack/extensions.py                  | 94 +++++++++++++++++++++--
 nova/tests/api/openstack/extensions/foxinsocks.py | 70 +++++++++++++++++
 nova/tests/api/openstack/extensions/widgets.py    | 54 -------------
 nova/tests/api/openstack/test_extensions.py       | 68 +++++++++++-----
 4 files changed, 204 insertions(+), 82 deletions(-)
 create mode 100644 nova/tests/api/openstack/extensions/foxinsocks.py
 delete mode 100644 nova/tests/api/openstack/extensions/widgets.py

(limited to 'nova')

diff --git a/nova/api/openstack/extensions.py b/nova/api/openstack/extensions.py
index 8b8806c8a..66ddd8078 100644
--- a/nova/api/openstack/extensions.py
+++ b/nova/api/openstack/extensions.py
@@ -25,6 +25,7 @@ import webob.exc
 from nova import flags
 from nova import log as logging
 from nova import wsgi
+from nova.api.openstack import faults
 
 
 LOG = logging.getLogger('extensions')
@@ -70,6 +71,42 @@ class ResponseExtensionController(wsgi.Controller):
             return handler(res)
 
 
+class ExtensionController(wsgi.Controller):
+
+    def __init__(self, extension_manager):
+        self.extension_manager = extension_manager
+
+    def _translate(self, ext):
+        ext_data = {}
+        ext_data['name'] = ext.get_name()
+        ext_data['alias'] = ext.get_alias()
+        ext_data['description'] = ext.get_description()
+        ext_data['namespace'] = ext.get_namespace()
+        ext_data['updated'] = ext.get_updated()
+        ext_data['links'] = []  # TODO: implement extension links
+        return ext_data
+
+    def index(self, req):
+        extensions = []
+        for alias, ext in self.extension_manager.extensions.iteritems():
+            extensions.append(self._translate(ext))
+        return dict(extensions=extensions)
+
+    def show(self, req, id):
+        # NOTE: the extensions alias is used as the 'id' for show
+        ext = self.extension_manager.extensions[id]
+        return self._translate(ext)
+
+    def delete(self, req, id):
+        raise faults.Fault(exc.HTTPNotFound())
+
+    def create(self, req):
+        raise faults.Fault(exc.HTTPNotFound())
+
+    def delete(self, req, id):
+        raise faults.Fault(exc.HTTPNotFound())
+
+
 class ExtensionMiddleware(wsgi.Middleware):
     """
     Extensions middleware that intercepts configured routes for extensions.
@@ -183,12 +220,17 @@ class ExtensionMiddleware(wsgi.Middleware):
 
 
 class ExtensionManager(object):
+    """
+    Load extensions from the configured extension path.
+    See nova/tests/api/openstack/extensions/foxinsocks.py for an example
+    extension implementation.
+    """
 
     def __init__(self, path):
         LOG.audit(_('Initializing extension manager.'))
 
         self.path = path
-        self.extensions = []
+        self.extensions = {}
         self._load_extensions()
 
     def get_resources(self):
@@ -196,8 +238,14 @@ class ExtensionManager(object):
         returns a list of ResourceExtension objects
         """
         resources = []
-        for ext in self.extensions:
-            resources.extend(ext.get_resources())
+        resources.append(ResourceExtension('extensions',
+                                            ExtensionController(self)))
+        for alias, ext in self.extensions.iteritems():
+            try:
+                resources.extend(ext.get_resources())
+            except AttributeError:
+                # NOTE: Extension aren't required to have resource extensions
+                pass
         return resources
 
     def get_actions(self):
@@ -205,8 +253,12 @@ class ExtensionManager(object):
         returns a list of ActionExtension objects
         """
         actions = []
-        for ext in self.extensions:
-            actions.extend(ext.get_actions())
+        for alias, ext in self.extensions.iteritems():
+            try:
+                actions.extend(ext.get_actions())
+            except AttributeError:
+                # NOTE: Extension aren't required to have action extensions
+                pass
         return actions
 
     def get_response_extensions(self):
@@ -214,16 +266,36 @@ class ExtensionManager(object):
         returns a list of ResponseExtension objects
         """
         response_exts = []
-        for ext in self.extensions:
-            response_exts.extend(ext.get_response_extensions())
+        for alias, ext in self.extensions.iteritems():
+            try:
+                response_exts.extend(ext.get_response_extensions())
+            except AttributeError:
+                # NOTE: Extension aren't required to have response extensions
+                pass
         return response_exts
 
+    def _check_extension(self, extension):
+        """
+        Checks for required methods in extension objects.
+        """
+        try:
+            LOG.debug(_('Ext name: %s'), extension.get_name())
+            LOG.debug(_('Ext alias: %s'), extension.get_alias())
+            LOG.debug(_('Ext description: %s'), extension.get_description())
+            LOG.debug(_('Ext namespace: %s'), extension.get_namespace())
+            LOG.debug(_('Ext updated: %s'), extension.get_updated())
+        except AttributeError as ex:
+            LOG.exception(_("Exception loading extension: %s"), unicode(ex))
+
     def _load_extensions(self):
         """
         Load extensions from the configured path. The extension name is
         constructed from the camel cased module_name + 'Extension'. If your
         extension module was named widgets.py the extension class within that
         module should be 'WidgetsExtension'.
+
+        See nova/tests/api/openstack/extensions/foxinsocks.py for an example
+        extension implementation.
         """
         if not os.path.exists(self.path):
             return
@@ -235,7 +307,13 @@ class ExtensionManager(object):
             if file_ext.lower() == '.py':
                 mod = imp.load_source(mod_name, ext_path)
                 ext_name = mod_name[0].upper() + mod_name[1:]
-                self.extensions.append(getattr(mod, ext_name)())
+                try:
+                    new_ext = getattr(mod, ext_name)()
+                    self._check_extension(new_ext)
+                    self.extensions[new_ext.get_alias()] = new_ext
+                except AttributeError as ex:
+                    LOG.exception(_("Exception loading extension: %s"),
+                                   unicode(ex))
 
 
 class ResponseExtension(object):
diff --git a/nova/tests/api/openstack/extensions/foxinsocks.py b/nova/tests/api/openstack/extensions/foxinsocks.py
new file mode 100644
index 000000000..09a328273
--- /dev/null
+++ b/nova/tests/api/openstack/extensions/foxinsocks.py
@@ -0,0 +1,70 @@
+import json
+
+from nova import wsgi
+
+from nova.api.openstack import extensions
+
+
+class FoxInSocksController(wsgi.Controller):
+
+    def index(self, req):
+        return "Try to say this Mr. Knox, sir..."
+
+
+class Foxinsocks(object):
+
+    def __init__(self):
+        pass
+
+    def get_name(self):
+        return "Fox In Socks"
+
+    def get_alias(self):
+        return "FOXNSOX"
+
+    def get_description(self):
+        return "The Fox In Socks Extension"
+
+    def get_namespace(self):
+        return "http://www.fox.in.socks/api/ext/pie/v1.0"
+
+    def get_updated(self):
+        return "2011-01-22T13:25:27-06:00"
+
+    def get_resources(self):
+        resources = []
+        resource = extensions.ResourceExtension('foxnsocks',
+                                               FoxInSocksController())
+        resources.append(resource)
+        return resources
+
+    def get_actions(self):
+        actions = []
+        actions.append(extensions.ActionExtension('servers', 'add_tweedle',
+                                                    self._add_tweedle))
+        actions.append(extensions.ActionExtension('servers', 'delete_tweedle',
+                                                    self._delete_tweedle))
+        return actions
+
+    def get_response_extensions(self):
+        response_exts = []
+
+        def _resp_handler(res):
+            #NOTE: This only handles JSON responses.
+            # You can use content type header to test for XML.
+            data = json.loads(res.body)
+            data['flavor']['googoose'] = "Gooey goo for chewy chewing!"
+            return data
+
+        resp_ext = extensions.ResponseExtension('/v1.0/flavors/:(id)', 'GET',
+                                                _resp_handler)
+        response_exts.append(resp_ext)
+        return response_exts
+
+    def _add_tweedle(self, input_dict, req, id):
+
+        return "Tweedle Beetle Added."
+
+    def _delete_tweedle(self, input_dict, req, id):
+
+        return "Tweedle Beetle Deleted."
diff --git a/nova/tests/api/openstack/extensions/widgets.py b/nova/tests/api/openstack/extensions/widgets.py
deleted file mode 100644
index f463721f1..000000000
--- a/nova/tests/api/openstack/extensions/widgets.py
+++ /dev/null
@@ -1,54 +0,0 @@
-import json
-
-from nova import wsgi
-
-from nova.api.openstack import extensions
-
-
-class WidgetsController(wsgi.Controller):
-
-    def index(self, req):
-        return "Buy more widgets!"
-
-
-class Widgets(object):
-
-    def __init__(self):
-        pass
-
-    def get_resources(self):
-        resources = []
-        widgets = extensions.ResourceExtension('widgets',
-                                               WidgetsController())
-        resources.append(widgets)
-        return resources
-
-    def get_actions(self):
-        actions = []
-        actions.append(extensions.ActionExtension('servers', 'add_widget',
-                                                    self._add_widget))
-        actions.append(extensions.ActionExtension('servers', 'delete_widget',
-                                                    self._delete_widget))
-        return actions
-
-    def get_response_extensions(self):
-        response_exts = []
-
-        def _resp_handler(res):
-            # only handle JSON responses
-            data = json.loads(res.body)
-            data['flavor']['widgets'] = "Buy more widgets!"
-            return data
-
-        widgets = extensions.ResponseExtension('/v1.0/flavors/:(id)', 'GET',
-                                                _resp_handler)
-        response_exts.append(widgets)
-        return response_exts
-
-    def _add_widget(self, input_dict, req, id):
-
-        return "Widget Added."
-
-    def _delete_widget(self, input_dict, req, id):
-
-        return "Widget Deleted."
diff --git a/nova/tests/api/openstack/test_extensions.py b/nova/tests/api/openstack/test_extensions.py
index 8725c8f0e..0f99dec55 100644
--- a/nova/tests/api/openstack/test_extensions.py
+++ b/nova/tests/api/openstack/test_extensions.py
@@ -48,6 +48,15 @@ class StubExtensionManager(object):
         self.action_ext = action_ext
         self.response_ext = response_ext
 
+    def get_name(self):
+        return "Tweedle Beetle Extension"
+
+    def get_alias(self):
+        return "TWDLBETL"
+
+    def get_description(self):
+        return "Provides access to Tweedle Beetles"
+
     def get_resources(self):
         resource_exts = []
         if self.resource_ext:
@@ -67,36 +76,53 @@ class StubExtensionManager(object):
         return response_exts
 
 
+class ExtensionControllerTest(unittest.TestCase):
+
+    def test_index(self):
+        app = openstack.APIRouter()
+        ext_midware = extensions.ExtensionMiddleware(app)
+        request = webob.Request.blank("/extensions")
+        response = request.get_response(ext_midware)
+        self.assertEqual(200, response.status_int)
+
+    def test_get_by_alias(self):
+        app = openstack.APIRouter()
+        ext_midware = extensions.ExtensionMiddleware(app)
+        request = webob.Request.blank("/extensions/FOXNSOX")
+        response = request.get_response(ext_midware)
+        self.assertEqual(200, response.status_int)
+
+response_body = "Try to say this Mr. Knox, sir..."
+
 class ResourceExtensionTest(unittest.TestCase):
 
+
     def test_no_extension_present(self):
         manager = StubExtensionManager(None)
         app = openstack.APIRouter()
         ext_midware = extensions.ExtensionMiddleware(app, manager)
-        request = webob.Request.blank("/widgets")
+        request = webob.Request.blank("/blah")
         response = request.get_response(ext_midware)
         self.assertEqual(404, response.status_int)
 
     def test_get_resources(self):
-        response_body = "Buy more widgets!"
-        widgets = extensions.ResourceExtension('widgets',
+        res_ext = extensions.ResourceExtension('tweedles',
                                                StubController(response_body))
-        manager = StubExtensionManager(widgets)
+        manager = StubExtensionManager(res_ext)
         app = openstack.APIRouter()
         ext_midware = extensions.ExtensionMiddleware(app, manager)
-        request = webob.Request.blank("/widgets")
+        request = webob.Request.blank("/tweedles")
         response = request.get_response(ext_midware)
         self.assertEqual(200, response.status_int)
         self.assertEqual(response_body, response.body)
 
     def test_get_resources_with_controller(self):
-        response_body = "Buy more widgets!"
-        widgets = extensions.ResourceExtension('widgets',
+        res_ext = extensions.ResourceExtension('tweedles',
                                                StubController(response_body))
-        manager = StubExtensionManager(widgets)
+        manager = StubExtensionManager(res_ext)
         app = openstack.APIRouter()
         ext_midware = extensions.ExtensionMiddleware(app, manager)
-        request = webob.Request.blank("/widgets")
+        request = webob.Request.blank("/tweedles")
         response = request.get_response(ext_midware)
         self.assertEqual(200, response.status_int)
         self.assertEqual(response_body, response.body)
@@ -104,6 +130,8 @@ class ResourceExtensionTest(unittest.TestCase):
 
 class ExtensionManagerTest(unittest.TestCase):
 
+    response_body = "Try to say this Mr. Knox, sir..."
+
     def setUp(self):
         FLAGS.osapi_extensions_path = os.path.join(os.path.dirname(__file__),
                                                     "extensions")
@@ -111,10 +139,10 @@ class ExtensionManagerTest(unittest.TestCase):
     def test_get_resources(self):
         app = openstack.APIRouter()
         ext_midware = extensions.ExtensionMiddleware(app)
-        request = webob.Request.blank("/widgets")
+        request = webob.Request.blank("/foxnsocks")
         response = request.get_response(ext_midware)
         self.assertEqual(200, response.status_int)
-        self.assertEqual("Buy more widgets!", response.body)
+        self.assertEqual(response_body, response.body)
 
 
 class ActionExtensionTest(unittest.TestCase):
@@ -134,15 +162,15 @@ class ActionExtensionTest(unittest.TestCase):
         return response
 
     def test_extended_action(self):
-        body = dict(add_widget=dict(name="test"))
+        body = dict(add_tweedle=dict(name="test"))
         response = self._send_server_action_request("/servers/1/action", body)
         self.assertEqual(200, response.status_int)
-        self.assertEqual("Widget Added.", response.body)
+        self.assertEqual("Tweedle Beetle Added.", response.body)
 
-        body = dict(delete_widget=dict(name="test"))
+        body = dict(delete_tweedle=dict(name="test"))
         response = self._send_server_action_request("/servers/1/action", body)
         self.assertEqual(200, response.status_int)
-        self.assertEqual("Widget Deleted.", response.body)
+        self.assertEqual("Tweedle Beetle Deleted.", response.body)
 
     def test_invalid_action_body(self):
         body = dict(blah=dict(name="test"))  # Doesn't exist
@@ -169,21 +197,21 @@ class ResponseExtensionTest(unittest.TestCase):
 
     def test_get_resources(self):
 
-        test_resp = "Buy more widgets!"
+        test_resp = "Gooey goo for chewy chewing!"
 
         def _resp_handler(res):
             # only handle JSON responses
             data = json.loads(res.body)
-            data['flavor']['widgets'] = test_resp
+            data['flavor']['googoose'] = test_resp
             return data
 
-        widgets = extensions.ResponseExtension('/v1.0/flavors/:(id)', 'GET',
+        resp_ext = extensions.ResponseExtension('/v1.0/flavors/:(id)', 'GET',
                                                 _resp_handler)
-        manager = StubExtensionManager(None, None, widgets)
+        manager = StubExtensionManager(None, None, resp_ext)
         app = fakes.wsgi_app()
         ext_midware = extensions.ExtensionMiddleware(app, manager)
         request = webob.Request.blank("/v1.0/flavors/1")
         response = request.get_response(ext_midware)
         self.assertEqual(200, response.status_int)
         response_data = json.loads(response.body)
-        self.assertEqual(test_resp, response_data['flavor']['widgets'])
+        self.assertEqual(test_resp, response_data['flavor']['googoose'])
-- 
cgit 


From 45ca7b71a8e749cbd9b7729b922190e9aaa53744 Mon Sep 17 00:00:00 2001
From: sateesh <sateesh.chodapuneedi@citrix.com>
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/console/vmrc.py                   |  16 ++--
 nova/console/vmrc_manager.py           |  35 ++++++--
 nova/network/vmwareapi_net.py          |  36 ++++----
 nova/tests/test_vmwareapi.py           |  28 +++---
 nova/tests/vmwareapi/__init__.py       |   5 ++
 nova/tests/vmwareapi/db_fakes.py       |  12 +--
 nova/tests/vmwareapi/stubs.py          |   6 +-
 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 +++++++++--------
 18 files changed, 479 insertions(+), 529 deletions(-)

(limited to 'nova')

diff --git a/nova/console/vmrc.py b/nova/console/vmrc.py
index f448d094b..521da289f 100644
--- a/nova/console/vmrc.py
+++ b/nova/console/vmrc.py
@@ -65,11 +65,13 @@ class VMRCConsole(object):
 
     def fix_pool_password(self, password):
         """Encode password."""
-        #TODO:Encrypt pool password
+        # TODO(sateesh): Encrypt pool password
         return password
 
     def generate_password(self, vim_session, pool, instance_name):
-        """Returns a VMRC Connection credentials
+        """
+        Returns VMRC Connection credentials.
+
         Return string is of the form '<VM PATH>:<ESX Username>@<ESX Password>'.
         """
         username, password = pool['username'], pool['password']
@@ -98,12 +100,12 @@ class VMRCConsole(object):
         return base64.b64encode(json_data)
 
     def is_otp(self):
-        """Is one time password."""
+        """Is one time password or not."""
         return False
 
 
 class VMRCSessionConsole(VMRCConsole):
-    """VMRC console driver with VMRC One Time Sessions"""
+    """VMRC console driver with VMRC One Time Sessions."""
 
     def __init__(self):
         super(VMRCSessionConsole, self).__init__()
@@ -113,7 +115,9 @@ class VMRCSessionConsole(VMRCConsole):
         return 'vmrc+session'
 
     def generate_password(self, vim_session, pool, instance_name):
-        """Returns a VMRC Session
+        """
+        Returns a VMRC Session.
+
         Return string is of the form '<VM MOID>:<VMRC Ticket>'.
         """
         vms = vim_session._call_method(vim_util, "get_objects",
@@ -136,5 +140,5 @@ class VMRCSessionConsole(VMRCConsole):
         return base64.b64encode(json_data)
 
     def is_otp(self):
-        """Is one time password."""
+        """Is one time password or not."""
         return True
diff --git a/nova/console/vmrc_manager.py b/nova/console/vmrc_manager.py
index 24f7f5fe2..09beac7a0 100644
--- a/nova/console/vmrc_manager.py
+++ b/nova/console/vmrc_manager.py
@@ -16,7 +16,7 @@
 #    under the License.
 
 """
-VMRC Console Manager
+VMRC Console Manager.
 """
 
 from nova import exception
@@ -25,6 +25,7 @@ from nova import log as logging
 from nova import manager
 from nova import rpc
 from nova import utils
+from nova.virt.vmwareapi_conn import VMWareAPISession
 
 LOG = logging.getLogger("nova.console.vmrc_manager")
 
@@ -39,8 +40,8 @@ flags.DEFINE_string('console_driver',
 
 class ConsoleVMRCManager(manager.Manager):
 
-    """Manager to handle VMRC connections needed for accessing
-       instance consoles
+    """
+    Manager to handle VMRC connections needed for accessing instance consoles.
     """
 
     def __init__(self, console_driver=None, *args, **kwargs):
@@ -48,15 +49,29 @@ class ConsoleVMRCManager(manager.Manager):
         super(ConsoleVMRCManager, self).__init__(*args, **kwargs)
 
     def init_host(self):
+        self.sessions = {}
         self.driver.init_host()
 
+    def _get_vim_session(self, pool):
+        """Get VIM session for the pool specified."""
+        vim_session = None
+        if pool['id'] not in self.sessions.keys():
+            vim_session = VMWareAPISession(pool['address'],
+                                           pool['username'],
+                                            pool['password'],
+                                           FLAGS.console_vmrc_error_retries)
+            self.sessions[pool['id']] = vim_session
+        return self.sessions[pool['id']]
+
     def _generate_console(self, context, pool, name, instance_id, instance):
+        """Sets up console for the instance."""
         LOG.debug(_("Adding console"))
+
         password = self.driver.generate_password(
-                        pool['address'],
-                        pool['username'],
-                        pool['password'],
+                        self._get_vim_session(pool),
+                        pool,
                         instance.name)
+
         console_data = {'instance_name': name,
                         'instance_id': instance_id,
                         'password': password,
@@ -69,6 +84,10 @@ class ConsoleVMRCManager(manager.Manager):
     @exception.wrap_exception
     def add_console(self, context, instance_id, password=None,
                     port=None, **kwargs):
+        """
+        Adds a console for the instance. If it is one time password, then we
+        generate new console credentials.
+        """
         instance = self.db.instance_get(context, instance_id)
         host = instance['host']
         name = instance['name']
@@ -95,6 +114,7 @@ class ConsoleVMRCManager(manager.Manager):
 
     @exception.wrap_exception
     def remove_console(self, context, console_id, **_kwargs):
+        """Removes a console entry."""
         try:
             console = self.db.console_get(context, console_id)
         except exception.NotFound:
@@ -109,6 +129,7 @@ class ConsoleVMRCManager(manager.Manager):
         self.driver.teardown_console(context, console)
 
     def get_pool_for_instance_host(self, context, instance_host):
+        """Gets console pool info for the instance."""
         context = context.elevated()
         console_type = self.driver.console_type
         try:
@@ -126,7 +147,7 @@ class ConsoleVMRCManager(manager.Manager):
             pool_info['password'] = self.driver.fix_pool_password(
                                                     pool_info['password'])
             pool_info['host'] = self.host
-            #ESX Address or Proxy Address
+            # ESX Address or Proxy Address
             public_host_name = pool_info['address']
             if FLAGS.console_public_hostname:
                 public_host_name = FLAGS.console_public_hostname
diff --git a/nova/network/vmwareapi_net.py b/nova/network/vmwareapi_net.py
index 13b619df5..f1232dada 100644
--- a/nova/network/vmwareapi_net.py
+++ b/nova/network/vmwareapi_net.py
@@ -16,7 +16,7 @@
 #    under the License.
 
 """
-Implements vlans for vmwareapi
+Implements vlans for vmwareapi.
 """
 
 from nova import db
@@ -36,8 +36,8 @@ flags.DEFINE_string('vlan_interface', 'vmnic0',
 
 
 def ensure_vlan_bridge(vlan_num, bridge, net_attrs=None):
-    """Create a vlan and bridge unless they already exist"""
-    #open vmwareapi session
+    """Create a vlan and bridge unless they already exist."""
+    # Open vmwareapi session
     host_ip = FLAGS.vmwareapi_host_ip
     host_username = FLAGS.vmwareapi_host_username
     host_password = FLAGS.vmwareapi_host_password
@@ -49,49 +49,43 @@ def ensure_vlan_bridge(vlan_num, bridge, net_attrs=None):
     session = VMWareAPISession(host_ip, host_username, host_password,
                                FLAGS.vmwareapi_api_retry_count)
     vlan_interface = FLAGS.vlan_interface
-    #Check if the vlan_interface physical network adapter exists on the host
+    # Check if the vlan_interface physical network adapter exists on the host
     if not NetworkHelper.check_if_vlan_interface_exists(session,
                                                         vlan_interface):
         raise exception.NotFound(_("There is no physical network adapter with "
                           "the name %s on the ESX host") % vlan_interface)
 
-    #Get the vSwitch associated with the Physical Adapter
+    # Get the vSwitch associated with the Physical Adapter
     vswitch_associated = NetworkHelper.get_vswitch_for_vlan_interface(
                                         session, vlan_interface)
     if vswitch_associated is None:
         raise exception.NotFound(_("There is no virtual switch associated "
             "with the physical network adapter with name %s") %
             vlan_interface)
-    #check whether bridge already exists and retrieve the the ref of the
-    #network whose name_label is "bridge"
+    # Check whether bridge already exists and retrieve the the ref of the
+    # network whose name_label is "bridge"
     network_ref = NetworkHelper.get_network_with_the_name(session, bridge)
     if network_ref == None:
-        #Create a port group on the vSwitch associated with the vlan_interface
-        #corresponding physical network adapter on the ESX host
+        # Create a port group on the vSwitch associated with the vlan_interface
+        # corresponding physical network adapter on the ESX host
         NetworkHelper.create_port_group(session, bridge, vswitch_associated,
                                 vlan_num)
     else:
-        #Get the vlan id and vswitch corresponding to the port group
+        # Get the vlan id and vswitch corresponding to the port group
         pg_vlanid, pg_vswitch = \
-            NetworkHelper.get_vlanid_and_vswicth_for_portgroup(session, bridge)
+            NetworkHelper.get_vlanid_and_vswitch_for_portgroup(session, bridge)
 
-        #Check if the vsiwtch associated is proper
+        # Check if the vsiwtch associated is proper
         if pg_vswitch != vswitch_associated:
             raise exception.Invalid(_("vSwitch which contains the port group "
                             "%(bridge)s is not associated with the desired "
                             "physical adapter. Expected vSwitch is "
                             "%(vswitch_associated)s, but the one associated"
-                            " is %(pg_vswitch)s") %\
-                            {"bridge": bridge,
-                             "vswitch_associated": vswitch_associated,
-                             "pg_vswitch": pg_vswitch})
+                            " is %(pg_vswitch)s") % locals())
 
-        #Check if the vlan id is proper for the port group
+        # Check if the vlan id is proper for the port group
         if pg_vlanid != vlan_num:
             raise exception.Invalid(_("VLAN tag is not appropriate for the "
                             "port group %(bridge)s. Expected VLAN tag is "
                             "%(vlan_num)s, but the one associated with the "
-                            "port group is %(pg_vlanid)s") %\
-                            {"bridge": bridge,
-                             "vlan_num": vlan_num,
-                             "pg_vlanid": pg_vlanid})
+                            "port group is %(pg_vlanid)s") % locals())
diff --git a/nova/tests/test_vmwareapi.py b/nova/tests/test_vmwareapi.py
index 65cdd5fcf..b22d8b7b9 100644
--- a/nova/tests/test_vmwareapi.py
+++ b/nova/tests/test_vmwareapi.py
@@ -16,8 +16,9 @@
 #    under the License.
 
 """
-Test suite for VMWareAPI
+Test suite for VMWareAPI.
 """
+
 import stubout
 
 from nova import context
@@ -38,9 +39,7 @@ FLAGS = flags.FLAGS
 
 
 class VMWareAPIVMTestCase(test.TestCase):
-    """
-    Unit tests for Vmware API connection calls
-    """
+    """Unit tests for Vmware API connection calls."""
 
     def setUp(self):
         super(VMWareAPIVMTestCase, self).setUp()
@@ -61,7 +60,7 @@ class VMWareAPIVMTestCase(test.TestCase):
         self.conn = vmwareapi_conn.get_connection(False)
 
     def _create_vm(self):
-        """ Create and spawn the VM """
+        """Create and spawn the VM."""
         values = {'name': 1,
                   'id': 1,
                   'project_id': self.project.id,
@@ -78,15 +77,17 @@ class VMWareAPIVMTestCase(test.TestCase):
         self._check_vm_record()
 
     def _check_vm_record(self):
-        """ Check if the spawned VM's properties corresponds to the instance in
-        the db """
+        """
+        Check if the spawned VM's properties correspond to the instance in
+        the db.
+        """
         instances = self.conn.list_instances()
         self.assertEquals(len(instances), 1)
 
         # Get Nova record for VM
         vm_info = self.conn.get_info(1)
 
-        # Get record for VMs
+        # Get record for VM
         vms = vmwareapi_fake._get_objects("VirtualMachine")
         vm = vms[0]
 
@@ -106,8 +107,10 @@ class VMWareAPIVMTestCase(test.TestCase):
         self.assertEquals(vm.get("runtime.powerState"), 'poweredOn')
 
     def _check_vm_info(self, info, pwr_state=power_state.RUNNING):
-        """ Check if the get_info returned values correspond to the instance
-        object in the db """
+        """
+        Check if the get_info returned values correspond to the instance
+        object in the db.
+        """
         mem_kib = long(self.type_data['memory_mb']) << 10
         self.assertEquals(info["state"], pwr_state)
         self.assertEquals(info["max_mem"], mem_kib)
@@ -194,8 +197,9 @@ class VMWareAPIVMTestCase(test.TestCase):
         pass
 
     def dummy_callback_handler(self, ret):
-        """ Dummy callback function to be passed to suspend, resume, etc.
-        calls """
+        """
+        Dummy callback function to be passed to suspend, resume, etc., calls.
+        """
         pass
 
     def tearDown(self):
diff --git a/nova/tests/vmwareapi/__init__.py b/nova/tests/vmwareapi/__init__.py
index f346c053b..478ee742b 100644
--- a/nova/tests/vmwareapi/__init__.py
+++ b/nova/tests/vmwareapi/__init__.py
@@ -14,3 +14,8 @@
 #    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` -- Stubs for VMware API
+=======================================
+"""
diff --git a/nova/tests/vmwareapi/db_fakes.py b/nova/tests/vmwareapi/db_fakes.py
index 026a2038e..0addd5573 100644
--- a/nova/tests/vmwareapi/db_fakes.py
+++ b/nova/tests/vmwareapi/db_fakes.py
@@ -26,7 +26,7 @@ from nova import utils
 
 
 def stub_out_db_instance_api(stubs):
-    """ Stubs out the db API for creating Instances """
+    """Stubs out the db API for creating Instances."""
 
     INSTANCE_TYPES = {
         'm1.tiny': dict(memory_mb=512, vcpus=1, local_gb=0, flavorid=1),
@@ -38,7 +38,7 @@ def stub_out_db_instance_api(stubs):
             dict(memory_mb=16384, vcpus=8, local_gb=160, flavorid=5)}
 
     class FakeModel(object):
-        """ Stubs out for model """
+        """Stubs out for model."""
 
         def __init__(self, values):
             self.values = values
@@ -53,7 +53,7 @@ def stub_out_db_instance_api(stubs):
                 raise NotImplementedError()
 
     def fake_instance_create(values):
-        """ Stubs out the db.instance_create method """
+        """Stubs out the db.instance_create method."""
 
         type_data = INSTANCE_TYPES[values['instance_type']]
 
@@ -77,7 +77,7 @@ def stub_out_db_instance_api(stubs):
         return FakeModel(base_options)
 
     def fake_network_get_by_instance(context, instance_id):
-        """ Stubs out the db.network_get_by_instance method """
+        """Stubs out the db.network_get_by_instance method."""
 
         fields = {
             'bridge': 'vmnet0',
@@ -87,11 +87,11 @@ def stub_out_db_instance_api(stubs):
         return FakeModel(fields)
 
     def fake_instance_action_create(context, action):
-        """ Stubs out the db.instance_action_create method """
+        """Stubs out the db.instance_action_create method."""
         pass
 
     def fake_instance_get_fixed_address(context, instance_id):
-        """ Stubs out the db.instance_get_fixed_address method """
+        """Stubs out the db.instance_get_fixed_address method."""
         return '10.10.10.10'
 
     def fake_instance_type_get_all(context, inactive=0):
diff --git a/nova/tests/vmwareapi/stubs.py b/nova/tests/vmwareapi/stubs.py
index da2d43c29..a648efb16 100644
--- a/nova/tests/vmwareapi/stubs.py
+++ b/nova/tests/vmwareapi/stubs.py
@@ -25,17 +25,17 @@ from nova.virt.vmwareapi import vmware_images
 
 
 def fake_get_vim_object(arg):
-    """ Stubs out the VMWareAPISession's get_vim_object method """
+    """Stubs out the VMWareAPISession's get_vim_object method."""
     return fake.FakeVim()
 
 
 def fake_is_vim_object(arg, module):
-    """ Stubs out the VMWareAPISession's is_vim_object method """
+    """Stubs out the VMWareAPISession's is_vim_object method."""
     return isinstance(module, fake.FakeVim)
 
 
 def set_stubs(stubs):
-    """ Set the stubs """
+    """Set the stubs."""
     stubs.Set(vmware_images, 'fetch_image', fake.fake_fetch_image)
     stubs.Set(vmware_images, 'get_vmdk_size_and_properties',
               fake.fake_get_vmdk_size_and_properties)
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://<server>/vimService.wsdl'
+                   'e.g http://<server>/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 <test/> as opposed to <test>test</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. <test/> as opposed to <test>test</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 d1469d1566a67d41cb4de4ff06deaf441e099062 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Wed, 16 Mar 2011 11:26:40 -0500
Subject: Some typos

---
 nova/compute/api.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/compute/api.py b/nova/compute/api.py
index 0e9bf2424..08947eb3a 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -443,6 +443,8 @@ class API(base.Base):
         params = {'migration_id': migration_ref['id']}
         self._cast_compute_message('revert_resize', context, instance_id,
                 migration_ref['dest_compute'], params=params)
+        self.db.migration_update(context, migration_ref['id'],
+                {'status': 'reverted'})
 
     def confirm_resize(self, context, instance_id):
         """Confirms a migration/resize, deleting the 'old' instance in the
@@ -458,7 +460,7 @@ class API(base.Base):
         self._cast_compute_message('confirm_resize', context, instance_id,
                 migration_ref['source_compute'], params=params)
 
-        self.db.migration_update(context, migration_id,
+        self.db.migration_update(context, migration_ref['id'],
                 {'status': 'confirmed'})
         self.db.instance_update(context, instance_id,
                 {'host': migration_ref['dest_compute'], })
-- 
cgit 


From f5ad4125d00396a7a3a334eb347aeeb47d8d4989 Mon Sep 17 00:00:00 2001
From: sateesh <sateesh.chodapuneedi@citrix.com>
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')

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 <matt.dietz@rackspace.com>
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')

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 <matt.dietz@rackspace.com>
Date: Wed, 16 Mar 2011 11:54:10 -0500
Subject: tweak

---
 nova/compute/manager.py   | 1 -
 nova/virt/xenapi/vmops.py | 2 +-
 2 files changed, 1 insertion(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 307c91650..1587660a3 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -546,7 +546,6 @@ class ComputeManager(manager.Manager):
                     vcpus=instance_type['vcpus'],
                     local_gb=instance_type['local_gb']))
 
-        self.driver.resize_instance(instance_ref, disk_info)
         self.driver.finish_resize(instance_ref, disk_info)
 
         self.db.migration_update(context, migration_id,
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')

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 5473f3a47c1b11c6625960e1ed73c28c7b061fcb Mon Sep 17 00:00:00 2001
From: Brian Waldon <brian.waldon@rackspace.com>
Date: Wed, 16 Mar 2011 13:41:00 -0400
Subject: moving code out of try/except that would never trigger NotFound

---
 nova/api/openstack/servers.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index dc62882eb..818dd825f 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -57,11 +57,12 @@ class Controller(wsgi.Controller):
     def ips(self, req, id):
         try:
             instance = self.compute_api.get(req.environ['nova.context'], id)
-            builder = addresses_views.get_view_builder(req)
-            return builder.build(instance)
         except exception.NotFound:
             return faults.Fault(exc.HTTPNotFound())
 
+        builder = addresses_views.get_view_builder(req)
+        return builder.build(instance)
+
     def index(self, req):
         """ Returns a list of server names and ids for a given user """
         return self._items(req, is_detail=False)
-- 
cgit 


From 5379f3654e04a0443f3237623f772a17f13e9d90 Mon Sep 17 00:00:00 2001
From: Trey Morris <trey.morris@rackspace.com>
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')

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 <trey.morris@rackspace.com>
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')

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 <matt.dietz@rackspace.com>
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')

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 b2456e983178b97ad94f48c77ef210000d6d6ca4 Mon Sep 17 00:00:00 2001
From: Dan Prince <dan.prince@rackspace.com>
Date: Wed, 16 Mar 2011 14:03:38 -0400
Subject: Move mapper code into the _action_ext_controllers and
 _response_ext_controllers methods.

---
 nova/api/openstack/extensions.py                  | 65 ++++++++++++-----------
 nova/tests/api/openstack/extensions/foxinsocks.py |  2 +-
 nova/tests/api/openstack/test_extensions.py       |  7 +--
 3 files changed, 39 insertions(+), 35 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/extensions.py b/nova/api/openstack/extensions.py
index 66ddd8078..4adfcfc5b 100644
--- a/nova/api/openstack/extensions.py
+++ b/nova/api/openstack/extensions.py
@@ -118,7 +118,7 @@ class ExtensionMiddleware(wsgi.Middleware):
             return cls(app, **local_config)
         return _factory
 
-    def _actions_by_collection(self, application, ext_mgr):
+    def _action_ext_controllers(self, application, ext_mgr, mapper):
         """
         Return a dict of ActionExtensionController objects by collection
         """
@@ -126,18 +126,38 @@ class ExtensionMiddleware(wsgi.Middleware):
         for action in ext_mgr.get_actions():
             if not action.collection in action_controllers.keys():
                 controller = ActionExtensionController(application)
+                mapper.connect("/%s/:(id)/action.:(format)" %
+                                action.collection,
+                                action='action',
+                                controller=controller,
+                                conditions=dict(method=['POST']))
+                mapper.connect("/%s/:(id)/action" % action.collection,
+                                action='action',
+                                controller=controller,
+                                conditions=dict(method=['POST']))
                 action_controllers[action.collection] = controller
+
         return action_controllers
 
-    def _responses_by_collection(self, application, ext_mgr):
+    def _response_ext_controllers(self, application, ext_mgr, mapper):
         """
         Return a dict of ResponseExtensionController objects by collection
         """
         response_ext_controllers = {}
         for resp_ext in ext_mgr.get_response_extensions():
-            if not resp_ext.url_route in response_ext_controllers.keys():
+            if not resp_ext.key in response_ext_controllers.keys():
                 controller = ResponseExtensionController(application)
-                response_ext_controllers[resp_ext.url_route] = controller
+                mapper.connect(resp_ext.url_route + '.:(format)',
+                                action='process',
+                                controller=controller,
+                                conditions=resp_ext.conditions)
+
+                mapper.connect(resp_ext.url_route,
+                                action='process',
+                                controller=controller,
+                                conditions=resp_ext.conditions)
+                response_ext_controllers[resp_ext.key] = controller
+
         return response_ext_controllers
 
     def __init__(self, application, ext_mgr=None):
@@ -159,38 +179,20 @@ class ExtensionMiddleware(wsgi.Middleware):
                             parent_resource=resource.parent)
 
         # extended actions
-        action_controllers = self._actions_by_collection(application, ext_mgr)
+        action_controllers = self._action_ext_controllers(application, ext_mgr,
+                                                        mapper)
         for action in ext_mgr.get_actions():
-            LOG.debug(_('Extended collection/action: %s/%s'),
-                        action.collection,
-                        action.action_name)
+            LOG.debug(_('Extended action: %s'), action.action_name)
             controller = action_controllers[action.collection]
             controller.add_action(action.action_name, action.handler)
 
-            mapper.connect("/%s/:(id)/action.:(format)" % action.collection,
-                            action='action',
-                            controller=controller,
-                            conditions=dict(method=['POST']))
-            mapper.connect("/%s/:(id)/action" % action.collection,
-                            action='action',
-                            controller=controller,
-                            conditions=dict(method=['POST']))
-
         # extended responses
-        resp_controllers = self._responses_by_collection(application, ext_mgr)
+        resp_controllers = self._response_ext_controllers(application, ext_mgr,
+                                                            mapper)
         for response_ext in ext_mgr.get_response_extensions():
-            LOG.debug(_('Extended response: %s'), response_ext.url_route)
-            controller = resp_controllers[response_ext.url_route]
+            LOG.debug(_('Extended response: %s'), response_ext.key)
+            controller = resp_controllers[response_ext.key]
             controller.add_handler(response_ext.handler)
-            mapper.connect(response_ext.url_route + '.:(format)',
-                            action='process',
-                            controller=controller,
-                            conditions=response_ext.conditions)
-
-            mapper.connect(response_ext.url_route,
-                            action='process',
-                            controller=controller,
-                            conditions=response_ext.conditions)
 
         self._router = routes.middleware.RoutesMiddleware(self._dispatch,
                                                           mapper)
@@ -322,10 +324,11 @@ class ResponseExtension(object):
     core nova OpenStack API controllers.
     """
 
-    def __init__(self, url_route, method, handler):
+    def __init__(self, method, url_route, handler):
         self.url_route = url_route
-        self.conditions = dict(method=[method])
         self.handler = handler
+        self.conditions = dict(method=[method])
+        self.key = "%s-%s" % (method, url_route)
 
 
 class ActionExtension(object):
diff --git a/nova/tests/api/openstack/extensions/foxinsocks.py b/nova/tests/api/openstack/extensions/foxinsocks.py
index 09a328273..2e93d8a55 100644
--- a/nova/tests/api/openstack/extensions/foxinsocks.py
+++ b/nova/tests/api/openstack/extensions/foxinsocks.py
@@ -56,7 +56,7 @@ class Foxinsocks(object):
             data['flavor']['googoose'] = "Gooey goo for chewy chewing!"
             return data
 
-        resp_ext = extensions.ResponseExtension('/v1.0/flavors/:(id)', 'GET',
+        resp_ext = extensions.ResponseExtension('GET', '/flavors/:(id)',
                                                 _resp_handler)
         response_exts.append(resp_ext)
         return response_exts
diff --git a/nova/tests/api/openstack/test_extensions.py b/nova/tests/api/openstack/test_extensions.py
index 0f99dec55..149f1973e 100644
--- a/nova/tests/api/openstack/test_extensions.py
+++ b/nova/tests/api/openstack/test_extensions.py
@@ -31,6 +31,8 @@ import nova.wsgi
 
 FLAGS = flags.FLAGS
 
+response_body = "Try to say this Mr. Knox, sir..."
+
 
 class StubController(nova.wsgi.Controller):
 
@@ -92,11 +94,9 @@ class ExtensionControllerTest(unittest.TestCase):
         response = request.get_response(ext_midware)
         self.assertEqual(200, response.status_int)
 
-response_body = "Try to say this Mr. Knox, sir..."
 
 class ResourceExtensionTest(unittest.TestCase):
 
-
     def test_no_extension_present(self):
         manager = StubExtensionManager(None)
         app = openstack.APIRouter()
@@ -205,7 +205,8 @@ class ResponseExtensionTest(unittest.TestCase):
             data['flavor']['googoose'] = test_resp
             return data
 
-        resp_ext = extensions.ResponseExtension('/v1.0/flavors/:(id)', 'GET',
+        resp_ext = extensions.ResponseExtension('GET',
+                                                '/v1.0/flavors/:(id)',
                                                 _resp_handler)
         manager = StubExtensionManager(None, None, resp_ext)
         app = fakes.wsgi_app()
-- 
cgit 


From e2399c434386a31114273f2cf6f14586a25480c2 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
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')

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 f91cd67c403d7de54600eea0d91c223af0493788 Mon Sep 17 00:00:00 2001
From: Dan Prince <dan.prince@rackspace.com>
Date: Wed, 16 Mar 2011 14:09:29 -0400
Subject: Comment update.

---
 nova/api/openstack/extensions.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/api/openstack/extensions.py b/nova/api/openstack/extensions.py
index 4adfcfc5b..557b12fd9 100644
--- a/nova/api/openstack/extensions.py
+++ b/nova/api/openstack/extensions.py
@@ -345,7 +345,7 @@ class ActionExtension(object):
 
 class ResourceExtension(object):
     """
-    ResourceExtension objects can be used to add add top level resources
+    ResourceExtension objects can be used to add top level resources
     to the OpenStack API in nova.
     """
 
-- 
cgit 


From 647f5f0d0283b3852115d821b80a965b0bc92c35 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
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')

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 <matt.dietz@rackspace.com>
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')

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 <matt.dietz@rackspace.com>
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')

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 4d057c9c2df77816ead6f30fa2795148aa8148d3 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Wed, 16 Mar 2011 11:44:40 -0700
Subject: Refactored ZoneRedirect into ZoneChildHelper so ZoneManager can use
 this too.

---
 nova/api/zone_redirect.py      | 79 +++++++++++++++++++++++-------------------
 nova/compute/api.py            |  8 ++---
 nova/scheduler/api.py          | 40 ++++++++++++++++-----
 nova/scheduler/zone_manager.py |  2 +-
 4 files changed, 79 insertions(+), 50 deletions(-)

(limited to 'nova')

diff --git a/nova/api/zone_redirect.py b/nova/api/zone_redirect.py
index fec1b1af3..0adf94046 100644
--- a/nova/api/zone_redirect.py
+++ b/nova/api/zone_redirect.py
@@ -28,6 +28,7 @@ import urllib
 from nova import exception
 from nova import log as logging
 from nova import wsgi
+from nova.scheduler import api
 
 import novaclient.client as client
 import novaclient.exceptions as osexceptions
@@ -41,6 +42,43 @@ except ImportError:
 LOG = logging.getLogger('server')
 
 
+class RequestForwarder(api.ChildZoneHelper):
+
+    def __init__(self, resource, method, body):
+        self.resource = resource
+        self.method = method
+        self.body = body
+    
+    def process(self, client, zone):
+        api_url = zone.api_url
+        LOG.debug(_("Zone redirect to: %(api_url)s, " % locals()))
+        try:
+            if self.method == 'GET':
+                response, body = client.get(self.resource, body=self.body)
+            elif self.method == 'POST':
+                response, body = client.post(self.resource, body=self.body)
+            elif self.method == 'PUT':
+                response, body = client.put(self.resource, body=self.body)
+            elif self.method == 'DELETE':
+                response, body = client.delete(self.resource, body=self.body)
+        except osexceptions.OpenStackException, e:
+            LOG.info(_("Zone returned error: %s ('%s', '%s')"),
+                                e.code, e.message, e.details)
+            res = webob.Response()
+            res.status = "404"
+            return res
+
+        status = response.status
+        LOG.debug(_("Zone %(api_url)s response: "
+                                "%(response)s [%(status)s]/ %(body)s") %
+                                    locals())
+        res = webob.Response()
+        res.status = response['status']
+        res.content_type = response['content-type']
+        res.body = json.dumps(body)
+        return res
+
+
 class ZoneRedirectMiddleware(wsgi.Middleware):
     """Catches Zone Routing exceptions and delegates the call
        to child zones."""
@@ -57,10 +95,8 @@ class ZoneRedirectMiddleware(wsgi.Middleware):
 
             # Todo(sandy): This only works for OpenStack API currently.
             # Needs to be broken out into a driver. 
-            new_req = req.copy()
-
             scheme, netloc, path, query, frag = \
-                                    urlparse.urlsplit(new_req.path_qs)
+                                    urlparse.urlsplit(req.path_qs)
             query = urlparse.parse_qsl(query)
             query = [(key, value) for key, value in query if key != 'fresh']
             query = urllib.urlencode(query)
@@ -69,38 +105,11 @@ class ZoneRedirectMiddleware(wsgi.Middleware):
             m = re.search('/v\d+\.\d+/(.+)', url)
             resource = m.group(1)
 
-            for zone in e.zones:
-                LOG.debug(_("Zone redirect to:[url:%(api_url)s, "
-                                                "username:%(username)s]"
-                            % dict(api_url=zone.api_url,
-                                            username=zone.username)))
-
-                nova = client.OpenStackClient(zone.username, zone.password,
-                                                    zone.api_url)
-                nova.authenticate()
-                try:
-                    if req.method == 'GET':
-                        response, body = nova.get(resource, body=new_req.body)
-                    elif req.method == 'POST':
-                        response, body = nova.post(resource, body=new_req.body)
-                    elif req.method == 'PUT':
-                        response, body = nova.put(resource, body=new_req.body)
-                    elif req.method == 'DELETE':
-                        response, body = nova.delete(resource,
-                                                            body=new_req.body)
-                except osexceptions.OpenStackException, e:
-                    LOG.info(_("Zone returned error: %s ('%s', '%s')"),
-                                        e.code, e.message, e.details)
-                    continue
-
-                LOG.debug(_("Zone Response: %s [%s]/ %s"), response,
-                                                        response.status, body)
-                if response.status == 200:
-                    res = webob.Response()
-                    res.status = response['status']
-                    res.content_type = response['content-type']
-                    res.body = json.dumps(body)
-                    return res
+            forwarder = RequestForwarder(resource, req.method, req.body)
+            for result in forwarder.start(e.zones):
+                # Todo(sandy): We need to aggregate multiple successes.
+                if result.status_int == 200:
+                    return result
 
             LOG.debug(_("Zone Redirect Middleware returning 404 ..."))
             res = webob.Response()
diff --git a/nova/compute/api.py b/nova/compute/api.py
index 1185b9964..215257217 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -385,9 +385,7 @@ class API(base.Base):
         if not host:
             instance = self.get(context, instance_id)
             host = instance['host']
-        #queue = self.db.queue_get_for(context, FLAGS.compute_topic, host)
-        queue = self.scheduler_api.get_queue_for_instance(context,
-                                            FLAGS.compute_topic, host)
+        queue = self.db.queue_get_for(context, FLAGS.compute_topic, host)
         params['instance_id'] = instance_id
         kwargs = {'method': method, 'args': params}
         rpc.cast(context, queue, kwargs)
@@ -406,9 +404,7 @@ class API(base.Base):
         if not host:
             instance = self.get(context, instance_id)
             host = instance["host"]
-        #queue = self.db.queue_get_for(context, FLAGS.compute_topic, host)
-        queue = self.scheduler_api.get_queue_for_instance(context,
-                                                FLAGS.compute_topic, host)
+        queue = self.db.queue_get_for(context, FLAGS.compute_topic, host)
         params['instance_id'] = instance_id
         kwargs = {'method': method, 'args': params}
         return rpc.call(context, queue, kwargs)
diff --git a/nova/scheduler/api.py b/nova/scheduler/api.py
index 48da5bcfc..073784f31 100644
--- a/nova/scheduler/api.py
+++ b/nova/scheduler/api.py
@@ -23,6 +23,10 @@ from nova import flags
 from nova import log as logging
 from nova import rpc
 
+import novaclient.client as client
+
+from eventlet import greenpool
+
 FLAGS = flags.FLAGS
 LOG = logging.getLogger('nova.scheduler.api')
 
@@ -76,6 +80,8 @@ class API(object):
         
     @classmethod
     def get_instance_or_reroute(cls, context, instance_id):
+        """Return an instance from the db or throw a ZoneRouteException
+           if not found."""
         try:
             instance = db.instance_get(context, instance_id)
             return instance
@@ -88,12 +94,30 @@ class API(object):
         zones = db.zone_get_all(context)
         raise exception.ZoneRouteException(zones)
 
-    @classmethod
-    def get_queue_for_instance(cls, context, service, instance_id):
-        instance = db.instance_get(context, instance_id)
-        zone = db.get_zone(instance.zone.id)
-        if cls._is_current_zone(zone):
-            return db.queue_get_for(context, service, instance['host'])
 
-        # Throw a reroute Exception for the middleware to pick up. 
-        raise exception.ZoneRouteException(zone)
+def _wrap_method(function, self):
+    def _wrap(*args, **kwargs):
+        return function(self, *args, **kwargs)
+    return _wrap
+
+
+def _process(self, zone):
+    nova = client.OpenStackClient(zone.username, zone.password,
+                                        zone.api_url)
+    nova.authenticate()
+    return self.process(nova, zone)
+   
+
+class ChildZoneHelper(object):
+    """Delegate a call to a set of Child Zones and wait for their
+       responses. Could be used for Zone Redirect or by the Scheduler
+       plug-ins to query the children."""
+
+    def start(self, zone_list):
+        self.green_pool = greenpool.GreenPool()
+        return [ result for result in self.green_pool.imap(
+                        _wrap_method(_process, self), zone_list)]
+  
+    def process(self, client, zone):
+        """Derived class must override."""
+        pass
diff --git a/nova/scheduler/zone_manager.py b/nova/scheduler/zone_manager.py
index c1a50dbc3..d32cc2e8f 100644
--- a/nova/scheduler/zone_manager.py
+++ b/nova/scheduler/zone_manager.py
@@ -104,7 +104,7 @@ class ZoneManager(object):
     """Keeps the zone states updated."""
     def __init__(self):
         self.last_zone_db_check = datetime.min
-        self.zone_states = {}
+        self.zone_states = {}  # { <zone_id> : ZoneState }
         self.service_states = {}  # { <service> : { <host> : { cap k : v }}}
         self.green_pool = greenpool.GreenPool()
 
-- 
cgit 


From 7fa96f6292ff7d63621fe024b1ef45b1a1996121 Mon Sep 17 00:00:00 2001
From: "jaypipes@gmail.com" <>
Date: Wed, 16 Mar 2011 14:49:18 -0400
Subject: Re-commit r804

---
 nova/tests/api/openstack/test_servers.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 40026a615..cde2fc036 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -216,7 +216,7 @@ class ServersTest(test.TestCase):
         servers = json.loads(res.body)['servers']
         self.assertEqual([s['id'] for s in servers], [1, 2])
 
-    def _test_create_instance_helper(self, with_key_pair):
+    def _test_create_instance_helper(self):
         def instance_create(context, inst):
             return {'id': '1', 'display_name': 'server_test'}
 
@@ -272,11 +272,11 @@ class ServersTest(test.TestCase):
         self.assertEqual(res.status_int, 200)
 
     def test_create_instance(self):
-        self._test_create_instance_helper(True)
+        self._test_create_instance_helper()
 
     def test_create_instance_no_key_pair(self):
-        fakes.stub_out_key_pair_funcs(self.stubs, False)
-        self._test_create_instance_helper(False)
+        fakes.stub_out_key_pair_funcs(self.stubs, have_key_pair=False)
+        self._test_create_instance_helper()
 
     def test_update_no_body(self):
         req = webob.Request.blank('/v1.0/servers/1')
-- 
cgit 


From 663c1726d9a96540b8fd729223fcb34d7cf3cdf7 Mon Sep 17 00:00:00 2001
From: "jaypipes@gmail.com" <>
Date: Wed, 16 Mar 2011 14:49:25 -0400
Subject: Re-commit r805

---
 nova/tests/api/openstack/test_servers.py | 1 +
 1 file changed, 1 insertion(+)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index cde2fc036..ad36fa551 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -217,6 +217,7 @@ class ServersTest(test.TestCase):
         self.assertEqual([s['id'] for s in servers], [1, 2])
 
     def _test_create_instance_helper(self):
+        """Shared implementation for tests below that create instance"""
         def instance_create(context, inst):
             return {'id': '1', 'display_name': 'server_test'}
 
-- 
cgit 


From af754e3bba9b2ee93147a3533319ac5a5e199f45 Mon Sep 17 00:00:00 2001
From: Ilya Alekseyev <ialekseev@griddynamics.com>
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')

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 @@
         </disk>
     #end if
 #end if
+
+#for $nic in $nics
         <interface type='bridge'>
-            <source bridge='${bridge_name}'/>
-            <mac address='${mac_address}'/>
+            <source bridge='${nic.bridge_name}'/>
+            <mac address='${nic.mac_address}'/>
             <!--   <model type='virtio'/>  CANT RUN virtio network right now -->
-            <filterref filter="nova-instance-${name}">
-                <parameter name="IP" value="${ip_address}" />
-                <parameter name="DHCPSERVER" value="${dhcp_server}" />           
-#if $getVar('extra_params', False)
-                ${extra_params}
+            <filterref filter="nova-instance-${name}-${nic.id}">
+                <parameter name="IP" value="${nic.ip_address}" />
+                <parameter name="DHCPSERVER" value="${nic.dhcp_server}" />
+#if $getVar('nic.extra_params', False)
+                ${nic.extra_params}
 #end if
-#if $getVar('ra_server', False)
-                <parameter name="RASERVER" value="${ra_server}" />
+#if $getVar('nic.ra_server', False)
+                <parameter name="RASERVER" value="${nic.ra_server}" />
 #end if
             </filterref>
         </interface>
+#end for
 
         <!-- The order is significant here.  File must be defined first -->
         <serial type="file">
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):
                               </rule>
                             </filter>'''
 
-    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 ebd452eab95c2f205d3f7419c08c288030c38aba Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Wed, 16 Mar 2011 13:53:49 -0500
Subject: chchchchchanges

---
 nova/compute/manager.py | 1 +
 1 file changed, 1 insertion(+)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 1587660a3..351e02f51 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -546,6 +546,7 @@ class ComputeManager(manager.Manager):
                     vcpus=instance_type['vcpus'],
                     local_gb=instance_type['local_gb']))
 
+        instance_ref = self.db.instance_get(context, instance_id)
         self.driver.finish_resize(instance_ref, disk_info)
 
         self.db.migration_update(context, migration_id,
-- 
cgit 


From 157ea09c03148ff4615bae27ca3f276a05620825 Mon Sep 17 00:00:00 2001
From: Christian Berendt <berendt@b1-systems.de>
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')

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 5ca10673e77763706e7b26e30f0212930ad1f929 Mon Sep 17 00:00:00 2001
From: Rick Harris <rick.harris@rackspace.com>
Date: Wed, 16 Mar 2011 18:56:31 +0000
Subject: Typo fix

---
 nova/image/glance.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/image/glance.py b/nova/image/glance.py
index ae831e270..2def6fb60 100644
--- a/nova/image/glance.py
+++ b/nova/image/glance.py
@@ -104,7 +104,7 @@ class GlanceImageService(service.BaseImageService):
         :raises AlreadyExists if the image already exist.
 
         """
-        LOG.debug(_("Creating image in Glance. Metdata passed in %s"),
+        LOG.debug(_("Creating image in Glance. Metadata passed in %s"),
                   metadata)
         meta = self._translate_from_image_service_to_glance(metadata)
         LOG.debug(_("Metadata after formatting for Glance %s"), meta)
-- 
cgit 


From 1d4d0e26ae6ece5e68417deaa4ddcf4b7757bd37 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Wed, 16 Mar 2011 14:09:14 -0500
Subject: Fudge

---
 nova/compute/api.py | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'nova')

diff --git a/nova/compute/api.py b/nova/compute/api.py
index 08947eb3a..ddf439b35 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -468,11 +468,15 @@ class API(base.Base):
     def resize(self, context, instance_id, flavor_id):
         """Resize a running instance."""
         instance = self.db.instance_get(context, instance_id)
+        LOG.debug(_("Resizing instance %s to flavor %d") %
+                (instance.name, flavor_id))
         current_instance_type = self.db.instance_type_get_by_name(
             context, instance['instance_type'])
 
         new_instance_type = self.db.instance_type_get_by_flavor_id(
                 context, flavor_id)
+        LOG.debug(_("Old instance type %s -> New instance type %s") %
+                (current_instance_type['name'], new_instance_type['name']))
         if not new_instance_type:
             raise exception.ApiError(_("Requested flavor does not exist"))
 
-- 
cgit 


From 7de1ef791296d547c2691454d5cb5451087cd76b Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Wed, 16 Mar 2011 12:15:57 -0700
Subject: User ids are strings, and are not necessarily == name.  Also fix so
 that non-existent user gives a 404, not a 500.

---
 nova/api/openstack/users.py               | 17 +++++++--
 nova/auth/manager.py                      | 11 +++++-
 nova/tests/api/openstack/fakes.py         |  4 +--
 nova/tests/api/openstack/test_accounts.py | 22 ++++++------
 nova/tests/api/openstack/test_auth.py     |  8 ++---
 nova/tests/api/openstack/test_users.py    | 58 +++++++++++++++++++++----------
 6 files changed, 79 insertions(+), 41 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/users.py b/nova/api/openstack/users.py
index ebd0f4512..d3ab3d553 100644
--- a/nova/api/openstack/users.py
+++ b/nova/api/openstack/users.py
@@ -13,13 +13,14 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-import common
+from webob import exc
 
 from nova import exception
 from nova import flags
 from nova import log as logging
 from nova import wsgi
-
+from nova.api.openstack import common
+from nova.api.openstack import faults
 from nova.auth import manager
 
 FLAGS = flags.FLAGS
@@ -63,7 +64,17 @@ class Controller(wsgi.Controller):
 
     def show(self, req, id):
         """Return data about the given user id"""
-        user = self.manager.get_user(id)
+
+        #NOTE(justinsb): The drivers are a little inconsistent in how they
+        #  deal with "NotFound" - some throw, some return None.
+        try:
+            user = self.manager.get_user(id)
+        except exception.NotFound:
+            user = None
+
+        if user is None:
+            raise faults.Fault(exc.HTTPNotFound())
+
         return dict(user=_translate_keys(user))
 
     def delete(self, req, id):
diff --git a/nova/auth/manager.py b/nova/auth/manager.py
index 450ab803a..793499629 100644
--- a/nova/auth/manager.py
+++ b/nova/auth/manager.py
@@ -96,10 +96,19 @@ class AuthBase(object):
 
 
 class User(AuthBase):
-    """Object representing a user"""
+    """Object representing a user
+
+    The following attributes are defined:
+    :id:       A system identifier for the user.  A string (for LDAP)
+    :name:     The user name, potentially in some more friendly format
+    :access:   The 'username' for EC2 authentication
+    :secret:   The 'password' for EC2 authenticatoin
+    :admin:    ???
+    """
 
     def __init__(self, id, name, access, secret, admin):
         AuthBase.__init__(self)
+        assert isinstance(id, basestring)
         self.id = id
         self.name = name
         self.access = access
diff --git a/nova/tests/api/openstack/fakes.py b/nova/tests/api/openstack/fakes.py
index c2ae48ce4..5decb2bad 100644
--- a/nova/tests/api/openstack/fakes.py
+++ b/nova/tests/api/openstack/fakes.py
@@ -240,10 +240,10 @@ class FakeAuthManager(object):
 
     @classmethod
     def reset_fake_data(cls):
-        cls.auth_data = dict(acc1=User(1, 'guy1', 'acc1', 'fortytwo!', False))
+        cls.auth_data = dict(u1=User('id1', 'guy1', 'acc1', 'secret1', False))
         cls.projects = dict(testacct=Project('testacct',
                                              'testacct',
-                                             'guy1',
+                                             'id1',
                                              'test',
                                               []))
 
diff --git a/nova/tests/api/openstack/test_accounts.py b/nova/tests/api/openstack/test_accounts.py
index 5cb08ffd2..64abcf48c 100644
--- a/nova/tests/api/openstack/test_accounts.py
+++ b/nova/tests/api/openstack/test_accounts.py
@@ -19,11 +19,9 @@ import json
 import stubout
 import webob
 
-import nova.api
-import nova.api.openstack.auth
-from nova import context
 from nova import flags
 from nova import test
+from nova.api.openstack import accounts
 from nova.auth.manager import User
 from nova.tests.api.openstack import fakes
 
@@ -44,9 +42,9 @@ class AccountsTest(test.TestCase):
     def setUp(self):
         super(AccountsTest, self).setUp()
         self.stubs = stubout.StubOutForTesting()
-        self.stubs.Set(nova.api.openstack.accounts.Controller, '__init__',
+        self.stubs.Set(accounts.Controller, '__init__',
                        fake_init)
-        self.stubs.Set(nova.api.openstack.accounts.Controller, '_check_admin',
+        self.stubs.Set(accounts.Controller, '_check_admin',
                        fake_admin_check)
         fakes.FakeAuthManager.clear_fakes()
         fakes.FakeAuthDatabase.data = {}
@@ -57,8 +55,8 @@ class AccountsTest(test.TestCase):
         self.allow_admin = FLAGS.allow_admin_api
         FLAGS.allow_admin_api = True
         fakemgr = fakes.FakeAuthManager()
-        joeuser = User(1, 'guy1', 'acc1', 'fortytwo!', False)
-        superuser = User(2, 'guy2', 'acc2', 'swordfish', True)
+        joeuser = User('id1', 'guy1', 'acc1', 'secret1', False)
+        superuser = User('id2', 'guy2', 'acc2', 'secret2', True)
         fakemgr.add_user(joeuser)
         fakemgr.add_user(superuser)
         fakemgr.create_project('test1', joeuser)
@@ -76,7 +74,7 @@ class AccountsTest(test.TestCase):
 
         self.assertEqual(res_dict['account']['id'], 'test1')
         self.assertEqual(res_dict['account']['name'], 'test1')
-        self.assertEqual(res_dict['account']['manager'], 'guy1')
+        self.assertEqual(res_dict['account']['manager'], 'id1')
         self.assertEqual(res.status_int, 200)
 
     def test_account_delete(self):
@@ -88,7 +86,7 @@ class AccountsTest(test.TestCase):
 
     def test_account_create(self):
         body = dict(account=dict(description='test account',
-                              manager='guy1'))
+                                 manager='id1'))
         req = webob.Request.blank('/v1.0/accounts/newacct')
         req.headers["Content-Type"] = "application/json"
         req.method = 'PUT'
@@ -101,14 +99,14 @@ class AccountsTest(test.TestCase):
         self.assertEqual(res_dict['account']['id'], 'newacct')
         self.assertEqual(res_dict['account']['name'], 'newacct')
         self.assertEqual(res_dict['account']['description'], 'test account')
-        self.assertEqual(res_dict['account']['manager'], 'guy1')
+        self.assertEqual(res_dict['account']['manager'], 'id1')
         self.assertTrue('newacct' in
                         fakes.FakeAuthManager.projects)
         self.assertEqual(len(fakes.FakeAuthManager.projects.values()), 3)
 
     def test_account_update(self):
         body = dict(account=dict(description='test account',
-                              manager='guy2'))
+                                 manager='id2'))
         req = webob.Request.blank('/v1.0/accounts/test1')
         req.headers["Content-Type"] = "application/json"
         req.method = 'PUT'
@@ -121,5 +119,5 @@ class AccountsTest(test.TestCase):
         self.assertEqual(res_dict['account']['id'], 'test1')
         self.assertEqual(res_dict['account']['name'], 'test1')
         self.assertEqual(res_dict['account']['description'], 'test account')
-        self.assertEqual(res_dict['account']['manager'], 'guy2')
+        self.assertEqual(res_dict['account']['manager'], 'id2')
         self.assertEqual(len(fakes.FakeAuthManager.projects.values()), 2)
diff --git a/nova/tests/api/openstack/test_auth.py b/nova/tests/api/openstack/test_auth.py
index e1f936bb1..446c5c149 100644
--- a/nova/tests/api/openstack/test_auth.py
+++ b/nova/tests/api/openstack/test_auth.py
@@ -51,7 +51,7 @@ class Test(test.TestCase):
 
     def test_authorize_user(self):
         f = fakes.FakeAuthManager()
-        u = nova.auth.manager.User(1, 'user1', 'user1_key', None, None)
+        u = nova.auth.manager.User('id1', 'user1', 'user1_key', None, None)
         f.add_user(u)
 
         req = webob.Request.blank('/v1.0/')
@@ -66,7 +66,7 @@ class Test(test.TestCase):
 
     def test_authorize_token(self):
         f = fakes.FakeAuthManager()
-        u = nova.auth.manager.User(1, 'user1', 'user1_key', None, None)
+        u = nova.auth.manager.User('id1', 'user1', 'user1_key', None, None)
         f.add_user(u)
         f.create_project('user1_project', u)
 
@@ -124,7 +124,7 @@ class Test(test.TestCase):
 
     def test_bad_user_good_key(self):
         f = fakes.FakeAuthManager()
-        u = nova.auth.manager.User(1, 'user1', 'user1_key', None, None)
+        u = nova.auth.manager.User('id1', 'user1', 'user1_key', None, None)
         f.add_user(u)
 
         req = webob.Request.blank('/v1.0/')
@@ -190,7 +190,7 @@ class TestLimiter(test.TestCase):
 
     def test_authorize_token(self):
         f = fakes.FakeAuthManager()
-        u = nova.auth.manager.User(1, 'user1', 'user1_key', None, None)
+        u = nova.auth.manager.User('id1', 'user1', 'user1_key', None, None)
         f.add_user(u)
         f.create_project('test', u)
 
diff --git a/nova/tests/api/openstack/test_users.py b/nova/tests/api/openstack/test_users.py
index 652aac936..effb2f592 100644
--- a/nova/tests/api/openstack/test_users.py
+++ b/nova/tests/api/openstack/test_users.py
@@ -18,11 +18,10 @@ import json
 import stubout
 import webob
 
-import nova.api
-import nova.api.openstack.auth
-from nova import context
 from nova import flags
 from nova import test
+from nova import utils
+from nova.api.openstack import users
 from nova.auth.manager import User, Project
 from nova.tests.api.openstack import fakes
 
@@ -43,14 +42,14 @@ class UsersTest(test.TestCase):
     def setUp(self):
         super(UsersTest, self).setUp()
         self.stubs = stubout.StubOutForTesting()
-        self.stubs.Set(nova.api.openstack.users.Controller, '__init__',
+        self.stubs.Set(users.Controller, '__init__',
                        fake_init)
-        self.stubs.Set(nova.api.openstack.users.Controller, '_check_admin',
+        self.stubs.Set(users.Controller, '_check_admin',
                        fake_admin_check)
         fakes.FakeAuthManager.clear_fakes()
         fakes.FakeAuthManager.projects = dict(testacct=Project('testacct',
                                                                'testacct',
-                                                               'guy1',
+                                                               'id1',
                                                                'test',
                                                                []))
         fakes.FakeAuthDatabase.data = {}
@@ -61,8 +60,8 @@ class UsersTest(test.TestCase):
         self.allow_admin = FLAGS.allow_admin_api
         FLAGS.allow_admin_api = True
         fakemgr = fakes.FakeAuthManager()
-        fakemgr.add_user(User(1, 'guy1', 'acc1', 'fortytwo!', False))
-        fakemgr.add_user(User(2, 'guy2', 'acc2', 'swordfish', True))
+        fakemgr.add_user(User('id1', 'guy1', 'acc1', 'secret1', False))
+        fakemgr.add_user(User('id2', 'guy2', 'acc2', 'secret2', True))
 
     def tearDown(self):
         self.stubs.UnsetAll()
@@ -78,28 +77,44 @@ class UsersTest(test.TestCase):
         self.assertEqual(len(res_dict['users']), 2)
 
     def test_get_user_by_id(self):
-        req = webob.Request.blank('/v1.0/users/guy2')
+        req = webob.Request.blank('/v1.0/users/id2')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
 
-        self.assertEqual(res_dict['user']['id'], 'guy2')
+        self.assertEqual(res_dict['user']['id'], 'id2')
         self.assertEqual(res_dict['user']['name'], 'guy2')
-        self.assertEqual(res_dict['user']['secret'], 'swordfish')
+        self.assertEqual(res_dict['user']['secret'], 'secret2')
         self.assertEqual(res_dict['user']['admin'], True)
         self.assertEqual(res.status_int, 200)
 
     def test_user_delete(self):
-        req = webob.Request.blank('/v1.0/users/guy1')
+        # Check the user exists
+        req = webob.Request.blank('/v1.0/users/id1')
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+
+        self.assertEqual(res_dict['user']['id'], 'id1')
+        self.assertEqual(res.status_int, 200)
+
+        # Delete the user
+        req = webob.Request.blank('/v1.0/users/id1')
         req.method = 'DELETE'
         res = req.get_response(fakes.wsgi_app())
-        self.assertTrue('guy1' not in [u.id for u in
+        self.assertTrue('id1' not in [u.id for u in
                         fakes.FakeAuthManager.auth_data])
         self.assertEqual(res.status_int, 200)
 
+        # Check the user is not returned (and returns 404)
+        req = webob.Request.blank('/v1.0/users/id1')
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+        self.assertEqual(res.status_int, 404)
+
     def test_user_create(self):
+        secret = utils.generate_password()
         body = dict(user=dict(name='test_guy',
                               access='acc3',
-                              secret='invasionIsInNormandy',
+                              secret=secret,
                               admin=True))
         req = webob.Request.blank('/v1.0/users')
         req.headers["Content-Type"] = "application/json"
@@ -110,20 +125,25 @@ class UsersTest(test.TestCase):
         res_dict = json.loads(res.body)
 
         self.assertEqual(res.status_int, 200)
+
+        # NOTE(justinsb): This is a questionable assertion in general
+        # fake sets id=name, but others might not...
         self.assertEqual(res_dict['user']['id'], 'test_guy')
+
         self.assertEqual(res_dict['user']['name'], 'test_guy')
         self.assertEqual(res_dict['user']['access'], 'acc3')
-        self.assertEqual(res_dict['user']['secret'], 'invasionIsInNormandy')
+        self.assertEqual(res_dict['user']['secret'], secret)
         self.assertEqual(res_dict['user']['admin'], True)
         self.assertTrue('test_guy' in [u.id for u in
                         fakes.FakeAuthManager.auth_data])
         self.assertEqual(len(fakes.FakeAuthManager.auth_data), 3)
 
     def test_user_update(self):
+        new_secret = utils.generate_password()
         body = dict(user=dict(name='guy2',
                               access='acc2',
-                              secret='invasionIsInNormandy'))
-        req = webob.Request.blank('/v1.0/users/guy2')
+                              secret=new_secret))
+        req = webob.Request.blank('/v1.0/users/id2')
         req.headers["Content-Type"] = "application/json"
         req.method = 'PUT'
         req.body = json.dumps(body)
@@ -132,8 +152,8 @@ class UsersTest(test.TestCase):
         res_dict = json.loads(res.body)
 
         self.assertEqual(res.status_int, 200)
-        self.assertEqual(res_dict['user']['id'], 'guy2')
+        self.assertEqual(res_dict['user']['id'], 'id2')
         self.assertEqual(res_dict['user']['name'], 'guy2')
         self.assertEqual(res_dict['user']['access'], 'acc2')
-        self.assertEqual(res_dict['user']['secret'], 'invasionIsInNormandy')
+        self.assertEqual(res_dict['user']['secret'], new_secret)
         self.assertEqual(res_dict['user']['admin'], True)
-- 
cgit 


From 3459cfb89bd90605e54fd1fb28b8b38089f3e236 Mon Sep 17 00:00:00 2001
From: Mark Washenberger <mark.washenberger@rackspace.com>
Date: Wed, 16 Mar 2011 15:20:08 -0400
Subject: update image service documentation

---
 nova/image/service.py | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

(limited to 'nova')

diff --git a/nova/image/service.py b/nova/image/service.py
index c09052cab..78d8f33e9 100644
--- a/nova/image/service.py
+++ b/nova/image/service.py
@@ -40,9 +40,9 @@ class BaseImageService(object):
         :retval: a sequence of mappings with the following signature
                     {'id': opaque id of image,
                      'name': name of image,
-                     'created_at': creation timestamp,
-                     'updated_at': modification timestamp,
-                     'deleted_at': deletion timestamp or None,
+                     'created_at': creation datetime object,
+                     'updated_at': modification datetime object,
+                     'deleted_at': deletion datetime object or None,
                      'deleted': boolean indicating if image has been deleted,
                      'status': string description of image status,
                      'is_public': boolean indicating if image is public
@@ -64,9 +64,9 @@ class BaseImageService(object):
 
             {'id': opaque id of image,
              'name': name of image,
-             'created_at': creation timestamp,
-             'updated_at': modification timestamp,
-             'deleted_at': deletion timestamp or None,
+             'created_at': creation datetime object,
+             'updated_at': modification datetime object,
+             'deleted_at': deletion datetime object or None,
              'deleted': boolean indicating if image has been deleted,
              'status': string description of image status,
              'is_public': boolean indicating if image is public
-- 
cgit 


From 85bae497aa803914d329f2872d343a9982dc370e Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Wed, 16 Mar 2011 14:35:04 -0500
Subject: Changes

---
 nova/api/openstack/flavors.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/api/openstack/flavors.py b/nova/api/openstack/flavors.py
index f3d040ba3..b9e40371d 100644
--- a/nova/api/openstack/flavors.py
+++ b/nova/api/openstack/flavors.py
@@ -36,7 +36,7 @@ class Controller(wsgi.Controller):
 
     def index(self, req):
         """Return all flavors in brief."""
-        return dict(flavors=[dict(id=flavor['id'], name=flavor['name'])
+        return dict(flavors=[dict(id=flavor['flavorid'], name=flavor['name'])
                              for flavor in self.detail(req)['flavors']])
 
     def detail(self, req):
@@ -48,6 +48,7 @@ class Controller(wsgi.Controller):
         """Return data about the given flavor id."""
         ctxt = req.environ['nova.context']
         values = db.instance_type_get_by_flavor_id(ctxt, id)
+        values.update({'id': values['flavorid']})
         return dict(flavor=values)
         raise faults.Fault(exc.HTTPNotFound())
 
-- 
cgit 


From 227957e31d75b24bb8afa078c8d3f2bc447a8215 Mon Sep 17 00:00:00 2001
From: "matt.dietz@rackspace.com" <>
Date: Wed, 16 Mar 2011 19:40:16 +0000
Subject: Unit test update

---
 nova/tests/api/openstack/test_flavors.py | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/test_flavors.py b/nova/tests/api/openstack/test_flavors.py
index 8280a505f..30326dc50 100644
--- a/nova/tests/api/openstack/test_flavors.py
+++ b/nova/tests/api/openstack/test_flavors.py
@@ -15,6 +15,7 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+import json
 import stubout
 import webob
 
@@ -50,3 +51,5 @@ class FlavorsTest(test.TestCase):
         req = webob.Request.blank('/v1.0/flavors/1')
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 200)
+        body = json.loads(res.body)
+        self.assertEqual(body['flavor']['id'], 1)
-- 
cgit 


From f17fb9370d4af42267837a36c937f213669b0291 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Wed, 16 Mar 2011 14:43:57 -0500
Subject: Dumb

---
 nova/api/openstack/flavors.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/api/openstack/flavors.py b/nova/api/openstack/flavors.py
index b9e40371d..1c440b3a9 100644
--- a/nova/api/openstack/flavors.py
+++ b/nova/api/openstack/flavors.py
@@ -48,7 +48,7 @@ class Controller(wsgi.Controller):
         """Return data about the given flavor id."""
         ctxt = req.environ['nova.context']
         values = db.instance_type_get_by_flavor_id(ctxt, id)
-        values.update({'id': values['flavorid']})
+        values['id'] = values['flavorid']
         return dict(flavor=values)
         raise faults.Fault(exc.HTTPNotFound())
 
-- 
cgit 


From 77a48cdd8a22cc84ed67a6b3d1c3793dd93e44a8 Mon Sep 17 00:00:00 2001
From: Brian Waldon <brian.waldon@rackspace.com>
Date: Wed, 16 Mar 2011 16:15:56 -0400
Subject: expanding osapi flavors tests; rewriting flavors resource with view
 builders; adding 1.1 specific links to flavors resources

---
 nova/api/openstack/flavors.py            |  48 +++++++-------
 nova/api/openstack/views/flavors.py      |  45 ++++++++++++-
 nova/db/sqlalchemy/api.py                |   2 +-
 nova/tests/api/openstack/test_flavors.py | 107 +++++++++++++++++++++++++++++--
 4 files changed, 167 insertions(+), 35 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/flavors.py b/nova/api/openstack/flavors.py
index c99b945fb..bc61e8d1a 100644
--- a/nova/api/openstack/flavors.py
+++ b/nova/api/openstack/flavors.py
@@ -15,16 +15,12 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-from webob import exc
+import webob
 
 from nova import db
-from nova import context
-from nova.api.openstack import faults
-from nova.api.openstack import common
-from nova.compute import instance_types
-from nova.api.openstack.views import flavors as flavors_views
+from nova import exception
 from nova import wsgi
-import nova.api.openstack
+from nova.api.openstack.views import flavors as flavors_views
 
 
 class Controller(wsgi.Controller):
@@ -37,29 +33,31 @@ class Controller(wsgi.Controller):
 
     def index(self, req):
         """Return all flavors in brief."""
-        return dict(flavors=[dict(id=flavor['id'], name=flavor['name'])
-                             for flavor in self.detail(req)['flavors']])
+        items = self._get_flavors(req, False)
+        return dict(flavors=items)
 
     def detail(self, req):
         """Return all flavors in detail."""
-        items = [self.show(req, id)['flavor'] for id in self._all_ids(req)]
+        items = self._get_flavors(req, True)
         return dict(flavors=items)
 
+    def _get_flavors(self, req, is_detail):
+        """Helper function that returns a list of flavor dicts."""
+        ctxt = req.environ['nova.context']
+        flavors = db.api.instance_type_get_all(ctxt)
+        builder = flavors_views.get_view_builder(req)
+        items = [builder.build(flavor, is_detail=is_detail) \
+                 for flavor in flavors.values()]
+        return items
+
     def show(self, req, id):
         """Return data about the given flavor id."""
-        ctxt = req.environ['nova.context']
-        flavor = db.api.instance_type_get_by_flavor_id(ctxt, id)
-        values = {
-            "id": flavor["flavorid"],
-            "name": flavor["name"],
-            "ram": flavor["memory_mb"],
-            "disk": flavor["local_gb"],
-        }
+        try:
+            ctxt = req.environ['nova.context']
+            flavor = db.api.instance_type_get_by_flavor_id(ctxt, id)
+        except exception.NotFound:
+            return webob.exc.HTTPNotFound()
+
+        builder = flavors_views.get_view_builder(req)
+        values = builder.build(flavor, is_detail=True)
         return dict(flavor=values)
-
-    def _all_ids(self, req):
-        """Return the list of all flavorids."""
-        ctxt = req.environ['nova.context']
-        inst_types = db.api.instance_type_get_all(ctxt)
-        flavor_ids = [inst_types[i]['flavorid'] for i in inst_types.keys()]
-        return sorted(flavor_ids)
diff --git a/nova/api/openstack/views/flavors.py b/nova/api/openstack/views/flavors.py
index dd2e75a7a..19ac8f114 100644
--- a/nova/api/openstack/views/flavors.py
+++ b/nova/api/openstack/views/flavors.py
@@ -35,14 +35,55 @@ class ViewBuilder(object):
     def __init__(self):
         pass
 
-    def build(self, flavor_obj):
-        raise NotImplementedError()
+    def build(self, flavor_obj, is_detail=False):
+        if is_detail:
+            flavor = self._build_detail(flavor_obj)
+        else:
+            flavor = self._build_simple(flavor_obj)
+
+        full_flavor = self._build_extra(flavor)
+
+        return full_flavor
+
+    def _build_simple(self, flavor_obj):
+        return {
+            "id": flavor_obj["flavorid"],
+            "name": flavor_obj["name"],
+        }
+
+    def _build_detail(self, flavor_obj):
+        simple = self._build_simple(flavor_obj)
+
+        detail = {
+            "ram": flavor_obj["memory_mb"],
+            "disk": flavor_obj["local_gb"],
+        }
+
+        detail.update(simple)
+
+        return detail 
+    
+    def _build_extra(self, flavor_obj):
+        return flavor_obj
 
 
 class ViewBuilder_1_1(ViewBuilder):
     def __init__(self, base_url):
         self.base_url = base_url
 
+    def _build_extra(self, flavor_obj):
+        flavor_obj["links"] = self._build_links(flavor_obj)
+        return flavor_obj
+
+    def _build_links(self, flavor_obj):
+        links = [
+            {
+                "rel": "self",
+                "href": self.generate_href(flavor_obj["id"]),
+            },
+        ]
+        return links
+
     def generate_href(self, flavor_id):
         return "%s/flavors/%s" % (self.base_url, flavor_id)
 
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 56998ce05..6789ac22a 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -2356,7 +2356,7 @@ def instance_type_get_by_flavor_id(context, id):
                                     filter_by(flavorid=int(id)).\
                                     first()
     if not inst_type:
-        raise exception.NotFound(_("No flavor with name %s") % id)
+        raise exception.NotFound(_("No flavor with flavorid %s") % id)
     else:
         return dict(inst_type)
 
diff --git a/nova/tests/api/openstack/test_flavors.py b/nova/tests/api/openstack/test_flavors.py
index 4f504808c..197e907c4 100644
--- a/nova/tests/api/openstack/test_flavors.py
+++ b/nova/tests/api/openstack/test_flavors.py
@@ -19,11 +19,10 @@ import json
 import stubout
 import webob
 
-from nova import test
-import nova.api
+import nova.db.api
 from nova import context
-from nova.api.openstack import flavors
-from nova import db
+from nova import exception
+from nova import test
 from nova.tests.api.openstack import fakes
 
 
@@ -47,6 +46,9 @@ def return_instance_types(context, num=2):
         instance_types[name] = stub_flavor(i, name)
     return instance_types
 
+def return_instance_type_not_found(context, flavorid):
+    raise exception.NotFound()
+
 
 class FlavorsTest(test.TestCase):
     def setUp(self):
@@ -67,7 +69,7 @@ class FlavorsTest(test.TestCase):
         self.stubs.UnsetAll()
         super(FlavorsTest, self).tearDown()
 
-    def test_get_flavor_list(self):
+    def test_get_flavor_list_v1_0(self):
         req = webob.Request.blank('/v1.0/flavors')
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 200)
@@ -84,7 +86,7 @@ class FlavorsTest(test.TestCase):
         ]
         self.assertEqual(flavors, expected)
 
-    def test_get_flavor_list_detail(self):
+    def test_get_flavor_list_detail_v1_0(self):
         req = webob.Request.blank('/v1.0/flavors/detail')
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 200)
@@ -105,7 +107,7 @@ class FlavorsTest(test.TestCase):
         ]
         self.assertEqual(flavors, expected)
 
-    def test_get_flavor_by_id(self):
+    def test_get_flavor_by_id_v1_0(self):
         req = webob.Request.blank('/v1.0/flavors/12')
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 200)
@@ -117,3 +119,94 @@ class FlavorsTest(test.TestCase):
             "disk": "10",
         }
         self.assertEqual(flavor, expected)
+
+    def test_get_flavor_by_invalid_id(self):
+        self.stubs.Set(nova.db.api, "instance_type_get_by_flavor_id",
+                       return_instance_type_not_found)
+        req = webob.Request.blank('/v1.0/flavors/asdf')
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 404)
+
+    def test_get_flavor_by_id_v1_1(self):
+        req = webob.Request.blank('/v1.1/flavors/12')
+        req.environ['api.version'] = '1.1'
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
+        flavor = json.loads(res.body)["flavor"]
+        expected = {
+            "id": "12",
+            "name": "flavor 12",
+            "ram": "256",
+            "disk": "10",
+            "links": [
+                {
+                    "rel": "self",
+                    "href": "http://localhost/v1.1/flavors/12",
+                },
+            ],
+        }
+        self.assertEqual(flavor, expected)
+
+    def test_get_flavor_list_v1_1(self):
+        req = webob.Request.blank('/v1.1/flavors')
+        req.environ['api.version'] = '1.1'
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
+        flavor = json.loads(res.body)["flavors"]
+        expected = [
+            {
+                "id": "1",
+                "name": "flavor 1",
+                "links": [
+                    {
+                        "rel": "self",
+                        "href": "http://localhost/v1.1/flavors/1",
+                    },
+                ],
+            },
+            {
+                "id": "2",
+                "name": "flavor 2",
+                "links": [
+                    {
+                        "rel": "self",
+                        "href": "http://localhost/v1.1/flavors/2",
+                    },
+                ],
+            },
+        ]
+        self.assertEqual(flavor, expected)    
+
+    def test_get_flavor_list_detail_v1_1(self):
+        req = webob.Request.blank('/v1.1/flavors/detail')
+        req.environ['api.version'] = '1.1'
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
+        flavor = json.loads(res.body)["flavors"]
+        expected = [
+            {
+                "id": "1",
+                "name": "flavor 1",
+                "ram": "256",
+                "disk": "10",
+                "links": [
+                    {
+                        "rel": "self",
+                        "href": "http://localhost/v1.1/flavors/1",
+                    },
+                ],
+            },
+            {
+                "id": "2",
+                "name": "flavor 2",
+                "ram": "256",
+                "disk": "10",
+                "links": [
+                    {
+                        "rel": "self",
+                        "href": "http://localhost/v1.1/flavors/2",
+                    },
+                ],
+            },
+        ]
+        self.assertEqual(flavor, expected)
-- 
cgit 


From 007c2802e542bf954f0aa5b589f2adc3a1bfa89a Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
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')

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 bb606c7ba42fc567f2e9989e0f560783743e5ddd Mon Sep 17 00:00:00 2001
From: Brian Waldon <brian.waldon@rackspace.com>
Date: Wed, 16 Mar 2011 16:58:38 -0400
Subject: adding bookmarks links to 1.1 flavor entities

---
 nova/api/openstack/views/flavors.py      | 13 ++++++++-
 nova/tests/api/openstack/test_flavors.py | 50 ++++++++++++++++++++++++++++++++
 2 files changed, 62 insertions(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/api/openstack/views/flavors.py b/nova/api/openstack/views/flavors.py
index 19ac8f114..be7e68763 100644
--- a/nova/api/openstack/views/flavors.py
+++ b/nova/api/openstack/views/flavors.py
@@ -76,10 +76,21 @@ class ViewBuilder_1_1(ViewBuilder):
         return flavor_obj
 
     def _build_links(self, flavor_obj):
+        href = self.generate_href(flavor_obj["id"])
         links = [
             {
                 "rel": "self",
-                "href": self.generate_href(flavor_obj["id"]),
+                "href": href,
+            },
+            {
+                "rel": "bookmark",
+                "type": "application/json",
+                "href": href,
+            },
+            {
+                "rel": "bookmark",
+                "type": "application/xml",
+                "href": href,
             },
         ]
         return links
diff --git a/nova/tests/api/openstack/test_flavors.py b/nova/tests/api/openstack/test_flavors.py
index 197e907c4..8dfcfe293 100644
--- a/nova/tests/api/openstack/test_flavors.py
+++ b/nova/tests/api/openstack/test_flavors.py
@@ -143,6 +143,16 @@ class FlavorsTest(test.TestCase):
                     "rel": "self",
                     "href": "http://localhost/v1.1/flavors/12",
                 },
+                {
+                    "rel": "bookmark",
+                    "type": "application/json",
+                    "href": "http://localhost/v1.1/flavors/12",
+                },
+                {
+                    "rel": "bookmark",
+                    "type": "application/xml",
+                    "href": "http://localhost/v1.1/flavors/12",
+                },
             ],
         }
         self.assertEqual(flavor, expected)
@@ -162,6 +172,16 @@ class FlavorsTest(test.TestCase):
                         "rel": "self",
                         "href": "http://localhost/v1.1/flavors/1",
                     },
+                    {
+                        "rel": "bookmark",
+                        "type": "application/json",
+                        "href": "http://localhost/v1.1/flavors/1",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "type": "application/xml",
+                        "href": "http://localhost/v1.1/flavors/1",
+                    },
                 ],
             },
             {
@@ -172,6 +192,16 @@ class FlavorsTest(test.TestCase):
                         "rel": "self",
                         "href": "http://localhost/v1.1/flavors/2",
                     },
+                    {
+                        "rel": "bookmark",
+                        "type": "application/json",
+                        "href": "http://localhost/v1.1/flavors/2",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "type": "application/xml",
+                        "href": "http://localhost/v1.1/flavors/2",
+                    },
                 ],
             },
         ]
@@ -194,6 +224,16 @@ class FlavorsTest(test.TestCase):
                         "rel": "self",
                         "href": "http://localhost/v1.1/flavors/1",
                     },
+                    {
+                        "rel": "bookmark",
+                        "type": "application/json",
+                        "href": "http://localhost/v1.1/flavors/1",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "type": "application/xml",
+                        "href": "http://localhost/v1.1/flavors/1",
+                    },
                 ],
             },
             {
@@ -206,6 +246,16 @@ class FlavorsTest(test.TestCase):
                         "rel": "self",
                         "href": "http://localhost/v1.1/flavors/2",
                     },
+                    {
+                        "rel": "bookmark",
+                        "type": "application/json",
+                        "href": "http://localhost/v1.1/flavors/2",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "type": "application/xml",
+                        "href": "http://localhost/v1.1/flavors/2",
+                    },
                 ],
             },
         ]
-- 
cgit 


From d95187aaf144cb40558f48d584a6bb8e07c6937d Mon Sep 17 00:00:00 2001
From: Tushar Patil <tushar.vitthal.patil@gmail.com>
Date: Wed, 16 Mar 2011 14:13:57 -0700
Subject: converted new lines from CRLF to LF

---
 .../versions/012_add_ipv6_flatmanager.py           | 302 +++++++++----------
 nova/tests/network/__init__.py                     |  94 +++---
 nova/tests/network/base.py                         | 308 ++++++++++----------
 nova/tests/test_flat_network.py                    | 322 ++++++++++-----------
 4 files changed, 513 insertions(+), 513 deletions(-)

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/migrate_repo/versions/012_add_ipv6_flatmanager.py b/nova/db/sqlalchemy/migrate_repo/versions/012_add_ipv6_flatmanager.py
index 9f98f436f..5f5e3d007 100644
--- a/nova/db/sqlalchemy/migrate_repo/versions/012_add_ipv6_flatmanager.py
+++ b/nova/db/sqlalchemy/migrate_repo/versions/012_add_ipv6_flatmanager.py
@@ -1,151 +1,151 @@
-# Copyright 2010 OpenStack LLC.
-# 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.
-
-from sqlalchemy import *
-from migrate import *
-
-from nova import log as logging
-
-
-meta = MetaData()
-
-
-# Table stub-definitions
-# Just for the ForeignKey and column creation to succeed, these are not the
-# actual definitions of instances or services.
-#
-
-#
-# Tables to alter
-#
-networks = Table('networks', meta,
-        Column('created_at', DateTime(timezone=False)),
-        Column('updated_at', DateTime(timezone=False)),
-        Column('deleted_at', DateTime(timezone=False)),
-        Column('deleted', Boolean(create_constraint=True, name=None)),
-        Column('id', Integer(),  primary_key=True, nullable=False),
-        Column('injected', Boolean(create_constraint=True, name=None)),
-        Column('cidr',
-               String(length=255, convert_unicode=False, assert_unicode=None,
-                      unicode_error=None, _warn_on_bytestring=False)),
-        Column('netmask',
-               String(length=255, convert_unicode=False, assert_unicode=None,
-                      unicode_error=None, _warn_on_bytestring=False)),
-        Column('bridge',
-               String(length=255, convert_unicode=False, assert_unicode=None,
-                      unicode_error=None, _warn_on_bytestring=False)),
-        Column('gateway',
-               String(length=255, convert_unicode=False, assert_unicode=None,
-                      unicode_error=None, _warn_on_bytestring=False)),
-        Column('broadcast',
-               String(length=255, convert_unicode=False, assert_unicode=None,
-                      unicode_error=None, _warn_on_bytestring=False)),
-        Column('dns',
-               String(length=255, convert_unicode=False, assert_unicode=None,
-                      unicode_error=None, _warn_on_bytestring=False)),
-        Column('vlan', Integer()),
-        Column('vpn_public_address',
-               String(length=255, convert_unicode=False, assert_unicode=None,
-                      unicode_error=None, _warn_on_bytestring=False)),
-        Column('vpn_public_port', Integer()),
-        Column('vpn_private_address',
-               String(length=255, convert_unicode=False, assert_unicode=None,
-                      unicode_error=None, _warn_on_bytestring=False)),
-        Column('dhcp_start',
-               String(length=255, convert_unicode=False, assert_unicode=None,
-                      unicode_error=None, _warn_on_bytestring=False)),
-        Column('project_id',
-               String(length=255, convert_unicode=False, assert_unicode=None,
-                      unicode_error=None, _warn_on_bytestring=False)),
-        Column('host',
-               String(length=255, convert_unicode=False, assert_unicode=None,
-                      unicode_error=None, _warn_on_bytestring=False)),
-        Column('cidr_v6',
-        String(length=255, convert_unicode=False, assert_unicode=None,
-               unicode_error=None, _warn_on_bytestring=False)),
-        Column('ra_server', String(length=255,
-                                   convert_unicode=False,
-                                   assert_unicode=None,
-                                   unicode_error=None,
-                                   _warn_on_bytestring=False)),
-        Column(
-        'label',
-        String(length=255, convert_unicode=False, assert_unicode=None,
-               unicode_error=None, _warn_on_bytestring=False)))
-
-fixed_ips = Table('fixed_ips', meta,
-        Column('created_at', DateTime(timezone=False)),
-        Column('updated_at', DateTime(timezone=False)),
-        Column('deleted_at', DateTime(timezone=False)),
-        Column('deleted', Boolean(create_constraint=True, name=None)),
-        Column('id', Integer(),  primary_key=True, nullable=False),
-        Column('address',
-               String(length=255, convert_unicode=False, assert_unicode=None,
-                      unicode_error=None, _warn_on_bytestring=False)),
-        Column('network_id',
-               Integer(),
-               ForeignKey('networks.id'),
-               nullable=True),
-        Column('instance_id',
-               Integer(),
-               ForeignKey('instances.id'),
-               nullable=True),
-        Column('allocated', Boolean(create_constraint=True, name=None)),
-        Column('leased', Boolean(create_constraint=True, name=None)),
-        Column('reserved', Boolean(create_constraint=True, name=None)),
-        Column("addressV6", String(length=255,
-                                   convert_unicode=False,
-                                   assert_unicode=None,
-                                   unicode_error=None,
-                                   _warn_on_bytestring=False)),
-        Column("netmaskV6", String(length=3,
-                                   convert_unicode=False,
-                                   assert_unicode=None,
-                                   unicode_error=None,
-                                   _warn_on_bytestring=False)),
-        Column("gatewayV6", String(length=255,
-                                   convert_unicode=False,
-                                   assert_unicode=None,
-                                   unicode_error=None,
-                                   _warn_on_bytestring=False)),
-        )
-#
-# New Tables
-#
-# None
-
-#
-# Columns to add to existing tables
-#
-networks_netmask_v6 = Column(
-        'netmask_v6',
-        String(length=255, convert_unicode=False, assert_unicode=None,
-               unicode_error=None, _warn_on_bytestring=False))
-
-
-def upgrade(migrate_engine):
-    # Upgrade operations go here. Don't create your own engine;
-    # bind migrate_engine to your metadata
-    meta.bind = migrate_engine
-
-    # Alter column name
-    networks.c.ra_server.alter(name='gateway_v6')
-    # Add new column to existing table
-    networks.create_column(networks_netmask_v6)
-
-    # drop existing columns from table
-    fixed_ips.c.addressV6.drop()
-    fixed_ips.c.netmaskV6.drop()
-    fixed_ips.c.gatewayV6.drop()
+# Copyright 2010 OpenStack LLC.
+# 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.
+
+from sqlalchemy import *
+from migrate import *
+
+from nova import log as logging
+
+
+meta = MetaData()
+
+
+# Table stub-definitions
+# Just for the ForeignKey and column creation to succeed, these are not the
+# actual definitions of instances or services.
+#
+
+#
+# Tables to alter
+#
+networks = Table('networks', meta,
+        Column('created_at', DateTime(timezone=False)),
+        Column('updated_at', DateTime(timezone=False)),
+        Column('deleted_at', DateTime(timezone=False)),
+        Column('deleted', Boolean(create_constraint=True, name=None)),
+        Column('id', Integer(),  primary_key=True, nullable=False),
+        Column('injected', Boolean(create_constraint=True, name=None)),
+        Column('cidr',
+               String(length=255, convert_unicode=False, assert_unicode=None,
+                      unicode_error=None, _warn_on_bytestring=False)),
+        Column('netmask',
+               String(length=255, convert_unicode=False, assert_unicode=None,
+                      unicode_error=None, _warn_on_bytestring=False)),
+        Column('bridge',
+               String(length=255, convert_unicode=False, assert_unicode=None,
+                      unicode_error=None, _warn_on_bytestring=False)),
+        Column('gateway',
+               String(length=255, convert_unicode=False, assert_unicode=None,
+                      unicode_error=None, _warn_on_bytestring=False)),
+        Column('broadcast',
+               String(length=255, convert_unicode=False, assert_unicode=None,
+                      unicode_error=None, _warn_on_bytestring=False)),
+        Column('dns',
+               String(length=255, convert_unicode=False, assert_unicode=None,
+                      unicode_error=None, _warn_on_bytestring=False)),
+        Column('vlan', Integer()),
+        Column('vpn_public_address',
+               String(length=255, convert_unicode=False, assert_unicode=None,
+                      unicode_error=None, _warn_on_bytestring=False)),
+        Column('vpn_public_port', Integer()),
+        Column('vpn_private_address',
+               String(length=255, convert_unicode=False, assert_unicode=None,
+                      unicode_error=None, _warn_on_bytestring=False)),
+        Column('dhcp_start',
+               String(length=255, convert_unicode=False, assert_unicode=None,
+                      unicode_error=None, _warn_on_bytestring=False)),
+        Column('project_id',
+               String(length=255, convert_unicode=False, assert_unicode=None,
+                      unicode_error=None, _warn_on_bytestring=False)),
+        Column('host',
+               String(length=255, convert_unicode=False, assert_unicode=None,
+                      unicode_error=None, _warn_on_bytestring=False)),
+        Column('cidr_v6',
+        String(length=255, convert_unicode=False, assert_unicode=None,
+               unicode_error=None, _warn_on_bytestring=False)),
+        Column('ra_server', String(length=255,
+                                   convert_unicode=False,
+                                   assert_unicode=None,
+                                   unicode_error=None,
+                                   _warn_on_bytestring=False)),
+        Column(
+        'label',
+        String(length=255, convert_unicode=False, assert_unicode=None,
+               unicode_error=None, _warn_on_bytestring=False)))
+
+fixed_ips = Table('fixed_ips', meta,
+        Column('created_at', DateTime(timezone=False)),
+        Column('updated_at', DateTime(timezone=False)),
+        Column('deleted_at', DateTime(timezone=False)),
+        Column('deleted', Boolean(create_constraint=True, name=None)),
+        Column('id', Integer(),  primary_key=True, nullable=False),
+        Column('address',
+               String(length=255, convert_unicode=False, assert_unicode=None,
+                      unicode_error=None, _warn_on_bytestring=False)),
+        Column('network_id',
+               Integer(),
+               ForeignKey('networks.id'),
+               nullable=True),
+        Column('instance_id',
+               Integer(),
+               ForeignKey('instances.id'),
+               nullable=True),
+        Column('allocated', Boolean(create_constraint=True, name=None)),
+        Column('leased', Boolean(create_constraint=True, name=None)),
+        Column('reserved', Boolean(create_constraint=True, name=None)),
+        Column("addressV6", String(length=255,
+                                   convert_unicode=False,
+                                   assert_unicode=None,
+                                   unicode_error=None,
+                                   _warn_on_bytestring=False)),
+        Column("netmaskV6", String(length=3,
+                                   convert_unicode=False,
+                                   assert_unicode=None,
+                                   unicode_error=None,
+                                   _warn_on_bytestring=False)),
+        Column("gatewayV6", String(length=255,
+                                   convert_unicode=False,
+                                   assert_unicode=None,
+                                   unicode_error=None,
+                                   _warn_on_bytestring=False)),
+        )
+#
+# New Tables
+#
+# None
+
+#
+# Columns to add to existing tables
+#
+networks_netmask_v6 = Column(
+        'netmask_v6',
+        String(length=255, convert_unicode=False, assert_unicode=None,
+               unicode_error=None, _warn_on_bytestring=False))
+
+
+def upgrade(migrate_engine):
+    # Upgrade operations go here. Don't create your own engine;
+    # bind migrate_engine to your metadata
+    meta.bind = migrate_engine
+
+    # Alter column name
+    networks.c.ra_server.alter(name='gateway_v6')
+    # Add new column to existing table
+    networks.create_column(networks_netmask_v6)
+
+    # drop existing columns from table
+    fixed_ips.c.addressV6.drop()
+    fixed_ips.c.netmaskV6.drop()
+    fixed_ips.c.gatewayV6.drop()
diff --git a/nova/tests/network/__init__.py b/nova/tests/network/__init__.py
index 8f71a30ba..e0d479f8c 100644
--- a/nova/tests/network/__init__.py
+++ b/nova/tests/network/__init__.py
@@ -1,47 +1,47 @@
-import os
-
-from nova import context
-from nova import db
-from nova import flags
-from nova import log as logging
-from nova import utils
-
-FLAGS = flags.FLAGS
-LOG = logging.getLogger('nova.tests.network')
-
-
-def binpath(script):
-    """Returns the absolute path to a script in bin"""
-    return os.path.abspath(os.path.join(__file__, "../../../../bin", script))
-
-
-def lease_ip(private_ip):
-    """Run add command on dhcpbridge"""
-    network_ref = db.fixed_ip_get_network(context.get_admin_context(),
-                                          private_ip)
-    instance_ref = db.fixed_ip_get_instance(context.get_admin_context(),
-                                            private_ip)
-    cmd = (binpath('nova-dhcpbridge'), 'add',
-           instance_ref['mac_address'],
-           private_ip, 'fake')
-    env = {'DNSMASQ_INTERFACE': network_ref['bridge'],
-           'TESTING': '1',
-           'FLAGFILE': FLAGS.dhcpbridge_flagfile}
-    (out, err) = utils.execute(*cmd, addl_env=env)
-    LOG.debug("ISSUE_IP: %s, %s ", out, err)
-
-
-def release_ip(private_ip):
-    """Run del command on dhcpbridge"""
-    network_ref = db.fixed_ip_get_network(context.get_admin_context(),
-                                          private_ip)
-    instance_ref = db.fixed_ip_get_instance(context.get_admin_context(),
-                                            private_ip)
-    cmd = (binpath('nova-dhcpbridge'), 'del',
-           instance_ref['mac_address'],
-           private_ip, 'fake')
-    env = {'DNSMASQ_INTERFACE': network_ref['bridge'],
-           'TESTING': '1',
-           'FLAGFILE': FLAGS.dhcpbridge_flagfile}
-    (out, err) = utils.execute(*cmd, addl_env=env)
-    LOG.debug("RELEASE_IP: %s, %s ", out, err)
+import os
+
+from nova import context
+from nova import db
+from nova import flags
+from nova import log as logging
+from nova import utils
+
+FLAGS = flags.FLAGS
+LOG = logging.getLogger('nova.tests.network')
+
+
+def binpath(script):
+    """Returns the absolute path to a script in bin"""
+    return os.path.abspath(os.path.join(__file__, "../../../../bin", script))
+
+
+def lease_ip(private_ip):
+    """Run add command on dhcpbridge"""
+    network_ref = db.fixed_ip_get_network(context.get_admin_context(),
+                                          private_ip)
+    instance_ref = db.fixed_ip_get_instance(context.get_admin_context(),
+                                            private_ip)
+    cmd = (binpath('nova-dhcpbridge'), 'add',
+           instance_ref['mac_address'],
+           private_ip, 'fake')
+    env = {'DNSMASQ_INTERFACE': network_ref['bridge'],
+           'TESTING': '1',
+           'FLAGFILE': FLAGS.dhcpbridge_flagfile}
+    (out, err) = utils.execute(*cmd, addl_env=env)
+    LOG.debug("ISSUE_IP: %s, %s ", out, err)
+
+
+def release_ip(private_ip):
+    """Run del command on dhcpbridge"""
+    network_ref = db.fixed_ip_get_network(context.get_admin_context(),
+                                          private_ip)
+    instance_ref = db.fixed_ip_get_instance(context.get_admin_context(),
+                                            private_ip)
+    cmd = (binpath('nova-dhcpbridge'), 'del',
+           instance_ref['mac_address'],
+           private_ip, 'fake')
+    env = {'DNSMASQ_INTERFACE': network_ref['bridge'],
+           'TESTING': '1',
+           'FLAGFILE': FLAGS.dhcpbridge_flagfile}
+    (out, err) = utils.execute(*cmd, addl_env=env)
+    LOG.debug("RELEASE_IP: %s, %s ", out, err)
diff --git a/nova/tests/network/base.py b/nova/tests/network/base.py
index 2dd8178ff..988a1de72 100644
--- a/nova/tests/network/base.py
+++ b/nova/tests/network/base.py
@@ -1,154 +1,154 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 United States Government as represented by the
-# Administrator of the National Aeronautics and Space Administration.
-# 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.
-"""
-Base class of Unit Tests for all network models
-"""
-import IPy
-import os
-
-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 test
-from nova import utils
-from nova.auth import manager
-
-FLAGS = flags.FLAGS
-LOG = logging.getLogger('nova.tests.network')
-
-
-class NetworkTestCase(test.TestCase):
-    """Test cases for network code"""
-    def setUp(self):
-        super(NetworkTestCase, self).setUp()
-        # NOTE(vish): if you change these flags, make sure to change the
-        #             flags in the corresponding section in nova-dhcpbridge
-        self.flags(connection_type='fake',
-                   fake_call=True,
-                   fake_network=True)
-        self.manager = manager.AuthManager()
-        self.user = self.manager.create_user('netuser', 'netuser', 'netuser')
-        self.projects = []
-        self.network = utils.import_object(FLAGS.network_manager)
-        self.context = context.RequestContext(project=None, user=self.user)
-        for i in range(FLAGS.num_networks):
-            name = 'project%s' % i
-            project = self.manager.create_project(name, 'netuser', name)
-            self.projects.append(project)
-            # create the necessary network data for the project
-            user_context = context.RequestContext(project=self.projects[i],
-                                                     user=self.user)
-            host = self.network.get_network_host(user_context.elevated())
-        instance_ref = self._create_instance(0)
-        self.instance_id = instance_ref['id']
-        instance_ref = self._create_instance(1)
-        self.instance2_id = instance_ref['id']
-
-    def tearDown(self):
-        # TODO(termie): this should really be instantiating clean datastores
-        #               in between runs, one failure kills all the tests
-        db.instance_destroy(context.get_admin_context(), self.instance_id)
-        db.instance_destroy(context.get_admin_context(), self.instance2_id)
-        for project in self.projects:
-            self.manager.delete_project(project)
-        self.manager.delete_user(self.user)
-        super(NetworkTestCase, self).tearDown()
-
-    def _create_instance(self, project_num, mac=None):
-        if not mac:
-            mac = utils.generate_mac()
-        project = self.projects[project_num]
-        self.context._project = project
-        self.context.project_id = project.id
-        return db.instance_create(self.context,
-                                  {'project_id': project.id,
-                                   'mac_address': mac})
-
-    def _create_address(self, project_num, instance_id=None):
-        """Create an address in given project num"""
-        if instance_id is None:
-            instance_id = self.instance_id
-        self.context._project = self.projects[project_num]
-        self.context.project_id = self.projects[project_num].id
-        return self.network.allocate_fixed_ip(self.context, instance_id)
-
-    def _deallocate_address(self, project_num, address):
-        self.context._project = self.projects[project_num]
-        self.context.project_id = self.projects[project_num].id
-        self.network.deallocate_fixed_ip(self.context, address)
-
-    def _is_allocated_in_project(self, address, project_id):
-        """Returns true if address is in specified project"""
-        project_net = db.network_get_by_bridge(context.get_admin_context(),
-                                           FLAGS.flat_network_bridge)
-        network = db.fixed_ip_get_network(context.get_admin_context(),
-                                          address)
-        instance = db.fixed_ip_get_instance(context.get_admin_context(),
-                                            address)
-        # instance exists until release
-        return instance is not None and network['id'] == project_net['id']
-
-    def test_private_ipv6(self):
-        """Make sure ipv6 is OK"""
-        if FLAGS.use_ipv6:
-            instance_ref = self._create_instance(0)
-            address = self._create_address(0, instance_ref['id'])
-            network_ref = db.project_get_network(
-                                                 context.get_admin_context(),
-                                                 self.context.project_id)
-            address_v6 = db.instance_get_fixed_address_v6(
-                                                 context.get_admin_context(),
-                                                 instance_ref['id'])
-            self.assertEqual(instance_ref['mac_address'],
-                             utils.to_mac(address_v6))
-            instance_ref2 = db.fixed_ip_get_instance_v6(
-                                                 context.get_admin_context(),
-                                                 address_v6)
-            self.assertEqual(instance_ref['id'], instance_ref2['id'])
-            self.assertEqual(address_v6,
-                             utils.to_global_ipv6(
-                                                 network_ref['cidr_v6'],
-                                                 instance_ref['mac_address']))
-            self._deallocate_address(0, address)
-            db.instance_destroy(context.get_admin_context(),
-                                instance_ref['id'])
-
-    def test_available_ips(self):
-        """Make sure the number of available ips for the network is correct
-
-        The number of available IP addresses depends on the test
-        environment's setup.
-
-        Network size is set in test fixture's setUp method.
-
-        There are ips reserved at the bottom and top of the range.
-        services (network, gateway, CloudPipe, broadcast)
-        """
-        network = db.project_get_network(context.get_admin_context(),
-                                         self.projects[0].id)
-        net_size = flags.FLAGS.network_size
-        admin_context = context.get_admin_context()
-        total_ips = (db.network_count_available_ips(admin_context,
-                                                    network['id']) +
-                     db.network_count_reserved_ips(admin_context,
-                                                   network['id']) +
-                     db.network_count_allocated_ips(admin_context,
-                                                    network['id']))
-        self.assertEqual(total_ips, net_size)
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# 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.
+"""
+Base class of Unit Tests for all network models
+"""
+import IPy
+import os
+
+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 test
+from nova import utils
+from nova.auth import manager
+
+FLAGS = flags.FLAGS
+LOG = logging.getLogger('nova.tests.network')
+
+
+class NetworkTestCase(test.TestCase):
+    """Test cases for network code"""
+    def setUp(self):
+        super(NetworkTestCase, self).setUp()
+        # NOTE(vish): if you change these flags, make sure to change the
+        #             flags in the corresponding section in nova-dhcpbridge
+        self.flags(connection_type='fake',
+                   fake_call=True,
+                   fake_network=True)
+        self.manager = manager.AuthManager()
+        self.user = self.manager.create_user('netuser', 'netuser', 'netuser')
+        self.projects = []
+        self.network = utils.import_object(FLAGS.network_manager)
+        self.context = context.RequestContext(project=None, user=self.user)
+        for i in range(FLAGS.num_networks):
+            name = 'project%s' % i
+            project = self.manager.create_project(name, 'netuser', name)
+            self.projects.append(project)
+            # create the necessary network data for the project
+            user_context = context.RequestContext(project=self.projects[i],
+                                                     user=self.user)
+            host = self.network.get_network_host(user_context.elevated())
+        instance_ref = self._create_instance(0)
+        self.instance_id = instance_ref['id']
+        instance_ref = self._create_instance(1)
+        self.instance2_id = instance_ref['id']
+
+    def tearDown(self):
+        # TODO(termie): this should really be instantiating clean datastores
+        #               in between runs, one failure kills all the tests
+        db.instance_destroy(context.get_admin_context(), self.instance_id)
+        db.instance_destroy(context.get_admin_context(), self.instance2_id)
+        for project in self.projects:
+            self.manager.delete_project(project)
+        self.manager.delete_user(self.user)
+        super(NetworkTestCase, self).tearDown()
+
+    def _create_instance(self, project_num, mac=None):
+        if not mac:
+            mac = utils.generate_mac()
+        project = self.projects[project_num]
+        self.context._project = project
+        self.context.project_id = project.id
+        return db.instance_create(self.context,
+                                  {'project_id': project.id,
+                                   'mac_address': mac})
+
+    def _create_address(self, project_num, instance_id=None):
+        """Create an address in given project num"""
+        if instance_id is None:
+            instance_id = self.instance_id
+        self.context._project = self.projects[project_num]
+        self.context.project_id = self.projects[project_num].id
+        return self.network.allocate_fixed_ip(self.context, instance_id)
+
+    def _deallocate_address(self, project_num, address):
+        self.context._project = self.projects[project_num]
+        self.context.project_id = self.projects[project_num].id
+        self.network.deallocate_fixed_ip(self.context, address)
+
+    def _is_allocated_in_project(self, address, project_id):
+        """Returns true if address is in specified project"""
+        project_net = db.network_get_by_bridge(context.get_admin_context(),
+                                           FLAGS.flat_network_bridge)
+        network = db.fixed_ip_get_network(context.get_admin_context(),
+                                          address)
+        instance = db.fixed_ip_get_instance(context.get_admin_context(),
+                                            address)
+        # instance exists until release
+        return instance is not None and network['id'] == project_net['id']
+
+    def test_private_ipv6(self):
+        """Make sure ipv6 is OK"""
+        if FLAGS.use_ipv6:
+            instance_ref = self._create_instance(0)
+            address = self._create_address(0, instance_ref['id'])
+            network_ref = db.project_get_network(
+                                                 context.get_admin_context(),
+                                                 self.context.project_id)
+            address_v6 = db.instance_get_fixed_address_v6(
+                                                 context.get_admin_context(),
+                                                 instance_ref['id'])
+            self.assertEqual(instance_ref['mac_address'],
+                             utils.to_mac(address_v6))
+            instance_ref2 = db.fixed_ip_get_instance_v6(
+                                                 context.get_admin_context(),
+                                                 address_v6)
+            self.assertEqual(instance_ref['id'], instance_ref2['id'])
+            self.assertEqual(address_v6,
+                             utils.to_global_ipv6(
+                                                 network_ref['cidr_v6'],
+                                                 instance_ref['mac_address']))
+            self._deallocate_address(0, address)
+            db.instance_destroy(context.get_admin_context(),
+                                instance_ref['id'])
+
+    def test_available_ips(self):
+        """Make sure the number of available ips for the network is correct
+
+        The number of available IP addresses depends on the test
+        environment's setup.
+
+        Network size is set in test fixture's setUp method.
+
+        There are ips reserved at the bottom and top of the range.
+        services (network, gateway, CloudPipe, broadcast)
+        """
+        network = db.project_get_network(context.get_admin_context(),
+                                         self.projects[0].id)
+        net_size = flags.FLAGS.network_size
+        admin_context = context.get_admin_context()
+        total_ips = (db.network_count_available_ips(admin_context,
+                                                    network['id']) +
+                     db.network_count_reserved_ips(admin_context,
+                                                   network['id']) +
+                     db.network_count_allocated_ips(admin_context,
+                                                    network['id']))
+        self.assertEqual(total_ips, net_size)
diff --git a/nova/tests/test_flat_network.py b/nova/tests/test_flat_network.py
index b6f7762c5..dcc617e25 100644
--- a/nova/tests/test_flat_network.py
+++ b/nova/tests/test_flat_network.py
@@ -1,161 +1,161 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 United States Government as represented by the
-# Administrator of the National Aeronautics and Space Administration.
-# 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.
-"""
-Unit Tests for flat network code
-"""
-import IPy
-import os
-import unittest
-
-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 test
-from nova import utils
-from nova.auth import manager
-from nova.tests.network import base
-
-
-FLAGS = flags.FLAGS
-LOG = logging.getLogger('nova.tests.network')
-
-
-class FlatNetworkTestCase(base.NetworkTestCase):
-    """Test cases for network code"""
-    def test_public_network_association(self):
-        """Makes sure that we can allocate a public ip"""
-        # TODO(vish): better way of adding floating ips
-
-        self.context._project = self.projects[0]
-        self.context.project_id = self.projects[0].id
-        pubnet = IPy.IP(flags.FLAGS.floating_range)
-        address = str(pubnet[0])
-        try:
-            db.floating_ip_get_by_address(context.get_admin_context(), address)
-        except exception.NotFound:
-            db.floating_ip_create(context.get_admin_context(),
-                                  {'address': address,
-                                   'host': FLAGS.host})
-
-        self.assertRaises(NotImplementedError,
-                          self.network.allocate_floating_ip,
-                          self.context, self.projects[0].id)
-
-        fix_addr = self._create_address(0)
-        float_addr = address
-        self.assertRaises(NotImplementedError,
-                          self.network.associate_floating_ip,
-                          self.context, float_addr, fix_addr)
-
-        address = db.instance_get_floating_address(context.get_admin_context(),
-                                                   self.instance_id)
-        self.assertEqual(address, None)
-
-        self.assertRaises(NotImplementedError,
-                          self.network.disassociate_floating_ip,
-                          self.context, float_addr)
-
-        address = db.instance_get_floating_address(context.get_admin_context(),
-                                                   self.instance_id)
-        self.assertEqual(address, None)
-
-        self.assertRaises(NotImplementedError,
-                          self.network.deallocate_floating_ip,
-                          self.context, float_addr)
-
-        self.network.deallocate_fixed_ip(self.context, fix_addr)
-        db.floating_ip_destroy(context.get_admin_context(), float_addr)
-
-    def test_allocate_deallocate_fixed_ip(self):
-        """Makes sure that we can allocate and deallocate a fixed ip"""
-        address = self._create_address(0)
-        self.assertTrue(self._is_allocated_in_project(address,
-                                                      self.projects[0].id))
-        self._deallocate_address(0, address)
-
-        # check if the fixed ip address is really deallocated
-        self.assertFalse(self._is_allocated_in_project(address,
-                                                       self.projects[0].id))
-
-    def test_side_effects(self):
-        """Ensures allocating and releasing has no side effects"""
-        address = self._create_address(0)
-        address2 = self._create_address(1, self.instance2_id)
-
-        self.assertTrue(self._is_allocated_in_project(address,
-                                                      self.projects[0].id))
-        self.assertTrue(self._is_allocated_in_project(address2,
-                                                      self.projects[1].id))
-
-        self._deallocate_address(0, address)
-        self.assertFalse(self._is_allocated_in_project(address,
-                                                       self.projects[0].id))
-
-        # First address release shouldn't affect the second
-        self.assertTrue(self._is_allocated_in_project(address2,
-                                                      self.projects[0].id))
-
-        self._deallocate_address(1, address2)
-        self.assertFalse(self._is_allocated_in_project(address2,
-                                                 self.projects[1].id))
-
-    def test_ips_are_reused(self):
-        """Makes sure that ip addresses that are deallocated get reused"""
-        address = self._create_address(0)
-        self.network.deallocate_fixed_ip(self.context, address)
-
-        address2 = self._create_address(0)
-        self.assertEqual(address, address2)
-
-        self.network.deallocate_fixed_ip(self.context, address2)
-
-    def test_too_many_addresses(self):
-        """Test for a NoMoreAddresses exception when all fixed ips are used.
-        """
-        admin_context = context.get_admin_context()
-        network = db.project_get_network(admin_context, self.projects[0].id)
-        num_available_ips = db.network_count_available_ips(admin_context,
-                                                           network['id'])
-        addresses = []
-        instance_ids = []
-        for i in range(num_available_ips):
-            instance_ref = self._create_instance(0)
-            instance_ids.append(instance_ref['id'])
-            address = self._create_address(0, instance_ref['id'])
-            addresses.append(address)
-
-        ip_count = db.network_count_available_ips(context.get_admin_context(),
-                                                  network['id'])
-        self.assertEqual(ip_count, 0)
-        self.assertRaises(db.NoMoreAddresses,
-                          self.network.allocate_fixed_ip,
-                          self.context,
-                          'foo')
-
-        for i in range(num_available_ips):
-            self.network.deallocate_fixed_ip(self.context, addresses[i])
-            db.instance_destroy(context.get_admin_context(), instance_ids[i])
-        ip_count = db.network_count_available_ips(context.get_admin_context(),
-                                                  network['id'])
-        self.assertEqual(ip_count, num_available_ips)
-
-    def run(self, result=None):
-        if(FLAGS.network_manager == 'nova.network.manager.FlatManager'):
-            super(FlatNetworkTestCase, self).run(result)
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# 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.
+"""
+Unit Tests for flat network code
+"""
+import IPy
+import os
+import unittest
+
+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 test
+from nova import utils
+from nova.auth import manager
+from nova.tests.network import base
+
+
+FLAGS = flags.FLAGS
+LOG = logging.getLogger('nova.tests.network')
+
+
+class FlatNetworkTestCase(base.NetworkTestCase):
+    """Test cases for network code"""
+    def test_public_network_association(self):
+        """Makes sure that we can allocate a public ip"""
+        # TODO(vish): better way of adding floating ips
+
+        self.context._project = self.projects[0]
+        self.context.project_id = self.projects[0].id
+        pubnet = IPy.IP(flags.FLAGS.floating_range)
+        address = str(pubnet[0])
+        try:
+            db.floating_ip_get_by_address(context.get_admin_context(), address)
+        except exception.NotFound:
+            db.floating_ip_create(context.get_admin_context(),
+                                  {'address': address,
+                                   'host': FLAGS.host})
+
+        self.assertRaises(NotImplementedError,
+                          self.network.allocate_floating_ip,
+                          self.context, self.projects[0].id)
+
+        fix_addr = self._create_address(0)
+        float_addr = address
+        self.assertRaises(NotImplementedError,
+                          self.network.associate_floating_ip,
+                          self.context, float_addr, fix_addr)
+
+        address = db.instance_get_floating_address(context.get_admin_context(),
+                                                   self.instance_id)
+        self.assertEqual(address, None)
+
+        self.assertRaises(NotImplementedError,
+                          self.network.disassociate_floating_ip,
+                          self.context, float_addr)
+
+        address = db.instance_get_floating_address(context.get_admin_context(),
+                                                   self.instance_id)
+        self.assertEqual(address, None)
+
+        self.assertRaises(NotImplementedError,
+                          self.network.deallocate_floating_ip,
+                          self.context, float_addr)
+
+        self.network.deallocate_fixed_ip(self.context, fix_addr)
+        db.floating_ip_destroy(context.get_admin_context(), float_addr)
+
+    def test_allocate_deallocate_fixed_ip(self):
+        """Makes sure that we can allocate and deallocate a fixed ip"""
+        address = self._create_address(0)
+        self.assertTrue(self._is_allocated_in_project(address,
+                                                      self.projects[0].id))
+        self._deallocate_address(0, address)
+
+        # check if the fixed ip address is really deallocated
+        self.assertFalse(self._is_allocated_in_project(address,
+                                                       self.projects[0].id))
+
+    def test_side_effects(self):
+        """Ensures allocating and releasing has no side effects"""
+        address = self._create_address(0)
+        address2 = self._create_address(1, self.instance2_id)
+
+        self.assertTrue(self._is_allocated_in_project(address,
+                                                      self.projects[0].id))
+        self.assertTrue(self._is_allocated_in_project(address2,
+                                                      self.projects[1].id))
+
+        self._deallocate_address(0, address)
+        self.assertFalse(self._is_allocated_in_project(address,
+                                                       self.projects[0].id))
+
+        # First address release shouldn't affect the second
+        self.assertTrue(self._is_allocated_in_project(address2,
+                                                      self.projects[0].id))
+
+        self._deallocate_address(1, address2)
+        self.assertFalse(self._is_allocated_in_project(address2,
+                                                 self.projects[1].id))
+
+    def test_ips_are_reused(self):
+        """Makes sure that ip addresses that are deallocated get reused"""
+        address = self._create_address(0)
+        self.network.deallocate_fixed_ip(self.context, address)
+
+        address2 = self._create_address(0)
+        self.assertEqual(address, address2)
+
+        self.network.deallocate_fixed_ip(self.context, address2)
+
+    def test_too_many_addresses(self):
+        """Test for a NoMoreAddresses exception when all fixed ips are used.
+        """
+        admin_context = context.get_admin_context()
+        network = db.project_get_network(admin_context, self.projects[0].id)
+        num_available_ips = db.network_count_available_ips(admin_context,
+                                                           network['id'])
+        addresses = []
+        instance_ids = []
+        for i in range(num_available_ips):
+            instance_ref = self._create_instance(0)
+            instance_ids.append(instance_ref['id'])
+            address = self._create_address(0, instance_ref['id'])
+            addresses.append(address)
+
+        ip_count = db.network_count_available_ips(context.get_admin_context(),
+                                                  network['id'])
+        self.assertEqual(ip_count, 0)
+        self.assertRaises(db.NoMoreAddresses,
+                          self.network.allocate_fixed_ip,
+                          self.context,
+                          'foo')
+
+        for i in range(num_available_ips):
+            self.network.deallocate_fixed_ip(self.context, addresses[i])
+            db.instance_destroy(context.get_admin_context(), instance_ids[i])
+        ip_count = db.network_count_available_ips(context.get_admin_context(),
+                                                  network['id'])
+        self.assertEqual(ip_count, num_available_ips)
+
+    def run(self, result=None):
+        if(FLAGS.network_manager == 'nova.network.manager.FlatManager'):
+            super(FlatNetworkTestCase, self).run(result)
-- 
cgit 


From 05ccc91bdb3ad47ffecee29d21835ded17f65816 Mon Sep 17 00:00:00 2001
From: Brian Waldon <brian.waldon@rackspace.com>
Date: Wed, 16 Mar 2011 17:24:32 -0400
Subject: pep8

---
 nova/api/openstack/views/flavors.py      | 4 ++--
 nova/tests/api/openstack/test_flavors.py | 3 ++-
 2 files changed, 4 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/views/flavors.py b/nova/api/openstack/views/flavors.py
index be7e68763..7d75c0aa2 100644
--- a/nova/api/openstack/views/flavors.py
+++ b/nova/api/openstack/views/flavors.py
@@ -61,8 +61,8 @@ class ViewBuilder(object):
 
         detail.update(simple)
 
-        return detail 
-    
+        return detail
+
     def _build_extra(self, flavor_obj):
         return flavor_obj
 
diff --git a/nova/tests/api/openstack/test_flavors.py b/nova/tests/api/openstack/test_flavors.py
index 8dfcfe293..954d72adf 100644
--- a/nova/tests/api/openstack/test_flavors.py
+++ b/nova/tests/api/openstack/test_flavors.py
@@ -46,6 +46,7 @@ def return_instance_types(context, num=2):
         instance_types[name] = stub_flavor(i, name)
     return instance_types
 
+
 def return_instance_type_not_found(context, flavorid):
     raise exception.NotFound()
 
@@ -205,7 +206,7 @@ class FlavorsTest(test.TestCase):
                 ],
             },
         ]
-        self.assertEqual(flavor, expected)    
+        self.assertEqual(flavor, expected)
 
     def test_get_flavor_list_detail_v1_1(self):
         req = webob.Request.blank('/v1.1/flavors/detail')
-- 
cgit 


From 0e63a45f40a2069d497878b7c05d00522c3a2774 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
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')

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 <matt.dietz@rackspace.com>
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')

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 cc2d4728d32d016ef803d0def456cac6e315e8fa Mon Sep 17 00:00:00 2001
From: Mark Washenberger <mark.washenberger@rackspace.com>
Date: Wed, 16 Mar 2011 17:56:40 -0400
Subject: get started testing

---
 nova/image/glance.py            |  6 ++++--
 nova/tests/image/__init__.py    |  0
 nova/tests/image/test_glance.py | 18 ++++++++++++++++++
 3 files changed, 22 insertions(+), 2 deletions(-)
 create mode 100644 nova/tests/image/__init__.py
 create mode 100644 nova/tests/image/test_glance.py

(limited to 'nova')

diff --git a/nova/image/glance.py b/nova/image/glance.py
index 15fca69b8..3b448db4b 100644
--- a/nova/image/glance.py
+++ b/nova/image/glance.py
@@ -37,8 +37,10 @@ GlanceClient = utils.import_class('glance.client.Client')
 class GlanceImageService(service.BaseImageService):
     """Provides storage and retrieval of disk image objects within Glance."""
 
-    def __init__(self):
-        self.client = GlanceClient(FLAGS.glance_host, FLAGS.glance_port)
+    def __init__(self, client=None):
+        if client is None:
+            self.client = GlanceClient(FLAGS.glance_host, FLAGS.glance_port)
+        self.client = client
 
     def index(self, context):
         """
diff --git a/nova/tests/image/__init__.py b/nova/tests/image/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/nova/tests/image/test_glance.py b/nova/tests/image/test_glance.py
new file mode 100644
index 000000000..b568f593d
--- /dev/null
+++ b/nova/tests/image/test_glance.py
@@ -0,0 +1,18 @@
+import unittest
+
+from nova.image import glance
+
+class StubGlanceClient(object):
+
+    def __init__(self, images):
+        self._images = images
+
+    def get_image_meta(id):
+        return self._images[id]
+
+class TestGlance(unittest.TestCase):
+
+    def test(self):
+        images = {'xyz': "image"}
+        client = StubGlanceClient(images)
+        service = glance.GlanceImageService(client)
-- 
cgit 


From 8385599f941c5fe886de570b67f5e57e64e96468 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Wed, 16 Mar 2011 16:58:46 -0500
Subject: hurr

---
 nova/db/sqlalchemy/api.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index f4773ce32..84db330ec 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -2206,8 +2206,8 @@ def migration_get_by_instance_and_status(context, instance_id, status):
                      filter_by(instance_id=instance_id).\
                      filter_by(status=status).first()
     if not result:
-        raise exception.NotFound(_("No migration found with instance id %s")
-                % migration_id)
+        raise exception.NotFound(_("No migration found for instance %d")
+                "with status %s" % (instance_id, status))
     return result
 
 
-- 
cgit 


From 524eb966045192dd535648929d70cac091d8e24e Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Wed, 16 Mar 2011 17:00:22 -0500
Subject: hurr

---
 nova/db/sqlalchemy/api.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 84db330ec..7e358e64b 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -2206,8 +2206,8 @@ def migration_get_by_instance_and_status(context, instance_id, status):
                      filter_by(instance_id=instance_id).\
                      filter_by(status=status).first()
     if not result:
-        raise exception.NotFound(_("No migration found for instance %d")
-                "with status %s" % (instance_id, status))
+        raise exception.NotFound(_("No migration found for instance %d"
+                "with status %s" % (instance_id, status)))
     return result
 
 
-- 
cgit 


From adb9c0f0d933f8a56e688b89cfa632ce5c9e4888 Mon Sep 17 00:00:00 2001
From: Trey Morris <trey.morris@rackspace.com>
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')

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 bf2f491f3e7aa5522d306c2182c3d220eb49a55f Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Wed, 16 Mar 2011 17:56:48 -0500
Subject: foo

---
 nova/compute/manager.py   | 5 +++--
 nova/db/sqlalchemy/api.py | 2 +-
 2 files changed, 4 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 351e02f51..e69544b6e 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -458,7 +458,7 @@ class ComputeManager(manager.Manager):
 
         #Just roll back the record. There's no need to resize down since
         #the 'old' VM already has the preferred attributes
-        self.db.instance_update(context,
+        self.db.instance_update(context, instance_id
            dict(memory_mb=instance_type['memory_mb'],
                 vcpus=instance_type['vcpus'],
                 local_gb=instance_type['local_gb']))
@@ -542,7 +542,8 @@ class ComputeManager(manager.Manager):
         instance_type = self.db.instance_type_get_by_flavor_id(context,
                 migration_ref['new_flavor_id'])
         self.db.instance_update(context, instance_id,
-               dict(memory_mb=instance_type['memory_mb'],
+               dict(instance_type=instance_type['name'],
+                    memory_mb=instance_type['memory_mb'],
                     vcpus=instance_type['vcpus'],
                     local_gb=instance_type['local_gb']))
 
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 7e358e64b..47b84af50 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -2206,7 +2206,7 @@ def migration_get_by_instance_and_status(context, instance_id, status):
                      filter_by(instance_id=instance_id).\
                      filter_by(status=status).first()
     if not result:
-        raise exception.NotFound(_("No migration found for instance %d"
+        raise exception.NotFound(_("No migration found for instance %s"
                 "with status %s" % (instance_id, status)))
     return result
 
-- 
cgit 


From 3c0ae08b71c860383c215fa30c36693fd80f34c2 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Wed, 16 Mar 2011 17:58:16 -0500
Subject: foo

---
 nova/compute/manager.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index e69544b6e..3135d5801 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -458,7 +458,7 @@ class ComputeManager(manager.Manager):
 
         #Just roll back the record. There's no need to resize down since
         #the 'old' VM already has the preferred attributes
-        self.db.instance_update(context, instance_id
+        self.db.instance_update(context, instance_id,
            dict(memory_mb=instance_type['memory_mb'],
                 vcpus=instance_type['vcpus'],
                 local_gb=instance_type['local_gb']))
-- 
cgit 


From 703e680aa6d0da1953ec6f8ae3a6aa66dc9fad7e Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Wed, 16 Mar 2011 16:13:24 -0700
Subject: Fix the errors that pylint was reporting on this file

This was meant more as a test of whether pylint was now returning false-positives.  It looks like the bugs it's reporting are at least partially real.
---
 nova/api/openstack/servers.py | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 3ecd4fb01..dfaf35128 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -25,8 +25,9 @@ from nova import compute
 from nova import exception
 from nova import flags
 from nova import log as logging
-from nova import wsgi
+from nova import quota
 from nova import utils
+from nova import wsgi
 from nova.api.openstack import common
 from nova.api.openstack import faults
 from nova.auth import manager as auth_manager
@@ -188,7 +189,7 @@ class Controller(wsgi.Controller):
                 key_data=key_data,
                 metadata=metadata,
                 injected_files=injected_files)
-        except QuotaError as error:
+        except quota.QuotaError as error:
             self._handle_quota_error(error)
 
         server = _translate_keys(instances[0])
@@ -238,7 +239,7 @@ class Controller(wsgi.Controller):
             injected_files.append((path, contents))
         return injected_files
 
-    def _handle_quota_errors(self, error):
+    def _handle_quota_error(self, error):
         """
         Reraise quota errors as api-specific http exceptions
         """
-- 
cgit 


From 038d99d9fa4354bd617adfa332d69a87a9f7918e Mon Sep 17 00:00:00 2001
From: Trey Morris <trey.morris@rackspace.com>
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')

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 a1e2959312b51757653447de3e8c9e92029da6fd Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Wed, 16 Mar 2011 16:23:31 -0700
Subject: Fix a few of the more obvious non-errors while we're in here

---
 nova/api/openstack/servers.py | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index dfaf35128..42cf693de 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -15,11 +15,10 @@
 
 import base64
 import hashlib
-import json
 import traceback
-from xml.dom import minidom
 
 from webob import exc
+from xml.dom import minidom
 
 from nova import compute
 from nova import exception
@@ -33,7 +32,6 @@ from nova.api.openstack import faults
 from nova.auth import manager as auth_manager
 from nova.compute import instance_types
 from nova.compute import power_state
-import nova.api.openstack
 
 
 LOG = logging.getLogger('server')
@@ -270,7 +268,7 @@ class Controller(wsgi.Controller):
             update_dict['admin_pass'] = inst_dict['server']['adminPass']
             try:
                 self.compute_api.set_admin_password(ctxt, id)
-            except exception.TimeoutException, e:
+            except exception.TimeoutException:
                 return exc.HTTPRequestTimeout()
         if 'name' in inst_dict['server']:
             update_dict['display_name'] = inst_dict['server']['name']
-- 
cgit 


From c9158dfcf4efd2cf22df9aed7b1bb01e037e8eb2 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Wed, 16 Mar 2011 19:04:27 -0700
Subject: moved scheduler API check into db.api decorator

---
 nova/api/zone_redirect.py |  5 ++++-
 nova/compute/api.py       | 10 ++--------
 nova/compute/manager.py   |  5 +----
 nova/db/api.py            | 35 ++++++++++++++++++++++++++++++++++-
 nova/exception.py         |  4 +++-
 nova/scheduler/api.py     | 23 ++++++-----------------
 6 files changed, 50 insertions(+), 32 deletions(-)

(limited to 'nova')

diff --git a/nova/api/zone_redirect.py b/nova/api/zone_redirect.py
index 0adf94046..4fe255c99 100644
--- a/nova/api/zone_redirect.py
+++ b/nova/api/zone_redirect.py
@@ -43,7 +43,7 @@ LOG = logging.getLogger('server')
 
 
 class RequestForwarder(api.ChildZoneHelper):
-
+    """Worker for sending an OpenStack Request to each child zone."""
     def __init__(self, resource, method, body):
         self.resource = resource
         self.method = method
@@ -98,10 +98,13 @@ class ZoneRedirectMiddleware(wsgi.Middleware):
             scheme, netloc, path, query, frag = \
                                     urlparse.urlsplit(req.path_qs)
             query = urlparse.parse_qsl(query)
+            # Remove any cache busters from old novaclient calls ...
             query = [(key, value) for key, value in query if key != 'fresh']
             query = urllib.urlencode(query)
             url = urlparse.urlunsplit((scheme, netloc, path, query, frag))
 
+            # Strip off the API version, since this is given when the
+            # child zone was added.
             m = re.search('/v\d+\.\d+/(.+)', url)
             resource = m.group(1)
 
diff --git a/nova/compute/api.py b/nova/compute/api.py
index 215257217..f4bfe720c 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -34,7 +34,6 @@ from nova import rpc
 from nova import utils
 from nova import volume
 from nova.compute import instance_types
-from nova.scheduler import api as scheduler
 from nova.db import base
 
 FLAGS = flags.FLAGS
@@ -51,7 +50,7 @@ class API(base.Base):
 
     def __init__(self, image_service=None, network_api=None,
                  volume_api=None, hostname_factory=generate_default_hostname,
-                 scheduler_api=None, **kwargs):
+                 **kwargs):
         if not image_service:
             image_service = utils.import_object(FLAGS.image_service)
         self.image_service = image_service
@@ -61,9 +60,6 @@ class API(base.Base):
         if not volume_api:
             volume_api = volume.API()
         self.volume_api = volume_api
-        if not scheduler_api:
-            scheduler_api = scheduler.API()
-        self.scheduler_api = scheduler_api
         self.hostname_factory = hostname_factory
         super(API, self).__init__(**kwargs)
 
@@ -347,8 +343,7 @@ class API(base.Base):
 
     def get(self, context, instance_id):
         """Get a single instance with the given ID."""
-        rv = self.scheduler_api.get_instance_or_reroute(context, instance_id)
-        #rv = self.db.instance_get(context, instance_id)
+        rv = self.db.instance_get(context, instance_id)
         return dict(rv.iteritems())
 
     def get_all(self, context, project_id=None, reservation_id=None,
@@ -513,7 +508,6 @@ class API(base.Base):
 
     def get_ajax_console(self, context, instance_id):
         """Get a url to an AJAX Console"""
-        instance = self.get(context, instance_id)
         output = self._call_compute_message('get_ajax_console',
                                             context,
                                             instance_id)
diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 499b212e2..ce60c6b43 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -48,7 +48,6 @@ from nova import scheduler_manager
 from nova import rpc
 from nova import utils
 from nova.compute import power_state
-from nova.scheduler import api as scheduler_api
 
 FLAGS = flags.FLAGS
 flags.DEFINE_string('instances_path', '$state_path/instances',
@@ -523,9 +522,7 @@ class ComputeManager(scheduler_manager.SchedulerDependentManager):
         """Pause an instance on this server."""
         context = context.elevated()
         LOG.debug(_('*** instance %s: starting pause'), instance_id)
-        instance_ref = scheduler_api.get_instance_or_reroute(context,
-                                            instance_id)
-        #instance_ref = self.db.instance_get(context, instance_id)
+        instance_ref = self.db.instance_get(context, instance_id)
         LOG.audit(_('instance %s: pausing'), instance_id, context=context)
         self.db.instance_set_state(context,
                                    instance_id,
diff --git a/nova/db/api.py b/nova/db/api.py
index 2ecfc0211..6298e16ad 100644
--- a/nova/db/api.py
+++ b/nova/db/api.py
@@ -34,6 +34,7 @@ The underlying driver is loaded as a :class:`LazyPluggable`.
 
 from nova import exception
 from nova import flags
+from nova import log as logging
 from nova import utils
 
 
@@ -52,6 +53,9 @@ IMPL = utils.LazyPluggable(FLAGS['db_backend'],
                            sqlalchemy='nova.db.sqlalchemy.api')
 
 
+LOG = logging.getLogger('server')
+
+
 class NoMoreAddresses(exception.Error):
     """No more available addresses."""
     pass
@@ -71,6 +75,34 @@ class NoMoreTargets(exception.Error):
     """No more available blades"""
     pass
 
+
+###################
+
+
+def reroute_if_not_found(key_args_index=None):
+    """Decorator used to indicate that the method should throw
+       a RouteRedirectException if the query can't find anything.
+    """
+    def wrap(f):
+        def wrapped_f(*args, **kwargs):
+            try:
+                return f(*args, **kwargs)
+            except exception.InstanceNotFound, e:
+                context = args[0]
+                key = None
+                if key_args_index:
+                    key = args[key_args_index]
+                LOG.debug(_("Instance %(key)s not found locally: '%(e)s'" %
+                                                    locals()))
+
+                # Throw a reroute Exception for the middleware to pick up. 
+                LOG.debug("Firing ZoneRouteException")
+                zones = zone_get_all(context)
+                raise exception.ZoneRouteException(zones, e)
+        return wrapped_f
+    return wrap
+
+
 ###################
 
 
@@ -367,7 +399,8 @@ def instance_destroy(context, instance_id):
     return IMPL.instance_destroy(context, instance_id)
 
 
-def instance_get(context, instance_id):
+@reroute_if_not_found(key_args_index=1)
+def instance_get(context, instance_id, reroute=True):
     """Get an instance or raise if it does not exist."""
     return IMPL.instance_get(context, instance_id)
 
diff --git a/nova/exception.py b/nova/exception.py
index d0baa2e29..cfed32a72 100644
--- a/nova/exception.py
+++ b/nova/exception.py
@@ -93,8 +93,10 @@ class TimeoutException(Error):
 
 
 class ZoneRouteException(Error):
-    def __init__(self, zones, *args, **kwargs):
+    """Thrown in API to reroute request to child zones."""
+    def __init__(self, zones, original_exception, *args, **kwargs):
         self.zones = zones
+        self.original_exception = original_exception
         super(ZoneRouteException, self).__init__(*args, **kwargs)
 
 
diff --git a/nova/scheduler/api.py b/nova/scheduler/api.py
index 073784f31..2da2dabfe 100644
--- a/nova/scheduler/api.py
+++ b/nova/scheduler/api.py
@@ -78,30 +78,16 @@ class API(object):
                                 capabilities=capabilities))
         return rpc.fanout_cast(context, 'scheduler', kwargs)
         
-    @classmethod
-    def get_instance_or_reroute(cls, context, instance_id):
-        """Return an instance from the db or throw a ZoneRouteException
-           if not found."""
-        try:
-            instance = db.instance_get(context, instance_id)
-            return instance
-        except exception.InstanceNotFound, e:
-            LOG.debug(_("Instance %(instance_id)s not found locally: '%(e)s'" %
-                                                locals()))
-
-        # Throw a reroute Exception for the middleware to pick up. 
-        LOG.debug("Firing ZoneRouteException")
-        zones = db.zone_get_all(context)
-        raise exception.ZoneRouteException(zones)
-
 
 def _wrap_method(function, self):
+    """Wrap method to supply 'self'."""
     def _wrap(*args, **kwargs):
         return function(self, *args, **kwargs)
     return _wrap
 
 
 def _process(self, zone):
+    """Worker stub for green thread pool"""
     nova = client.OpenStackClient(zone.username, zone.password,
                                         zone.api_url)
     nova.authenticate()
@@ -114,10 +100,13 @@ class ChildZoneHelper(object):
        plug-ins to query the children."""
 
     def start(self, zone_list):
+        """Spawn a green thread for each child zone, calling the
+        derived classes process() method as the worker. Returns
+        a list of HTTP Responses. 1 per child."""
         self.green_pool = greenpool.GreenPool()
         return [ result for result in self.green_pool.imap(
                         _wrap_method(_process, self), zone_list)]
   
     def process(self, client, zone):
-        """Derived class must override."""
+        """Worker Method. Derived class must override."""
         pass
-- 
cgit 


From a766b4111addad804e47b8be3e6dedb5f80a83c4 Mon Sep 17 00:00:00 2001
From: Monsyne Dragon <mdragon@rackspace.com>
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/api/openstack/servers.py |  3 ++-
 nova/tests/db/fakes.py        | 30 +++++++++++++++++++++++++-----
 nova/tests/test_xenapi.py     |  8 ++++++++
 nova/virt/xenapi/vm_utils.py  |  9 ++++++---
 nova/virt/xenapi/vmops.py     |  9 +++++++--
 5 files changed, 48 insertions(+), 11 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 3ecd4fb01..2f26fa873 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -32,6 +32,7 @@ from nova.api.openstack import faults
 from nova.auth import manager as auth_manager
 from nova.compute import instance_types
 from nova.compute import power_state
+from nova.quota import QuotaError
 import nova.api.openstack
 
 
@@ -189,7 +190,7 @@ class Controller(wsgi.Controller):
                 metadata=metadata,
                 injected_files=injected_files)
         except QuotaError as error:
-            self._handle_quota_error(error)
+            self._handle_quota_errors(error)
 
         server = _translate_keys(instances[0])
         password = "%s%s" % (server['server']['name'][:4],
diff --git a/nova/tests/db/fakes.py b/nova/tests/db/fakes.py
index 5e9a3aa3b..2d25d5fc5 100644
--- a/nova/tests/db/fakes.py
+++ b/nova/tests/db/fakes.py
@@ -28,13 +28,33 @@ def stub_out_db_instance_api(stubs):
     """ Stubs out the db API for creating Instances """
 
     INSTANCE_TYPES = {
-        'm1.tiny': dict(memory_mb=512, vcpus=1, local_gb=0, flavorid=1),
-        'm1.small': dict(memory_mb=2048, vcpus=1, local_gb=20, flavorid=2),
+        'm1.tiny': dict(memory_mb=512,
+                        vcpus=1,
+                        local_gb=0,
+                        flavorid=1,
+                        rxtx_cap=1),
+        'm1.small': dict(memory_mb=2048,
+                         vcpus=1,
+                         local_gb=20,
+                         flavorid=2,
+                         rxtx_cap=2),
         'm1.medium':
-            dict(memory_mb=4096, vcpus=2, local_gb=40, flavorid=3),
-        'm1.large': dict(memory_mb=8192, vcpus=4, local_gb=80, flavorid=4),
+            dict(memory_mb=4096,
+                 vcpus=2,
+                 local_gb=40,
+                 flavorid=3,
+                 rxtx_cap=3),
+        'm1.large': dict(memory_mb=8192,
+                         vcpus=4,
+                         local_gb=80,
+                         flavorid=4,
+                         rxtx_cap=4),
         'm1.xlarge':
-            dict(memory_mb=16384, vcpus=8, local_gb=160, flavorid=5)}
+            dict(memory_mb=16384,
+                 vcpus=8,
+                 local_gb=160,
+                 flavorid=5,
+                 rxtx_cap=5)}
 
     class FakeModel(object):
         """ Stubs out for model """
diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index 8b0affd5c..66a973a78 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -361,6 +361,14 @@ class XenAPIVMTestCase(test.TestCase):
                          glance_stubs.FakeGlance.IMAGE_RAMDISK)
         self.check_vm_params_for_linux_with_external_kernel()
 
+    def test_spawn_with_network_qos(self):
+        self._create_instance()
+        for vif_ref in xenapi_fake.get_all('VIF'):
+            vif_rec = xenapi_fake.get_record('VIF', vif_ref)
+            self.assertEquals(vif_rec['qos_algorithm_type'], 'ratelimit')
+            self.assertEquals(vif_rec['qos_algorithm_params']['kbps'],
+                              str(4 * 1024))
+
     def tearDown(self):
         super(XenAPIVMTestCase, self).tearDown()
         self.manager.delete_project(self.project)
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 cfe77c1236b68aa96dd85503582e08a07a23f77f Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Wed, 16 Mar 2011 19:21:32 -0700
Subject: cleanup

---
 nova/api/openstack/servers.py | 1 -
 nova/compute/manager.py       | 1 -
 nova/db/api.py                | 2 +-
 3 files changed, 1 insertion(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index ffcbe628c..85999764f 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -343,7 +343,6 @@ class Controller(wsgi.Controller):
         """ Permit Admins to Pause the server. """
         ctxt = req.environ['nova.context']
         try:
-            LOG.debug(_("*** Compute.api::pause %s"), id)
             self.compute_api.pause(ctxt, id)
         except:
             readable = traceback.format_exc()
diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index ce60c6b43..ebe1ce6f0 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -521,7 +521,6 @@ class ComputeManager(scheduler_manager.SchedulerDependentManager):
     def pause_instance(self, context, instance_id):
         """Pause an instance on this server."""
         context = context.elevated()
-        LOG.debug(_('*** instance %s: starting pause'), instance_id)
         instance_ref = self.db.instance_get(context, instance_id)
         LOG.audit(_('instance %s: pausing'), instance_id, context=context)
         self.db.instance_set_state(context,
diff --git a/nova/db/api.py b/nova/db/api.py
index 6298e16ad..d56d6f404 100644
--- a/nova/db/api.py
+++ b/nova/db/api.py
@@ -400,7 +400,7 @@ def instance_destroy(context, instance_id):
 
 
 @reroute_if_not_found(key_args_index=1)
-def instance_get(context, instance_id, reroute=True):
+def instance_get(context, instance_id):
     """Get an instance or raise if it does not exist."""
     return IMPL.instance_get(context, instance_id)
 
-- 
cgit 


From 609a912fa8a816c1f47140489dcc1131356cd67c Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Wed, 16 Mar 2011 19:26:54 -0700
Subject: pep8

---
 nova/api/zone_redirect.py | 8 ++++----
 nova/scheduler/api.py     | 8 ++++----
 2 files changed, 8 insertions(+), 8 deletions(-)

(limited to 'nova')

diff --git a/nova/api/zone_redirect.py b/nova/api/zone_redirect.py
index 4fe255c99..7ebae1401 100644
--- a/nova/api/zone_redirect.py
+++ b/nova/api/zone_redirect.py
@@ -48,7 +48,7 @@ class RequestForwarder(api.ChildZoneHelper):
         self.resource = resource
         self.method = method
         self.body = body
-    
+
     def process(self, client, zone):
         api_url = zone.api_url
         LOG.debug(_("Zone redirect to: %(api_url)s, " % locals()))
@@ -89,12 +89,12 @@ class ZoneRedirectMiddleware(wsgi.Middleware):
             return req.get_response(self.application)
         except exception.ZoneRouteException as e:
             if not e.zones:
-                exc = webob.exc.HTTPInternalServerError(explanation=
-                                        _("No zones to reroute to."))
+                exc = webob.exc.HTTPInternalServerError(explanation=_(
+                                            "No zones to reroute to."))
                 return faults.Fault(exc)
 
             # Todo(sandy): This only works for OpenStack API currently.
-            # Needs to be broken out into a driver. 
+            # Needs to be broken out into a driver.
             scheme, netloc, path, query, frag = \
                                     urlparse.urlsplit(req.path_qs)
             query = urlparse.parse_qsl(query)
diff --git a/nova/scheduler/api.py b/nova/scheduler/api.py
index 2da2dabfe..f0b645c09 100644
--- a/nova/scheduler/api.py
+++ b/nova/scheduler/api.py
@@ -77,7 +77,7 @@ class API(object):
                       args=dict(service_name=service_name, host=host,
                                 capabilities=capabilities))
         return rpc.fanout_cast(context, 'scheduler', kwargs)
-        
+
 
 def _wrap_method(function, self):
     """Wrap method to supply 'self'."""
@@ -92,7 +92,7 @@ def _process(self, zone):
                                         zone.api_url)
     nova.authenticate()
     return self.process(nova, zone)
-   
+
 
 class ChildZoneHelper(object):
     """Delegate a call to a set of Child Zones and wait for their
@@ -104,9 +104,9 @@ class ChildZoneHelper(object):
         derived classes process() method as the worker. Returns
         a list of HTTP Responses. 1 per child."""
         self.green_pool = greenpool.GreenPool()
-        return [ result for result in self.green_pool.imap(
+        return [result for result in self.green_pool.imap(
                         _wrap_method(_process, self), zone_list)]
-  
+ 
     def process(self, client, zone):
         """Worker Method. Derived class must override."""
         pass
-- 
cgit 


From 2f72127478405f5d87a40d799cc04e77e744f35b Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Wed, 16 Mar 2011 23:31:06 -0300
Subject: removed dead method

---
 nova/scheduler/api.py | 4 ----
 1 file changed, 4 deletions(-)

(limited to 'nova')

diff --git a/nova/scheduler/api.py b/nova/scheduler/api.py
index 804dade6b..71d211fe9 100644
--- a/nova/scheduler/api.py
+++ b/nova/scheduler/api.py
@@ -49,10 +49,6 @@ def _call_scheduler(method, context, params=None):
 class API(object):
     """API for interacting with the scheduler."""
 
-    @classmethod
-    def _is_current_zone(cls, zone):
-        return True
-
     @classmethod
     def get_zone_list(cls, context):
         """Return a list of zones assoicated with this zone."""
-- 
cgit 


From 82a65107ba3e3df8ec52984bb835b71fe4283b4c Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Wed, 16 Mar 2011 23:33:32 -0300
Subject: fix up copyright

---
 nova/api/zone_redirect.py | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/api/zone_redirect.py b/nova/api/zone_redirect.py
index 7ebae1401..c600b9ab5 100644
--- a/nova/api/zone_redirect.py
+++ b/nova/api/zone_redirect.py
@@ -1,6 +1,4 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 OpenStack LLC.
+# Copyright 2011 OpenStack LLC.
 # All Rights Reserved.
 #
 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
-- 
cgit 


From 11698a131fe6b99bfd91a977a975b07bcd4c2b2b Mon Sep 17 00:00:00 2001
From: Naveed Massjouni <naveedm9@gmail.com>
Date: Thu, 17 Mar 2011 03:21:09 -0400
Subject: Added mechanism for versioned controllers for openstack api versions
 1.0/1.1. Create servers in the 1.1 api now supports imageRef/flavorRef
 instead of imageId/flavorId.

---
 nova/api/openstack/__init__.py           | 29 ++++++++++---
 nova/api/openstack/auth.py               |  2 +-
 nova/api/openstack/common.py             |  1 +
 nova/api/openstack/servers.py            | 64 +++++++++++++++++++++++-----
 nova/api/openstack/views/addresses.py    | 16 +------
 nova/api/openstack/views/flavors.py      | 18 +-------
 nova/api/openstack/views/images.py       | 18 +-------
 nova/api/openstack/views/servers.py      | 49 ++++++++-------------
 nova/tests/api/openstack/fakes.py        | 18 +++++---
 nova/tests/api/openstack/test_auth.py    |  6 +--
 nova/tests/api/openstack/test_servers.py | 73 +++++++++++++++++++++++++++++---
 11 files changed, 179 insertions(+), 115 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/__init__.py b/nova/api/openstack/__init__.py
index 0244bc93c..0b50d17d0 100644
--- a/nova/api/openstack/__init__.py
+++ b/nova/api/openstack/__init__.py
@@ -71,9 +71,14 @@ class APIRouter(wsgi.Router):
         return cls()
 
     def __init__(self):
+        self.server_members = {}
         mapper = routes.Mapper()
+        self._setup_routes(mapper)
+        super(APIRouter, self).__init__(mapper)
 
-        server_members = {'action': 'POST'}
+    def _setup_routes(self, mapper):
+        server_members = self.server_members
+        server_members['action'] = 'POST'
         if FLAGS.allow_admin_api:
             LOG.debug(_("Including admin operations in API."))
 
@@ -98,10 +103,6 @@ class APIRouter(wsgi.Router):
                             controller=accounts.Controller(),
                             collection={'detail': 'GET'})
 
-        mapper.resource("server", "servers", controller=servers.Controller(),
-                        collection={'detail': 'GET'},
-                        member=server_members)
-
         mapper.resource("backup_schedule", "backup_schedule",
                         controller=backup_schedules.Controller(),
                         parent_resource=dict(member_name='server',
@@ -120,7 +121,23 @@ class APIRouter(wsgi.Router):
                         collection={'detail': 'GET'},
                         controller=shared_ip_groups.Controller())
 
-        super(APIRouter, self).__init__(mapper)
+
+class APIRouterV10(APIRouter):
+    def _setup_routes(self, mapper):
+        APIRouter._setup_routes(self, mapper)
+        mapper.resource("server", "servers",
+                        controller=servers.ControllerV10(),
+                        collection={'detail': 'GET'},
+                        member=self.server_members)
+
+
+class APIRouterV11(APIRouter):
+    def _setup_routes(self, mapper):
+        APIRouter._setup_routes(self, mapper)
+        mapper.resource("server", "servers",
+                        controller=servers.ControllerV11(),
+                        collection={'detail': 'GET'},
+                        member=self.server_members)
 
 
 class Versions(wsgi.Application):
diff --git a/nova/api/openstack/auth.py b/nova/api/openstack/auth.py
index 7ae285019..6f1cf5e63 100644
--- a/nova/api/openstack/auth.py
+++ b/nova/api/openstack/auth.py
@@ -70,7 +70,7 @@ class AuthMiddleware(wsgi.Middleware):
 
         req.environ['nova.context'] = context.RequestContext(user, account)
         version = req.path.split('/')[1].replace('v', '')
-        req.environ['nova.api.openstack.version'] = version
+        req.environ['api.version'] = version
         return self.application
 
     def has_authentication(self, req):
diff --git a/nova/api/openstack/common.py b/nova/api/openstack/common.py
index d94969ff5..d6679de01 100644
--- a/nova/api/openstack/common.py
+++ b/nova/api/openstack/common.py
@@ -75,5 +75,6 @@ def get_image_id_from_image_hash(image_service, context, image_hash):
             return image_id
     raise exception.NotFound(image_hash)
 
+
 def get_api_version(req):
     return req.environ.get('api.version')
diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index dc62882eb..9ce0caa46 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -27,8 +27,9 @@ from nova import wsgi
 from nova import utils
 from nova.api.openstack import common
 from nova.api.openstack import faults
-from nova.api.openstack.views import servers as servers_views
-from nova.api.openstack.views import addresses as addresses_views
+import nova.api.openstack.views.addresses
+import nova.api.openstack.views.flavors
+import nova.api.openstack.views.servers
 from nova.auth import manager as auth_manager
 from nova.compute import instance_types
 from nova.compute import power_state
@@ -57,7 +58,7 @@ class Controller(wsgi.Controller):
     def ips(self, req, id):
         try:
             instance = self.compute_api.get(req.environ['nova.context'], id)
-            builder = addresses_views.get_view_builder(req)
+            builder = self._get_addresses_view_builder(req)
             return builder.build(instance)
         except exception.NotFound:
             return faults.Fault(exc.HTTPNotFound())
@@ -77,7 +78,7 @@ class Controller(wsgi.Controller):
         """
         instance_list = self.compute_api.get_all(req.environ['nova.context'])
         limited_list = common.limited(instance_list, req)
-        builder = servers_views.get_view_builder(req)
+        builder = self._get_view_builder(req)
         servers = [builder.build(inst, is_detail)['server']
                 for inst in limited_list]
         return dict(servers=servers)
@@ -86,7 +87,7 @@ class Controller(wsgi.Controller):
         """ Returns server details by server id """
         try:
             instance = self.compute_api.get(req.environ['nova.context'], id)
-            builder = servers_views.get_view_builder(req)
+            builder = self._get_view_builder(req)
             return builder.build(instance, is_detail=True)
         except exception.NotFound:
             return faults.Fault(exc.HTTPNotFound())
@@ -111,8 +112,9 @@ class Controller(wsgi.Controller):
             raise exception.NotFound(_("No keypairs defined"))
         key_pair = key_pairs[0]
 
+        requested_image_id = self._image_id_from_req_data(env)
         image_id = common.get_image_id_from_image_hash(self._image_service,
-            context, env['server']['imageId'])
+            context, requested_image_id)
         kernel_id, ramdisk_id = self._get_kernel_ramdisk_from_image(
             req, image_id)
 
@@ -126,9 +128,10 @@ class Controller(wsgi.Controller):
             for k, v in env['server']['metadata'].items():
                 metadata.append({'key': k, 'value': v})
 
-        instances = self.compute_api.create(
+        flavor_id = self._flavor_id_from_req_data(env)
+        (inst,) = self.compute_api.create(
             context,
-            instance_types.get_by_flavor_id(env['server']['flavorId']),
+            instance_types.get_by_flavor_id(flavor_id),
             image_id,
             kernel_id=kernel_id,
             ramdisk_id=ramdisk_id,
@@ -138,9 +141,11 @@ class Controller(wsgi.Controller):
             key_data=key_pair['public_key'],
             metadata=metadata,
             onset_files=env.get('onset_files', []))
+        inst['instance_type'] = flavor_id
+        inst['image_id'] = requested_image_id
 
-        builder = servers_views.get_view_builder(req)
-        server = builder.build(instances[0], is_detail=False)
+        builder = self._get_view_builder(req)
+        server = builder.build(inst, is_detail=True)
         password = "%s%s" % (server['server']['name'][:4],
                              utils.generate_password(12))
         server['server']['adminPass'] = password
@@ -437,3 +442,42 @@ class Controller(wsgi.Controller):
                 _("Ramdisk not found for image %(image_id)s") % locals())
 
         return kernel_id, ramdisk_id
+
+
+class ControllerV10(Controller):
+    def _image_id_from_req_data(self, data):
+        return data['server']['imageId']
+
+    def _flavor_id_from_req_data(self, data):
+        return data['server']['flavorId']
+
+    def _get_view_builder(self, req):
+        addresses_builder = nova.api.openstack.views.addresses.ViewBuilderV10()
+        return nova.api.openstack.views.servers.ViewBuilderV10(
+            addresses_builder)
+
+    def _get_addresses_view_builder(self, req):
+        return nova.api.openstack.views.addresses.ViewBuilderV10(req)
+
+
+class ControllerV11(Controller):
+    def _image_id_from_req_data(self, data):
+        href = data['server']['imageRef']
+        return href.split('/')[-1]
+
+    def _flavor_id_from_req_data(self, data):
+        href = data['server']['flavorRef']
+        return href.split('/')[-1]
+
+    def _get_view_builder(self, req):
+        base_url = req.application_url
+        flavor_builder = nova.api.openstack.views.flavors.ViewBuilderV11(
+            base_url)
+        image_builder = nova.api.openstack.views.images.ViewBuilderV11(
+            base_url)
+        addresses_builder = nova.api.openstack.views.addresses.ViewBuilderV11()
+        return nova.api.openstack.views.servers.ViewBuilderV11(
+            addresses_builder, flavor_builder, image_builder)
+
+    def _get_addresses_view_builder(self, req):
+        return nova.api.openstack.views.addresses.ViewBuilderV11(req)
diff --git a/nova/api/openstack/views/addresses.py b/nova/api/openstack/views/addresses.py
index 9d392aace..90c77855b 100644
--- a/nova/api/openstack/views/addresses.py
+++ b/nova/api/openstack/views/addresses.py
@@ -19,18 +19,6 @@ from nova import utils
 from nova.api.openstack import common
 
 
-def get_view_builder(req):
-    '''
-    A factory method that returns the correct builder based on the version of
-    the api requested.
-    '''
-    version = common.get_api_version(req)
-    if version == '1.1':
-        return ViewBuilder_1_1()
-    else:
-        return ViewBuilder_1_0()
-
-
 class ViewBuilder(object):
     ''' Models a server addresses response as a python dictionary.'''
 
@@ -38,14 +26,14 @@ class ViewBuilder(object):
         raise NotImplementedError()
 
 
-class ViewBuilder_1_0(ViewBuilder):
+class ViewBuilderV10(ViewBuilder):
     def build(self, inst):
         private_ips = utils.get_from_path(inst, 'fixed_ip/address')
         public_ips = utils.get_from_path(inst, 'fixed_ip/floating_ips/address')
         return dict(public=public_ips, private=private_ips)
 
 
-class ViewBuilder_1_1(ViewBuilder):
+class ViewBuilderV11(ViewBuilder):
     def build(self, inst):
         private_ips = utils.get_from_path(inst, 'fixed_ip/address')
         private_ips = [dict(version=4, addr=a) for a in private_ips]
diff --git a/nova/api/openstack/views/flavors.py b/nova/api/openstack/views/flavors.py
index aa3c2aeb2..18bd779c0 100644
--- a/nova/api/openstack/views/flavors.py
+++ b/nova/api/openstack/views/flavors.py
@@ -17,18 +17,6 @@
 
 from nova.api.openstack import common
 
-def get_view_builder(req):
-    '''
-    A factory method that returns the correct builder based on the version of
-    the api requested.
-    '''
-    version = common.get_api_version(req)
-    base_url = req.application_url
-    if version == '1.1':
-        return ViewBuilder_1_1(base_url)
-    else:
-        return ViewBuilder_1_0()
-
 
 class ViewBuilder(object):
     def __init__(self):
@@ -38,13 +26,9 @@ class ViewBuilder(object):
         raise NotImplementedError()
 
 
-class ViewBuilder_1_1(ViewBuilder):
+class ViewBuilderV11(ViewBuilder):
     def __init__(self, base_url):
         self.base_url = base_url
 
     def generate_href(self, flavor_id):
         return "%s/flavors/%s" % (self.base_url, flavor_id)
-
-
-class ViewBuilder_1_0(ViewBuilder):
-    pass
diff --git a/nova/api/openstack/views/images.py b/nova/api/openstack/views/images.py
index 930b464b0..a6c6ad7d1 100644
--- a/nova/api/openstack/views/images.py
+++ b/nova/api/openstack/views/images.py
@@ -17,18 +17,6 @@
 
 from nova.api.openstack import common
 
-def get_view_builder(req):
-    '''
-    A factory method that returns the correct builder based on the version of
-    the api requested.
-    '''
-    version = common.get_api_version(req)
-    base_url = req.application_url
-    if version == '1.1':
-        return ViewBuilder_1_1(base_url)
-    else:
-        return ViewBuilder_1_0()
-
 
 class ViewBuilder(object):
     def __init__(self):
@@ -38,13 +26,9 @@ class ViewBuilder(object):
         raise NotImplementedError()
 
 
-class ViewBuilder_1_1(ViewBuilder):
+class ViewBuilderV11(ViewBuilder):
     def __init__(self, base_url):
         self.base_url = base_url
 
     def generate_href(self, image_id):
         return "%s/images/%s" % (self.base_url, image_id)
-
-
-class ViewBuilder_1_0(ViewBuilder):
-    pass
diff --git a/nova/api/openstack/views/servers.py b/nova/api/openstack/views/servers.py
index 261acfed0..8d47ac757 100644
--- a/nova/api/openstack/views/servers.py
+++ b/nova/api/openstack/views/servers.py
@@ -24,22 +24,6 @@ from nova.api.openstack.views import images as images_view
 from nova import utils
 
 
-def get_view_builder(req):
-    '''
-    A factory method that returns the correct builder based on the version of
-    the api requested.
-    '''
-    version = common.get_api_version(req)
-    addresses_builder = addresses_view.get_view_builder(req)
-    if version == '1.1':
-        flavor_builder = flavors_view.get_view_builder(req)
-        image_builder = images_view.get_view_builder(req)
-        return ViewBuilder_1_1(addresses_builder, flavor_builder,
-                               image_builder)
-    else:
-        return ViewBuilder_1_0(addresses_builder)
-
-
 class ViewBuilder(object):
     '''
     Models a server response as a python dictionary.
@@ -76,25 +60,20 @@ class ViewBuilder(object):
             power_state.FAILED: 'error'}
         inst_dict = {}
 
-        #mapped_keys = dict(status='state', imageId='image_id',
-        #    flavorId='instance_type', name='display_name', id='id')
-
-        mapped_keys = dict(status='state', name='display_name', id='id')
-
-        for k, v in mapped_keys.iteritems():
-            inst_dict[k] = inst[v]
-
-        inst_dict['status'] = power_mapping[inst_dict['status']]
+        inst_dict['id'] = int(inst['id'])
+        inst_dict['name'] = inst['display_name']
+        inst_dict['status'] = power_mapping[inst.get('state')]
         inst_dict['addresses'] = self.addresses_builder.build(inst)
 
         # Return the metadata as a dictionary
         metadata = {}
-        for item in inst['metadata']:
-            metadata[item['key']] = item['value']
+        if 'metadata' in inst:
+            for item in inst['metadata']:
+                metadata[item['key']] = item['value']
         inst_dict['metadata'] = metadata
 
         inst_dict['hostId'] = ''
-        if inst['host']:
+        if inst.get('host'):
             inst_dict['hostId'] = hashlib.sha224(inst['host']).hexdigest()
 
         self._build_image(inst_dict, inst)
@@ -109,24 +88,30 @@ class ViewBuilder(object):
         raise NotImplementedError()
 
 
-class ViewBuilder_1_0(ViewBuilder):
+class ViewBuilderV10(ViewBuilder):
     def _build_image(self, response, inst):
-        response["imageId"] = inst["image_id"]
+        if inst.get('image_id') != None:
+            response['imageId'] = inst['image_id']
 
     def _build_flavor(self, response, inst):
-        response["flavorId"] = inst["instance_type"]
+        if inst.get('instance_type') != None:
+            response['flavorId'] = inst['instance_type']
 
 
-class ViewBuilder_1_1(ViewBuilder):
+class ViewBuilderV11(ViewBuilder):
     def __init__(self, addresses_builder, flavor_builder, image_builder):
         ViewBuilder.__init__(self, addresses_builder)
         self.flavor_builder = flavor_builder
         self.image_builder = image_builder
 
     def _build_image(self, response, inst):
+        if inst.get('image_id') == None:
+            return
         image_id = inst["image_id"]
         response["imageRef"] = self.image_builder.generate_href(image_id)
 
     def _build_flavor(self, response, inst):
+        if inst.get('instance_type') == None:
+            return
         flavor_id = inst["instance_type"]
         response["flavorRef"] = self.flavor_builder.generate_href(flavor_id)
diff --git a/nova/tests/api/openstack/fakes.py b/nova/tests/api/openstack/fakes.py
index a3968b57b..370eb68cb 100644
--- a/nova/tests/api/openstack/fakes.py
+++ b/nova/tests/api/openstack/fakes.py
@@ -76,14 +76,18 @@ def fake_wsgi(self, req):
     return self.application
 
 
-def wsgi_app(inner_application=None):
-    if not inner_application:
-        inner_application = openstack.APIRouter()
+def wsgi_app(inner_app10=None, inner_app11=None):
+    if not inner_app10:
+        inner_app10 = openstack.APIRouterV10()
+    if not inner_app11:
+        inner_app11 = openstack.APIRouterV11()
     mapper = urlmap.URLMap()
-    api = openstack.FaultWrapper(auth.AuthMiddleware(
-              ratelimiting.RateLimitingMiddleware(inner_application)))
-    mapper['/v1.0'] = api
-    mapper['/v1.1'] = api
+    api10 = openstack.FaultWrapper(auth.AuthMiddleware(
+              ratelimiting.RateLimitingMiddleware(inner_app10)))
+    api11 = openstack.FaultWrapper(auth.AuthMiddleware(
+              ratelimiting.RateLimitingMiddleware(inner_app11)))
+    mapper['/v1.0'] = api10
+    mapper['/v1.1'] = api11
     mapper['/'] = openstack.FaultWrapper(openstack.Versions())
     return mapper
 
diff --git a/nova/tests/api/openstack/test_auth.py b/nova/tests/api/openstack/test_auth.py
index aaaa4e415..b7f0dfbe5 100644
--- a/nova/tests/api/openstack/test_auth.py
+++ b/nova/tests/api/openstack/test_auth.py
@@ -82,8 +82,7 @@ class Test(test.TestCase):
         self.assertEqual(result.headers['X-Storage-Url'], "")
 
         token = result.headers['X-Auth-Token']
-        self.stubs.Set(nova.api.openstack, 'APIRouter',
-            fakes.FakeRouter)
+        self.stubs.Set(nova.api.openstack, 'APIRouterV10', fakes.FakeRouter)
         req = webob.Request.blank('/v1.0/fake')
         req.headers['X-Auth-Token'] = token
         result = req.get_response(fakes.wsgi_app())
@@ -189,8 +188,7 @@ class TestLimiter(test.TestCase):
         self.assertEqual(len(result.headers['X-Auth-Token']), 40)
 
         token = result.headers['X-Auth-Token']
-        self.stubs.Set(nova.api.openstack, 'APIRouter',
-            fakes.FakeRouter)
+        self.stubs.Set(nova.api.openstack, 'APIRouterV10', fakes.FakeRouter)
         req = webob.Request.blank('/v1.0/fake')
         req.method = 'POST'
         req.headers['X-Auth-Token'] = token
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 27d174fe9..0116bbed1 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -158,7 +158,7 @@ class ServersTest(test.TestCase):
         req = webob.Request.blank('/v1.0/servers/1')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
-        self.assertEqual(res_dict['server']['id'], '1')
+        self.assertEqual(res_dict['server']['id'], 1)
         self.assertEqual(res_dict['server']['name'], 'server1')
 
     def test_get_server_by_id_with_addresses(self):
@@ -169,7 +169,7 @@ class ServersTest(test.TestCase):
         req = webob.Request.blank('/v1.0/servers/1')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
-        self.assertEqual(res_dict['server']['id'], '1')
+        self.assertEqual(res_dict['server']['id'], 1)
         self.assertEqual(res_dict['server']['name'], 'server1')
         addresses = res_dict['server']['addresses']
         self.assertEqual(len(addresses["public"]), len(public))
@@ -177,7 +177,7 @@ class ServersTest(test.TestCase):
         self.assertEqual(len(addresses["private"]), 1)
         self.assertEqual(addresses["private"][0], private)
 
-    def test_get_server_by_id_with_addresses_v1_1(self):
+    def test_get_server_by_id_with_addresses_v11(self):
         private = "192.168.0.3"
         public = ["1.2.3.4"]
         new_return_server = return_server_with_addresses(private, public)
@@ -186,7 +186,7 @@ class ServersTest(test.TestCase):
         req.environ['api.version'] = '1.1'
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
-        self.assertEqual(res_dict['server']['id'], '1')
+        self.assertEqual(res_dict['server']['id'], 1)
         self.assertEqual(res_dict['server']['name'], 'server1')
         addresses = res_dict['server']['addresses']
         self.assertEqual(len(addresses["public"]), len(public))
@@ -273,13 +273,13 @@ class ServersTest(test.TestCase):
             "get_image_id_from_image_hash", image_id_from_hash)
 
         body = dict(server=dict(
-            name='server_test', imageId=2, flavorId=2,
+            name='server_test', imageId=3, flavorId=2,
             metadata={'hello': 'world', 'open': 'stack'},
             personality={}))
         req = webob.Request.blank('/v1.0/servers')
         req.method = 'POST'
         req.body = json.dumps(body)
-        req.headers["Content-Type"] = "application/json"
+        req.headers["content-type"] = "application/json"
 
         res = req.get_response(fakes.wsgi_app())
 
@@ -287,8 +287,67 @@ class ServersTest(test.TestCase):
         self.assertEqual('serv', server['adminPass'][:4])
         self.assertEqual(16, len(server['adminPass']))
         self.assertEqual('server_test', server['name'])
-        self.assertEqual('1', server['id'])
+        self.assertEqual(1, server['id'])
+        self.assertEqual(2, server['flavorId'])
+        self.assertEqual(3, server['imageId'])
+        self.assertEqual(res.status_int, 200)
+
+    def test_create_instance_v11(self):
+        def instance_create(context, inst):
+            return {'id': '1', 'display_name': 'server_test'}
+
+        def server_update(context, id, params):
+            return instance_create(context, id)
+
+        def fake_method(*args, **kwargs):
+            pass
+
+        def project_get_network(context, user_id):
+            return dict(id='1', host='localhost')
+
+        def queue_get_for(context, *args):
+            return 'network_topic'
+
+        def kernel_ramdisk_mapping(*args, **kwargs):
+            return (1, 1)
+
+        def image_id_from_hash(*args, **kwargs):
+            return 2
+
+        self.stubs.Set(nova.db.api, 'project_get_network', project_get_network)
+        self.stubs.Set(nova.db.api, 'instance_create', instance_create)
+        self.stubs.Set(nova.rpc, 'cast', fake_method)
+        self.stubs.Set(nova.rpc, 'call', fake_method)
+        self.stubs.Set(nova.db.api, 'instance_update',
+            server_update)
+        self.stubs.Set(nova.db.api, 'queue_get_for', queue_get_for)
+        self.stubs.Set(nova.network.manager.VlanManager, 'allocate_fixed_ip',
+            fake_method)
+        self.stubs.Set(nova.api.openstack.servers.Controller,
+            "_get_kernel_ramdisk_from_image", kernel_ramdisk_mapping)
+        self.stubs.Set(nova.api.openstack.common,
+            "get_image_id_from_image_hash", image_id_from_hash)
 
+        imageRef = 'http://localhost/v1.1/images/2'
+        flavorRef = 'http://localhost/v1.1/flavors/3'
+        body = dict(server=dict(
+            name='server_test', imageRef=imageRef, flavorRef=flavorRef,
+            metadata={'hello': 'world', 'open': 'stack'},
+            personality={}))
+        req = webob.Request.blank('/v1.1/servers')
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        req.headers["content-type"] = "application/json"
+
+        res = req.get_response(fakes.wsgi_app())
+
+        server = json.loads(res.body)['server']
+        self.assertEqual('serv', server['adminPass'][:4])
+        self.assertEqual(16, len(server['adminPass']))
+        self.assertEqual('server_test', server['name'])
+        self.assertEqual(1, server['id'])
+        self.assertEqual(flavorRef, server['flavorRef'])
+        self.assertEqual(imageRef, server['imageRef'])
         self.assertEqual(res.status_int, 200)
 
     def test_update_no_body(self):
-- 
cgit 


From 05ca6e24d4a3cf64bbe371f1c9c74088110eba68 Mon Sep 17 00:00:00 2001
From: Naveed Massjouni <naveedm9@gmail.com>
Date: Thu, 17 Mar 2011 04:32:24 -0400
Subject: Setting the api verion in the request in the auth middle is no longer
 needed. Also, common.get_api_version is no longer needed. As Eric Day noted,
 having versioned controllers will make that unnecessary.

---
 nova/api/openstack/auth.py   | 2 --
 nova/api/openstack/common.py | 4 ----
 2 files changed, 6 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/auth.py b/nova/api/openstack/auth.py
index 6f1cf5e63..4c6b58eff 100644
--- a/nova/api/openstack/auth.py
+++ b/nova/api/openstack/auth.py
@@ -69,8 +69,6 @@ class AuthMiddleware(wsgi.Middleware):
             return faults.Fault(webob.exc.HTTPUnauthorized())
 
         req.environ['nova.context'] = context.RequestContext(user, account)
-        version = req.path.split('/')[1].replace('v', '')
-        req.environ['api.version'] = version
         return self.application
 
     def has_authentication(self, req):
diff --git a/nova/api/openstack/common.py b/nova/api/openstack/common.py
index d6679de01..74ac21024 100644
--- a/nova/api/openstack/common.py
+++ b/nova/api/openstack/common.py
@@ -74,7 +74,3 @@ def get_image_id_from_image_hash(image_service, context, image_hash):
         if abs(hash(image_id)) == int(image_hash):
             return image_id
     raise exception.NotFound(image_hash)
-
-
-def get_api_version(req):
-    return req.environ.get('api.version')
-- 
cgit 


From 41619f49ce72d8e85f013c5a5dd248faa8490555 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
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')

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 c5378e09be3d633b79e4a8c62b51d1e56cdaa67b Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Thu, 17 Mar 2011 12:58:45 +0100
Subject: Fix a number of place in the volume driver where the argv hadn't been
 fully split

---
 nova/volume/driver.py | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

(limited to 'nova')

diff --git a/nova/volume/driver.py b/nova/volume/driver.py
index 7b4bacdec..9ebc67abc 100644
--- a/nova/volume/driver.py
+++ b/nova/volume/driver.py
@@ -207,8 +207,8 @@ class AOEDriver(VolumeDriver):
         (shelf_id,
          blade_id) = self.db.volume_get_shelf_and_blade(context,
                                                         _volume['id'])
-        self._execute("sudo aoe-discover")
-        out, err = self._execute("sudo aoe-stat", check_exit_code=False)
+        self._execute('sudo', 'aoe-discover')
+        out, err = self._execute('sudo', 'aoe-stat', check_exit_code=False)
         device_path = 'e%(shelf_id)d.%(blade_id)d' % locals()
         if out.find(device_path) >= 0:
             return "/dev/etherd/%s" % device_path
@@ -224,8 +224,8 @@ class AOEDriver(VolumeDriver):
         (shelf_id,
          blade_id) = self.db.volume_get_shelf_and_blade(context,
                                                         volume_id)
-        cmd = "sudo vblade-persist ls --no-header"
-        out, _err = self._execute(cmd)
+        cmd = ('sudo', 'vblade-persist', 'ls', '--no-header')
+        out, _err = self._execute(*cmd)
         exported = False
         for line in out.split('\n'):
             param = line.split(' ')
@@ -318,8 +318,8 @@ class ISCSIDriver(VolumeDriver):
         iscsi_name = "%s%s" % (FLAGS.iscsi_target_prefix, volume['name'])
         volume_path = "/dev/%s/%s" % (FLAGS.volume_group, volume['name'])
         self._execute('sudo', 'ietadm', '--op', 'new',
-                      '--tid=%s --params Name=%s' %
-                      (iscsi_target, iscsi_name))
+                      '--tid=%s' % iscsi_target,
+                      '--params', 'Name=%s' % iscsi_name)
         self._execute('sudo', 'ietadm', '--op', 'new',
                       '--tid=%s' % iscsi_target,
                       '--lun=0', '--params',
@@ -500,7 +500,7 @@ class ISCSIDriver(VolumeDriver):
 
         tid = self.db.volume_get_iscsi_target_num(context, volume_id)
         try:
-            self._execute("sudo ietadm --op show --tid=%(tid)d" % locals())
+            self._execute('sudo', 'ietadm', '--op', 'show', '--tid=%(tid)d' % locals())
         except exception.ProcessExecutionError, e:
             # Instances remount read-only in this case.
             # /etc/init.d/iscsitarget restart and rebooting nova-volume
@@ -551,7 +551,7 @@ class RBDDriver(VolumeDriver):
     def delete_volume(self, volume):
         """Deletes a logical volume."""
         self._try_execute('rbd', '--pool', FLAGS.rbd_pool,
-                          'rm', voluname['name'])
+                          'rm', volume['name'])
 
     def local_path(self, volume):
         """Returns the path of the rbd volume."""
-- 
cgit 


From 732633c93f8d8cf71875d2caf096c9efbcf9dbce Mon Sep 17 00:00:00 2001
From: Dan Prince <dan.prince@rackspace.com>
Date: Thu, 17 Mar 2011 09:55:41 -0400
Subject: Update the Openstack API to handle case where personality is set but
 null in the request to create a server.

---
 nova/api/openstack/servers.py            |  5 +++++
 nova/tests/api/openstack/test_servers.py | 13 +++++++++++--
 2 files changed, 16 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 3ecd4fb01..bf21ed17f 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -220,6 +220,11 @@ class Controller(wsgi.Controller):
         underlying compute service.
         """
         injected_files = []
+
+        # NOTE(dprince): handle case where 'personality: null' is in JSON req
+        if not personality:
+            return injected_files
+
         for item in personality:
             try:
                 path = item['path']
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 03e00af2a..230c9d03c 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -943,11 +943,13 @@ class TestServerInstanceCreation(test.TestCase):
         server['name'] = 'new-server-test'
         server['imageId'] = 1
         server['flavorId'] = 1
-        if personality_files is not None:
+        if personality_files:
             personalities = []
             for path, contents in personality_files:
                 personalities.append({'path': path, 'contents': contents})
             server['personality'] = personalities
+        else:
+            server['personality'] = None
         return {'server': server}
 
     def _get_create_request_json(self, body_dict):
@@ -976,7 +978,7 @@ class TestServerInstanceCreation(test.TestCase):
             for item in metadata.iteritems():
                 body_parts.append('<meta key="%s">%s</meta>' % item)
             body_parts.append('</metadata>')
-        if 'personality' in server:
+        if 'personality' in server and server['personality'] is not None:
             personalities = server['personality']
             body_parts.append('<personality>')
             for file in personalities:
@@ -1093,6 +1095,13 @@ class TestServerInstanceCreation(test.TestCase):
         self.assertEquals(response.status_int, 400)
         self.assertEquals(injected_files, None)
 
+    def test_create_instance_with_null_personality(self):
+        personality = None
+        request, response, injected_files = \
+            self._create_instance_with_personality_json(personality)
+        self.assertEquals(response.status_int, 200)
+        self.assertEquals(injected_files, [])
+
     def test_create_instance_with_three_personalities(self):
         files = [
             ('/etc/sudoers', 'ALL ALL=NOPASSWD: ALL\n'),
-- 
cgit 


From abc6c82449dfc46a33dcd8190840e51f44b5b930 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Thu, 17 Mar 2011 07:30:22 -0700
Subject: Replaced capability flags with List

---
 nova/api/openstack/zones.py            | 4 ++--
 nova/flags.py                          | 5 +++--
 nova/tests/api/openstack/test_zones.py | 6 +++---
 3 files changed, 8 insertions(+), 7 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/zones.py b/nova/api/openstack/zones.py
index 547920901..ebfc7743c 100644
--- a/nova/api/openstack/zones.py
+++ b/nova/api/openstack/zones.py
@@ -71,9 +71,9 @@ class Controller(wsgi.Controller):
         items = api.API.get_zone_capabilities(req.environ['nova.context'])
 
         zone = dict(name=FLAGS.zone_name)
-        caps = FLAGS.zone_capabilities.split(';')
+        caps = FLAGS.zone_capabilities
         for cap in caps:
-            key_values = cap.split(':')
+            key_values = cap.split('=')
             zone[key_values[0]] = key_values[1]
         for item, (min_value, max_value) in items.iteritems():
             zone[item] = "%s,%s" % (min_value, max_value)
diff --git a/nova/flags.py b/nova/flags.py
index c05cef373..3a8ec1a39 100644
--- a/nova/flags.py
+++ b/nova/flags.py
@@ -358,5 +358,6 @@ DEFINE_string('node_availability_zone', 'nova',
               'availability zone of this node')
 
 DEFINE_string('zone_name', 'nova', 'name of this zone')
-DEFINE_string('zone_capabilities', 'hypervisor:xenserver;os:linux',
-              'Key/Value tags which represent capabilities of this zone')
+DEFINE_list('zone_capabilities',
+                ['hypervisor=xenserver;kvm', 'os=linux;windows'],
+                'Key/Multi-value list representng capabilities of this zone')
diff --git a/nova/tests/api/openstack/test_zones.py b/nova/tests/api/openstack/test_zones.py
index 5e3aee4a7..12d39fd29 100644
--- a/nova/tests/api/openstack/test_zones.py
+++ b/nova/tests/api/openstack/test_zones.py
@@ -178,7 +178,7 @@ class ZonesTest(test.TestCase):
 
     def test_zone_info(self):
         FLAGS.zone_name = 'darksecret'
-        FLAGS.zone_capabilities = 'cap1:a,b;cap2:c,d'
+        FLAGS.zone_capabilities = ['cap1=a;b', 'cap2=c;d']
         self.stubs.Set(api, '_call_scheduler', zone_caps)
 
         body = dict(zone=dict(username='zeb', password='sneaky'))
@@ -188,5 +188,5 @@ class ZonesTest(test.TestCase):
         res_dict = json.loads(res.body)
         self.assertEqual(res.status_int, 200)
         self.assertEqual(res_dict['zone']['name'], 'darksecret')
-        self.assertEqual(res_dict['zone']['cap1'], 'a,b')
-        self.assertEqual(res_dict['zone']['cap2'], 'c,d')
+        self.assertEqual(res_dict['zone']['cap1'], 'a;b')
+        self.assertEqual(res_dict['zone']['cap2'], 'c;d')
-- 
cgit 


From cbcda1ec466fd498fb8e9fe47c72b52c2d4b3dde Mon Sep 17 00:00:00 2001
From: sateesh <sateesh.chodapuneedi@citrix.com>
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/tests/test_vmwareapi.py         |  6 +++---
 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 ++++++++++----------
 5 files changed, 39 insertions(+), 39 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/test_vmwareapi.py b/nova/tests/test_vmwareapi.py
index b22d8b7b9..d17805b99 100644
--- a/nova/tests/test_vmwareapi.py
+++ b/nova/tests/test_vmwareapi.py
@@ -43,15 +43,15 @@ class VMWareAPIVMTestCase(test.TestCase):
 
     def setUp(self):
         super(VMWareAPIVMTestCase, self).setUp()
+        self.flags(vmwareapi_host_ip='test_url',
+                   vmwareapi_host_username='test_username',
+                   vmware_host_password='test_pass')
         self.manager = manager.AuthManager()
         self.user = self.manager.create_user('fake', 'fake', 'fake',
                                              admin=True)
         self.project = self.manager.create_project('fake', 'fake', 'fake')
         self.network = utils.import_object(FLAGS.network_manager)
         self.stubs = stubout.StubOutForTesting()
-        FLAGS.vmwareapi_host_ip = 'test_url'
-        FLAGS.vmwareapi_host_username = 'test_username'
-        FLAGS.vmwareapi_host_password = 'test_pass'
         vmwareapi_fake.reset()
         db_fakes.stub_out_db_instance_api(self.stubs)
         stubs.set_stubs(self.stubs)
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 f8aa9485fe2048ff916d9dd40478ef0b1486077f Mon Sep 17 00:00:00 2001
From: Dan Prince <dan.prince@rackspace.com>
Date: Thu, 17 Mar 2011 10:45:46 -0400
Subject: Switch back to 'is not None' for personality_files check. (makes mark
 happy)

---
 nova/api/openstack/servers.py            | 1 -
 nova/tests/api/openstack/test_servers.py | 2 +-
 2 files changed, 1 insertion(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index bf21ed17f..6dd66a9a5 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -221,7 +221,6 @@ class Controller(wsgi.Controller):
         """
         injected_files = []
 
-        # NOTE(dprince): handle case where 'personality: null' is in JSON req
         if not personality:
             return injected_files
 
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 230c9d03c..71c57bfbf 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -943,7 +943,7 @@ class TestServerInstanceCreation(test.TestCase):
         server['name'] = 'new-server-test'
         server['imageId'] = 1
         server['flavorId'] = 1
-        if personality_files:
+        if personality_files is not None:
             personalities = []
             for path, contents in personality_files:
                 personalities.append({'path': path, 'contents': contents})
-- 
cgit 


From aa13754d04c17ae9985017e22ae4f68916bc2781 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Thu, 17 Mar 2011 10:03:47 -0500
Subject: Foo

---
 nova/compute/manager.py   | 1 -
 nova/virt/xenapi/vmops.py | 3 ++-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 3135d5801..b8c3c24cd 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -547,7 +547,6 @@ class ComputeManager(manager.Manager):
                     vcpus=instance_type['vcpus'],
                     local_gb=instance_type['local_gb']))
 
-        instance_ref = self.db.instance_get(context, instance_id)
         self.driver.finish_resize(instance_ref, disk_info)
 
         self.db.migration_update(context, migration_id,
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 66d9c0d51d410998de86508359135a7d978997ef Mon Sep 17 00:00:00 2001
From: Dan Prince <dan.prince@rackspace.com>
Date: Thu, 17 Mar 2011 11:05:31 -0400
Subject: Call _create_personality_request_dict within the personalities_null
 test.

---
 nova/tests/api/openstack/test_servers.py | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 71c57bfbf..6969e88c7 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -948,8 +948,6 @@ class TestServerInstanceCreation(test.TestCase):
             for path, contents in personality_files:
                 personalities.append({'path': path, 'contents': contents})
             server['personality'] = personalities
-        else:
-            server['personality'] = None
         return {'server': server}
 
     def _get_create_request_json(self, body_dict):
@@ -1097,10 +1095,12 @@ class TestServerInstanceCreation(test.TestCase):
 
     def test_create_instance_with_null_personality(self):
         personality = None
-        request, response, injected_files = \
-            self._create_instance_with_personality_json(personality)
+        body_dict = self._create_personality_request_dict(personality)
+        body_dict['server']['personality'] = None
+        request = self._get_create_request_json(body_dict)
+        compute_api, response = \
+            self._run_create_instance_with_mock_compute_api(request)
         self.assertEquals(response.status_int, 200)
-        self.assertEquals(injected_files, [])
 
     def test_create_instance_with_three_personalities(self):
         files = [
-- 
cgit 


From ba0160cacac1c7db71eadd6624ee75a014c18378 Mon Sep 17 00:00:00 2001
From: Ilya Alekseyev <ialekseev@griddynamics.com>
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')

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 137bbc37e9fb664d0b97a607b5f69c38df938077 Mon Sep 17 00:00:00 2001
From: Dan Prince <dan.prince@rackspace.com>
Date: Thu, 17 Mar 2011 11:10:58 -0400
Subject: No need to modify this test case function as well.

---
 nova/tests/api/openstack/test_servers.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 6969e88c7..d0b07b7ae 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -976,7 +976,7 @@ class TestServerInstanceCreation(test.TestCase):
             for item in metadata.iteritems():
                 body_parts.append('<meta key="%s">%s</meta>' % item)
             body_parts.append('</metadata>')
-        if 'personality' in server and server['personality'] is not None:
+        if 'personality' in server:
             personalities = server['personality']
             body_parts.append('<personality>')
             for file in personalities:
-- 
cgit 


From 1d64d0a3d7f25448361ce54e32bba3de68c7afd1 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Thu, 17 Mar 2011 16:14:59 +0100
Subject: Remove unconditional raise, probably left over from debugging.

---
 nova/api/ec2/cloud.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 40a9da0e7..e257e44e7 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -959,7 +959,7 @@ class CloudController(object):
             raise exception.NotFound(_('Image %s not found') % image_id)
         internal_id = image['id']
         del(image['id'])
-        raise Exception(image)
+
         image['properties']['is_public'] = (operation_type == 'add')
         return self.image_service.update(context, internal_id, image)
 
-- 
cgit 


From 720ba5d5c9ad2c24d9f0275fb783f191836a75f3 Mon Sep 17 00:00:00 2001
From: Ilya Alekseyev <ialekseev@griddynamics.com>
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')

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 <soren@linux2go.dk>
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')

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 41c097000c1eeb4f1532b22f136c383b8174e6cc Mon Sep 17 00:00:00 2001
From: Dan Prince <dan.prince@rackspace.com>
Date: Thu, 17 Mar 2011 11:35:32 -0400
Subject: Add tests and code to handle multiple ResponseExtension objects.

---
 nova/api/openstack/extensions.py                  | 13 ++++++++++++-
 nova/tests/api/openstack/extensions/foxinsocks.py | 17 ++++++++++++++---
 nova/tests/api/openstack/test_extensions.py       | 17 ++++++++++++++++-
 3 files changed, 42 insertions(+), 5 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/extensions.py b/nova/api/openstack/extensions.py
index 557b12fd9..23181d2a6 100644
--- a/nova/api/openstack/extensions.py
+++ b/nova/api/openstack/extensions.py
@@ -66,9 +66,20 @@ class ResponseExtensionController(wsgi.Controller):
 
     def process(self, req, *args, **kwargs):
         res = req.get_response(self.application)
+        content_type = req.best_match_content_type()
         # currently response handlers are un-ordered
         for handler in self.handlers:
-            return handler(res)
+            res=handler(res)
+            try:
+                body = res.body
+                headers = res.headers
+            except AttributeError:
+                body = self._serialize(res, content_type)
+                headers={"Content-Type": content_type}
+            res = webob.Response()
+            res.body = body
+            res.headers = headers
+        return res
 
 
 class ExtensionController(wsgi.Controller):
diff --git a/nova/tests/api/openstack/extensions/foxinsocks.py b/nova/tests/api/openstack/extensions/foxinsocks.py
index 2e93d8a55..fa979c7b5 100644
--- a/nova/tests/api/openstack/extensions/foxinsocks.py
+++ b/nova/tests/api/openstack/extensions/foxinsocks.py
@@ -49,16 +49,27 @@ class Foxinsocks(object):
     def get_response_extensions(self):
         response_exts = []
 
-        def _resp_handler(res):
+        def _goose_handler(res):
             #NOTE: This only handles JSON responses.
             # You can use content type header to test for XML.
             data = json.loads(res.body)
             data['flavor']['googoose'] = "Gooey goo for chewy chewing!"
             return data
 
-        resp_ext = extensions.ResponseExtension('GET', '/flavors/:(id)',
-                                                _resp_handler)
+        resp_ext = extensions.ResponseExtension('GET', '/v1.0/flavors/:(id)',
+                                                _goose_handler)
         response_exts.append(resp_ext)
+
+        def _bands_handler(res):
+            #NOTE: This only handles JSON responses.
+            # You can use content type header to test for XML.
+            data = json.loads(res.body)
+            data['big_bands'] = 'Pig Bands!'
+            return data
+
+        resp_ext2 = extensions.ResponseExtension('GET', '/v1.0/flavors/:(id)',
+                                                _bands_handler)
+        response_exts.append(resp_ext2)
         return response_exts
 
     def _add_tweedle(self, input_dict, req, id):
diff --git a/nova/tests/api/openstack/test_extensions.py b/nova/tests/api/openstack/test_extensions.py
index 149f1973e..11ed61e0d 100644
--- a/nova/tests/api/openstack/test_extensions.py
+++ b/nova/tests/api/openstack/test_extensions.py
@@ -195,7 +195,7 @@ class ResponseExtensionTest(unittest.TestCase):
         fakes.stub_out_auth(self.stubs)
         self.context = context.get_admin_context()
 
-    def test_get_resources(self):
+    def test_get_resources_with_stub_mgr(self):
 
         test_resp = "Gooey goo for chewy chewing!"
 
@@ -208,6 +208,7 @@ class ResponseExtensionTest(unittest.TestCase):
         resp_ext = extensions.ResponseExtension('GET',
                                                 '/v1.0/flavors/:(id)',
                                                 _resp_handler)
+
         manager = StubExtensionManager(None, None, resp_ext)
         app = fakes.wsgi_app()
         ext_midware = extensions.ExtensionMiddleware(app, manager)
@@ -216,3 +217,17 @@ class ResponseExtensionTest(unittest.TestCase):
         self.assertEqual(200, response.status_int)
         response_data = json.loads(response.body)
         self.assertEqual(test_resp, response_data['flavor']['googoose'])
+
+    def test_get_resources_with_mgr(self):
+
+        test_resp = "Gooey goo for chewy chewing!"
+
+        app = fakes.wsgi_app()
+        ext_midware = extensions.ExtensionMiddleware(app)
+        request = webob.Request.blank("/v1.0/flavors/1")
+        response = request.get_response(ext_midware)
+        self.assertEqual(200, response.status_int)
+        response_data = json.loads(response.body)
+        print response_data
+        self.assertEqual(test_resp, response_data['flavor']['googoose'])
+        self.assertEqual("Pig Bands!", response_data['big_bands'])
-- 
cgit 


From 4f1f5bb1ed2cbb57e9ba8ea481ae31c0e6acc7bd Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Thu, 17 Mar 2011 11:03:07 -0500
Subject: refactoring

---
 nova/compute/manager.py   |  5 +----
 nova/virt/xenapi/vmops.py | 22 +++++++++++++++++-----
 nova/virt/xenapi_conn.py  | 10 +++++-----
 3 files changed, 23 insertions(+), 14 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index b8c3c24cd..6b784f1e3 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -463,7 +463,7 @@ class ComputeManager(manager.Manager):
                 vcpus=instance_type['vcpus'],
                 local_gb=instance_type['local_gb']))
 
-        self.driver._start(instance_ref)
+        self.driver.revert_resize(instance_ref)
         self.db.migration_update(context, migration_id,
                 {'status': 'reverted'})
 
@@ -514,8 +514,6 @@ class ComputeManager(manager.Manager):
         self.db.migration_update(context, migration_id,
                 {'status': 'post-migrating', })
 
-        
-
         service = self.db.service_get_by_host_and_topic(context,
                 migration_ref['dest_compute'], FLAGS.compute_topic)
         topic = self.db.queue_get_for(context, FLAGS.compute_topic,
@@ -536,7 +534,6 @@ class ComputeManager(manager.Manager):
         migration_ref = self.db.migration_get(context, migration_id)
         instance_ref = self.db.instance_get(context,
                 migration_ref['instance_id'])
-        
         #TODO(mdietz): apply the rest of the instance_type attributes going
         #after they're supported
         instance_type = self.db.instance_type_get_by_flavor_id(context,
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 <matt.dietz@rackspace.com>
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')

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 e79eaca86c4073cc8bc6c59be83d0f1bf5e2cea4 Mon Sep 17 00:00:00 2001
From: Mark Washenberger <mark.washenberger@rackspace.com>
Date: Thu, 17 Mar 2011 12:20:22 -0400
Subject: glance image service show testcases

---
 nova/image/glance.py            | 14 +++++++++
 nova/tests/image/test_glance.py | 64 ++++++++++++++++++++++++++++++++++++-----
 2 files changed, 71 insertions(+), 7 deletions(-)

(limited to 'nova')

diff --git a/nova/image/glance.py b/nova/image/glance.py
index 3b448db4b..d0c191ea1 100644
--- a/nova/image/glance.py
+++ b/nova/image/glance.py
@@ -18,6 +18,8 @@
 
 from __future__ import absolute_import
 
+import datetime as dt
+
 from glance.common import exception as glance_exception
 
 from nova import exception
@@ -60,6 +62,18 @@ class GlanceImageService(service.BaseImageService):
         """
         try:
             image = self.client.get_image_meta(image_id)
+            if 'created_at' in image:
+                image['created_at'] = \
+                        dt.datetime.strptime(image['created_at'],
+                                             "%Y-%m-%dT%H:%M:%S.%f")
+            if 'updated_at' in image:
+                image['updated_at'] = \
+                        dt.datetime.strptime(image['updated_at'],
+                                             "%Y-%m-%dT%H:%M:%S.%f")
+            if 'deleted_at' in image and image['deleted_at'] is not None:
+                image['deleted_at'] = \
+                        dt.datetime.strptime(image['deleted_at'],
+                                             "%Y-%m-%dT%H:%M:%S.%f")
         except glance_exception.NotFound:
             raise exception.NotFound
         return image
diff --git a/nova/tests/image/test_glance.py b/nova/tests/image/test_glance.py
index b568f593d..971a32a17 100644
--- a/nova/tests/image/test_glance.py
+++ b/nova/tests/image/test_glance.py
@@ -1,3 +1,4 @@
+import datetime as dt
 import unittest
 
 from nova.image import glance
@@ -5,14 +6,63 @@ from nova.image import glance
 class StubGlanceClient(object):
 
     def __init__(self, images):
-        self._images = images
+        self.images = images
 
-    def get_image_meta(id):
-        return self._images[id]
+    def get_image_meta(self, id):
+        return self.images[id]
+
+    def get_images_detailed(self):
+        return self.images
 
 class TestGlance(unittest.TestCase):
 
-    def test(self):
-        images = {'xyz': "image"}
-        client = StubGlanceClient(images)
-        service = glance.GlanceImageService(client)
+    def setUp(self):
+        self.client = StubGlanceClient(None)
+        self.service = glance.GlanceImageService(self.client)
+
+    def test_show_passes_through_to_client(self):
+        self.client.images = {'xyz': "image"}
+        self.assertEqual(self.service.show({}, 'xyz'), "image")
+
+    def test_detail_passes_through_to_client(self):
+        self.client.images = "these are the images"
+        self.assertEqual(self.service.detail({}), self.client.images)
+
+    def test_show_makes_create_datetimes(self):
+        create_time = dt.datetime.utcnow()
+        self.client.images = {'xyz': {
+            'id': "id",
+            'name': "my awesome image",
+            'created_at': create_time.isoformat(),
+        }}
+        actual = self.service.show({}, 'xyz')
+        self.assertEqual(actual['created_at'], create_time)
+
+    def test_show_makes_update_datetimes(self):
+        update_time = dt.datetime.utcnow()
+        self.client.images = {'abc': {
+            'id': "id",
+            'name': "my okay image",
+            'updated_at': update_time.isoformat(),
+        }}
+        actual = self.service.show({}, 'abc')
+        self.assertEqual(actual['updated_at'], update_time)
+
+    def test_show_makes_delete_datetimes(self):
+        delete_time = dt.datetime.utcnow()
+        self.client.images = {'123': {
+            'id': "123",
+            'name': "my lame image",
+            'deleted_at': delete_time.isoformat(),
+        }}
+        actual = self.service.show({}, '123')
+        self.assertEqual(actual['deleted_at'], delete_time)
+
+    def test_show_handles_deleted_at_none(self):
+        self.client.images = {'747': {
+            'id': "747",
+            'name': "not deleted",
+            'deleted_at': None,
+        }}
+        actual = self.service.show({}, '747')
+        self.assertEqual(actual['deleted_at'], None)
-- 
cgit 


From d6ae8e4c2f6011497b1db23fcbafb23b663f924d Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Thu, 17 Mar 2011 11:24:24 -0500
Subject: Foo

---
 nova/compute/manager.py   | 1 +
 nova/virt/xenapi/vmops.py | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 6b784f1e3..186b6f6a5 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -544,6 +544,7 @@ class ComputeManager(manager.Manager):
                     vcpus=instance_type['vcpus'],
                     local_gb=instance_type['local_gb']))
 
+        instance_ref = self.db.instance_get(context, instance_id)
         self.driver.finish_resize(instance_ref, disk_info)
 
         self.db.migration_update(context, migration_id,
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 b135bc23cca1494049dd9978cb18b52f2b4d99c7 Mon Sep 17 00:00:00 2001
From: Mark Washenberger <mark.washenberger@rackspace.com>
Date: Thu, 17 Mar 2011 12:30:32 -0400
Subject: refactor to simpler implementation

---
 nova/image/glance.py | 27 +++++++++++++++------------
 1 file changed, 15 insertions(+), 12 deletions(-)

(limited to 'nova')

diff --git a/nova/image/glance.py b/nova/image/glance.py
index d0c191ea1..188b6e588 100644
--- a/nova/image/glance.py
+++ b/nova/image/glance.py
@@ -62,22 +62,25 @@ class GlanceImageService(service.BaseImageService):
         """
         try:
             image = self.client.get_image_meta(image_id)
-            if 'created_at' in image:
-                image['created_at'] = \
-                        dt.datetime.strptime(image['created_at'],
-                                             "%Y-%m-%dT%H:%M:%S.%f")
-            if 'updated_at' in image:
-                image['updated_at'] = \
-                        dt.datetime.strptime(image['updated_at'],
-                                             "%Y-%m-%dT%H:%M:%S.%f")
-            if 'deleted_at' in image and image['deleted_at'] is not None:
-                image['deleted_at'] = \
-                        dt.datetime.strptime(image['deleted_at'],
-                                             "%Y-%m-%dT%H:%M:%S.%f")
         except glance_exception.NotFound:
             raise exception.NotFound
+        return self._convert_timestamps_to_datetimes(image)
+
+    def _convert_timestamps_to_datetimes(self, image):
+        """
+        Returns image with known timestamp fields converted to datetime objects
+        """
+        for attr in ['created_at', 'updated_at', 'deleted_at']:
+            if attr in image and image[attr] is not None:
+                image[attr] = self._parse_glance_iso8601_timestamp(image[attr])
         return image
 
+    def _parse_glance_iso8601_timestamp(self, timestamp):
+        """
+        Parse a subset of iso8601 timestamps into datetime objects
+        """
+        return dt.datetime.strptime(timestamp, "%Y-%m-%dT%H:%M:%S.%f")
+
     def show_by_name(self, context, name):
         """
         Returns a dict containing image data for the given name.
-- 
cgit 


From c1f7df80d22b718bc96332c2f52354627d11700d Mon Sep 17 00:00:00 2001
From: Brian Waldon <brian.waldon@rackspace.com>
Date: Thu, 17 Mar 2011 12:31:16 -0400
Subject: adding comments; removing returns from build_extra; removing
 unnecessary backslash

---
 nova/api/openstack/flavors.py       |  2 +-
 nova/api/openstack/views/flavors.py | 26 ++++++++++++++++++++------
 2 files changed, 21 insertions(+), 7 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/flavors.py b/nova/api/openstack/flavors.py
index bc61e8d1a..6eba0f9b8 100644
--- a/nova/api/openstack/flavors.py
+++ b/nova/api/openstack/flavors.py
@@ -46,7 +46,7 @@ class Controller(wsgi.Controller):
         ctxt = req.environ['nova.context']
         flavors = db.api.instance_type_get_all(ctxt)
         builder = flavors_views.get_view_builder(req)
-        items = [builder.build(flavor, is_detail=is_detail) \
+        items = [builder.build(flavor, is_detail=is_detail)
                  for flavor in flavors.values()]
         return items
 
diff --git a/nova/api/openstack/views/flavors.py b/nova/api/openstack/views/flavors.py
index 7d75c0aa2..92003a19f 100644
--- a/nova/api/openstack/views/flavors.py
+++ b/nova/api/openstack/views/flavors.py
@@ -32,26 +32,27 @@ def get_view_builder(req):
 
 
 class ViewBuilder(object):
-    def __init__(self):
-        pass
 
     def build(self, flavor_obj, is_detail=False):
+        """Generic method used to generate a flavor entity."""
         if is_detail:
             flavor = self._build_detail(flavor_obj)
         else:
             flavor = self._build_simple(flavor_obj)
 
-        full_flavor = self._build_extra(flavor)
+        self._build_extra(flavor)
 
-        return full_flavor
+        return flavor
 
     def _build_simple(self, flavor_obj):
+        """Build a minimal representation of a flavor."""
         return {
             "id": flavor_obj["flavorid"],
             "name": flavor_obj["name"],
         }
 
     def _build_detail(self, flavor_obj):
+        """Build a more complete representation of a flavor."""
         simple = self._build_simple(flavor_obj)
 
         detail = {
@@ -64,19 +65,26 @@ class ViewBuilder(object):
         return detail
 
     def _build_extra(self, flavor_obj):
-        return flavor_obj
+        """Hook for version-specific changes to newly created flavor object."""
+        pass
 
 
 class ViewBuilder_1_1(ViewBuilder):
+    """Openstack API v1.1 flavors view builder."""
+
     def __init__(self, base_url):
+        """
+        :param base_url: url of the root wsgi application
+        """
         self.base_url = base_url
 
     def _build_extra(self, flavor_obj):
         flavor_obj["links"] = self._build_links(flavor_obj)
-        return flavor_obj
 
     def _build_links(self, flavor_obj):
+        """Generate a container of links that refer to the provided flavor."""
         href = self.generate_href(flavor_obj["id"])
+
         links = [
             {
                 "rel": "self",
@@ -93,11 +101,17 @@ class ViewBuilder_1_1(ViewBuilder):
                 "href": href,
             },
         ]
+
         return links
 
     def generate_href(self, flavor_id):
+        """Create an url that refers to a specific flavor id."""
         return "%s/flavors/%s" % (self.base_url, flavor_id)
 
 
 class ViewBuilder_1_0(ViewBuilder):
+    """
+    Openstack API v1.0 flavors view builder. Currently, there
+    are no 1.0-specific attributes of a flavor.
+    """
     pass
-- 
cgit 


From d31e0f0ad048fbd0374170ea76968859a4c6df34 Mon Sep 17 00:00:00 2001
From: Brian Lamar <brian.lamar@rackspace.com>
Date: Thu, 17 Mar 2011 12:39:09 -0400
Subject: Fixed pep8 violation.

---
 nova/api/openstack/faults.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/api/openstack/faults.py b/nova/api/openstack/faults.py
index d05c61fc7..56f5b8e7e 100644
--- a/nova/api/openstack/faults.py
+++ b/nova/api/openstack/faults.py
@@ -94,5 +94,6 @@ class OverLimitFault(webob.exc.HTTPException):
         """Currently just return the wrapped exception."""
         serializer = wsgi.Serializer(self._serialization_metadata)
         content_type = request.best_match_content_type()
-        self.wrapped_exc.body = serializer.serialize(self.content, content_type)
+        content = serializer.serialize(self.content, content_type)
+        self.wrapped_exc.body = content
         return self.wrapped_exc
-- 
cgit 


From 686e113188aaf8195aed7bea8bf70c21b6bff498 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Thu, 17 Mar 2011 12:04:49 -0500
Subject: Mapping the resize status

---
 nova/api/openstack/servers.py | 8 +++++++-
 nova/compute/manager.py       | 2 ++
 2 files changed, 9 insertions(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 47ed254ec..59234b0de 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -61,7 +61,13 @@ def _translate_detail_keys(inst):
     for k, v in mapped_keys.iteritems():
         inst_dict[k] = inst[v]
 
-    inst_dict['status'] = power_mapping[inst_dict['status']]
+    context = req.environ['nova.context'].elevated()
+    migration = self.db.migrate_get_by_instance_and_status(context,
+            inst['id'], 'finished') 
+    if migration:
+        inst_dict['status'] = 'resize-confirm'
+    else
+        inst_dict['status'] = power_mapping[inst_dict['status']]
     inst_dict['addresses'] = dict(public=[], private=[])
 
     # grab single private fixed ip
diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 186b6f6a5..7993298b9 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -544,6 +544,8 @@ class ComputeManager(manager.Manager):
                     vcpus=instance_type['vcpus'],
                     local_gb=instance_type['local_gb']))
 
+        # reload the updated instance ref
+        # FIXME: is there reload functionality?
         instance_ref = self.db.instance_get(context, instance_id)
         self.driver.finish_resize(instance_ref, disk_info)
 
-- 
cgit 


From 3afeb8466fa9f005edc9da182b1e0af6ffb00ade Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Thu, 17 Mar 2011 12:05:43 -0500
Subject: Mapping the resize status

---
 nova/api/openstack/servers.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 59234b0de..fd835c247 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -66,7 +66,7 @@ def _translate_detail_keys(inst):
             inst['id'], 'finished') 
     if migration:
         inst_dict['status'] = 'resize-confirm'
-    else
+    else:
         inst_dict['status'] = power_mapping[inst_dict['status']]
     inst_dict['addresses'] = dict(public=[], private=[])
 
-- 
cgit 


From f96dea3da633fc71f16de1bdb95e88249b316e29 Mon Sep 17 00:00:00 2001
From: Brian Lamar <brian.lamar@rackspace.com>
Date: Thu, 17 Mar 2011 13:11:40 -0400
Subject: Pep8 error, oddly specific to pep8 v0.5 < x > v0.6

---
 nova/api/openstack/faults.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/faults.py b/nova/api/openstack/faults.py
index 56f5b8e7e..ccccbd3d2 100644
--- a/nova/api/openstack/faults.py
+++ b/nova/api/openstack/faults.py
@@ -71,9 +71,9 @@ class OverLimitFault(webob.exc.HTTPException):
     _serialization_metadata = {
         "application/xml": {
             "attributes": {
-                "overLimitFault": "code"
-            }
-        }
+                "overLimitFault": "code",
+            },
+        },
     }
 
     def __init__(self, message, details, retry_time):
-- 
cgit 


From 1f99a95b8615e55c9828eb36e12b9aaa762470bb Mon Sep 17 00:00:00 2001
From: Eldar Nugaev <enugaev@griddynamics.com>
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')

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 3ee835c60d2b43086b1e324501025d1f0221da27 Mon Sep 17 00:00:00 2001
From: Mark Washenberger <mark.washenberger@rackspace.com>
Date: Thu, 17 Mar 2011 13:50:41 -0400
Subject: handle timestamps in glance service detail

---
 nova/image/glance.py            |  3 ++-
 nova/tests/image/test_glance.py | 27 ++++++++++++++++++++++++---
 2 files changed, 26 insertions(+), 4 deletions(-)

(limited to 'nova')

diff --git a/nova/image/glance.py b/nova/image/glance.py
index 188b6e588..7706a42e4 100644
--- a/nova/image/glance.py
+++ b/nova/image/glance.py
@@ -54,7 +54,8 @@ class GlanceImageService(service.BaseImageService):
         """
         Calls out to Glance for a list of detailed image information
         """
-        return self.client.get_images_detailed()
+        for image in self.client.get_images_detailed():
+            yield self._convert_timestamps_to_datetimes(image)
 
     def show(self, context, image_id):
         """
diff --git a/nova/tests/image/test_glance.py b/nova/tests/image/test_glance.py
index 971a32a17..16fe0e7c0 100644
--- a/nova/tests/image/test_glance.py
+++ b/nova/tests/image/test_glance.py
@@ -12,7 +12,7 @@ class StubGlanceClient(object):
         return self.images[id]
 
     def get_images_detailed(self):
-        return self.images
+        return self.images.itervalues()
 
 class TestGlance(unittest.TestCase):
 
@@ -25,8 +25,8 @@ class TestGlance(unittest.TestCase):
         self.assertEqual(self.service.show({}, 'xyz'), "image")
 
     def test_detail_passes_through_to_client(self):
-        self.client.images = "these are the images"
-        self.assertEqual(self.service.detail({}), self.client.images)
+        self.client.images = {1: "an image"}
+        self.assertEqual(list(self.service.detail({})), ["an image"])
 
     def test_show_makes_create_datetimes(self):
         create_time = dt.datetime.utcnow()
@@ -66,3 +66,24 @@ class TestGlance(unittest.TestCase):
         }}
         actual = self.service.show({}, '747')
         self.assertEqual(actual['deleted_at'], None)
+
+    def test_detail_handles_timestamps(self):
+        now = dt.datetime.utcnow()
+        image1 = {
+            'id': 1,
+            'name': 'image 1',
+            'created_at': now.isoformat(),
+            'updated_at': now.isoformat(),
+            'deleted_at': None,
+        }
+        image2 = {
+            'id': 2,
+            'name': 'image 2',
+            'deleted_at': now.isoformat(),
+        }
+        self.client.images = {1: image1, 2: image2}
+        i1, i2 = self.service.detail({})
+        self.assertEqual(i1['created_at'], now)
+        self.assertEqual(i1['updated_at'], now)
+        self.assertEqual(i1['deleted_at'], None)
+        self.assertEqual(i2['deleted_at'], now)
-- 
cgit 


From 31388f18f8c0ebe3cae58ebd2a46e2bedb376fd4 Mon Sep 17 00:00:00 2001
From: Ilya Alekseyev <ialekseev@griddynamics.com>
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')

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 66c237a4d321887830e5282781870525abf00365 Mon Sep 17 00:00:00 2001
From: Mark Washenberger <mark.washenberger@rackspace.com>
Date: Thu, 17 Mar 2011 14:04:31 -0400
Subject: teach glance image server get to handle timestamps

---
 nova/image/glance.py            |  2 +-
 nova/tests/image/test_glance.py | 30 +++++++++++++++++++++++++++++-
 2 files changed, 30 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/image/glance.py b/nova/image/glance.py
index 7706a42e4..f725fe176 100644
--- a/nova/image/glance.py
+++ b/nova/image/glance.py
@@ -108,7 +108,7 @@ class GlanceImageService(service.BaseImageService):
             raise exception.NotFound
         for chunk in image_chunks:
             data.write(chunk)
-        return metadata
+        return self._convert_timestamps_to_datetimes(metadata)
 
     def create(self, context, metadata, data=None):
         """
diff --git a/nova/tests/image/test_glance.py b/nova/tests/image/test_glance.py
index 16fe0e7c0..1e6c45219 100644
--- a/nova/tests/image/test_glance.py
+++ b/nova/tests/image/test_glance.py
@@ -14,7 +14,17 @@ class StubGlanceClient(object):
     def get_images_detailed(self):
         return self.images.itervalues()
 
-class TestGlance(unittest.TestCase):
+    def get_image(self, id):
+        return self.images[id], []
+
+
+class NullWriter(object):
+
+    def write(self, *arg, **kwargs):
+        pass
+
+
+class TestGlanceImageServiceDatetimes(unittest.TestCase):
 
     def setUp(self):
         self.client = StubGlanceClient(None)
@@ -87,3 +97,21 @@ class TestGlance(unittest.TestCase):
         self.assertEqual(i1['updated_at'], now)
         self.assertEqual(i1['deleted_at'], None)
         self.assertEqual(i2['deleted_at'], now)
+
+    def test_get_handles_timestamps(self):
+        now = dt.datetime.utcnow()
+        self.client.images = {'abcd': {
+            'id': 'abcd',
+            'name': 'nifty image',
+            'created_at': now.isoformat(),
+            'updated_at': now.isoformat(),
+            'deleted_at': now.isoformat(),
+        }}
+        actual = self.service.get({}, 'abcd', NullWriter())
+        for attr in ('created_at', 'updated_at', 'deleted_at'):
+            self.assertEqual(actual[attr], now)
+
+    def test_get_handles_deleted_at_none(self):
+        self.client.images = {'abcd': {'deleted_at': None}}
+        actual = self.service.get({}, 'abcd', NullWriter())
+        self.assertEqual(actual['deleted_at'], None)
-- 
cgit 


From c8e474d04dce462650c2a9f57cbcb106ce3ef0c9 Mon Sep 17 00:00:00 2001
From: Mark Washenberger <mark.washenberger@rackspace.com>
Date: Thu, 17 Mar 2011 14:05:08 -0400
Subject: pep8

---
 nova/tests/image/test_glance.py | 1 +
 1 file changed, 1 insertion(+)

(limited to 'nova')

diff --git a/nova/tests/image/test_glance.py b/nova/tests/image/test_glance.py
index 1e6c45219..9b17cf261 100644
--- a/nova/tests/image/test_glance.py
+++ b/nova/tests/image/test_glance.py
@@ -3,6 +3,7 @@ import unittest
 
 from nova.image import glance
 
+
 class StubGlanceClient(object):
 
     def __init__(self, images):
-- 
cgit 


From 99a3899291ef14149bee0581ad7615e07dfc55c1 Mon Sep 17 00:00:00 2001
From: Brian Waldon <brian.waldon@rackspace.com>
Date: Thu, 17 Mar 2011 14:07:25 -0400
Subject: adding serialization_metadata to encode links on flavors

---
 nova/api/openstack/flavors.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/api/openstack/flavors.py b/nova/api/openstack/flavors.py
index 6eba0f9b8..f0936332c 100644
--- a/nova/api/openstack/flavors.py
+++ b/nova/api/openstack/flavors.py
@@ -29,7 +29,11 @@ class Controller(wsgi.Controller):
     _serialization_metadata = {
         'application/xml': {
             "attributes": {
-                "flavor": ["id", "name", "ram", "disk"]}}}
+                "flavor": ["id", "name", "ram", "disk"],
+                "link": ["rel","type","href"],
+            }
+        }
+    }
 
     def index(self, req):
         """Return all flavors in brief."""
-- 
cgit 


From 5a141466db962e184ced0a57efb6bfe94ff5a246 Mon Sep 17 00:00:00 2001
From: Brian Waldon <brian.waldon@rackspace.com>
Date: Thu, 17 Mar 2011 14:09:44 -0400
Subject: pep8

---
 nova/api/openstack/flavors.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/api/openstack/flavors.py b/nova/api/openstack/flavors.py
index f0936332c..e9ee9d012 100644
--- a/nova/api/openstack/flavors.py
+++ b/nova/api/openstack/flavors.py
@@ -30,7 +30,7 @@ class Controller(wsgi.Controller):
         'application/xml': {
             "attributes": {
                 "flavor": ["id", "name", "ram", "disk"],
-                "link": ["rel","type","href"],
+                "link": ["rel", "type", "href"],
             }
         }
     }
-- 
cgit 


From 6d6d0f686a7f8d47263b7ed725bdae0f322b2a4e Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Thu, 17 Mar 2011 11:34:14 -0700
Subject: better implementation of try..except..else

---
 nova/image/local.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/image/local.py b/nova/image/local.py
index c304a2212..609d6c42a 100644
--- a/nova/image/local.py
+++ b/nova/image/local.py
@@ -53,13 +53,13 @@ class LocalImageService(service.BaseImageService):
         images = []
         for image_dir in os.listdir(self._path):
             try:
-                images.append(int(image_dir, 16))
+                unhexed_image_id = int(image_dir, 16)
             except ValueError:
                 LOG.error(
                     _("%s is not in correct directory naming format"\
                        % image_dir))
-            except:
-                raise
+            else:
+                images.append(unhexed_image_id)
         return images
 
     def index(self, context):
-- 
cgit 


From 4334ca9d6b0ac8a9b2edb1fbcbf0bc4df28b2961 Mon Sep 17 00:00:00 2001
From: Mark Washenberger <mark.washenberger@rackspace.com>
Date: Thu, 17 Mar 2011 15:04:28 -0400
Subject: get api openstack test_images working

---
 nova/image/glance.py                    | 7 ++++---
 nova/tests/api/openstack/test_images.py | 8 ++++----
 2 files changed, 8 insertions(+), 7 deletions(-)

(limited to 'nova')

diff --git a/nova/image/glance.py b/nova/image/glance.py
index f725fe176..55dc5488d 100644
--- a/nova/image/glance.py
+++ b/nova/image/glance.py
@@ -42,7 +42,8 @@ class GlanceImageService(service.BaseImageService):
     def __init__(self, client=None):
         if client is None:
             self.client = GlanceClient(FLAGS.glance_host, FLAGS.glance_port)
-        self.client = client
+        else:
+            self.client = client
 
     def index(self, context):
         """
@@ -54,8 +55,8 @@ class GlanceImageService(service.BaseImageService):
         """
         Calls out to Glance for a list of detailed image information
         """
-        for image in self.client.get_images_detailed():
-            yield self._convert_timestamps_to_datetimes(image)
+        return [self._convert_timestamps_to_datetimes(image)
+                for image in self.client.get_images_detailed()]
 
     def show(self, context, image_id):
         """
diff --git a/nova/tests/api/openstack/test_images.py b/nova/tests/api/openstack/test_images.py
index 76f758929..47dd11e5b 100644
--- a/nova/tests/api/openstack/test_images.py
+++ b/nova/tests/api/openstack/test_images.py
@@ -182,8 +182,8 @@ class ImageControllerWithGlanceServiceTest(test.TestCase):
         {'id': '23g2ogk23k4hhkk4k42l',
          'imageId': '23g2ogk23k4hhkk4k42l',
          'name': 'public image #1',
-         'created_at': str(datetime.datetime.utcnow()),
-         'updated_at': str(datetime.datetime.utcnow()),
+         'created_at': datetime.datetime.utcnow().isoformat(),
+         'updated_at': datetime.datetime.utcnow().isoformat(),
          'deleted_at': None,
          'deleted': False,
          'is_public': True,
@@ -192,8 +192,8 @@ class ImageControllerWithGlanceServiceTest(test.TestCase):
         {'id': 'slkduhfas73kkaskgdas',
          'imageId': 'slkduhfas73kkaskgdas',
          'name': 'public image #2',
-         'created_at': str(datetime.datetime.utcnow()),
-         'updated_at': str(datetime.datetime.utcnow()),
+         'created_at': datetime.datetime.utcnow().isoformat(),
+         'updated_at': datetime.datetime.utcnow().isoformat(),
          'deleted_at': None,
          'deleted': False,
          'is_public': True,
-- 
cgit 


From 25c407b6ade499dd0bdd470e7fd46682c34a98b7 Mon Sep 17 00:00:00 2001
From: "matt.dietz@rackspace.com" <>
Date: Thu, 17 Mar 2011 19:13:09 +0000
Subject: Get the migration out

---
 nova/api/openstack/servers.py | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index fd835c247..601a68508 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -20,6 +20,8 @@ import traceback
 from webob import exc
 
 from nova import compute
+from nova import context
+from nova import db
 from nova import exception
 from nova import flags
 from nova import log as logging
@@ -61,12 +63,12 @@ def _translate_detail_keys(inst):
     for k, v in mapped_keys.iteritems():
         inst_dict[k] = inst[v]
 
-    context = req.environ['nova.context'].elevated()
-    migration = self.db.migrate_get_by_instance_and_status(context,
-            inst['id'], 'finished') 
-    if migration:
+    ctxt = context.get_admin_context()
+    try:
+        migration = db.migration_get_by_instance_and_status(ctxt,
+                inst['id'], 'finished') 
         inst_dict['status'] = 'resize-confirm'
-    else:
+    except Exception, e:
         inst_dict['status'] = power_mapping[inst_dict['status']]
     inst_dict['addresses'] = dict(public=[], private=[])
 
-- 
cgit 


From ca267d0e52ed721f1236dc4b6030433fe92d0d51 Mon Sep 17 00:00:00 2001
From: Dan Prince <dan.prince@rackspace.com>
Date: Thu, 17 Mar 2011 15:27:20 -0400
Subject: Move the check for None personalities into the create method.

---
 nova/api/openstack/servers.py | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 6dd66a9a5..c6422add4 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -172,8 +172,10 @@ class Controller(wsgi.Controller):
             for k, v in env['server']['metadata'].items():
                 metadata.append({'key': k, 'value': v})
 
-        personality = env['server'].get('personality', [])
-        injected_files = self._get_injected_files(personality)
+        personality = env['server'].get('personality')
+        injected_files = []
+        if personality:
+            injected_files = self._get_injected_files(personality)
 
         try:
             instances = self.compute_api.create(
@@ -221,9 +223,6 @@ class Controller(wsgi.Controller):
         """
         injected_files = []
 
-        if not personality:
-            return injected_files
-
         for item in personality:
             try:
                 path = item['path']
-- 
cgit 


From 2f1a1d293915cde6e15c85e0bb43fb21ae26f7b0 Mon Sep 17 00:00:00 2001
From: Mark Washenberger <mark.washenberger@rackspace.com>
Date: Thu, 17 Mar 2011 15:29:54 -0400
Subject: handle create and update requests, and update the base image service
 documentation to reflect the (defacto) behavior

---
 nova/image/glance.py            |  7 +++---
 nova/image/service.py           |  4 +--
 nova/tests/image/test_glance.py | 54 ++++++++++++++++++++++++++++++++++++++++-
 3 files changed, 59 insertions(+), 6 deletions(-)

(limited to 'nova')

diff --git a/nova/image/glance.py b/nova/image/glance.py
index 55dc5488d..fbb578585 100644
--- a/nova/image/glance.py
+++ b/nova/image/glance.py
@@ -118,7 +118,8 @@ class GlanceImageService(service.BaseImageService):
         :raises AlreadyExists if the image already exist.
 
         """
-        return self.client.add_image(metadata, data)
+        return self._convert_timestamps_to_datetimes(
+            self.client.add_image(metadata, data))
 
     def update(self, context, image_id, metadata, data=None):
         """Replace the contents of the given image with the new data.
@@ -127,10 +128,10 @@ class GlanceImageService(service.BaseImageService):
 
         """
         try:
-            result = self.client.update_image(image_id, metadata, data)
+            metadata = self.client.update_image(image_id, metadata, data)
         except glance_exception.NotFound:
             raise exception.NotFound
-        return result
+        return self._convert_timestamps_to_datetimes(metadata)
 
     def delete(self, context, image_id):
         """
diff --git a/nova/image/service.py b/nova/image/service.py
index 78d8f33e9..e907381c9 100644
--- a/nova/image/service.py
+++ b/nova/image/service.py
@@ -88,7 +88,7 @@ class BaseImageService(object):
 
     def create(self, context, metadata, data=None):
         """
-        Store the image metadata and data and return the new image id.
+        Store the image metadata and data and return the new image metadata.
 
         :raises AlreadyExists if the image already exist.
 
@@ -96,7 +96,7 @@ class BaseImageService(object):
         raise NotImplementedError
 
     def update(self, context, image_id, metadata, data=None):
-        """Update the given image with the new metadata and data.
+        """Update the given image metadata and data and return the metadata
 
         :raises NotFound if the image does not exist.
 
diff --git a/nova/tests/image/test_glance.py b/nova/tests/image/test_glance.py
index 9b17cf261..6e94aa909 100644
--- a/nova/tests/image/test_glance.py
+++ b/nova/tests/image/test_glance.py
@@ -6,8 +6,10 @@ from nova.image import glance
 
 class StubGlanceClient(object):
 
-    def __init__(self, images):
+    def __init__(self, images, add_response=None, update_response=None):
         self.images = images
+        self.add_response = add_response
+        self.update_response = update_response
 
     def get_image_meta(self, id):
         return self.images[id]
@@ -18,6 +20,12 @@ class StubGlanceClient(object):
     def get_image(self, id):
         return self.images[id], []
 
+    def add_image(self, metadata, data):
+        return self.add_response
+
+    def update_image(self, image_id, metadata, data):
+        return self.update_response
+
 
 class NullWriter(object):
 
@@ -116,3 +124,47 @@ class TestGlanceImageServiceDatetimes(unittest.TestCase):
         self.client.images = {'abcd': {'deleted_at': None}}
         actual = self.service.get({}, 'abcd', NullWriter())
         self.assertEqual(actual['deleted_at'], None)
+
+    def test_create_handles_timestamps(self):
+        now = dt.datetime.utcnow()
+        self.client.add_response = {
+            'id': 'abcd',
+            'name': 'blah',
+            'created_at': now.isoformat(),
+            'updated_at': now.isoformat(),
+            'deleted_at': now.isoformat(),
+        }
+        actual = self.service.create({}, {})
+        for attr in ('created_at', 'updated_at', 'deleted_at'):
+            self.assertEqual(actual[attr], now)
+
+    def test_create_handles_deleted_at_none(self):
+        self.client.add_response = {
+            'id': 'abcd',
+            'name': 'blah',
+            'deleted_at': None,
+        }
+        actual = self.service.create({}, {})
+        self.assertEqual(actual['deleted_at'], None)
+
+    def test_update_handles_timestamps(self):
+        now = dt.datetime.utcnow()
+        self.client.update_response = {
+            'id': 'abcd',
+            'name': 'blah',
+            'created_at': now.isoformat(),
+            'updated_at': now.isoformat(),
+            'deleted_at': now.isoformat(),
+        }
+        actual = self.service.update({}, 'dummy_id', {})
+        for attr in ('created_at', 'updated_at', 'deleted_at'):
+            self.assertEqual(actual[attr], now)
+
+    def test_create_handles_deleted_at_none(self):
+        self.client.update_response = {
+            'id': 'abcd',
+            'name': 'blah',
+            'deleted_at': None,
+        }
+        actual = self.service.update({}, 'dummy_id', {})
+        self.assertEqual(actual['deleted_at'], None)
-- 
cgit 


From 192d3ad7bb9cf49abbca98b0d8e9ae822b204365 Mon Sep 17 00:00:00 2001
From: Monsyne Dragon <mdragon@rackspace.com>
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')

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 35bd58bd9dc6441f5620b262d1f65b852f56c67c Mon Sep 17 00:00:00 2001
From: Brian Waldon <brian.waldon@rackspace.com>
Date: Thu, 17 Mar 2011 15:43:56 -0400
Subject: moving Versions app out of __init__.py into its own module; adding
 openstack versions tests; adding links to version entities

---
 nova/api/openstack/__init__.py            | 18 ---------
 nova/api/openstack/versions.py            | 55 ++++++++++++++++++++++++++++
 nova/api/openstack/views/versions.py      | 57 +++++++++++++++++++++++++++++
 nova/tests/api/openstack/fakes.py         |  3 +-
 nova/tests/api/openstack/test_versions.py | 61 +++++++++++++++++++++++++++++++
 5 files changed, 175 insertions(+), 19 deletions(-)
 create mode 100644 nova/api/openstack/versions.py
 create mode 100644 nova/api/openstack/views/versions.py
 create mode 100644 nova/tests/api/openstack/test_versions.py

(limited to 'nova')

diff --git a/nova/api/openstack/__init__.py b/nova/api/openstack/__init__.py
index 0244bc93c..eb0402962 100644
--- a/nova/api/openstack/__init__.py
+++ b/nova/api/openstack/__init__.py
@@ -121,21 +121,3 @@ class APIRouter(wsgi.Router):
                         controller=shared_ip_groups.Controller())
 
         super(APIRouter, self).__init__(mapper)
-
-
-class Versions(wsgi.Application):
-    @webob.dec.wsgify(RequestClass=wsgi.Request)
-    def __call__(self, req):
-        """Respond to a request for all OpenStack API versions."""
-        response = {
-            "versions": [
-                dict(status="DEPRECATED", id="v1.0"),
-                dict(status="CURRENT", id="v1.1"),
-            ],
-        }
-        metadata = {
-            "application/xml": {
-                "attributes": dict(version=["status", "id"])}}
-
-        content_type = req.best_match_content_type()
-        return wsgi.Serializer(metadata).serialize(response, content_type)
diff --git a/nova/api/openstack/versions.py b/nova/api/openstack/versions.py
new file mode 100644
index 000000000..f0f2c484c
--- /dev/null
+++ b/nova/api/openstack/versions.py
@@ -0,0 +1,55 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# 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.
+
+import webob.dec
+import webob.exc
+
+from nova import wsgi
+import nova.api.openstack.views.versions
+
+
+class Versions(wsgi.Application):
+    @webob.dec.wsgify(RequestClass=wsgi.Request)
+    def __call__(self, req):
+        """Respond to a request for all OpenStack API versions."""
+        version_objs = [
+            {
+                "id": "v1.1",
+                "status": "CURRENT",
+            },
+            {
+                "id": "v1.0",
+                "status": "DEPRECATED",
+            },
+        ]
+
+        builder = nova.api.openstack.views.versions.get_view_builder(req)
+        versions = [builder.build(version) for version in version_objs]
+        response = dict(versions=versions)
+
+        metadata = {
+            "application/xml": {
+                "attributes": {
+                    "version": ["status", "id"],
+                    "link": ["rel", "href"],
+                }
+            }
+        }
+
+        content_type = req.best_match_content_type()
+        return wsgi.Serializer(metadata).serialize(response, content_type)
diff --git a/nova/api/openstack/views/versions.py b/nova/api/openstack/views/versions.py
new file mode 100644
index 000000000..555d58d5c
--- /dev/null
+++ b/nova/api/openstack/views/versions.py
@@ -0,0 +1,57 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010-2011 OpenStack LLC.
+# 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.
+
+
+def get_view_builder(req):
+    base_url = req.application_url
+    return ViewBuilder(base_url)
+
+
+class ViewBuilder(object):
+
+    def __init__(self, base_url):
+        """
+        :param base_url: url of the root wsgi application
+        """
+        self.base_url = base_url
+
+    def build(self, version_data):
+        """Generic method used to generate a version entity."""
+        version = {
+            "id": version_data["id"],
+            "status": version_data["status"],
+            "links": self._build_links(version_data),
+        }
+
+        return version
+
+    def _build_links(self, version_data):
+        """Generate a container of links that refer to the provided version."""
+        href = self.generate_href(version_data["id"])
+
+        links = [
+            {
+                "rel": "self",
+                "href": href,
+            },
+        ]
+
+        return links
+
+    def generate_href(self, version_number):
+        """Create an url that refers to a specific version_number."""
+        return "%s/%s" % (self.base_url, version_number)
diff --git a/nova/tests/api/openstack/fakes.py b/nova/tests/api/openstack/fakes.py
index a08fe385a..3b7e558b6 100644
--- a/nova/tests/api/openstack/fakes.py
+++ b/nova/tests/api/openstack/fakes.py
@@ -35,6 +35,7 @@ import nova.api.openstack.auth
 from nova.api import openstack
 from nova.api.openstack import auth
 from nova.api.openstack import ratelimiting
+from nova.api.openstack import versions
 from nova.auth.manager import User, Project
 from nova.image import glance
 from nova.image import local
@@ -80,7 +81,7 @@ def wsgi_app(inner_application=None):
               ratelimiting.RateLimitingMiddleware(inner_application)))
     mapper['/v1.0'] = api
     mapper['/v1.1'] = api
-    mapper['/'] = openstack.FaultWrapper(openstack.Versions())
+    mapper['/'] = openstack.FaultWrapper(versions.Versions())
     return mapper
 
 
diff --git a/nova/tests/api/openstack/test_versions.py b/nova/tests/api/openstack/test_versions.py
new file mode 100644
index 000000000..330d74dde
--- /dev/null
+++ b/nova/tests/api/openstack/test_versions.py
@@ -0,0 +1,61 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 OpenStack LLC.
+# 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.
+
+import json
+import webob
+
+from nova import context
+from nova import test
+from nova.tests.api.openstack import fakes
+
+
+class VersionsTest(test.TestCase):
+    def setUp(self):
+        super(VersionsTest, self).setUp()
+        self.context = context.get_admin_context()
+
+    def tearDown(self):
+        super(VersionsTest, self).tearDown()
+
+    def test_get_version_list(self):
+        req = webob.Request.blank('/')
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
+        versions = json.loads(res.body)["versions"]
+        expected = [
+            {
+                "id": "v1.1",
+                "status": "CURRENT",
+                "links": [
+                    {
+                        "rel": "self",
+                        "href": "http://localhost/v1.1",
+                    }
+                ],
+            },
+            {
+                "id": "v1.0",
+                "status": "DEPRECATED",
+                "links": [
+                    {
+                        "rel": "self",
+                        "href": "http://localhost/v1.0",
+                    }
+                ],
+            },
+        ]
+        self.assertEqual(versions, expected)
-- 
cgit 


From e138e0836922ee0608feefbff5e4e5d03ad14197 Mon Sep 17 00:00:00 2001
From: Naveed Massjouni <naveedm9@gmail.com>
Date: Thu, 17 Mar 2011 16:02:37 -0400
Subject: Now returns a 400 for a create server request with invalid hrefs for
 imageRef/flavorRef values. Also added tests.

---
 nova/api/openstack/common.py             | 12 +++++-
 nova/api/openstack/servers.py            |  5 +--
 nova/tests/api/openstack/test_servers.py | 64 +++++++++++++-------------------
 3 files changed, 37 insertions(+), 44 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/common.py b/nova/api/openstack/common.py
index 74ac21024..b224cbfb4 100644
--- a/nova/api/openstack/common.py
+++ b/nova/api/openstack/common.py
@@ -15,9 +15,10 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-import webob.exc
-
+import re
 from nova import exception
+from webob import exc
+import webob.exc
 
 
 def limited(items, request, max_limit=1000):
@@ -74,3 +75,10 @@ def get_image_id_from_image_hash(image_service, context, image_hash):
         if abs(hash(image_id)) == int(image_hash):
             return image_id
     raise exception.NotFound(image_hash)
+
+
+def get_id_from_href(href):
+    m = re.match(r'http.+/.+/(\d)+$', href)
+    if not m:
+        raise exc.HTTPBadRequest(_('could not parse id from href'))
+    return int(m.group(1))
diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index f03225b55..6f25d10bd 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -512,7 +512,6 @@ class Controller(wsgi.Controller):
 
         return kernel_id, ramdisk_id
 
-
 class ControllerV10(Controller):
     def _image_id_from_req_data(self, data):
         return data['server']['imageId']
@@ -532,11 +531,11 @@ class ControllerV10(Controller):
 class ControllerV11(Controller):
     def _image_id_from_req_data(self, data):
         href = data['server']['imageRef']
-        return href.split('/')[-1]
+        return common.get_id_from_href(href)
 
     def _flavor_id_from_req_data(self, data):
         href = data['server']['flavorRef']
-        return href.split('/')[-1]
+        return common.get_id_from_href(href)
 
     def _get_view_builder(self, req):
         base_url = req.application_url
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 846af5c3a..6e78db9da 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -239,7 +239,7 @@ class ServersTest(test.TestCase):
         servers = json.loads(res.body)['servers']
         self.assertEqual([s['id'] for s in servers], [1, 2])
 
-    def _test_create_instance_helper(self):
+    def _setup_for_create_instance(self):
         """Shared implementation for tests below that create instance"""
         def instance_create(context, inst):
             return {'id': '1', 'display_name': 'server_test'}
@@ -276,6 +276,9 @@ class ServersTest(test.TestCase):
         self.stubs.Set(nova.api.openstack.common,
             "get_image_id_from_image_hash", image_id_from_hash)
 
+    def _test_create_instance_helper(self):
+        self._setup_for_create_instance()
+
         body = dict(server=dict(
             name='server_test', imageId=3, flavorId=2,
             metadata={'hello': 'world', 'open': 'stack'},
@@ -296,41 +299,15 @@ class ServersTest(test.TestCase):
         self.assertEqual(3, server['imageId'])
         self.assertEqual(res.status_int, 200)
 
-    def test_create_instance_v11(self):
-        def instance_create(context, inst):
-            return {'id': '1', 'display_name': 'server_test'}
-
-        def server_update(context, id, params):
-            return instance_create(context, id)
-
-        def fake_method(*args, **kwargs):
-            pass
-
-        def project_get_network(context, user_id):
-            return dict(id='1', host='localhost')
-
-        def queue_get_for(context, *args):
-            return 'network_topic'
-
-        def kernel_ramdisk_mapping(*args, **kwargs):
-            return (1, 1)
+    def test_create_instance(self):
+        self._test_create_instance_helper()
 
-        def image_id_from_hash(*args, **kwargs):
-            return 2
+    def test_create_instance_no_key_pair(self):
+        fakes.stub_out_key_pair_funcs(self.stubs, have_key_pair=False)
+        self._test_create_instance_helper()
 
-        self.stubs.Set(nova.db.api, 'project_get_network', project_get_network)
-        self.stubs.Set(nova.db.api, 'instance_create', instance_create)
-        self.stubs.Set(nova.rpc, 'cast', fake_method)
-        self.stubs.Set(nova.rpc, 'call', fake_method)
-        self.stubs.Set(nova.db.api, 'instance_update',
-            server_update)
-        self.stubs.Set(nova.db.api, 'queue_get_for', queue_get_for)
-        self.stubs.Set(nova.network.manager.VlanManager, 'allocate_fixed_ip',
-            fake_method)
-        self.stubs.Set(nova.api.openstack.servers.Controller,
-            "_get_kernel_ramdisk_from_image", kernel_ramdisk_mapping)
-        self.stubs.Set(nova.api.openstack.common,
-            "get_image_id_from_image_hash", image_id_from_hash)
+    def test_create_instance_v11(self):
+        self._setup_for_create_instance()
 
         imageRef = 'http://localhost/v1.1/images/2'
         flavorRef = 'http://localhost/v1.1/flavors/3'
@@ -354,12 +331,21 @@ class ServersTest(test.TestCase):
         self.assertEqual(imageRef, server['imageRef'])
         self.assertEqual(res.status_int, 200)
 
-    def test_create_instance(self):
-        self._test_create_instance_helper()
+    def test_create_instance_v11_bad_href(self):
+        self._setup_for_create_instance()
 
-    def test_create_instance_no_key_pair(self):
-        fakes.stub_out_key_pair_funcs(self.stubs, have_key_pair=False)
-        self._test_create_instance_helper()
+        imageRef = 'http://localhost/v1.1/images/asdf'
+        flavorRef = 'http://localhost/v1.1/flavors/3'
+        body = dict(server=dict(
+            name='server_test', imageRef=imageRef, flavorRef=flavorRef,
+            metadata={'hello': 'world', 'open': 'stack'},
+            personality={}))
+        req = webob.Request.blank('/v1.1/servers')
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 400)
 
     def test_update_no_body(self):
         req = webob.Request.blank('/v1.0/servers/1')
-- 
cgit 


From d70bbdf43c4cba5a0b9c0ab93ff06031a2604db6 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
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')

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 <soren@linux2go.dk>
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')

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 3628f50b4ecd2db0377fd9c158248d3b7e8e98ff Mon Sep 17 00:00:00 2001
From: Brian Lamar <brian.lamar@rackspace.com>
Date: Thu, 17 Mar 2011 16:26:52 -0400
Subject: Better comment for fault. Improved readability of two small sections.

---
 nova/api/openstack/faults.py            | 5 ++++-
 nova/api/openstack/limits.py            | 2 +-
 nova/tests/api/openstack/test_limits.py | 2 +-
 3 files changed, 6 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/faults.py b/nova/api/openstack/faults.py
index ccccbd3d2..0e9c4b26f 100644
--- a/nova/api/openstack/faults.py
+++ b/nova/api/openstack/faults.py
@@ -91,7 +91,10 @@ class OverLimitFault(webob.exc.HTTPException):
 
     @webob.dec.wsgify(RequestClass=wsgi.Request)
     def __call__(self, request):
-        """Currently just return the wrapped exception."""
+        """
+        Return the wrapped exception with a serialized body conforming to our
+        error format.
+        """
         serializer = wsgi.Serializer(self._serialization_metadata)
         content_type = request.best_match_content_type()
         content = serializer.serialize(self.content, content_type)
diff --git a/nova/api/openstack/limits.py b/nova/api/openstack/limits.py
index 1fe519f8a..efc7d193d 100644
--- a/nova/api/openstack/limits.py
+++ b/nova/api/openstack/limits.py
@@ -151,7 +151,7 @@ class Limit(object):
         water = self.water_level
         val = self.value
 
-        self.remaining = math.floor((cap - water) / cap * val)
+        self.remaining = math.floor(((cap - water) / cap) * val)
         self.next_request = now
 
     def _get_time(self):
diff --git a/nova/tests/api/openstack/test_limits.py b/nova/tests/api/openstack/test_limits.py
index d1db93a59..05cfacc60 100644
--- a/nova/tests/api/openstack/test_limits.py
+++ b/nova/tests/api/openstack/test_limits.py
@@ -273,7 +273,7 @@ class LimiterTest(BaseLimitTestSuite):
     def _check_sum(self, num, verb, url, username=None):
         """Check and sum results from checks."""
         results = self._check(num, verb, url, username)
-        return sum(filter(lambda x: x != None, results))
+        return sum(item for item in results if item)
 
     def test_no_delay_GET(self):
         """
-- 
cgit 


From ccad7a5d36d27a1854d12d3e45d1c6099983e56c Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Thu, 17 Mar 2011 13:29:22 -0700
Subject: Mark instance metadata as deleted when we delete the instance

---
 nova/db/sqlalchemy/api.py | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 44540617f..2bfe9a52a 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -797,6 +797,11 @@ def instance_destroy(context, instance_id):
                 update({'deleted': 1,
                         'deleted_at': datetime.datetime.utcnow(),
                         'updated_at': literal_column('updated_at')})
+        session.query(models.InstanceMetadata).\
+                filter_by(instance_id=instance_id).\
+                update({'deleted': 1,
+                        'deleted_at': datetime.datetime.utcnow(),
+                        'updated_at': literal_column('updated_at')})
 
 
 @require_context
-- 
cgit 


From f7d5dea09568c6440918264d97ecdbcc316c0ec4 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Thu, 17 Mar 2011 15:31:48 -0500
Subject: pep8

---
 nova/api/openstack/servers.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index b0e355232..050450457 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -69,7 +69,7 @@ def _translate_detail_keys(inst):
     ctxt = context.get_admin_context()
     try:
         migration = db.migration_get_by_instance_and_status(ctxt,
-                inst['id'], 'finished') 
+                inst['id'], 'finished')
         inst_dict['status'] = 'resize-confirm'
     except Exception, e:
         inst_dict['status'] = power_mapping[inst_dict['status']]
-- 
cgit 


From b331a3df4d921414409ebb7a738d97e34f782102 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Thu, 17 Mar 2011 21:39:55 +0100
Subject: Adjust test cases.

---
 nova/tests/test_volume.py | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/test_volume.py b/nova/tests/test_volume.py
index 1b1d72092..5d68ca2ae 100644
--- a/nova/tests/test_volume.py
+++ b/nova/tests/test_volume.py
@@ -336,8 +336,8 @@ class ISCSITestCase(DriverTestCase):
         self.mox.StubOutWithMock(self.volume.driver, '_execute')
         for i in volume_id_list:
             tid = db.volume_get_iscsi_target_num(self.context, i)
-            self.volume.driver._execute("sudo ietadm --op show --tid=%(tid)d"
-                                        % locals())
+            self.volume.driver._execute("sudo", "ietadm", "--op", "show",
+                                        "--tid=%(tid)d" % locals())
 
         self.stream.truncate(0)
         self.mox.ReplayAll()
@@ -355,8 +355,9 @@ class ISCSITestCase(DriverTestCase):
         # the first vblade process isn't running
         tid = db.volume_get_iscsi_target_num(self.context, volume_id_list[0])
         self.mox.StubOutWithMock(self.volume.driver, '_execute')
-        self.volume.driver._execute("sudo ietadm --op show --tid=%(tid)d"
-            % locals()).AndRaise(exception.ProcessExecutionError())
+        self.volume.driver._execute("sudo", "ietadm", "--op", "show",
+                                    "--tid=%(tid)d" % locals()
+                                 ).AndRaise(exception.ProcessExecutionError())
 
         self.mox.ReplayAll()
         self.assertRaises(exception.ProcessExecutionError,
-- 
cgit 


From 06c0b81e54adf3fb0635a7cd7679bcdb051e6263 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Thu, 17 Mar 2011 21:43:22 +0100
Subject: pep8

---
 nova/tests/test_utils.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/tests/test_utils.py b/nova/tests/test_utils.py
index 51cd57c76..e08d229b0 100644
--- a/nova/tests/test_utils.py
+++ b/nova/tests/test_utils.py
@@ -62,7 +62,8 @@ exit 1
                                                           'always get passed '
                                                           'correctly')
             runs = int(runs.strip())
-            self.assertEquals(runs, 10, 'Ran %d times instead of 10.' % (runs,))
+            self.assertEquals(runs, 10,
+                              'Ran %d times instead of 10.' % (runs,))
         finally:
             os.unlink(tmpfilename)
             os.unlink(tmpfilename2)
@@ -95,6 +96,7 @@ grep foo
             os.unlink(tmpfilename)
             os.unlink(tmpfilename2)
 
+
 class GetFromPathTestCase(test.TestCase):
     def test_tolerates_nones(self):
         f = utils.get_from_path
-- 
cgit 


From b605b53e4b652e0a3f364d505b5fd7240fd4ea36 Mon Sep 17 00:00:00 2001
From: "matt.dietz@rackspace.com" <>
Date: Thu, 17 Mar 2011 20:44:15 +0000
Subject: Test changes

---
 nova/tests/api/openstack/test_servers.py | 22 ++++++++++++----------
 nova/tests/xenapi/stubs.py               |  7 +++++--
 2 files changed, 17 insertions(+), 12 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 03e00af2a..14b72e097 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -491,16 +491,6 @@ class ServersTest(test.TestCase):
         req.body = json.dumps(body)
         res = req.get_response(fakes.wsgi_app())
 
-    def test_server_resize(self):
-        body = dict(server=dict(
-            name='server_test', imageId=2, flavorId=2, metadata={},
-            personality={}))
-        req = webob.Request.blank('/v1.0/servers/1/action')
-        req.method = 'POST'
-        req.content_type = 'application/json'
-        req.body = json.dumps(body)
-        res = req.get_response(fakes.wsgi_app())
-
     def test_delete_server_instance(self):
         req = webob.Request.blank('/v1.0/servers/1')
         req.method = 'DELETE'
@@ -556,6 +546,18 @@ class ServersTest(test.TestCase):
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 400)
 
+    def test_resized_server_has_correct_status(self):
+        req = self.webreq('/1', 'GET', dict(resize=dict(flavorId=3)))
+        def fake_migration_get(*args):
+            return {}
+
+        self.stubs.Set(nova.db, 'migration_get_by_instance_and_status',
+                fake_migration_get)
+        res = req.get_response(fakes.wsgi_app())
+        body = json.loads(res.body)
+        self.assertEqual(body['server']['status'], 'resize-confirm')
+        
+
     def test_confirm_resize_server(self):
         req = self.webreq('/1/action', 'POST', dict(confirmResize=None))
 
diff --git a/nova/tests/xenapi/stubs.py b/nova/tests/xenapi/stubs.py
index 70d46a1fb..7f9706a3d 100644
--- a/nova/tests/xenapi/stubs.py
+++ b/nova/tests/xenapi/stubs.py
@@ -228,6 +228,9 @@ class FakeSessionForMigrationTests(fake.SessionBase):
     def VDI_get_by_uuid(*args):
         return 'hurr'
 
+    def VDI_resize_online(*args):
+        pass
+
     def VM_start(self, _1, ref, _2, _3):
         vm = fake.get_record('VM', ref)
         if vm['power_state'] != 'Halted':
@@ -240,7 +243,7 @@ class FakeSessionForMigrationTests(fake.SessionBase):
 
 def stub_out_migration_methods(stubs):
     def fake_get_snapshot(self, instance):
-        return 'foo', 'bar'
+        return 'vm_ref', dict(image='foo', snap='bar')
 
     @classmethod
     def fake_get_vdi(cls, session, vm_ref):
@@ -249,7 +252,7 @@ def stub_out_migration_methods(stubs):
         vdi_rec = session.get_xenapi().VDI.get_record(vdi_ref)
         return vdi_ref, {'uuid': vdi_rec['uuid'], }
 
-    def fake_shutdown(self, inst, vm, method='clean'):
+    def fake_shutdown(self, inst, vm, hard=True):
         pass
 
     @classmethod
-- 
cgit 


From 8d5ffa079e768adec969a4e8ab540c24a7faaaa6 Mon Sep 17 00:00:00 2001
From: "matt.dietz@rackspace.com" <>
Date: Thu, 17 Mar 2011 20:45:18 +0000
Subject: Pep8

---
 nova/tests/api/openstack/test_servers.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 14b72e097..07ebfdd88 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -548,6 +548,7 @@ class ServersTest(test.TestCase):
 
     def test_resized_server_has_correct_status(self):
         req = self.webreq('/1', 'GET', dict(resize=dict(flavorId=3)))
+
         def fake_migration_get(*args):
             return {}
 
@@ -556,7 +557,6 @@ class ServersTest(test.TestCase):
         res = req.get_response(fakes.wsgi_app())
         body = json.loads(res.body)
         self.assertEqual(body['server']['status'], 'resize-confirm')
-        
 
     def test_confirm_resize_server(self):
         req = self.webreq('/1/action', 'POST', dict(confirmResize=None))
-- 
cgit 


From a437ea845bd83c8b1da9de81253132cbad6b48b7 Mon Sep 17 00:00:00 2001
From: Trey Morris <trey.morris@rackspace.com>
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')

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 <trey.morris@rackspace.com>
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')

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 afda510637577748d311f0779596c6fec17b00fa Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Thu, 17 Mar 2011 22:21:55 +0100
Subject: pep8 is hard

---
 nova/volume/driver.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/volume/driver.py b/nova/volume/driver.py
index 9ebc67abc..779b46755 100644
--- a/nova/volume/driver.py
+++ b/nova/volume/driver.py
@@ -500,7 +500,8 @@ class ISCSIDriver(VolumeDriver):
 
         tid = self.db.volume_get_iscsi_target_num(context, volume_id)
         try:
-            self._execute('sudo', 'ietadm', '--op', 'show', '--tid=%(tid)d' % locals())
+            self._execute('sudo', 'ietadm', '--op', 'show',
+                          '--tid=%(tid)d' % locals())
         except exception.ProcessExecutionError, e:
             # Instances remount read-only in this case.
             # /etc/init.d/iscsitarget restart and rebooting nova-volume
-- 
cgit 


From cf648ea89015818a3ec7c8d6d59b50f8ed3604f7 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
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')

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 e2d66aaa670817bda9bf1b494b6a4cfde32b6daf Mon Sep 17 00:00:00 2001
From: Anthony Young <sleepsonthefloor@gmail.com>
Date: Thu, 17 Mar 2011 14:28:03 -0700
Subject: fix for lp712982, and likely a variety of other dashboard error
 handling issues.  This fix simply causes the default error code for ApiError
 to be 'ApiError' rather than 'Unknown', which makes dashboard handle the
 error gracefully, and makes euca error output slightly prettier

---
 nova/exception.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/exception.py b/nova/exception.py
index 93c5fe3d7..4e2bbdbaf 100644
--- a/nova/exception.py
+++ b/nova/exception.py
@@ -46,7 +46,7 @@ class Error(Exception):
 
 
 class ApiError(Error):
-    def __init__(self, message='Unknown', code='Unknown'):
+    def __init__(self, message='Unknown', code='ApiError'):
         self.message = message
         self.code = code
         super(ApiError, self).__init__('%s: %s' % (code, message))
-- 
cgit 


From 385b513822dff84e2faeb7f1d1b60efdf3d82fab Mon Sep 17 00:00:00 2001
From: Josh Kleinpeter <josh@kleinpeter.org>
Date: Thu, 17 Mar 2011 15:09:09 -0700
Subject: Made fixed_range a required parameter for nova-manage network create.
 Changed default num_networks to 1; 1000 seems large.

---
 nova/network/manager.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/network/manager.py b/nova/network/manager.py
index 3dfc48934..f2025af06 100644
--- a/nova/network/manager.py
+++ b/nova/network/manager.py
@@ -73,7 +73,7 @@ flags.DEFINE_string('flat_interface', None,
 flags.DEFINE_string('flat_network_dhcp_start', '10.0.0.2',
                     'Dhcp start for FlatDhcp')
 flags.DEFINE_integer('vlan_start', 100, 'First VLAN for private networks')
-flags.DEFINE_integer('num_networks', 1000, 'Number of networks to support')
+flags.DEFINE_integer('num_networks', 1, 'Number of networks to support')
 flags.DEFINE_string('vpn_ip', '$my_ip',
                     'Public IP for the cloudpipe VPN servers')
 flags.DEFINE_integer('vpn_start', 1000, 'First Vpn port for private networks')
-- 
cgit 


From 4940654f04c50c8593f8e5486fa9e4998f2a3fc7 Mon Sep 17 00:00:00 2001
From: Todd Willey <todd@ansolabs.com>
Date: Thu, 17 Mar 2011 19:32:25 -0400
Subject: Changing project manager should make sure that user is a project
 member.

---
 nova/auth/dbdriver.py   | 2 ++
 nova/auth/ldapdriver.py | 2 ++
 nova/tests/test_auth.py | 7 +++++++
 3 files changed, 11 insertions(+)

(limited to 'nova')

diff --git a/nova/auth/dbdriver.py b/nova/auth/dbdriver.py
index d8dad8edd..d1e3f2ed5 100644
--- a/nova/auth/dbdriver.py
+++ b/nova/auth/dbdriver.py
@@ -162,6 +162,8 @@ class DbDriver(object):
             values['description'] = description
 
         db.project_update(context.get_admin_context(), project_id, values)
+        if not self.is_in_project(manager_uid, project_id):
+            self.add_to_project(manager_uid, project_id)
 
     def add_to_project(self, uid, project_id):
         """Add user to project"""
diff --git a/nova/auth/ldapdriver.py b/nova/auth/ldapdriver.py
index 5da7751a0..647f70db1 100644
--- a/nova/auth/ldapdriver.py
+++ b/nova/auth/ldapdriver.py
@@ -275,6 +275,8 @@ class LdapDriver(object):
             attr.append((self.ldap.MOD_REPLACE, 'description', description))
         dn = self.__project_to_dn(project_id)
         self.conn.modify_s(dn, attr)
+        if not self.is_in_project(manager_uid, project_id):
+            self.add_to_project(manager_uid, project_id)
 
     @sanitize
     def add_to_project(self, uid, project_id):
diff --git a/nova/tests/test_auth.py b/nova/tests/test_auth.py
index 2a7817032..885596f56 100644
--- a/nova/tests/test_auth.py
+++ b/nova/tests/test_auth.py
@@ -299,6 +299,13 @@ class AuthManagerTestCase(object):
                 self.assertEqual('test2', project.project_manager_id)
                 self.assertEqual('new desc', project.description)
 
+    def test_modify_project_adds_new_manager(self):
+        with user_and_project_generator(self.manager):
+            with user_generator(self.manager, name='test2'):
+                self.manager.modify_project('testproj', 'test2', 'new desc')
+                project = self.manager.get_project('testproj')
+                self.assertTrue('test2' in project.member_ids)
+
     def test_can_delete_project(self):
         with user_generator(self.manager):
             self.manager.create_project('testproj', 'test1')
-- 
cgit 


From 79ed4a643df34029391685e13f04e3bfb8afa215 Mon Sep 17 00:00:00 2001
From: Todd Willey <todd@ansolabs.com>
Date: Thu, 17 Mar 2011 19:41:16 -0400
Subject: Add topic name to cast/call logs.

---
 nova/rpc.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/rpc.py b/nova/rpc.py
index fbb90299b..58715963a 100644
--- a/nova/rpc.py
+++ b/nova/rpc.py
@@ -311,7 +311,7 @@ def _pack_context(msg, context):
 
 def call(context, topic, msg):
     """Sends a message on a topic and wait for a response"""
-    LOG.debug(_("Making asynchronous call..."))
+    LOG.debug(_("Making asynchronous call on %s ..."), topic)
     msg_id = uuid.uuid4().hex
     msg.update({'_msg_id': msg_id})
     LOG.debug(_("MSG_ID is %s") % (msg_id))
@@ -352,7 +352,7 @@ def call(context, topic, msg):
 
 def cast(context, topic, msg):
     """Sends a message on a topic without waiting for a response"""
-    LOG.debug(_("Making asynchronous cast..."))
+    LOG.debug(_("Making asynchronous cast on %s..."), topic)
     _pack_context(msg, context)
     conn = Connection.instance()
     publisher = TopicPublisher(connection=conn, topic=topic)
-- 
cgit 


From 25199b6b93d17ff7dc192306e44932969846d9b6 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Thu, 17 Mar 2011 19:55:55 -0700
Subject: decorator more generic now

---
 nova/scheduler/api.py | 1 +
 1 file changed, 1 insertion(+)

(limited to 'nova')

diff --git a/nova/scheduler/api.py b/nova/scheduler/api.py
index 0e2c69f75..190eb363e 100644
--- a/nova/scheduler/api.py
+++ b/nova/scheduler/api.py
@@ -99,6 +99,7 @@ def child_zone_helper(zone_list, func):
 def _issue_novaclient_command(nova, zone, method_name, instance_id):
     server = None
     try:
+        manager = getattr(nova, "servers")
         if isinstance(instance_id, int) or instance_id.isdigit():
             server = manager.get(int(instance_id))
         else:
-- 
cgit 


From 47bec2abb39f76d5b3ea634dbb7012d55d7f99ce Mon Sep 17 00:00:00 2001
From: Brian Waldon <brian.waldon@rackspace.com>
Date: Thu, 17 Mar 2011 23:07:40 -0400
Subject: adding servers container to openstack api v1.1 servers entities

---
 nova/api/openstack/servers.py            | 11 ++++--
 nova/api/openstack/views/servers.py      | 56 +++++++++++++++++++++++++-----
 nova/tests/api/openstack/test_servers.py | 58 ++++++++++++++++++++++++++++++--
 3 files changed, 111 insertions(+), 14 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index e3141934b..de35aca8d 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -47,11 +47,15 @@ class Controller(wsgi.Controller):
     """ The Server API controller for the OpenStack API """
 
     _serialization_metadata = {
-        'application/xml': {
+        "application/xml": {
             "attributes": {
                 "server": ["id", "imageId", "name", "flavorId", "hostId",
                            "status", "progress", "adminPass", "flavorRef",
-                           "imageRef"]}}}
+                           "imageRef"],
+                "link": ["rel", "type", "href"],
+            },
+        },
+    }
 
     def __init__(self):
         self.compute_api = compute.API()
@@ -513,6 +517,7 @@ class Controller(wsgi.Controller):
 
         return kernel_id, ramdisk_id
 
+
 class ControllerV10(Controller):
     def _image_id_from_req_data(self, data):
         return data['server']['imageId']
@@ -546,7 +551,7 @@ class ControllerV11(Controller):
             base_url)
         addresses_builder = nova.api.openstack.views.addresses.ViewBuilderV11()
         return nova.api.openstack.views.servers.ViewBuilderV11(
-            addresses_builder, flavor_builder, image_builder)
+            addresses_builder, flavor_builder, image_builder, base_url)
 
     def _get_addresses_view_builder(self, req):
         return nova.api.openstack.views.addresses.ViewBuilderV11(req)
diff --git a/nova/api/openstack/views/servers.py b/nova/api/openstack/views/servers.py
index 8d47ac757..477f3caa0 100644
--- a/nova/api/openstack/views/servers.py
+++ b/nova/api/openstack/views/servers.py
@@ -39,12 +39,16 @@ class ViewBuilder(object):
         Rackspace-like attributes for return
         """
         if is_detail:
-            return self._build_detail(inst)
+            server = self._build_detail(inst)
         else:
-            return self._build_simple(inst)
+            server = self._build_simple(inst)
+
+        self._build_extra(server, inst)
+        
+        return dict(server=server)
 
     def _build_simple(self, inst):
-            return dict(server=dict(id=inst['id'], name=inst['display_name']))
+            return dict(id=inst['id'], name=inst['display_name'])
 
     def _build_detail(self, inst):
         power_mapping = {
@@ -79,7 +83,7 @@ class ViewBuilder(object):
         self._build_image(inst_dict, inst)
         self._build_flavor(inst_dict, inst)
 
-        return dict(server=inst_dict)
+        return inst_dict
 
     def _build_image(self, response, inst):
         raise NotImplementedError()
@@ -87,6 +91,9 @@ class ViewBuilder(object):
     def _build_flavor(self, response, inst):
         raise NotImplementedError()
 
+    def _build_extra(self, response, inst):
+        pass
+
 
 class ViewBuilderV10(ViewBuilder):
     def _build_image(self, response, inst):
@@ -99,19 +106,50 @@ class ViewBuilderV10(ViewBuilder):
 
 
 class ViewBuilderV11(ViewBuilder):
-    def __init__(self, addresses_builder, flavor_builder, image_builder):
+    def __init__(self, addresses_builder, flavor_builder, image_builder,
+                 base_url):
         ViewBuilder.__init__(self, addresses_builder)
         self.flavor_builder = flavor_builder
         self.image_builder = image_builder
+        self.base_url = base_url
 
     def _build_image(self, response, inst):
-        if inst.get('image_id') == None:
+        image_id = inst.get("image_id", None)
+        if image_id == None:
             return
-        image_id = inst["image_id"]
         response["imageRef"] = self.image_builder.generate_href(image_id)
 
     def _build_flavor(self, response, inst):
-        if inst.get('instance_type') == None:
+        flavor_id = inst.get("instance_type", None)
+        if flavor_id == None:
             return
-        flavor_id = inst["instance_type"]
         response["flavorRef"] = self.flavor_builder.generate_href(flavor_id)
+
+    def _build_extra(self, response, inst):
+        self._build_links(response, inst)
+
+    def _build_links(self, response, inst):
+        href = self.generate_href(inst["id"])
+
+        links = [
+            {
+                "rel": "self",
+                "href": href,
+            },
+            {
+                "rel": "bookmark",
+                "type": "application/json",
+                "href": href,
+            },
+            {
+                "rel": "bookmark",
+                "type": "application/xml",
+                "href": href,
+            },
+        ]
+
+        response["links"] = links
+
+    def generate_href(self, server_id):
+        """Create an url that refers to a specific server id."""
+        return "%s/servers/%s" % (self.base_url, server_id)
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 6e78db9da..17689d405 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -164,6 +164,32 @@ class ServersTest(test.TestCase):
         self.assertEqual(res_dict['server']['id'], 1)
         self.assertEqual(res_dict['server']['name'], 'server1')
 
+    def test_get_server_by_id_v11(self):
+        req = webob.Request.blank('/v1.1/servers/1')
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+        self.assertEqual(res_dict['server']['id'], 1)
+        self.assertEqual(res_dict['server']['name'], 'server1')
+
+        expected_links = [
+            {
+                "rel": "self",
+                "href": "http://localhost/v1.1/servers/1",
+            },
+            {
+                "rel": "bookmark",
+                "type": "application/json",
+                "href": "http://localhost/v1.1/servers/1",
+            },
+            {
+                "rel": "bookmark",
+                "type": "application/xml",
+                "href": "http://localhost/v1.1/servers/1",
+            },
+        ]
+
+        self.assertEqual(res_dict['server']['links'], expected_links)
+
     def test_get_server_by_id_with_addresses(self):
         private = "192.168.0.3"
         public = ["1.2.3.4"]
@@ -186,7 +212,6 @@ class ServersTest(test.TestCase):
         new_return_server = return_server_with_addresses(private, public)
         self.stubs.Set(nova.db.api, 'instance_get', new_return_server)
         req = webob.Request.blank('/v1.1/servers/1')
-        req.environ['api.version'] = '1.1'
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
         self.assertEqual(res_dict['server']['id'], 1)
@@ -211,6 +236,36 @@ class ServersTest(test.TestCase):
             self.assertEqual(s.get('imageId', None), None)
             i += 1
 
+    def test_get_server_list_v11(self):
+        req = webob.Request.blank('/v1.1/servers')
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+
+        for i,s in enumerate(res_dict['servers']):
+            self.assertEqual(s['id'], i)
+            self.assertEqual(s['name'], 'server%d' % i)
+            self.assertEqual(s.get('imageId', None), None)
+
+            expected_links = [
+            {
+                "rel": "self",
+                "href": "http://localhost/v1.1/servers/%d" % (i,),
+            },
+            {
+                "rel": "bookmark",
+                "type": "application/json",
+                "href": "http://localhost/v1.1/servers/%d" % (i,),
+            },
+            {
+                "rel": "bookmark",
+                "type": "application/xml",
+                "href": "http://localhost/v1.1/servers/%d" % (i,),
+            },
+        ]
+
+        self.assertEqual(s['links'], expected_links)
+
+
     def test_get_servers_with_limit(self):
         req = webob.Request.blank('/v1.0/servers?limit=3')
         res = req.get_response(fakes.wsgi_app())
@@ -419,7 +474,6 @@ class ServersTest(test.TestCase):
 
     def test_get_all_server_details_v1_1(self):
         req = webob.Request.blank('/v1.1/servers/detail')
-        req.environ['api.version'] = '1.1'
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
 
-- 
cgit 


From 0845d7081bc912e7eefa2d98e8c53033d872ef5e Mon Sep 17 00:00:00 2001
From: Brian Waldon <brian.waldon@rackspace.com>
Date: Thu, 17 Mar 2011 23:58:23 -0400
Subject: pep8

---
 nova/api/openstack/views/servers.py      | 2 +-
 nova/tests/api/openstack/test_servers.py | 3 +--
 2 files changed, 2 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/views/servers.py b/nova/api/openstack/views/servers.py
index 477f3caa0..5f4c0f740 100644
--- a/nova/api/openstack/views/servers.py
+++ b/nova/api/openstack/views/servers.py
@@ -44,7 +44,7 @@ class ViewBuilder(object):
             server = self._build_simple(inst)
 
         self._build_extra(server, inst)
-        
+
         return dict(server=server)
 
     def _build_simple(self, inst):
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 17689d405..9be68eb8d 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -241,7 +241,7 @@ class ServersTest(test.TestCase):
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
 
-        for i,s in enumerate(res_dict['servers']):
+        for i, s in enumerate(res_dict['servers']):
             self.assertEqual(s['id'], i)
             self.assertEqual(s['name'], 'server%d' % i)
             self.assertEqual(s.get('imageId', None), None)
@@ -265,7 +265,6 @@ class ServersTest(test.TestCase):
 
         self.assertEqual(s['links'], expected_links)
 
-
     def test_get_servers_with_limit(self):
         req = webob.Request.blank('/v1.0/servers?limit=3')
         res = req.get_response(fakes.wsgi_app())
-- 
cgit 


From acb7a7355055e04b9bb05fbba5f6590e57d681fa Mon Sep 17 00:00:00 2001
From: Naveed Massjouni <naveedm9@gmail.com>
Date: Fri, 18 Mar 2011 00:18:55 -0400
Subject: Support for markers for pagination as defined in the 1.1 spec.

---
 nova/api/openstack/common.py             | 28 ++++++++++++++++++++++++++++
 nova/api/openstack/servers.py            |  8 +++++++-
 nova/tests/api/openstack/test_servers.py |  7 +++++++
 3 files changed, 42 insertions(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/api/openstack/common.py b/nova/api/openstack/common.py
index b224cbfb4..8106f841b 100644
--- a/nova/api/openstack/common.py
+++ b/nova/api/openstack/common.py
@@ -55,6 +55,34 @@ def limited(items, request, max_limit=1000):
     return items[offset:range_end]
 
 
+def limited_by_marker(items, request, max_limit=1000):
+    ''' Return a slice of items according to requested marker and limit. '''
+
+    marker = request.GET.get('marker')
+
+    try:
+        limit = int(request.GET.get('limit', max_limit))
+    except ValueError:
+        raise webob.exc.HTTPBadRequest(_('limit param must be an integer'))
+
+    if limit < 0:
+        raise webob.exc.HTTPBadRequest(_('limit param must be positive'))
+
+    limit = min(max_limit, limit or max_limit)
+    start_index = 0
+    if marker != None:
+        found_it = False
+        for i, item in enumerate(items):
+            if str(item['id']) == marker:
+                start_index = i
+                found_it = True
+                break
+        if not found_it:
+            raise webob.exc.HTTPBadRequest(_('marker not found'))
+    range_end = start_index + limit
+    return items[start_index:range_end]
+
+
 def get_image_id_from_image_hash(image_service, context, image_hash):
     """Given an Image ID Hash, return an objectstore Image ID.
 
diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index e3141934b..461bf5989 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -81,7 +81,7 @@ class Controller(wsgi.Controller):
         builder - the response model builder
         """
         instance_list = self.compute_api.get_all(req.environ['nova.context'])
-        limited_list = common.limited(instance_list, req)
+        limited_list = self._limit_items(instance_list, req)
         builder = self._get_view_builder(req)
         servers = [builder.build(inst, is_detail)['server']
                 for inst in limited_list]
@@ -528,6 +528,9 @@ class ControllerV10(Controller):
     def _get_addresses_view_builder(self, req):
         return nova.api.openstack.views.addresses.ViewBuilderV10(req)
 
+    def _limit_items(self, items, req):
+        return common.limited(items, req)
+
 
 class ControllerV11(Controller):
     def _image_id_from_req_data(self, data):
@@ -551,6 +554,9 @@ class ControllerV11(Controller):
     def _get_addresses_view_builder(self, req):
         return nova.api.openstack.views.addresses.ViewBuilderV11(req)
 
+    def _limit_items(self, items, req):
+        return common.limited_by_marker(items, req)
+
 
 class ServerCreateRequestXMLDeserializer(object):
     """
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 6e78db9da..e1cadcef6 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -239,6 +239,13 @@ class ServersTest(test.TestCase):
         servers = json.loads(res.body)['servers']
         self.assertEqual([s['id'] for s in servers], [1, 2])
 
+    def test_get_servers_with_marker(self):
+        req = webob.Request.blank('/v1.1/servers?marker=2')
+        res = req.get_response(fakes.wsgi_app())
+        print 'body:', res.body
+        servers = json.loads(res.body)['servers']
+        self.assertEqual([s['id'] for s in servers], [2, 3, 4])
+
     def _setup_for_create_instance(self):
         """Shared implementation for tests below that create instance"""
         def instance_create(context, inst):
-- 
cgit 


From 1abcdbea89e69013c193d2eb0b4b7a0bc2e2fa58 Mon Sep 17 00:00:00 2001
From: Dan Prince <dan.prince@rackspace.com>
Date: Fri, 18 Mar 2011 02:14:36 -0400
Subject: Implement metadata resource for Openstack API v1.1. Includes:    
 -GET /servers/id/meta     -POST /servers/id/meta     -GET
 /servers/id/meta/key     -PUT /servers/id/meta/key     -DELETE
 /servers/id/meta/key

---
 nova/api/openstack/__init__.py                   |   5 +
 nova/api/openstack/server_metadata.py            |  75 ++++++++++++
 nova/compute/api.py                              |  15 +++
 nova/db/api.py                                   |  18 +++
 nova/db/sqlalchemy/api.py                        |  60 +++++++++
 nova/tests/api/openstack/test_server_metadata.py | 150 +++++++++++++++++++++++
 6 files changed, 323 insertions(+)
 create mode 100644 nova/api/openstack/server_metadata.py
 create mode 100644 nova/tests/api/openstack/test_server_metadata.py

(limited to 'nova')

diff --git a/nova/api/openstack/__init__.py b/nova/api/openstack/__init__.py
index 0b50d17d0..4beb84dcd 100644
--- a/nova/api/openstack/__init__.py
+++ b/nova/api/openstack/__init__.py
@@ -34,6 +34,7 @@ from nova.api.openstack import consoles
 from nova.api.openstack import flavors
 from nova.api.openstack import images
 from nova.api.openstack import servers
+from nova.api.openstack import server_metadata
 from nova.api.openstack import shared_ip_groups
 from nova.api.openstack import users
 from nova.api.openstack import zones
@@ -138,6 +139,10 @@ class APIRouterV11(APIRouter):
                         controller=servers.ControllerV11(),
                         collection={'detail': 'GET'},
                         member=self.server_members)
+        mapper.resource("server_meta", "meta",
+                        controller=server_metadata.Controller(),
+                        parent_resource=dict(member_name='server',
+                        collection_name='servers'))
 
 
 class Versions(wsgi.Application):
diff --git a/nova/api/openstack/server_metadata.py b/nova/api/openstack/server_metadata.py
new file mode 100644
index 000000000..1408f59a6
--- /dev/null
+++ b/nova/api/openstack/server_metadata.py
@@ -0,0 +1,75 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# 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.
+
+from webob import exc
+
+from nova import compute
+from nova import wsgi
+from nova.api.openstack import faults
+
+
+class Controller(wsgi.Controller):
+    """ The server metadata API controller for the Openstack API """
+
+    def __init__(self):
+        self.compute_api = compute.API()
+        super(Controller, self).__init__()
+
+    def _get_metadata(self, context, server_id):
+        metadata = self.compute_api.get_instance_metadata(context, server_id)
+        meta_dict = {}
+        for key, value in metadata.iteritems():
+            meta_dict[key] = value
+        return dict(metadata=meta_dict)
+
+    def index(self, req, server_id):
+        """ Returns the list of metadata for a given instance """
+        context = req.environ['nova.context']
+        return self._get_metadata(context, server_id)
+
+    def create(self, req, server_id):
+        context = req.environ['nova.context']
+        body = self._deserialize(req.body, req.get_content_type())
+        self.compute_api.update_or_create_instance_metadata(context,
+                                                            server_id,
+                                                            body['metadata'])
+        return req.body
+
+    def update(self, req, server_id, id):
+        context = req.environ['nova.context']
+        body = self._deserialize(req.body, req.get_content_type())
+        if not id in body:
+            expl = _('Request body and URI mismatch')
+            raise exc.HTTPBadRequest(explanation=expl)
+        self.compute_api.update_or_create_instance_metadata(context,
+                                                            server_id,
+                                                            body)
+        return req.body
+
+    def show(self, req, server_id, id):
+        """ Return a single metadata item """
+        context = req.environ['nova.context']
+        data = self._get_metadata(context, server_id)
+        if id in data['metadata']:
+            return {id: data['metadata'][id]}
+        else:
+            return faults.Fault(exc.HTTPNotFound())
+
+    def delete(self, req, server_id, id):
+        """ Deletes an existing metadata """
+        context = req.environ['nova.context']
+        self.compute_api.delete_instance_metadata(context, server_id, id)
diff --git a/nova/compute/api.py b/nova/compute/api.py
index 32577af82..e70817212 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -612,3 +612,18 @@ class API(base.Base):
         instance = self.get(context, instance_id)
         self.network_api.associate_floating_ip(context, address,
                                                instance['fixed_ip'])
+
+    def get_instance_metadata(self, context, instance_id):
+        """Get all metadata associated with an instance."""
+        rv = self.db.get_instance_metadata(context, instance_id)
+        return dict(rv.iteritems())
+
+    def delete_instance_metadata(self, context, instance_id, key):
+        """Delete the given metadata item"""
+        self.db.delete_instance_metadata(context, instance_id, key)
+
+    def update_or_create_instance_metadata(self, context, instance_id,
+                                            metadata):
+        """Updates or creates instance metadata"""
+        self.db.update_or_create_instance_metadata(context, instance_id,
+                                                    metadata)
diff --git a/nova/db/api.py b/nova/db/api.py
index 3cb0e5811..5721fe8d6 100644
--- a/nova/db/api.py
+++ b/nova/db/api.py
@@ -1171,3 +1171,21 @@ def zone_get(context, zone_id):
 def zone_get_all(context):
     """Get all child Zones."""
     return IMPL.zone_get_all(context)
+
+
+####################
+
+
+def get_instance_metadata(context, instance_id):
+    """Get all metadata for an instance"""
+    return IMPL.get_instance_metadata(context, instance_id)
+
+
+def delete_instance_metadata(context, instance_id, key):
+    """Delete the given metadata item"""
+    IMPL.delete_instance_metadata(context, instance_id, key)
+
+
+def update_or_create_instance_metadata(context, instance_id, metadata):
+    """Creates or updates instance metadata"""
+    IMPL.update_or_create_instance_metadata(context, instance_id, metadata)
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 9d9b86c1d..8f656de0e 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -2457,3 +2457,63 @@ def zone_get(context, zone_id):
 def zone_get_all(context):
     session = get_session()
     return session.query(models.Zone).all()
+
+
+####################
+
+@require_context
+def get_instance_metadata(context, instance_id):
+    session = get_session()
+
+    meta_results = session.query(models.InstanceMetadata).\
+                    filter_by(instance_id=instance_id).\
+                    filter_by(deleted=False).\
+                    all()
+
+    meta_dict = {}
+    for i in meta_results:
+        meta_dict[i['key']] = i['value']
+    return meta_dict
+
+
+@require_context
+def delete_instance_metadata(context, instance_id, key):
+    session = get_session()
+    session.query(models.InstanceMetadata).\
+        filter_by(instance_id=instance_id).\
+        filter_by(key=key).\
+        update({'deleted': 1,
+                'deleted_at': datetime.datetime.utcnow(),
+                'updated_at': literal_column('updated_at')})
+
+
+@require_context
+def get_instance_metadata_item(context, instance_id, key):
+    session = get_session()
+
+    meta_result = session.query(models.InstanceMetadata).\
+                    filter_by(instance_id=instance_id).\
+                    filter_by(key=key).\
+                    filter_by(deleted=False).\
+                    first()
+
+    if not meta_result:
+        raise exception.NotFound(_('Invalid metadata key for instance %s') %
+                                    instance_id)
+    return meta_result
+
+
+@require_context
+def update_or_create_instance_metadata(context, instance_id, metadata):
+    session = get_session()
+    meta_ref = None
+    for key, value in metadata.iteritems():
+        try:
+            meta_ref = get_instance_metadata_item(context, instance_id, key,
+                                                        session)
+        except:
+            meta_ref = models.InstanceMetadata()
+        meta_ref.update({"key": key, "value": value,
+                            "instance_id": instance_id})
+        meta_ref.save(session=session)
+    return metadata
diff --git a/nova/tests/api/openstack/test_server_metadata.py b/nova/tests/api/openstack/test_server_metadata.py
new file mode 100644
index 000000000..b280ae94c
--- /dev/null
+++ b/nova/tests/api/openstack/test_server_metadata.py
@@ -0,0 +1,150 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# 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.
+
+import json
+import stubout
+import unittest
+import webob
+
+
+from nova.api import openstack
+from nova.tests.api.openstack import fakes
+import nova.wsgi
+
+
+def return_create_instance_metadata(context, server_id, metadata):
+    return stub_server_metadata()
+
+
+def return_server_metadata(context, server_id):
+    return stub_server_metadata()
+
+
+def return_empty_server_metadata(context, server_id):
+    return {}
+
+
+def delete_server_metadata(context, server_id, key):
+    pass
+
+
+def stub_server_metadata():
+    metadata = {
+            "key1": "value1",
+            "key2": "value2",
+            "key3": "value3",
+            "key4": "value4",
+            "key5": "value5"
+        }
+    return metadata
+
+
+class ServerMetaDataTest(unittest.TestCase):
+
+    def setUp(self):
+        super(ServerMetaDataTest, self).setUp()
+        self.stubs = stubout.StubOutForTesting()
+        fakes.FakeAuthManager.auth_data = {}
+        fakes.FakeAuthDatabase.data = {}
+        fakes.stub_out_auth(self.stubs)
+        fakes.stub_out_key_pair_funcs(self.stubs)
+        #self.allow_admin = FLAGS.allow_admin_api
+
+    def test_index(self):
+        self.stubs.Set(nova.db.api, 'get_instance_metadata',
+                        return_server_metadata)
+        req = webob.Request.blank('/v1.1/servers/1/meta')
+        req.environ['api.version'] = '1.1'
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+        self.assertEqual(200, res.status_int)
+        self.assertEqual('value1', res_dict['metadata']['key1'])
+
+    def test_index_no_data(self):
+        self.stubs.Set(nova.db.api, 'get_instance_metadata',
+                        return_empty_server_metadata)
+        req = webob.Request.blank('/v1.1/servers/1/meta')
+        req.environ['api.version'] = '1.1'
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+        self.assertEqual(200, res.status_int)
+        self.assertEqual(0, len(res_dict['metadata']))
+
+    def test_show(self):
+        self.stubs.Set(nova.db.api, 'get_instance_metadata',
+                        return_server_metadata)
+        req = webob.Request.blank('/v1.1/servers/1/meta/key5')
+        req.environ['api.version'] = '1.1'
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+        self.assertEqual(200, res.status_int)
+        self.assertEqual('value5', res_dict['key5'])
+
+    def test_show_meta_not_found(self):
+        self.stubs.Set(nova.db.api, 'get_instance_metadata',
+                        return_empty_server_metadata)
+        req = webob.Request.blank('/v1.1/servers/1/meta/key6')
+        req.environ['api.version'] = '1.1'
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+        self.assertEqual(404, res.status_int)
+
+    def test_delete(self):
+        self.stubs.Set(nova.db.api, 'delete_instance_metadata',
+                        delete_server_metadata)
+        req = webob.Request.blank('/v1.1/servers/1/meta/key5')
+        req.environ['api.version'] = '1.1'
+        req.method = 'DELETE'
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(200, res.status_int)
+
+    def test_create(self):
+        self.stubs.Set(nova.db.api, 'update_or_create_instance_metadata',
+                        return_create_instance_metadata)
+        req = webob.Request.blank('/v1.1/servers/1/meta')
+        req.environ['api.version'] = '1.1'
+        req.method = 'POST'
+        req.body = '{"metadata": {"key1": "value1"}}'
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+        self.assertEqual(200, res.status_int)
+        self.assertEqual('value1', res_dict['metadata']['key1'])
+
+    def test_update_item(self):
+        self.stubs.Set(nova.db.api, 'update_or_create_instance_metadata',
+                        return_create_instance_metadata)
+        req = webob.Request.blank('/v1.1/servers/1/meta/key1')
+        req.environ['api.version'] = '1.1'
+        req.method = 'PUT'
+        req.body = '{"key1": "value1"}'
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(200, res.status_int)
+        res_dict = json.loads(res.body)
+        self.assertEqual('value1', res_dict['key1'])
+
+    def test_update_item_body_uri_mismatch(self):
+        self.stubs.Set(nova.db.api, 'update_or_create_instance_metadata',
+                        return_create_instance_metadata)
+        req = webob.Request.blank('/v1.1/servers/1/meta/bad')
+        req.environ['api.version'] = '1.1'
+        req.method = 'PUT'
+        req.body = '{"key1": "value1"}'
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(400, res.status_int)
-- 
cgit 


From 745ade6a7759915eefe39eedc9be7e526df32547 Mon Sep 17 00:00:00 2001
From: Salvatore Orlando <salvatore.orlando@eu.citrix.com>
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')

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 <sateesh.chodapuneedi@citrix.com>
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/tests/test_vmwareapi.py           |   2 +-
 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 +-
 7 files changed, 293 insertions(+), 29 deletions(-)
 create mode 100644 nova/virt/vmwareapi/io_util.py

(limited to 'nova')

diff --git a/nova/tests/test_vmwareapi.py b/nova/tests/test_vmwareapi.py
index d17805b99..b31ac11f1 100644
--- a/nova/tests/test_vmwareapi.py
+++ b/nova/tests/test_vmwareapi.py
@@ -45,7 +45,7 @@ class VMWareAPIVMTestCase(test.TestCase):
         super(VMWareAPIVMTestCase, self).setUp()
         self.flags(vmwareapi_host_ip='test_url',
                    vmwareapi_host_username='test_username',
-                   vmware_host_password='test_pass')
+                   vmwareapi_host_password='test_pass')
         self.manager = manager.AuthManager()
         self.user = self.manager.create_user('fake', 'fake', 'fake',
                                              admin=True)
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 0bc393bd1a0b722b08a2834873a8a825b86035c2 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Fri, 18 Mar 2011 06:38:02 -0700
Subject: enable_zone_routing flag

---
 nova/compute/api.py   | 20 ++++++++---------
 nova/scheduler/api.py | 60 +++++++++++++++++++++++++++++++++++----------------
 2 files changed, 51 insertions(+), 29 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/api.py b/nova/compute/api.py
index 9fb4c8ae2..96538dd00 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -343,7 +343,7 @@ class API(base.Base):
         rv = self.db.instance_update(context, instance_id, kwargs)
         return dict(rv.iteritems())
 
-    #@scheduler_api.reroute_if_not_found("delete")
+    @scheduler_api.reroute("delete")
     def delete(self, context, instance_id):
         LOG.debug(_("Going to try to terminate %s"), instance_id)
         try:
@@ -373,12 +373,10 @@ class API(base.Base):
 
     def get(self, context, instance_id):
         """Get a single instance with the given ID."""
-        LOG.debug("*** COMPUTE.API::GET")
         rv = self.db.instance_get(context, instance_id)
-        LOG.debug("*** COMPUTE.API::GET OUT CLEAN")
         return dict(rv.iteritems())
 
-    @scheduler_api.reroute_if_not_found("get")
+    @scheduler_api.reroute_compute("get")
     def routing_get(self, context, instance_id):
         """Use this method instead of get() if this is the only
            operation you intend to to. It will route to novaclient.get
@@ -502,17 +500,17 @@ class API(base.Base):
                      "args": {"topic": FLAGS.compute_topic,
                               "instance_id": instance_id, }},)
 
-    #@scheduler_api.reroute_if_not_found("pause")
+    @scheduler_api.reroute_compute("pause")
     def pause(self, context, instance_id):
         """Pause the given instance."""
         self._cast_compute_message('pause_instance', context, instance_id)
 
-    #@scheduler_api.reroute_if_not_found("unpause")
+    @scheduler_api.reroute_compute("unpause")
     def unpause(self, context, instance_id):
         """Unpause the given instance."""
         self._cast_compute_message('unpause_instance', context, instance_id)
 
-    #@scheduler_api.reroute_if_not_found("diagnostics")
+    @scheduler_api.reroute_compute("diagnostics")
     def get_diagnostics(self, context, instance_id):
         """Retrieve diagnostics for the given instance."""
         return self._call_compute_message(
@@ -524,22 +522,22 @@ class API(base.Base):
         """Retrieve actions for the given instance."""
         return self.db.instance_get_actions(context, instance_id)
 
-    #@scheduler_api.reroute_if_not_found("suspend")
+    @scheduler_api.reroute_compute("suspend")
     def suspend(self, context, instance_id):
         """suspend the instance with instance_id"""
         self._cast_compute_message('suspend_instance', context, instance_id)
 
-    #@scheduler_api.reroute_if_not_found("resume")
+    @scheduler_api.reroute_compute("resume")
     def resume(self, context, instance_id):
         """resume the instance with instance_id"""
         self._cast_compute_message('resume_instance', context, instance_id)
 
-    #@scheduler_api.reroute_if_not_found("rescue")
+    @scheduler_api.reroute_compute("rescue")
     def rescue(self, context, instance_id):
         """Rescue the given instance."""
         self._cast_compute_message('rescue_instance', context, instance_id)
 
-    #@scheduler_api.reroute_if_not_found("unrescue")
+    @scheduler_api.reroute_compute("unrescue")
     def unrescue(self, context, instance_id):
         """Unrescue the given instance."""
         self._cast_compute_message('unrescue_instance', context, instance_id)
diff --git a/nova/scheduler/api.py b/nova/scheduler/api.py
index 190eb363e..90b92d7ed 100644
--- a/nova/scheduler/api.py
+++ b/nova/scheduler/api.py
@@ -28,6 +28,10 @@ import novaclient.client as client
 from eventlet import greenpool
 
 FLAGS = flags.FLAGS
+flags.DEFINE_bool('enable_zone_routing',
+    False,
+    'When True, routing to child zones will occur.')
+
 LOG = logging.getLogger('nova.scheduler.api')
 
 
@@ -83,7 +87,8 @@ def _wrap_method(function, self):
 
 
 def _process(func, zone):
-    """Worker stub for green thread pool"""
+    """Worker stub for green thread pool. Give the worker
+    an authenticated nova client and zone info."""
     nova = client.OpenStackClient(zone.username, zone.password,
                                         zone.api_url)
     nova.authenticate()
@@ -91,36 +96,42 @@ def _process(func, zone):
 
 
 def child_zone_helper(zone_list, func):
+    """Fire off a command to each zone in the list."""
     green_pool = greenpool.GreenPool()
     return [result for result in green_pool.imap(
                     _wrap_method(_process, func), zone_list)]
 
 
-def _issue_novaclient_command(nova, zone, method_name, instance_id):
-    server = None
+def _issue_novaclient_command(nova, zone, collection, method_name, \
+                                                        item_id):
+    """Use novaclient to issue command to a single child zone.
+       One of these will be run in parallel for each child zone."""
+    item = None
     try:
-        manager = getattr(nova, "servers")
-        if isinstance(instance_id, int) or instance_id.isdigit():
-            server = manager.get(int(instance_id))
+        manager = getattr(nova, collection)
+        if isinstance(item_id, int) or item_id.isdigit():
+            item = manager.get(int(item_id))
         else:
-            server = manager.find(name=instance_id)
+            item = manager.find(name=item_id)
     except novaclient.NotFound:
         url = zone.api_url
-        LOG.debug(_("Instance %(instance_id)s not found on '%(url)s'" %
+        LOG.debug(_("%(collection)s '%(item_id)s' not found on '%(url)s'" %
                                                 locals()))
         return
 
-    return getattr(server, method_name)()
+    return getattr(item, method_name)()
 
 
-def wrap_novaclient_function(f, method_name, instance_id):
+def wrap_novaclient_function(f, collection, method_name, item_id):
+    """Appends collection, method_name and item_id to the incoming
+    (nova, zone) call from child_zone_helper."""
     def inner(nova, zone):
-        return f(nova, zone, method_name, instance_id)
+        return f(nova, zone, collection, method_name, item_id)
         
     return inner
 
 
-class reroute_if_not_found(object):
+class reroute_compute(object):
     """Decorator used to indicate that the method should
        delegate the call the child zones if the db query
        can't find anything.
@@ -130,19 +141,32 @@ class reroute_if_not_found(object):
 
     def __call__(self, f):
         def wrapped_f(*args, **kwargs):
-            LOG.debug("***REROUTE-3: %s / %s" % (args, kwargs))
-            context = args[1]
-            instance_id = args[2]
+            collection, context, item_id = \
+                            self.get_collection_context_and_id()
             try:
                 return f(*args, **kwargs)
             except exception.InstanceNotFound, e:
-                LOG.debug(_("Instance %(instance_id)s not found "
+                LOG.debug(_("Instance %(item_id)s not found "
                                     "locally: '%(e)s'" % locals()))
 
+                if not FLAGS.enable_zone_routing:
+                    raise
+                    
                 zones = db.zone_get_all(context)
+                if not zones:
+                    raise
+
                 result = child_zone_helper(zones,
                             wrap_novaclient_function(_issue_novaclient_command,
-                                   self.method_name, instance_id))
+                                   collection, self.method_name, item_id))
                 LOG.debug("***REROUTE: %s" % result)
-                return result
+                return self.unmarshall_result(result)
         return wrapped_f
+
+    def get_collection_context_and_id(self, args):
+        """Returns a tuple of (novaclient collection name, security
+           context and resource id. Derived class should override this."""
+        return ("servers", args[1], args[2])
+
+    def unmarshall_result(self, result):
+        return result        
-- 
cgit 


From 6e9a95fe81c389c672b5150d64749b274975f7bc Mon Sep 17 00:00:00 2001
From: Brian Lamar <brian.lamar@rackspace.com>
Date: Fri, 18 Mar 2011 09:56:05 -0400
Subject: disable-msg -> disable

---
 nova/auth/fakeldap.py              |  8 ++++----
 nova/auth/ldapdriver.py            |  2 +-
 nova/auth/manager.py               |  2 +-
 nova/compute/manager.py            |  4 ++--
 nova/db/api.py                     |  2 +-
 nova/db/base.py                    |  2 +-
 nova/db/sqlalchemy/api.py          |  2 +-
 nova/network/linux_net.py          |  6 +++---
 nova/network/manager.py            |  4 ++--
 nova/objectstore/handler.py        | 14 +++++++-------
 nova/rpc.py                        |  6 +++---
 nova/service.py                    |  2 +-
 nova/tests/api/test_wsgi.py        |  2 +-
 nova/tests/hyperv_unittest.py      |  2 +-
 nova/tests/objectstore_unittest.py |  8 ++++----
 nova/tests/test_api.py             |  2 +-
 nova/tests/test_middleware.py      |  4 ++--
 17 files changed, 36 insertions(+), 36 deletions(-)

(limited to 'nova')

diff --git a/nova/auth/fakeldap.py b/nova/auth/fakeldap.py
index 4466051f0..e8f5771d5 100644
--- a/nova/auth/fakeldap.py
+++ b/nova/auth/fakeldap.py
@@ -90,12 +90,12 @@ MOD_DELETE = 1
 MOD_REPLACE = 2
 
 
-class NO_SUCH_OBJECT(Exception):  # pylint: disable-msg=C0103
+class NO_SUCH_OBJECT(Exception):  # pylint: disable=C0103
     """Duplicate exception class from real LDAP module."""
     pass
 
 
-class OBJECT_CLASS_VIOLATION(Exception):  # pylint: disable-msg=C0103
+class OBJECT_CLASS_VIOLATION(Exception):  # pylint: disable=C0103
     """Duplicate exception class from real LDAP module."""
     pass
 
@@ -268,7 +268,7 @@ class FakeLDAP(object):
             # get the attributes from the store
             attrs = store.hgetall(key)
             # turn the values from the store into lists
-            # pylint: disable-msg=E1103
+            # pylint: disable=E1103
             attrs = dict([(k, _from_json(v))
                           for k, v in attrs.iteritems()])
             # filter the objects by query
@@ -283,6 +283,6 @@ class FakeLDAP(object):
         return objects
 
     @property
-    def __prefix(self):  # pylint: disable-msg=R0201
+    def __prefix(self):  # pylint: disable=R0201
         """Get the prefix to use for all keys."""
         return 'ldap:'
diff --git a/nova/auth/ldapdriver.py b/nova/auth/ldapdriver.py
index 647f70db1..fcac55510 100644
--- a/nova/auth/ldapdriver.py
+++ b/nova/auth/ldapdriver.py
@@ -634,6 +634,6 @@ class LdapDriver(object):
 class FakeLdapDriver(LdapDriver):
     """Fake Ldap Auth driver"""
 
-    def __init__(self):  # pylint: disable-msg=W0231
+    def __init__(self):  # pylint: disable=W0231
         __import__('nova.auth.fakeldap')
         self.ldap = sys.modules['nova.auth.fakeldap']
diff --git a/nova/auth/manager.py b/nova/auth/manager.py
index 450ab803a..29811ea16 100644
--- a/nova/auth/manager.py
+++ b/nova/auth/manager.py
@@ -22,7 +22,7 @@ Nova authentication management
 
 import os
 import shutil
-import string  # pylint: disable-msg=W0402
+import string  # pylint: disable=W0402
 import tempfile
 import uuid
 import zipfile
diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 92deca813..c2781f6fb 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -220,7 +220,7 @@ class ComputeManager(manager.Manager):
             self.db.instance_update(context,
                                     instance_id,
                                     {'launched_at': now})
-        except Exception:  # pylint: disable-msg=W0702
+        except Exception:  # pylint: disable=W0702
             LOG.exception(_("instance %s: Failed to spawn"), instance_id,
                           context=context)
             self.db.instance_set_state(context,
@@ -692,7 +692,7 @@ class ComputeManager(manager.Manager):
                                     volume_id,
                                     instance_id,
                                     mountpoint)
-        except Exception as exc:  # pylint: disable-msg=W0702
+        except Exception as exc:  # pylint: disable=W0702
             # NOTE(vish): The inline callback eats the exception info so we
             #             log the traceback here and reraise the same
             #             ecxception below.
diff --git a/nova/db/api.py b/nova/db/api.py
index 3cb0e5811..94777f413 100644
--- a/nova/db/api.py
+++ b/nova/db/api.py
@@ -608,7 +608,7 @@ def network_get_all(context):
     return IMPL.network_get_all(context)
 
 
-# pylint: disable-msg=C0103
+# pylint: disable=C0103
 def network_get_associated_fixed_ips(context, network_id):
     """Get all network's ips that have been associated."""
     return IMPL.network_get_associated_fixed_ips(context, network_id)
diff --git a/nova/db/base.py b/nova/db/base.py
index 1d1e80866..a0f2180c6 100644
--- a/nova/db/base.py
+++ b/nova/db/base.py
@@ -33,4 +33,4 @@ class Base(object):
     def __init__(self, db_driver=None):
         if not db_driver:
             db_driver = FLAGS.db_driver
-        self.db = utils.import_object(db_driver)  # pylint: disable-msg=C0103
+        self.db = utils.import_object(db_driver)  # pylint: disable=C0103
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 9d9b86c1d..394d9a90a 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -1249,7 +1249,7 @@ def network_get_all(context):
 
 # NOTE(vish): pylint complains because of the long method name, but
 #             it fits with the names of the rest of the methods
-# pylint: disable-msg=C0103
+# pylint: disable=C0103
 
 
 @require_admin_context
diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index 7106e6164..565732869 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -582,7 +582,7 @@ def update_dhcp(context, network_id):
             try:
                 _execute('sudo', 'kill', '-HUP', pid)
                 return
-            except Exception as exc:  # pylint: disable-msg=W0703
+            except Exception as exc:  # pylint: disable=W0703
                 LOG.debug(_("Hupping dnsmasq threw %s"), exc)
         else:
             LOG.debug(_("Pid %d is stale, relaunching dnsmasq"), pid)
@@ -626,7 +626,7 @@ interface %s
         if conffile in out:
             try:
                 _execute('sudo', 'kill', pid)
-            except Exception as exc:  # pylint: disable-msg=W0703
+            except Exception as exc:  # pylint: disable=W0703
                 LOG.debug(_("killing radvd threw %s"), exc)
         else:
             LOG.debug(_("Pid %d is stale, relaunching radvd"), pid)
@@ -713,7 +713,7 @@ def _stop_dnsmasq(network):
     if pid:
         try:
             _execute('sudo', 'kill', '-TERM', pid)
-        except Exception as exc:  # pylint: disable-msg=W0703
+        except Exception as exc:  # pylint: disable=W0703
             LOG.debug(_("Killing dnsmasq threw %s"), exc)
 
 
diff --git a/nova/network/manager.py b/nova/network/manager.py
index 3dfc48934..0decb126a 100644
--- a/nova/network/manager.py
+++ b/nova/network/manager.py
@@ -322,12 +322,12 @@ class NetworkManager(manager.Manager):
                 self._create_fixed_ips(context, network_ref['id'])
 
     @property
-    def _bottom_reserved_ips(self):  # pylint: disable-msg=R0201
+    def _bottom_reserved_ips(self):  # pylint: disable=R0201
         """Number of reserved ips at the bottom of the range."""
         return 2  # network, gateway
 
     @property
-    def _top_reserved_ips(self):  # pylint: disable-msg=R0201
+    def _top_reserved_ips(self):  # pylint: disable=R0201
         """Number of reserved ips at the top of the range."""
         return 1  # broadcast
 
diff --git a/nova/objectstore/handler.py b/nova/objectstore/handler.py
index 05ddace4b..554c72848 100644
--- a/nova/objectstore/handler.py
+++ b/nova/objectstore/handler.py
@@ -167,7 +167,7 @@ class S3(ErrorHandlingResource):
     def __init__(self):
         ErrorHandlingResource.__init__(self)
 
-    def getChild(self, name, request):  # pylint: disable-msg=C0103
+    def getChild(self, name, request):  # pylint: disable=C0103
         """Returns either the image or bucket resource"""
         request.context = get_context(request)
         if name == '':
@@ -177,7 +177,7 @@ class S3(ErrorHandlingResource):
         else:
             return BucketResource(name)
 
-    def render_GET(self, request):  # pylint: disable-msg=R0201
+    def render_GET(self, request):  # pylint: disable=R0201
         """Renders the GET request for a list of buckets as XML"""
         LOG.debug(_('List of buckets requested'), context=request.context)
         buckets = [b for b in bucket.Bucket.all()
@@ -355,7 +355,7 @@ class ImagesResource(resource.Resource):
         else:
             return ImageResource(name)
 
-    def render_GET(self, request):  # pylint: disable-msg=R0201
+    def render_GET(self, request):  # pylint: disable=R0201
         """ returns a json listing of all images
             that a user has permissions to see """
 
@@ -384,7 +384,7 @@ class ImagesResource(resource.Resource):
         request.finish()
         return server.NOT_DONE_YET
 
-    def render_PUT(self, request):  # pylint: disable-msg=R0201
+    def render_PUT(self, request):  # pylint: disable=R0201
         """ create a new registered image """
 
         image_id = get_argument(request, 'image_id', u'')
@@ -413,7 +413,7 @@ class ImagesResource(resource.Resource):
         p.start()
         return ''
 
-    def render_POST(self, request):  # pylint: disable-msg=R0201
+    def render_POST(self, request):  # pylint: disable=R0201
         """Update image attributes: public/private"""
 
         # image_id required for all requests
@@ -441,7 +441,7 @@ class ImagesResource(resource.Resource):
             image_object.update_user_editable_fields(clean_args)
         return ''
 
-    def render_DELETE(self, request):  # pylint: disable-msg=R0201
+    def render_DELETE(self, request):  # pylint: disable=R0201
         """Delete a registered image"""
         image_id = get_argument(request, "image_id", u"")
         image_object = image.Image(image_id)
@@ -471,7 +471,7 @@ def get_application():
     application = service.Application("objectstore")
     # Disabled because of lack of proper introspection in Twisted
     # or possibly different versions of twisted?
-    # pylint: disable-msg=E1101
+    # pylint: disable=E1101
     objectStoreService = internet.TCPServer(FLAGS.s3_port, factory,
                                             interface=FLAGS.s3_listen_host)
     objectStoreService.setServiceParent(application)
diff --git a/nova/rpc.py b/nova/rpc.py
index 58715963a..5935e1fb3 100644
--- a/nova/rpc.py
+++ b/nova/rpc.py
@@ -62,7 +62,7 @@ class Connection(carrot_connection.BrokerConnection):
                 params['backend_cls'] = fakerabbit.Backend
 
             # NOTE(vish): magic is fun!
-            # pylint: disable-msg=W0142
+            # pylint: disable=W0142
             if new:
                 return cls(**params)
             else:
@@ -114,7 +114,7 @@ class Consumer(messaging.Consumer):
             if self.failed_connection:
                 # NOTE(vish): connection is defined in the parent class, we can
                 #             recreate it as long as we create the backend too
-                # pylint: disable-msg=W0201
+                # pylint: disable=W0201
                 self.connection = Connection.recreate()
                 self.backend = self.connection.create_backend()
                 self.declare()
@@ -125,7 +125,7 @@ class Consumer(messaging.Consumer):
         # NOTE(vish): This is catching all errors because we really don't
         #             want exceptions to be logged 10 times a second if some
         #             persistent failure occurs.
-        except Exception:  # pylint: disable-msg=W0703
+        except Exception:  # pylint: disable=W0703
             if not self.failed_connection:
                 LOG.exception(_("Failed to fetch message from queue"))
                 self.failed_connection = True
diff --git a/nova/service.py b/nova/service.py
index d60df987c..52bb15ad7 100644
--- a/nova/service.py
+++ b/nova/service.py
@@ -217,7 +217,7 @@ class Service(object):
                 logging.error(_("Recovered model server connection!"))
 
         # TODO(vish): this should probably only catch connection errors
-        except Exception:  # pylint: disable-msg=W0702
+        except Exception:  # pylint: disable=W0702
             if not getattr(self, "model_disconnected", False):
                 self.model_disconnected = True
                 logging.exception(_("model server went away"))
diff --git a/nova/tests/api/test_wsgi.py b/nova/tests/api/test_wsgi.py
index b1a849cf9..1ecdd1cfb 100644
--- a/nova/tests/api/test_wsgi.py
+++ b/nova/tests/api/test_wsgi.py
@@ -80,7 +80,7 @@ class ControllerTest(test.TestCase):
                     "attributes": {
                         "test": ["id"]}}}
 
-            def show(self, req, id):  # pylint: disable-msg=W0622,C0103
+            def show(self, req, id):  # pylint: disable=W0622,C0103
                 return {"test": {"id": id}}
 
         def __init__(self):
diff --git a/nova/tests/hyperv_unittest.py b/nova/tests/hyperv_unittest.py
index 3980ae3cb..042819b9c 100644
--- a/nova/tests/hyperv_unittest.py
+++ b/nova/tests/hyperv_unittest.py
@@ -51,7 +51,7 @@ class HyperVTestCase(test.TestCase):
         instance_ref = db.instance_create(self.context, instance)
 
         conn = hyperv.get_connection(False)
-        conn._create_vm(instance_ref)  # pylint: disable-msg=W0212
+        conn._create_vm(instance_ref)  # pylint: disable=W0212
         found = [n  for n in conn.list_instances()
                       if n == instance_ref['name']]
         self.assertTrue(len(found) == 1)
diff --git a/nova/tests/objectstore_unittest.py b/nova/tests/objectstore_unittest.py
index 5a1be08eb..5d160bdf8 100644
--- a/nova/tests/objectstore_unittest.py
+++ b/nova/tests/objectstore_unittest.py
@@ -179,7 +179,7 @@ class ObjectStoreTestCase(test.TestCase):
 class TestHTTPChannel(http.HTTPChannel):
     """Dummy site required for twisted.web"""
 
-    def checkPersistence(self, _, __):  # pylint: disable-msg=C0103
+    def checkPersistence(self, _, __):  # pylint: disable=C0103
         """Otherwise we end up with an unclean reactor."""
         return False
 
@@ -209,7 +209,7 @@ class S3APITestCase(test.TestCase):
 
         root = S3()
         self.site = TestSite(root)
-        # pylint: disable-msg=E1101
+        # pylint: disable=E1101
         self.listening_port = reactor.listenTCP(0, self.site,
                                                 interface='127.0.0.1')
         # pylint: enable-msg=E1101
@@ -231,11 +231,11 @@ class S3APITestCase(test.TestCase):
 
         self.conn.get_http_connection = get_http_connection
 
-    def _ensure_no_buckets(self, buckets):  # pylint: disable-msg=C0111
+    def _ensure_no_buckets(self, buckets):  # pylint: disable=C0111
         self.assertEquals(len(buckets), 0, "Bucket list was not empty")
         return True
 
-    def _ensure_one_bucket(self, buckets, name):  # pylint: disable-msg=C0111
+    def _ensure_one_bucket(self, buckets, name):  # pylint: disable=C0111
         self.assertEquals(len(buckets), 1,
                           "Bucket list didn't have exactly one element in it")
         self.assertEquals(buckets[0].name, name, "Wrong name")
diff --git a/nova/tests/test_api.py b/nova/tests/test_api.py
index d5c54a1c3..b67d6b12c 100644
--- a/nova/tests/test_api.py
+++ b/nova/tests/test_api.py
@@ -124,7 +124,7 @@ class ApiEc2TestCase(test.TestCase):
         self.mox.StubOutWithMock(self.ec2, 'new_http_connection')
         self.http = FakeHttplibConnection(
                 self.app, '%s:8773' % (self.host), False)
-        # pylint: disable-msg=E1103
+        # pylint: disable=E1103
         self.ec2.new_http_connection(host, is_secure).AndReturn(self.http)
         return self.http
 
diff --git a/nova/tests/test_middleware.py b/nova/tests/test_middleware.py
index 9d49167ba..6564a6955 100644
--- a/nova/tests/test_middleware.py
+++ b/nova/tests/test_middleware.py
@@ -40,12 +40,12 @@ def conditional_forbid(req):
 
 class LockoutTestCase(test.TestCase):
     """Test case for the Lockout middleware."""
-    def setUp(self):  # pylint: disable-msg=C0103
+    def setUp(self):  # pylint: disable=C0103
         super(LockoutTestCase, self).setUp()
         utils.set_time_override()
         self.lockout = ec2.Lockout(conditional_forbid)
 
-    def tearDown(self):  # pylint: disable-msg=C0103
+    def tearDown(self):  # pylint: disable=C0103
         utils.clear_time_override()
         super(LockoutTestCase, self).tearDown()
 
-- 
cgit 


From 204ec967ee46079fb95a18fcfb1167ff57458015 Mon Sep 17 00:00:00 2001
From: Brian Lamar <brian.lamar@rackspace.com>
Date: Fri, 18 Mar 2011 09:56:38 -0400
Subject: enable-msg -> enable

---
 nova/auth/fakeldap.py              | 2 +-
 nova/tests/objectstore_unittest.py | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/auth/fakeldap.py b/nova/auth/fakeldap.py
index e8f5771d5..79afb9109 100644
--- a/nova/auth/fakeldap.py
+++ b/nova/auth/fakeldap.py
@@ -277,7 +277,7 @@ class FakeLDAP(object):
                 attrs = dict([(k, v) for k, v in attrs.iteritems()
                               if not fields or k in fields])
                 objects.append((key[len(self.__prefix):], attrs))
-            # pylint: enable-msg=E1103
+            # pylint: enable=E1103
         if objects == []:
             raise NO_SUCH_OBJECT()
         return objects
diff --git a/nova/tests/objectstore_unittest.py b/nova/tests/objectstore_unittest.py
index 5d160bdf8..4e2ac205e 100644
--- a/nova/tests/objectstore_unittest.py
+++ b/nova/tests/objectstore_unittest.py
@@ -212,7 +212,7 @@ class S3APITestCase(test.TestCase):
         # pylint: disable=E1101
         self.listening_port = reactor.listenTCP(0, self.site,
                                                 interface='127.0.0.1')
-        # pylint: enable-msg=E1101
+        # pylint: enable=E1101
         self.tcp_port = self.listening_port.getHost().port
 
         if not boto.config.has_section('Boto'):
-- 
cgit 


From a50deeb264ff721584d5b0a6ace749d8e2c44842 Mon Sep 17 00:00:00 2001
From: Dan Prince <dan.prince@rackspace.com>
Date: Fri, 18 Mar 2011 10:10:46 -0400
Subject: Change cloud.id_to_ec2_id to ec2utils.id_to_ec2_id. Fixes EC2 API
 error handling when invalid instances and volume names are specified.

---
 nova/api/ec2/__init__.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/api/ec2/__init__.py b/nova/api/ec2/__init__.py
index fccebca5d..20701cfa8 100644
--- a/nova/api/ec2/__init__.py
+++ b/nova/api/ec2/__init__.py
@@ -31,7 +31,7 @@ from nova import log as logging
 from nova import utils
 from nova import wsgi
 from nova.api.ec2 import apirequest
-from nova.api.ec2 import cloud
+from nova.api.ec2 import ec2utils
 from nova.auth import manager
 
 
@@ -319,13 +319,13 @@ class Executor(wsgi.Application):
         except exception.InstanceNotFound as ex:
             LOG.info(_('InstanceNotFound raised: %s'), unicode(ex),
                      context=context)
-            ec2_id = cloud.id_to_ec2_id(ex.instance_id)
+            ec2_id = ec2utils.id_to_ec2_id(ex.instance_id)
             message = _('Instance %s not found') % ec2_id
             return self._error(req, context, type(ex).__name__, message)
         except exception.VolumeNotFound as ex:
             LOG.info(_('VolumeNotFound raised: %s'), unicode(ex),
                      context=context)
-            ec2_id = cloud.id_to_ec2_id(ex.volume_id, 'vol-%08x')
+            ec2_id = ec2utils.id_to_ec2_id(ex.volume_id, 'vol-%08x')
             message = _('Volume %s not found') % ec2_id
             return self._error(req, context, type(ex).__name__, message)
         except exception.NotFound as ex:
-- 
cgit 


From 70e8b431334989ad067f0a5543aea408b7186c5c Mon Sep 17 00:00:00 2001
From: Brian Lamar <brian.lamar@rackspace.com>
Date: Fri, 18 Mar 2011 10:34:08 -0400
Subject: Fixed 'Undefined variable' errors generated by pylint (E0602).

---
 nova/api/openstack/accounts.py                                     | 7 ++++---
 nova/compute/api.py                                                | 2 +-
 nova/db/sqlalchemy/api.py                                          | 5 +++--
 nova/db/sqlalchemy/migrate_repo/versions/008_add_instance_types.py | 2 --
 nova/virt/fake.py                                                  | 2 +-
 nova/virt/libvirt_conn.py                                          | 2 +-
 6 files changed, 10 insertions(+), 10 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/accounts.py b/nova/api/openstack/accounts.py
index 2510ffb61..86066fa20 100644
--- a/nova/api/openstack/accounts.py
+++ b/nova/api/openstack/accounts.py
@@ -14,6 +14,7 @@
 #    under the License.
 
 import common
+import webob.exc
 
 from nova import exception
 from nova import flags
@@ -51,10 +52,10 @@ class Controller(wsgi.Controller):
             raise exception.NotAuthorized(_("Not admin user."))
 
     def index(self, req):
-        raise faults.Fault(exc.HTTPNotImplemented())
+        raise faults.Fault(webob.exc.HTTPNotImplemented())
 
     def detail(self, req):
-        raise faults.Fault(exc.HTTPNotImplemented())
+        raise faults.Fault(webob.exc.HTTPNotImplemented())
 
     def show(self, req, id):
         """Return data about the given account id"""
@@ -69,7 +70,7 @@ class Controller(wsgi.Controller):
     def create(self, req):
         """We use update with create-or-update semantics
            because the id comes from an external source"""
-        raise faults.Fault(exc.HTTPNotImplemented())
+        raise faults.Fault(webob.exc.HTTPNotImplemented())
 
     def update(self, req, id):
         """This is really create or update."""
diff --git a/nova/compute/api.py b/nova/compute/api.py
index 32577af82..058b600bf 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -479,7 +479,7 @@ class API(base.Base):
         self._cast_compute_message('confirm_resize', context, instance_id,
                 migration_ref['source_compute'], params=params)
 
-        self.db.migration_update(context, migration_id,
+        self.db.migration_update(context, migration_ref['id'],
                 {'status': 'confirmed'})
         self.db.instance_update(context, instance_id,
                 {'host': migration_ref['dest_compute'], })
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 9d9b86c1d..98e6f938a 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -2204,7 +2204,7 @@ def migration_get(context, id, session=None):
                      filter_by(id=id).first()
     if not result:
         raise exception.NotFound(_("No migration found with id %s")
-                % migration_id)
+                % id)
     return result
 
 
@@ -2216,7 +2216,7 @@ def migration_get_by_instance_and_status(context, instance_id, status):
                      filter_by(status=status).first()
     if not result:
         raise exception.NotFound(_("No migration found with instance id %s")
-                % migration_id)
+                % id)
     return result
 
 
@@ -2427,6 +2427,7 @@ def zone_create(context, values):
 
 @require_admin_context
 def zone_update(context, zone_id, values):
+    session = get_session()
     zone = session.query(models.Zone).filter_by(id=zone_id).first()
     if not zone:
         raise exception.NotFound(_("No zone with id %(zone_id)s") % locals())
diff --git a/nova/db/sqlalchemy/migrate_repo/versions/008_add_instance_types.py b/nova/db/sqlalchemy/migrate_repo/versions/008_add_instance_types.py
index 66609054e..8b962bf7f 100644
--- a/nova/db/sqlalchemy/migrate_repo/versions/008_add_instance_types.py
+++ b/nova/db/sqlalchemy/migrate_repo/versions/008_add_instance_types.py
@@ -55,7 +55,6 @@ def upgrade(migrate_engine):
     try:
         instance_types.create()
     except Exception:
-        logging.info(repr(table))
         logging.exception('Exception while creating instance_types table')
         raise
 
@@ -76,7 +75,6 @@ def upgrade(migrate_engine):
                         'local_gb': values["local_gb"],
                         'flavorid': values["flavorid"]})
     except Exception:
-        logging.info(repr(table))
         logging.exception('Exception while seeding instance_types table')
         raise
 
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 047bff904817838279199a7099023b505e35343f Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Fri, 18 Mar 2011 07:43:42 -0700
Subject: whoopsy

---
 nova/compute/api.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/compute/api.py b/nova/compute/api.py
index 96538dd00..270600664 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -343,7 +343,7 @@ class API(base.Base):
         rv = self.db.instance_update(context, instance_id, kwargs)
         return dict(rv.iteritems())
 
-    @scheduler_api.reroute("delete")
+    @scheduler_api.reroute_compute("delete")
     def delete(self, context, instance_id):
         LOG.debug(_("Going to try to terminate %s"), instance_id)
         try:
-- 
cgit 


From 930d7bf1987c1b270ec0e456f982efb70527ed15 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Fri, 18 Mar 2011 07:47:23 -0700
Subject: whoopsy2

---
 nova/scheduler/api.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/scheduler/api.py b/nova/scheduler/api.py
index 90b92d7ed..b639ae786 100644
--- a/nova/scheduler/api.py
+++ b/nova/scheduler/api.py
@@ -142,7 +142,7 @@ class reroute_compute(object):
     def __call__(self, f):
         def wrapped_f(*args, **kwargs):
             collection, context, item_id = \
-                            self.get_collection_context_and_id()
+                            self.get_collection_context_and_id(args)
             try:
                 return f(*args, **kwargs)
             except exception.InstanceNotFound, e:
-- 
cgit 


From 0c779999a36186ae58343e169db6f2e71c9a3200 Mon Sep 17 00:00:00 2001
From: sateesh <sateesh.chodapuneedi@citrix.com>
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')

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 dba79cdf18f20f1e4e0758ae19b33de94881e440 Mon Sep 17 00:00:00 2001
From: Dan Prince <dan.prince@rackspace.com>
Date: Fri, 18 Mar 2011 11:12:44 -0400
Subject: Added test case.

---
 nova/tests/test_api.py | 12 ++++++++++++
 1 file changed, 12 insertions(+)

(limited to 'nova')

diff --git a/nova/tests/test_api.py b/nova/tests/test_api.py
index d5c54a1c3..7023eb410 100644
--- a/nova/tests/test_api.py
+++ b/nova/tests/test_api.py
@@ -20,6 +20,7 @@
 
 import boto
 from boto.ec2 import regioninfo
+from boto.exception import EC2ResponseError
 import datetime
 import httplib
 import random
@@ -177,6 +178,17 @@ class ApiEc2TestCase(test.TestCase):
         self.manager.delete_project(project)
         self.manager.delete_user(user)
 
+    def test_terminate_invalid_instance(self):
+        """Attempt to terminate an invalid instance"""
+        self.expect_http()
+        self.mox.ReplayAll()
+        user = self.manager.create_user('fake', 'fake', 'fake')
+        project = self.manager.create_project('fake', 'fake', 'fake')
+        self.assertRaises(EC2ResponseError, self.ec2.terminate_instances,
+                            "i-00000005")
+        self.manager.delete_project(project)
+        self.manager.delete_user(user)
+
     def test_get_all_key_pairs(self):
         """Test that, after creating a user and project and generating
          a key pair, that the API call to list key pairs works properly"""
-- 
cgit 


From 12ffa884c07b55c982a1ad60a94e72c955db81c3 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Fri, 18 Mar 2011 09:02:36 -0700
Subject: fixed up novaclient usage to include managers

---
 nova/scheduler/api.py | 12 +++++-------
 1 file changed, 5 insertions(+), 7 deletions(-)

(limited to 'nova')

diff --git a/nova/scheduler/api.py b/nova/scheduler/api.py
index b639ae786..7efc28072 100644
--- a/nova/scheduler/api.py
+++ b/nova/scheduler/api.py
@@ -17,14 +17,14 @@
 Handles all requests relating to schedulers.
 """
 
+import novaclient
+
 from nova import db
 from nova import exception
 from nova import flags
 from nova import log as logging
 from nova import rpc
 
-import novaclient.client as client
-
 from eventlet import greenpool
 
 FLAGS = flags.FLAGS
@@ -80,7 +80,7 @@ class API(object):
 
 
 def _wrap_method(function, self):
-    """Wrap method to supply 'self'."""
+    """Wrap method to supply self."""
     def _wrap(*args, **kwargs):
         return function(self, *args, **kwargs)
     return _wrap
@@ -89,8 +89,7 @@ def _wrap_method(function, self):
 def _process(func, zone):
     """Worker stub for green thread pool. Give the worker
     an authenticated nova client and zone info."""
-    nova = client.OpenStackClient(zone.username, zone.password,
-                                        zone.api_url)
+    nova = novaclient.OpenStack(zone.username, zone.password, zone.api_url)
     nova.authenticate()
     return func(nova, zone)
 
@@ -134,8 +133,7 @@ def wrap_novaclient_function(f, collection, method_name, item_id):
 class reroute_compute(object):
     """Decorator used to indicate that the method should
        delegate the call the child zones if the db query
-       can't find anything.
-    """
+       can't find anything."""
     def __init__(self, method_name):
         self.method_name = method_name
 
-- 
cgit 


From ef33d6bde27276fb4c93ed6bbcb972977f03a370 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Fri, 18 Mar 2011 09:21:08 -0700
Subject: results

---
 nova/api/openstack/servers.py | 2 +-
 nova/scheduler/api.py         | 5 ++++-
 2 files changed, 5 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 9f14a6b82..49f714d47 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -130,7 +130,7 @@ class Controller(wsgi.Controller):
         try:
             LOG.debug(_("***SHOW"))
             instance = self.compute_api.routing_get(req.environ['nova.context'], id)
-            LOG.debug(_("***SHOW"))
+            LOG.debug(_("***SHOW OUT %s" % instance))
             return _translate_detail_keys(instance)
         except exception.NotFound:
             return faults.Fault(exc.HTTPNotFound())
diff --git a/nova/scheduler/api.py b/nova/scheduler/api.py
index 7efc28072..6b0f804f9 100644
--- a/nova/scheduler/api.py
+++ b/nova/scheduler/api.py
@@ -118,7 +118,10 @@ def _issue_novaclient_command(nova, zone, collection, method_name, \
                                                 locals()))
         return
 
-    return getattr(item, method_name)()
+    LOG.debug("***CALLING CHILD ZONE")
+    result = getattr(item, method_name)()
+    LOG.debug("***CHILD ZONE GAVE %s", result)
+    return result
 
 
 def wrap_novaclient_function(f, collection, method_name, item_id):
-- 
cgit 


From 4f5dc6314f9dd7bb136a38fa07b109eb2e12734d Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Fri, 18 Mar 2011 10:06:36 -0700
Subject: auth_data is a list now (thanks Rick!)

---
 nova/tests/api/openstack/fakes.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/fakes.py b/nova/tests/api/openstack/fakes.py
index 5decb2bad..020682093 100644
--- a/nova/tests/api/openstack/fakes.py
+++ b/nova/tests/api/openstack/fakes.py
@@ -240,7 +240,8 @@ class FakeAuthManager(object):
 
     @classmethod
     def reset_fake_data(cls):
-        cls.auth_data = dict(u1=User('id1', 'guy1', 'acc1', 'secret1', False))
+        u1 = User('id1', 'guy1', 'acc1', 'secret1', False)
+        cls.auth_data = [u1]
         cls.projects = dict(testacct=Project('testacct',
                                              'testacct',
                                              'id1',
-- 
cgit 


From ee09125e31a3afe64f0a9540a88fdb5febd7ddd4 Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Fri, 18 Mar 2011 10:14:42 -0700
Subject: Avoid single-letter variable names

---
 nova/tests/api/openstack/fakes.py | 23 ++++++++++-------------
 1 file changed, 10 insertions(+), 13 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/fakes.py b/nova/tests/api/openstack/fakes.py
index 020682093..9b5ed8a15 100644
--- a/nova/tests/api/openstack/fakes.py
+++ b/nova/tests/api/openstack/fakes.py
@@ -255,21 +255,21 @@ class FakeAuthManager(object):
         return FakeAuthManager.auth_data
 
     def get_user(self, uid):
-        for u in FakeAuthManager.auth_data:
-            if u.id == uid:
-                return u
+        for user in FakeAuthManager.auth_data:
+            if user.id == uid:
+                return user
         return None
 
     def get_user_from_access_key(self, key):
-        for u in FakeAuthManager.auth_data:
-            if u.access == key:
-                return u
+        for user in FakeAuthManager.auth_data:
+            if user.access == key:
+                return user
         return None
 
     def delete_user(self, uid):
-        for u in FakeAuthManager.auth_data:
-            if u.id == uid:
-                FakeAuthManager.auth_data.remove(u)
+        for user in FakeAuthManager.auth_data:
+            if user.id == uid:
+                FakeAuthManager.auth_data.remove(user)
         return None
 
     def create_user(self, name, access=None, secret=None, admin=False):
@@ -278,10 +278,7 @@ class FakeAuthManager(object):
         return u
 
     def modify_user(self, user_id, access=None, secret=None, admin=None):
-        user = None
-        for u in FakeAuthManager.auth_data:
-            if u.id == user_id:
-                user = u
+        user = self.get_user(user_id)
         if user:
             user.access = access
             user.secret = secret
-- 
cgit 


From 48a1423081355b49340aa1a4a37361654d9c0d87 Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Fri, 18 Mar 2011 10:24:06 -0700
Subject: A few more single-letter variable names bite the dust

---
 nova/tests/api/openstack/test_auth.py | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/test_auth.py b/nova/tests/api/openstack/test_auth.py
index 446c5c149..21596fb25 100644
--- a/nova/tests/api/openstack/test_auth.py
+++ b/nova/tests/api/openstack/test_auth.py
@@ -51,8 +51,8 @@ class Test(test.TestCase):
 
     def test_authorize_user(self):
         f = fakes.FakeAuthManager()
-        u = nova.auth.manager.User('id1', 'user1', 'user1_key', None, None)
-        f.add_user(u)
+        user = nova.auth.manager.User('id1', 'user1', 'user1_key', None, None)
+        f.add_user(user)
 
         req = webob.Request.blank('/v1.0/')
         req.headers['X-Auth-User'] = 'user1'
@@ -66,9 +66,9 @@ class Test(test.TestCase):
 
     def test_authorize_token(self):
         f = fakes.FakeAuthManager()
-        u = nova.auth.manager.User('id1', 'user1', 'user1_key', None, None)
-        f.add_user(u)
-        f.create_project('user1_project', u)
+        user = nova.auth.manager.User('id1', 'user1', 'user1_key', None, None)
+        f.add_user(user)
+        f.create_project('user1_project', user)
 
         req = webob.Request.blank('/v1.0/', {'HTTP_HOST': 'foo'})
         req.headers['X-Auth-User'] = 'user1'
@@ -124,8 +124,8 @@ class Test(test.TestCase):
 
     def test_bad_user_good_key(self):
         f = fakes.FakeAuthManager()
-        u = nova.auth.manager.User('id1', 'user1', 'user1_key', None, None)
-        f.add_user(u)
+        user = nova.auth.manager.User('id1', 'user1', 'user1_key', None, None)
+        f.add_user(user)
 
         req = webob.Request.blank('/v1.0/')
         req.headers['X-Auth-User'] = 'unknown_user'
@@ -190,9 +190,9 @@ class TestLimiter(test.TestCase):
 
     def test_authorize_token(self):
         f = fakes.FakeAuthManager()
-        u = nova.auth.manager.User('id1', 'user1', 'user1_key', None, None)
-        f.add_user(u)
-        f.create_project('test', u)
+        user = nova.auth.manager.User('id1', 'user1', 'user1_key', None, None)
+        f.add_user(user)
+        f.create_project('test', user)
 
         req = webob.Request.blank('/v1.0/')
         req.headers['X-Auth-User'] = 'user1'
-- 
cgit 


From 705020cc4acded862633aa5e02d5bb46c88dbc51 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Fri, 18 Mar 2011 11:46:27 -0700
Subject: api decorator

---
 nova/api/openstack/servers.py |  2 ++
 nova/scheduler/api.py         | 37 +++++++++++++++++++++++++++++--------
 2 files changed, 31 insertions(+), 8 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 49f714d47..17d620562 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -33,6 +33,7 @@ from nova.auth import manager as auth_manager
 from nova.compute import instance_types
 from nova.compute import power_state
 import nova.api.openstack
+from nova.scheduler import api as scheduler_api
 
 
 LOG = logging.getLogger('server')
@@ -125,6 +126,7 @@ class Controller(wsgi.Controller):
         res = [entity_maker(inst)['server'] for inst in limited_list]
         return dict(servers=res)
 
+    @scheduler_api.redirect_handler
     def show(self, req, id):
         """ Returns server details by server id """
         try:
diff --git a/nova/scheduler/api.py b/nova/scheduler/api.py
index 6b0f804f9..f5df446b3 100644
--- a/nova/scheduler/api.py
+++ b/nova/scheduler/api.py
@@ -105,22 +105,25 @@ def _issue_novaclient_command(nova, zone, collection, method_name, \
                                                         item_id):
     """Use novaclient to issue command to a single child zone.
        One of these will be run in parallel for each child zone."""
-    item = None
+    result = None
     try:
         manager = getattr(nova, collection)
         if isinstance(item_id, int) or item_id.isdigit():
-            item = manager.get(int(item_id))
+            result = manager.get(int(item_id))
         else:
-            item = manager.find(name=item_id)
+            result = manager.find(name=item_id)
     except novaclient.NotFound:
         url = zone.api_url
         LOG.debug(_("%(collection)s '%(item_id)s' not found on '%(url)s'" %
                                                 locals()))
         return
 
-    LOG.debug("***CALLING CHILD ZONE")
-    result = getattr(item, method_name)()
-    LOG.debug("***CHILD ZONE GAVE %s", result)
+    if method_name.lower() not in ['get', 'find']:
+        LOG.debug("***CALLING CHILD ZONE")
+        m = getattr(item, method_name)
+        LOG.debug("***METHOD ATTR %s" % m)
+        result = getattr(item, method_name)()
+        LOG.debug("***CHILD ZONE GAVE %s", result)
     return result
 
 
@@ -133,6 +136,14 @@ def wrap_novaclient_function(f, collection, method_name, item_id):
     return inner
 
 
+class RedirectResult(exception.Error):
+    """Used to the HTTP API know that these results are pre-cooked
+    and they can be returned to the caller directly."""
+    def __init__(self, results):
+        self.results = results
+        super(RedirectResult, self).__init__(
+               message=_("Uncaught Zone redirection exception"))
+
 class reroute_compute(object):
     """Decorator used to indicate that the method should
        delegate the call the child zones if the db query
@@ -161,7 +172,7 @@ class reroute_compute(object):
                             wrap_novaclient_function(_issue_novaclient_command,
                                    collection, self.method_name, item_id))
                 LOG.debug("***REROUTE: %s" % result)
-                return self.unmarshall_result(result)
+                raise RedirectResult(self.unmarshall_result(result))
         return wrapped_f
 
     def get_collection_context_and_id(self, args):
@@ -170,4 +181,14 @@ class reroute_compute(object):
         return ("servers", args[1], args[2])
 
     def unmarshall_result(self, result):
-        return result        
+        return [server.__dict__ for server in result]
+
+
+def redirect_handler(f):
+    def new_f(*args, **kwargs):
+        try:
+            return f(*args, **kwargs)
+        except RedirectResult, e:
+            LOG.debug("***CAUGHT REROUTE: %s" % e.results)
+            return e.results
+    return new_f
-- 
cgit 


From 37f2c3036890f9bbfd88a369dfd590744256aaf9 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Fri, 18 Mar 2011 12:00:35 -0700
Subject: works again. woo hoo

---
 nova/scheduler/api.py | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/scheduler/api.py b/nova/scheduler/api.py
index f5df446b3..8b8457e8d 100644
--- a/nova/scheduler/api.py
+++ b/nova/scheduler/api.py
@@ -181,7 +181,13 @@ class reroute_compute(object):
         return ("servers", args[1], args[2])
 
     def unmarshall_result(self, result):
-        return [server.__dict__ for server in result]
+        server = result[0].__dict__
+
+        for k in server.keys():
+            if k[0] == '_' or k == 'manager':
+                del server[k]
+
+        return dict(server=server)
 
 
 def redirect_handler(f):
-- 
cgit 


From a0052203c7cc957677293e53ea7c0191d0493ea8 Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Fri, 18 Mar 2011 12:18:15 -0700
Subject: uses True/False instead of 1/0 for Postgres compatibility

---
 nova/db/api.py            | 2 +-
 nova/db/sqlalchemy/api.py | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/db/api.py b/nova/db/api.py
index 3cb0e5811..dd78fa3e7 100644
--- a/nova/db/api.py
+++ b/nova/db/api.py
@@ -1118,7 +1118,7 @@ def instance_type_create(context, values):
     return IMPL.instance_type_create(context, values)
 
 
-def instance_type_get_all(context, inactive=0):
+def instance_type_get_all(context, inactive=False):
     """Get all instance types"""
     return IMPL.instance_type_get_all(context, inactive)
 
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 9d9b86c1d..e72be0e0c 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -2337,7 +2337,7 @@ def instance_type_create(_context, values):
 
 
 @require_context
-def instance_type_get_all(context, inactive=0):
+def instance_type_get_all(context, inactive=False):
     """
     Returns a dict describing all instance_types with name as key.
     """
@@ -2392,7 +2392,7 @@ def instance_type_destroy(context, name):
     session = get_session()
     instance_type_ref = session.query(models.InstanceTypes).\
                                       filter_by(name=name)
-    records = instance_type_ref.update(dict(deleted=1))
+    records = instance_type_ref.update(dict(deleted=True))
     if records == 0:
         raise exception.NotFound
     else:
-- 
cgit 


From feb5c82e29303285d3f914c37116a59538fec28f Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Fri, 18 Mar 2011 12:23:57 -0700
Subject: fix ups

---
 nova/api/openstack/servers.py | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 17d620562..86414fab2 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -137,6 +137,7 @@ class Controller(wsgi.Controller):
         except exception.NotFound:
             return faults.Fault(exc.HTTPNotFound())
 
+    @scheduler_api.redirect_handler
     def delete(self, req, id):
         """ Destroys a server """
         try:
@@ -258,6 +259,7 @@ class Controller(wsgi.Controller):
         # if the original error is okay, just reraise it
         raise error
 
+    @scheduler_api.redirect_handler
     def update(self, req, id):
         """ Updates the server name or password """
         if len(req.body) == 0:
@@ -283,6 +285,7 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPNotFound())
         return exc.HTTPNoContent()
 
+    @scheduler_api.redirect_handler
     def action(self, req, id):
         """Multi-purpose method used to reboot, rebuild, or
         resize a server"""
@@ -348,6 +351,7 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPUnprocessableEntity())
         return exc.HTTPAccepted()
 
+    @scheduler_api.redirect_handler
     def lock(self, req, id):
         """
         lock the instance with id
@@ -363,6 +367,7 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPUnprocessableEntity())
         return exc.HTTPAccepted()
 
+    @scheduler_api.redirect_handler
     def unlock(self, req, id):
         """
         unlock the instance with id
@@ -378,6 +383,7 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPUnprocessableEntity())
         return exc.HTTPAccepted()
 
+    @scheduler_api.redirect_handler
     def get_lock(self, req, id):
         """
         return the boolean state of (instance with id)'s lock
@@ -392,6 +398,7 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPUnprocessableEntity())
         return exc.HTTPAccepted()
 
+    @scheduler_api.redirect_handler
     def reset_network(self, req, id):
         """
         Reset networking on an instance (admin only).
@@ -406,6 +413,7 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPUnprocessableEntity())
         return exc.HTTPAccepted()
 
+    @scheduler_api.redirect_handler
     def inject_network_info(self, req, id):
         """
         Inject network info for an instance (admin only).
@@ -420,6 +428,7 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPUnprocessableEntity())
         return exc.HTTPAccepted()
 
+    @scheduler_api.redirect_handler
     def pause(self, req, id):
         """ Permit Admins to Pause the server. """
         ctxt = req.environ['nova.context']
@@ -431,6 +440,7 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPUnprocessableEntity())
         return exc.HTTPAccepted()
 
+    @scheduler_api.redirect_handler
     def unpause(self, req, id):
         """ Permit Admins to Unpause the server. """
         ctxt = req.environ['nova.context']
@@ -442,6 +452,7 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPUnprocessableEntity())
         return exc.HTTPAccepted()
 
+    @scheduler_api.redirect_handler
     def suspend(self, req, id):
         """permit admins to suspend the server"""
         context = req.environ['nova.context']
@@ -453,6 +464,7 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPUnprocessableEntity())
         return exc.HTTPAccepted()
 
+    @scheduler_api.redirect_handler
     def resume(self, req, id):
         """permit admins to resume the server from suspend"""
         context = req.environ['nova.context']
@@ -464,6 +476,7 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPUnprocessableEntity())
         return exc.HTTPAccepted()
 
+    @scheduler_api.redirect_handler
     def rescue(self, req, id):
         """Permit users to rescue the server."""
         context = req.environ["nova.context"]
@@ -475,6 +488,7 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPUnprocessableEntity())
         return exc.HTTPAccepted()
 
+    @scheduler_api.redirect_handler
     def unrescue(self, req, id):
         """Permit users to unrescue the server."""
         context = req.environ["nova.context"]
@@ -486,6 +500,7 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPUnprocessableEntity())
         return exc.HTTPAccepted()
 
+    @scheduler_api.redirect_handler
     def get_ajax_console(self, req, id):
         """ Returns a url to an instance's ajaxterm console. """
         try:
@@ -495,6 +510,7 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPNotFound())
         return exc.HTTPAccepted()
 
+    @scheduler_api.redirect_handler
     def diagnostics(self, req, id):
         """Permit Admins to retrieve server diagnostics."""
         ctxt = req.environ["nova.context"]
-- 
cgit 


From 2f4c1802c7e482a447d348f049ff429b3d1a640c Mon Sep 17 00:00:00 2001
From: Mark Washenberger <mark.washenberger@rackspace.com>
Date: Fri, 18 Mar 2011 16:06:43 -0400
Subject: fix date formatting in images controller show

---
 nova/api/openstack/images.py            |  6 +++++
 nova/tests/api/openstack/fakes.py       | 20 +++++++++-----
 nova/tests/api/openstack/test_images.py | 46 ++++++++++++++++-----------------
 3 files changed, 43 insertions(+), 29 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/images.py b/nova/api/openstack/images.py
index 98f0dd96b..94e05823e 100644
--- a/nova/api/openstack/images.py
+++ b/nova/api/openstack/images.py
@@ -143,6 +143,7 @@ class Controller(wsgi.Controller):
 
         image = self._service.show(req.environ['nova.context'], image_id)
         _convert_image_id_to_hash(image)
+        self._format_image_dates(image)
         return dict(image=image)
 
     def delete(self, req, id):
@@ -164,3 +165,8 @@ class Controller(wsgi.Controller):
         # Users may not modify public images, and that's all that
         # we support for now.
         raise faults.Fault(exc.HTTPNotFound())
+
+    def _format_image_dates(self, image):
+        for attr in ['created_at', 'updated_at', 'deleted_at']:
+            if image[attr] is not None:
+                image[attr] = image[attr].strftime('%Y-%m-%dT%H:%M:%SZ')
diff --git a/nova/tests/api/openstack/fakes.py b/nova/tests/api/openstack/fakes.py
index 15f8a5b56..9573cf128 100644
--- a/nova/tests/api/openstack/fakes.py
+++ b/nova/tests/api/openstack/fakes.py
@@ -15,6 +15,7 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+import copy
 import datetime
 import json
 import random
@@ -151,22 +152,23 @@ def stub_out_glance(stubs, initial_fixtures=None):
                     for f in self.fixtures]
 
         def fake_get_images_detailed(self):
-            return self.fixtures
+            return copy.deepcopy(self.fixtures)
 
         def fake_get_image_meta(self, image_id):
-            for f in self.fixtures:
-                if f['id'] == image_id:
-                    return f
+            image = self._find_image(image_id)
+            if image:
+                return copy.deepcopy(image)
             raise glance_exc.NotFound
 
         def fake_add_image(self, image_meta, data=None):
+            image_meta = copy.deepcopy(image_meta)
             id = ''.join(random.choice(string.letters) for _ in range(20))
             image_meta['id'] = id
             self.fixtures.append(image_meta)
             return image_meta
 
         def fake_update_image(self, image_id, image_meta, data=None):
-            f = self.fake_get_image_meta(image_id)
+            f = self._find_image(image_id)
             if not f:
                 raise glance_exc.NotFound
 
@@ -174,7 +176,7 @@ def stub_out_glance(stubs, initial_fixtures=None):
             return f
 
         def fake_delete_image(self, image_id):
-            f = self.fake_get_image_meta(image_id)
+            f = self._find_image(image_id)
             if not f:
                 raise glance_exc.NotFound
 
@@ -183,6 +185,12 @@ def stub_out_glance(stubs, initial_fixtures=None):
         ##def fake_delete_all(self):
         ##    self.fixtures = []
 
+        def _find_image(self, image_id):
+            for f in self.fixtures:
+                if f['id'] == image_id:
+                    return f
+            return None
+
     GlanceClient = glance_client.Client
     fake = FakeGlanceClient(initial_fixtures)
 
diff --git a/nova/tests/api/openstack/test_images.py b/nova/tests/api/openstack/test_images.py
index 47dd11e5b..b771966f1 100644
--- a/nova/tests/api/openstack/test_images.py
+++ b/nova/tests/api/openstack/test_images.py
@@ -21,7 +21,7 @@ and as a WSGI layer
 """
 
 import json
-import datetime
+import datetime as dt
 import shutil
 import tempfile
 
@@ -177,13 +177,13 @@ class ImageControllerWithGlanceServiceTest(test.TestCase):
     """Test of the OpenStack API /images application controller"""
 
     # Registered images at start of each test.
-
+    now = dt.datetime.utcnow()
     IMAGE_FIXTURES = [
         {'id': '23g2ogk23k4hhkk4k42l',
          'imageId': '23g2ogk23k4hhkk4k42l',
          'name': 'public image #1',
-         'created_at': datetime.datetime.utcnow().isoformat(),
-         'updated_at': datetime.datetime.utcnow().isoformat(),
+         'created_at': now.isoformat(),
+         'updated_at': now.isoformat(),
          'deleted_at': None,
          'deleted': False,
          'is_public': True,
@@ -192,8 +192,8 @@ class ImageControllerWithGlanceServiceTest(test.TestCase):
         {'id': 'slkduhfas73kkaskgdas',
          'imageId': 'slkduhfas73kkaskgdas',
          'name': 'public image #2',
-         'created_at': datetime.datetime.utcnow().isoformat(),
-         'updated_at': datetime.datetime.utcnow().isoformat(),
+         'created_at': now.isoformat(),
+         'updated_at': now.isoformat(),
          'deleted_at': None,
          'deleted': False,
          'is_public': True,
@@ -235,20 +235,20 @@ class ImageControllerWithGlanceServiceTest(test.TestCase):
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
 
-        def _is_equivalent_subset(x, y):
-            if set(x) <= set(y):
-                for k, v in x.iteritems():
-                    if x[k] != y[k]:
-                        if x[k] == 'active' and y[k] == 'available':
-                            continue
-                        return False
-                return True
-            return False
-
-        for image in res_dict['images']:
-            for image_fixture in self.IMAGE_FIXTURES:
-                if _is_equivalent_subset(image, image_fixture):
-                    break
-            else:
-                self.assertEquals(1, 2, "image %s not in fixtures!" %
-                                                            str(image))
+        for image in self.IMAGE_FIXTURES:
+            expected = {
+                'id': abs(hash(image['imageId'])),
+                'name': image['name'],
+                'status': 'active',
+            }
+            self.assertTrue(expected in res_dict['images'])
+
+    def test_show_image(self):
+        expected = self.IMAGE_FIXTURES[0]
+        id = abs(hash(expected['id']))
+        expected_time = self.now.strftime('%Y-%m-%dT%H:%M:%SZ')
+        req = webob.Request.blank('/v1.0/images/%s' % id)
+        res = req.get_response(fakes.wsgi_app())
+        actual = json.loads(res.body)['image']
+        self.assertEqual(expected_time, actual['created_at'])
+        self.assertEqual(expected_time, actual['updated_at'])
-- 
cgit 


From 8437d947a6e94baf7aa53746ffd34aa5c0f521d9 Mon Sep 17 00:00:00 2001
From: Josh Kearney <josh.kearney@rackspace.com>
Date: Fri, 18 Mar 2011 15:34:50 -0500
Subject: Better errors when virt driver isn't loaded

---
 nova/compute/manager.py | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 92deca813..5b8e4dafb 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -39,6 +39,7 @@ import os
 import random
 import string
 import socket
+import sys
 import tempfile
 import time
 import functools
@@ -114,7 +115,13 @@ class ComputeManager(manager.Manager):
         #             and redocument the module docstring
         if not compute_driver:
             compute_driver = FLAGS.compute_driver
-        self.driver = utils.import_object(compute_driver)
+
+        try:
+            self.driver = utils.import_object(compute_driver)
+        except ImportError:
+            LOG.error("Unable to load the virtualization driver.")
+            sys.exit(1)
+
         self.network_manager = utils.import_object(FLAGS.network_manager)
         self.volume_manager = utils.import_object(FLAGS.volume_manager)
         super(ComputeManager, self).__init__(*args, **kwargs)
@@ -221,7 +228,8 @@ class ComputeManager(manager.Manager):
                                     instance_id,
                                     {'launched_at': now})
         except Exception:  # pylint: disable-msg=W0702
-            LOG.exception(_("instance %s: Failed to spawn"), instance_id,
+            LOG.exception(_("Instance '%s' failed to spawn. Is virtualization"
+                            "enabled in the BIOS?"), instance_id,
                           context=context)
             self.db.instance_set_state(context,
                                        instance_id,
-- 
cgit 


From 9351bd5538ea0fc0a77c4dee13406ac7a71ca1ae Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
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')

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 <trey.morris@rackspace.com>
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')

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 3113a9c523a37c777164b7d1216e1df61bd3f825 Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Fri, 18 Mar 2011 16:28:53 -0700
Subject: fixed migration instance_types migration to support postgres
 correctly

---
 nova/db/sqlalchemy/migrate_repo/versions/008_add_instance_types.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/migrate_repo/versions/008_add_instance_types.py b/nova/db/sqlalchemy/migrate_repo/versions/008_add_instance_types.py
index 66609054e..5e2cb69d9 100644
--- a/nova/db/sqlalchemy/migrate_repo/versions/008_add_instance_types.py
+++ b/nova/db/sqlalchemy/migrate_repo/versions/008_add_instance_types.py
@@ -55,7 +55,7 @@ def upgrade(migrate_engine):
     try:
         instance_types.create()
     except Exception:
-        logging.info(repr(table))
+        logging.info(repr(instance_types))
         logging.exception('Exception while creating instance_types table')
         raise
 
@@ -72,11 +72,11 @@ def upgrade(migrate_engine):
             # FIXME(kpepple) should we be seeding created_at / updated_at ?
             # now = datetime.datatime.utcnow()
             i.execute({'name': name, 'memory_mb': values["memory_mb"],
-                        'vcpus': values["vcpus"], 'deleted': 0,
+                        'vcpus': values["vcpus"], 'deleted': False,
                         'local_gb': values["local_gb"],
                         'flavorid': values["flavorid"]})
     except Exception:
-        logging.info(repr(table))
+        logging.info(repr(instance_types))
         logging.exception('Exception while seeding instance_types table')
         raise
 
-- 
cgit 


From 157b4d67ae2cfb7cda6cf145a5803ff83b848075 Mon Sep 17 00:00:00 2001
From: Ken Pepple <ken.pepple@gmail.com>
Date: Fri, 18 Mar 2011 16:50:08 -0700
Subject: fix nova-manage instance_type list for postgres compatibility

---
 nova/db/sqlalchemy/api.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 5430f89f9..3bf4f5eb8 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -2353,7 +2353,7 @@ def instance_type_get_all(context, inactive=False):
                         all()
     else:
         inst_types = session.query(models.InstanceTypes).\
-                        filter_by(deleted=inactive).\
+                        filter_by(deleted=False).\
                         order_by("name").\
                         all()
     if inst_types:
-- 
cgit 


From a3fe673108602e27cca132209e87369fa8bf1323 Mon Sep 17 00:00:00 2001
From: Tushar Patil <tushar.vitthal.patil@gmail.com>
Date: Fri, 18 Mar 2011 19:46:04 -0700
Subject: Changed Copyright to NTT for newly added files for flatmanager ipv6

---
 .../versions/012_add_ipv6_flatmanager.py             |  2 +-
 nova/tests/network/__init__.py                       | 20 ++++++++++++++++++++
 2 files changed, 21 insertions(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/migrate_repo/versions/012_add_ipv6_flatmanager.py b/nova/db/sqlalchemy/migrate_repo/versions/012_add_ipv6_flatmanager.py
index 5f5e3d007..8c9cf3377 100644
--- a/nova/db/sqlalchemy/migrate_repo/versions/012_add_ipv6_flatmanager.py
+++ b/nova/db/sqlalchemy/migrate_repo/versions/012_add_ipv6_flatmanager.py
@@ -1,4 +1,4 @@
-# Copyright 2010 OpenStack LLC.
+# Copyright (c) 2011 NTT.
 # All Rights Reserved.
 #
 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
diff --git a/nova/tests/network/__init__.py b/nova/tests/network/__init__.py
index e0d479f8c..97f96b6fa 100644
--- a/nova/tests/network/__init__.py
+++ b/nova/tests/network/__init__.py
@@ -1,3 +1,23 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# 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.
+"""
+Utility methods
+"""
 import os
 
 from nova import context
-- 
cgit 


From 98b0fd564ca86a7b38bca149b28a837c8aa2d1e8 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Sun, 20 Mar 2011 20:06:22 +0100
Subject: pep8

---
 nova/tests/api/openstack/test_servers.py | 2 --
 1 file changed, 2 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index bb33ec03d..efba2970f 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -1174,5 +1174,3 @@ class TestServerInstanceCreation(test.TestCase):
         server = dom.childNodes[0]
         self.assertEquals(server.nodeName, 'server')
         self.assertTrue(server.getAttribute('adminPass').startswith('fake'))
-
-
-- 
cgit 


From 9192e80d1161814e7b14946a5bd5787e9a8cf31d Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Mon, 21 Mar 2011 09:49:32 +0100
Subject: Wrap update_dhcp in utils.synchronized.

---
 nova/network/linux_net.py | 1 +
 1 file changed, 1 insertion(+)

(limited to 'nova')

diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index 565732869..ee36407a6 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -557,6 +557,7 @@ def get_dhcp_hosts(context, network_id):
 # NOTE(ja): Sending a HUP only reloads the hostfile, so any
 #           configuration options (like dchp-range, vlan, ...)
 #           aren't reloaded.
+@utils.synchronized('dnsmasq_start')
 def update_dhcp(context, network_id):
     """(Re)starts a dnsmasq server for a given network
 
-- 
cgit 


From 8f0b60f598c28b2f558f3ecdaa2f9604926393e6 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Mon, 21 Mar 2011 07:49:58 -0700
Subject: remove scheduler.api.API. naming changes.

---
 nova/api/openstack/zones.py            |  4 ++--
 nova/manager.py                        |  2 +-
 nova/rpc.py                            |  2 +-
 nova/scheduler/api.py                  | 43 +++++++++++++++-------------------
 nova/tests/api/openstack/test_zones.py |  8 +++----
 5 files changed, 27 insertions(+), 32 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/zones.py b/nova/api/openstack/zones.py
index ebfc7743c..d129cf34f 100644
--- a/nova/api/openstack/zones.py
+++ b/nova/api/openstack/zones.py
@@ -53,7 +53,7 @@ class Controller(wsgi.Controller):
         """Return all zones in brief"""
         # Ask the ZoneManager in the Scheduler for most recent data,
         # or fall-back to the database ...
-        items = api.API.get_zone_list(req.environ['nova.context'])
+        items = api.get_zone_list(req.environ['nova.context'])
         if not items:
             items = db.zone_get_all(req.environ['nova.context'])
 
@@ -68,7 +68,7 @@ class Controller(wsgi.Controller):
 
     def info(self, req):
         """Return name and capabilities for this zone."""
-        items = api.API.get_zone_capabilities(req.environ['nova.context'])
+        items = api.get_zone_capabilities(req.environ['nova.context'])
 
         zone = dict(name=FLAGS.zone_name)
         caps = FLAGS.zone_capabilities
diff --git a/nova/manager.py b/nova/manager.py
index f384e3f0f..508f133ca 100644
--- a/nova/manager.py
+++ b/nova/manager.py
@@ -96,7 +96,7 @@ class SchedulerDependentManager(Manager):
         """Pass data back to the scheduler at a periodic interval"""
         if self.last_capabilities:
             logging.debug(_("Notifying Schedulers of capabilities ..."))
-            api.API.update_service_capabilities(context, self.service_name,
+            api.update_service_capabilities(context, self.service_name,
                                 self.host, self.last_capabilities)
 
         super(SchedulerDependentManager, self).periodic_tasks(context)
diff --git a/nova/rpc.py b/nova/rpc.py
index 4918c0b95..2e3cd9057 100644
--- a/nova/rpc.py
+++ b/nova/rpc.py
@@ -244,7 +244,7 @@ class FanoutPublisher(Publisher):
         self.exchange = "%s_fanout" % topic
         self.queue = "%s_fanout" % topic
         self.durable = False
-        LOG.info(_("Writing to '%(exchange)s' fanout exchange"),
+        LOG.info(_("Creating '%(exchange)s' fanout exchange"),
                             dict(exchange=self.exchange))
         super(FanoutPublisher, self).__init__(connection=connection)
 
diff --git a/nova/scheduler/api.py b/nova/scheduler/api.py
index b6d27dacc..e2cf3b6a3 100644
--- a/nova/scheduler/api.py
+++ b/nova/scheduler/api.py
@@ -40,30 +40,25 @@ def _call_scheduler(method, context, params=None):
     return rpc.call(context, queue, kwargs)
 
 
-class API(object):
-    """API for interacting with the scheduler."""
+def get_zone_list(context):
+    """Return a list of zones assoicated with this zone."""
+    items = _call_scheduler('get_zone_list', context)
+    for item in items:
+        item['api_url'] = item['api_url'].replace('\\/', '/')
+    return items
 
-    @classmethod
-    def get_zone_list(cls, context):
-        """Return a list of zones assoicated with this zone."""
-        items = _call_scheduler('get_zone_list', context)
-        for item in items:
-            item['api_url'] = item['api_url'].replace('\\/', '/')
-        return items
 
-    @classmethod
-    def get_zone_capabilities(cls, context, service=None):
-        """Returns a dict of key, value capabilities for this zone,
-           or for a particular class of services running in this zone."""
-        return _call_scheduler('get_zone_capabilities', context=context,
-                            params=dict(service=service))
+def get_zone_capabilities(context, service=None):
+    """Returns a dict of key, value capabilities for this zone,
+       or for a particular class of services running in this zone."""
+    return _call_scheduler('get_zone_capabilities', context=context,
+                        params=dict(service=service))
 
-    @classmethod
-    def update_service_capabilities(cls, context, service_name, host,
-                                                capabilities):
-        """Send an update to all the scheduler services informing them
-           of the capabilities of this service."""
-        kwargs = dict(method='update_service_capabilities',
-                      args=dict(service_name=service_name, host=host,
-                                capabilities=capabilities))
-        return rpc.fanout_cast(context, 'scheduler', kwargs)
+
+def update_service_capabilities(context, service_name, host, capabilities):
+    """Send an update to all the scheduler services informing them
+       of the capabilities of this service."""
+    kwargs = dict(method='update_service_capabilities',
+                  args=dict(service_name=service_name, host=host,
+                            capabilities=capabilities))
+    return rpc.fanout_cast(context, 'scheduler', kwargs)
diff --git a/nova/tests/api/openstack/test_zones.py b/nova/tests/api/openstack/test_zones.py
index 12d39fd29..a3f191aaa 100644
--- a/nova/tests/api/openstack/test_zones.py
+++ b/nova/tests/api/openstack/test_zones.py
@@ -75,7 +75,7 @@ def zone_get_all_db(context):
     ]
 
 
-def zone_caps(method, context, params):
+def zone_capabilities(method, context, params):
     return dict()
 
 
@@ -98,13 +98,13 @@ class ZonesTest(test.TestCase):
         self.stubs.Set(nova.db, 'zone_delete', zone_delete)
 
         self.old_zone_name = FLAGS.zone_name
-        self.old_zone_caps = FLAGS.zone_capabilities
+        self.old_zone_capabilities = FLAGS.zone_capabilities
 
     def tearDown(self):
         self.stubs.UnsetAll()
         FLAGS.allow_admin_api = self.allow_admin
         FLAGS.zone_name = self.old_zone_name
-        FLAGS.zone_capabilities = self.old_zone_caps
+        FLAGS.zone_capabilities = self.old_zone_capabilities
         super(ZonesTest, self).tearDown()
 
     def test_get_zone_list_scheduler(self):
@@ -179,7 +179,7 @@ class ZonesTest(test.TestCase):
     def test_zone_info(self):
         FLAGS.zone_name = 'darksecret'
         FLAGS.zone_capabilities = ['cap1=a;b', 'cap2=c;d']
-        self.stubs.Set(api, '_call_scheduler', zone_caps)
+        self.stubs.Set(api, '_call_scheduler', zone_capabilities)
 
         body = dict(zone=dict(username='zeb', password='sneaky'))
         req = webob.Request.blank('/v1.0/zones/info')
-- 
cgit 


From b3bb847e3dc20611c4a975d3c772256700b2d018 Mon Sep 17 00:00:00 2001
From: Josh Kearney <josh.kearney@rackspace.com>
Date: Mon, 21 Mar 2011 10:41:03 -0500
Subject: Added space

---
 nova/compute/manager.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index ff33597ce..576937cd8 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -229,7 +229,7 @@ class ComputeManager(manager.Manager):
                                     {'launched_at': now})
         except Exception:  # pylint: disable=W0702
             LOG.exception(_("Instance '%s' failed to spawn. Is virtualization"
-                            "enabled in the BIOS?"), instance_id,
+                            " enabled in the BIOS?"), instance_id,
                                                      context=context)
             self.db.instance_set_state(context,
                                        instance_id,
-- 
cgit 


From 012c94e5304b9e00477409b92bf73f4316b19260 Mon Sep 17 00:00:00 2001
From: Dan Prince <dan.prince@rackspace.com>
Date: Mon, 21 Mar 2011 13:56:55 -0400
Subject: Fix limit unit tests (reconciles w/ trunk changes).

---
 nova/tests/api/openstack/test_extensions.py | 2 --
 1 file changed, 2 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/test_extensions.py b/nova/tests/api/openstack/test_extensions.py
index 11ed61e0d..d1f8c659e 100644
--- a/nova/tests/api/openstack/test_extensions.py
+++ b/nova/tests/api/openstack/test_extensions.py
@@ -190,8 +190,6 @@ class ResponseExtensionTest(unittest.TestCase):
         self.stubs = stubout.StubOutForTesting()
         fakes.FakeAuthManager.reset_fake_data()
         fakes.FakeAuthDatabase.data = {}
-        fakes.stub_out_networking(self.stubs)
-        fakes.stub_out_rate_limiting(self.stubs)
         fakes.stub_out_auth(self.stubs)
         self.context = context.get_admin_context()
 
-- 
cgit 


From f988df6c6f29d6c885d44c6768297aaf489faf34 Mon Sep 17 00:00:00 2001
From: Dan Prince <dan.prince@rackspace.com>
Date: Mon, 21 Mar 2011 13:58:39 -0400
Subject: Fix pep8 issues in nova/api/openstack/extensions.py.

---
 nova/api/openstack/extensions.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/extensions.py b/nova/api/openstack/extensions.py
index 23181d2a6..f881dbde7 100644
--- a/nova/api/openstack/extensions.py
+++ b/nova/api/openstack/extensions.py
@@ -69,13 +69,13 @@ class ResponseExtensionController(wsgi.Controller):
         content_type = req.best_match_content_type()
         # currently response handlers are un-ordered
         for handler in self.handlers:
-            res=handler(res)
+            res = handler(res)
             try:
                 body = res.body
                 headers = res.headers
             except AttributeError:
                 body = self._serialize(res, content_type)
-                headers={"Content-Type": content_type}
+                headers = {"Content-Type": content_type}
             res = webob.Response()
             res.body = body
             res.headers = headers
-- 
cgit 


From fbd94f236adaa906fcc9c90de94e491e3d75653b Mon Sep 17 00:00:00 2001
From: Dan Prince <dan.prince@rackspace.com>
Date: Mon, 21 Mar 2011 13:59:26 -0400
Subject: Added copyright header.

---
 nova/tests/api/openstack/extensions/foxinsocks.py | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/extensions/foxinsocks.py b/nova/tests/api/openstack/extensions/foxinsocks.py
index fa979c7b5..249dd81bf 100644
--- a/nova/tests/api/openstack/extensions/foxinsocks.py
+++ b/nova/tests/api/openstack/extensions/foxinsocks.py
@@ -1,3 +1,20 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# 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.
+
 import json
 
 from nova import wsgi
-- 
cgit 


From ff2d6dc656c03b8aeab5e50c5d39ca9dcde9b9b1 Mon Sep 17 00:00:00 2001
From: Dan Prince <dan.prince@rackspace.com>
Date: Mon, 21 Mar 2011 14:00:39 -0400
Subject: Updated comment per the extension naming convention we actually use.

---
 nova/api/openstack/extensions.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/extensions.py b/nova/api/openstack/extensions.py
index f881dbde7..9d98d849a 100644
--- a/nova/api/openstack/extensions.py
+++ b/nova/api/openstack/extensions.py
@@ -303,9 +303,9 @@ class ExtensionManager(object):
     def _load_extensions(self):
         """
         Load extensions from the configured path. The extension name is
-        constructed from the camel cased module_name + 'Extension'. If your
-        extension module was named widgets.py the extension class within that
-        module should be 'WidgetsExtension'.
+        constructed from the module_name. If your extension module was named
+        widgets.py the extension class within that module should be
+        'Widgets'.
 
         See nova/tests/api/openstack/extensions/foxinsocks.py for an example
         extension implementation.
-- 
cgit 


From 7976fb08d89a8e8b6bf8c276a50e30ae11584ce3 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Mon, 21 Mar 2011 11:01:34 -0700
Subject: more robust extraction of arguments

---
 nova/scheduler/api.py | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/scheduler/api.py b/nova/scheduler/api.py
index c7acd3548..935e7b366 100644
--- a/nova/scheduler/api.py
+++ b/nova/scheduler/api.py
@@ -149,7 +149,7 @@ class reroute_compute(object):
     def __call__(self, f):
         def wrapped_f(*args, **kwargs):
             collection, context, item_id = \
-                            self.get_collection_context_and_id(args)
+                            self.get_collection_context_and_id(args, kwargs)
             try:
                 return f(*args, **kwargs)
             except exception.InstanceNotFound, e:
@@ -170,10 +170,16 @@ class reroute_compute(object):
                 raise RedirectResult(self.unmarshall_result(result))
         return wrapped_f
 
-    def get_collection_context_and_id(self, args):
+    def get_collection_context_and_id(self, args, kwargs):
         """Returns a tuple of (novaclient collection name, security
            context and resource id. Derived class should override this."""
-        return ("servers", args[1], args[2])
+        context = kwargs.get('context', None)
+        instance_id = kwargs.get('instance_id', None)
+        if len(args) > 0 and not context:
+            context = args[1]
+        if len(args) > 1 and not instance_id:
+            context = args[2]
+        return ("servers", context, instance_id)
 
     def unmarshall_result(self, result):
         server = result[0].__dict__
-- 
cgit 


From b1def6b2b104a143b7491cef9a01babe9ab3e75d Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Mon, 21 Mar 2011 11:07:19 -0700
Subject: pep8

---
 nova/scheduler/api.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/scheduler/api.py b/nova/scheduler/api.py
index 935e7b366..aebfe1770 100644
--- a/nova/scheduler/api.py
+++ b/nova/scheduler/api.py
@@ -127,7 +127,7 @@ def wrap_novaclient_function(f, collection, method_name, item_id):
     (nova, zone) call from child_zone_helper."""
     def inner(nova, zone):
         return f(nova, zone, collection, method_name, item_id)
-        
+
     return inner
 
 
@@ -139,6 +139,7 @@ class RedirectResult(exception.Error):
         super(RedirectResult, self).__init__(
                message=_("Uncaught Zone redirection exception"))
 
+
 class reroute_compute(object):
     """Decorator used to indicate that the method should
        delegate the call the child zones if the db query
@@ -158,7 +159,7 @@ class reroute_compute(object):
 
                 if not FLAGS.enable_zone_routing:
                     raise
-                    
+
                 zones = db.zone_get_all(context)
                 if not zones:
                     raise
-- 
cgit 


From 6a893eabc83f4561025a9a655b0aabb2d3e1b3a7 Mon Sep 17 00:00:00 2001
From: Trey Morris <trey.morris@rackspace.com>
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')

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 <josh@jk0.org>
Date: Mon, 21 Mar 2011 13:21:26 -0500
Subject: Added XenAPI rescue unit tests

---
 nova/tests/test_xenapi.py  | 12 ++++++++++++
 nova/tests/xenapi/stubs.py | 19 +++++++++++++++++++
 nova/virt/xenapi/vmops.py  | 11 ++++++++---
 3 files changed, 39 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index 66a973a78..e54ffe712 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -186,6 +186,7 @@ class XenAPIVMTestCase(test.TestCase):
         stubs.stubout_stream_disk(self.stubs)
         stubs.stubout_is_vdi_pv(self.stubs)
         self.stubs.Set(VMOps, 'reset_network', reset_network)
+        stubs.stub_out_vm_methods(self.stubs)
         glance_stubs.stubout_glance_client(self.stubs,
                                            glance_stubs.FakeGlance)
         self.conn = xenapi_conn.get_connection(False)
@@ -369,6 +370,17 @@ class XenAPIVMTestCase(test.TestCase):
             self.assertEquals(vif_rec['qos_algorithm_params']['kbps'],
                               str(4 * 1024))
 
+    def test_rescue(self):
+        instance = self._create_instance()
+        conn = xenapi_conn.get_connection(False)
+        conn.rescue(instance, None)
+
+    def test_unrescue(self):
+        instance = self._create_instance()
+        conn = xenapi_conn.get_connection(False)
+        # Ensure that it will not unrescue a non-rescued instance.
+        self.assertRaises(Exception, conn.unrescue, instance, None)
+
     def tearDown(self):
         super(XenAPIVMTestCase, self).tearDown()
         self.manager.delete_project(self.project)
diff --git a/nova/tests/xenapi/stubs.py b/nova/tests/xenapi/stubs.py
index 70d46a1fb..a0370a2ec 100644
--- a/nova/tests/xenapi/stubs.py
+++ b/nova/tests/xenapi/stubs.py
@@ -185,6 +185,25 @@ class FakeSessionForVMTests(fake.SessionBase):
         pass
 
 
+def stub_out_vm_methods(stubs):
+    def fake_shutdown(self, inst, vm, method="clean"):
+        pass
+
+    def fake_acquire_bootlock(self, vm):
+        pass
+
+    def fake_release_bootlock(self, vm):
+        pass
+
+    def fake_spawn_rescue(self, inst):
+        pass
+
+    stubs.Set(vmops.VMOps, "_shutdown", fake_shutdown)
+    stubs.Set(vmops.VMOps, "_acquire_bootlock", fake_acquire_bootlock)
+    stubs.Set(vmops.VMOps, "_release_bootlock", fake_release_bootlock)
+    stubs.Set(vmops.VMOps, "spawn_rescue", fake_spawn_rescue)
+
+
 class FakeSessionForVolumeTests(fake.SessionBase):
     """ Stubs out a XenAPISession for Volume tests """
     def __init__(self, uri):
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 85f50cf496e2c193ddc715f3019b4a4769ab5bd9 Mon Sep 17 00:00:00 2001
From: Brian Waldon <brian.waldon@rackspace.com>
Date: Mon, 21 Mar 2011 15:14:24 -0400
Subject: pep8; various fixes

---
 nova/api/openstack/servers.py            |  1 +
 nova/api/openstack/views/servers.py      |  5 ++---
 nova/tests/api/openstack/test_servers.py | 17 +++++++++++++----
 3 files changed, 16 insertions(+), 7 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index e3141934b..dafc096ba 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -513,6 +513,7 @@ class Controller(wsgi.Controller):
 
         return kernel_id, ramdisk_id
 
+
 class ControllerV10(Controller):
     def _image_id_from_req_data(self, data):
         return data['server']['imageId']
diff --git a/nova/api/openstack/views/servers.py b/nova/api/openstack/views/servers.py
index 8d47ac757..078d5d484 100644
--- a/nova/api/openstack/views/servers.py
+++ b/nova/api/openstack/views/servers.py
@@ -67,9 +67,8 @@ class ViewBuilder(object):
 
         # Return the metadata as a dictionary
         metadata = {}
-        if 'metadata' in inst:
-            for item in inst['metadata']:
-                metadata[item['key']] = item['value']
+        for item in inst.get('metadata', []):
+            metadata[item['key']] = item['value']
         inst_dict['metadata'] = metadata
 
         inst_dict['hostId'] = ''
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 6e78db9da..a9e76b244 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -311,10 +311,19 @@ class ServersTest(test.TestCase):
 
         imageRef = 'http://localhost/v1.1/images/2'
         flavorRef = 'http://localhost/v1.1/flavors/3'
-        body = dict(server=dict(
-            name='server_test', imageRef=imageRef, flavorRef=flavorRef,
-            metadata={'hello': 'world', 'open': 'stack'},
-            personality={}))
+        body = {
+            'server': {
+                'name': 'server_test',
+                'imageRef': imageRef,
+                'flavorRef': flavorRef,
+                'metadata': {
+                    'hello': 'world',
+                    'open': 'stack',
+                },
+                'personality': {},
+            },
+        }
+
         req = webob.Request.blank('/v1.1/servers')
         req.method = 'POST'
         req.body = json.dumps(body)
-- 
cgit 


From 27ae9700739bd6a1e6f9db90e407f450ff3e770b Mon Sep 17 00:00:00 2001
From: Mark Washenberger <mark.washenberger@rackspace.com>
Date: Mon, 21 Mar 2011 16:35:38 -0400
Subject: added licenses

---
 nova/tests/image/__init__.py    | 17 +++++++++++++++++
 nova/tests/image/test_glance.py | 19 +++++++++++++++++++
 2 files changed, 36 insertions(+)

(limited to 'nova')

diff --git a/nova/tests/image/__init__.py b/nova/tests/image/__init__.py
index e69de29bb..fae25bca7 100644
--- a/nova/tests/image/__init__.py
+++ b/nova/tests/image/__init__.py
@@ -0,0 +1,17 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# 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.
diff --git a/nova/tests/image/test_glance.py b/nova/tests/image/test_glance.py
index 6e94aa909..fcd686c84 100644
--- a/nova/tests/image/test_glance.py
+++ b/nova/tests/image/test_glance.py
@@ -1,3 +1,22 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# 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.
+
+
 import datetime as dt
 import unittest
 
-- 
cgit 


From 414c615a3ac2e61f312f8383f764114e7d782de1 Mon Sep 17 00:00:00 2001
From: Mark Washenberger <mark.washenberger@rackspace.com>
Date: Mon, 21 Mar 2011 16:40:26 -0400
Subject: fix licenses

---
 nova/tests/image/__init__.py    | 3 +--
 nova/tests/image/test_glance.py | 3 +--
 2 files changed, 2 insertions(+), 4 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/image/__init__.py b/nova/tests/image/__init__.py
index fae25bca7..b94e2e54e 100644
--- a/nova/tests/image/__init__.py
+++ b/nova/tests/image/__init__.py
@@ -1,7 +1,6 @@
 # vim: tabstop=4 shiftwidth=4 softtabstop=4
 
-# Copyright 2011 United States Government as represented by the
-# Administrator of the National Aeronautics and Space Administration.
+# Copyright 2011 Openstack LLC.
 # All Rights Reserved.
 #
 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
diff --git a/nova/tests/image/test_glance.py b/nova/tests/image/test_glance.py
index fcd686c84..d49b3dfdb 100644
--- a/nova/tests/image/test_glance.py
+++ b/nova/tests/image/test_glance.py
@@ -1,7 +1,6 @@
 # vim: tabstop=4 shiftwidth=4 softtabstop=4
 
-# Copyright 2011 United States Government as represented by the
-# Administrator of the National Aeronautics and Space Administration.
+# Copyright 2011 Openstack LLC.
 # All Rights Reserved.
 #
 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
-- 
cgit 


From 39783f386a473ed28c786bb72a29e8403503c40c Mon Sep 17 00:00:00 2001
From: Mark Washenberger <mark.washenberger@rackspace.com>
Date: Mon, 21 Mar 2011 17:09:53 -0400
Subject: make bcwaldon happy

---
 nova/api/openstack/images.py            | 2 +-
 nova/image/glance.py                    | 6 +++---
 nova/tests/api/openstack/test_images.py | 4 ++--
 nova/tests/image/test_glance.py         | 8 ++++----
 4 files changed, 10 insertions(+), 10 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/images.py b/nova/api/openstack/images.py
index 94e05823e..99c14275a 100644
--- a/nova/api/openstack/images.py
+++ b/nova/api/openstack/images.py
@@ -168,5 +168,5 @@ class Controller(wsgi.Controller):
 
     def _format_image_dates(self, image):
         for attr in ['created_at', 'updated_at', 'deleted_at']:
-            if image[attr] is not None:
+            if image.get(attr) is not None:
                 image[attr] = image[attr].strftime('%Y-%m-%dT%H:%M:%SZ')
diff --git a/nova/image/glance.py b/nova/image/glance.py
index fbb578585..171b28fde 100644
--- a/nova/image/glance.py
+++ b/nova/image/glance.py
@@ -18,7 +18,7 @@
 
 from __future__ import absolute_import
 
-import datetime as dt
+import datetime
 
 from glance.common import exception as glance_exception
 
@@ -73,7 +73,7 @@ class GlanceImageService(service.BaseImageService):
         Returns image with known timestamp fields converted to datetime objects
         """
         for attr in ['created_at', 'updated_at', 'deleted_at']:
-            if attr in image and image[attr] is not None:
+            if image.get(attr) is not None:
                 image[attr] = self._parse_glance_iso8601_timestamp(image[attr])
         return image
 
@@ -81,7 +81,7 @@ class GlanceImageService(service.BaseImageService):
         """
         Parse a subset of iso8601 timestamps into datetime objects
         """
-        return dt.datetime.strptime(timestamp, "%Y-%m-%dT%H:%M:%S.%f")
+        return datetime.datetime.strptime(timestamp, "%Y-%m-%dT%H:%M:%S.%f")
 
     def show_by_name(self, context, name):
         """
diff --git a/nova/tests/api/openstack/test_images.py b/nova/tests/api/openstack/test_images.py
index b771966f1..a866c764d 100644
--- a/nova/tests/api/openstack/test_images.py
+++ b/nova/tests/api/openstack/test_images.py
@@ -21,7 +21,7 @@ and as a WSGI layer
 """
 
 import json
-import datetime as dt
+import datetime
 import shutil
 import tempfile
 
@@ -177,7 +177,7 @@ class ImageControllerWithGlanceServiceTest(test.TestCase):
     """Test of the OpenStack API /images application controller"""
 
     # Registered images at start of each test.
-    now = dt.datetime.utcnow()
+    now = datetime.datetime.utcnow()
     IMAGE_FIXTURES = [
         {'id': '23g2ogk23k4hhkk4k42l',
          'imageId': '23g2ogk23k4hhkk4k42l',
diff --git a/nova/tests/image/test_glance.py b/nova/tests/image/test_glance.py
index d49b3dfdb..30021dbc1 100644
--- a/nova/tests/image/test_glance.py
+++ b/nova/tests/image/test_glance.py
@@ -58,12 +58,12 @@ class TestGlanceImageServiceDatetimes(unittest.TestCase):
         self.service = glance.GlanceImageService(self.client)
 
     def test_show_passes_through_to_client(self):
-        self.client.images = {'xyz': "image"}
-        self.assertEqual(self.service.show({}, 'xyz'), "image")
+        self.client.images = {'xyz': {'foo': 'bar'}}
+        self.assertEqual(self.service.show({}, 'xyz'), {'foo': 'bar'})
 
     def test_detail_passes_through_to_client(self):
-        self.client.images = {1: "an image"}
-        self.assertEqual(list(self.service.detail({})), ["an image"])
+        self.client.images = {1: {'foo': 'bar'}}
+        self.assertEqual(list(self.service.detail({})), [{'foo': 'bar'}])
 
     def test_show_makes_create_datetimes(self):
         create_time = dt.datetime.utcnow()
-- 
cgit 


From 0cff0a13bac3539a46b3b932bfd016df7f190196 Mon Sep 17 00:00:00 2001
From: Vishvananda Ishaya <vishvananda@gmail.com>
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')

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 e1b9db2ac1af8f38084f9794a430e0292f110ed6 Mon Sep 17 00:00:00 2001
From: Mark Washenberger <mark.washenberger@rackspace.com>
Date: Mon, 21 Mar 2011 17:23:36 -0400
Subject: get rid of another datetime alias

---
 nova/tests/image/test_glance.py | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/image/test_glance.py b/nova/tests/image/test_glance.py
index 30021dbc1..f1f8504f3 100644
--- a/nova/tests/image/test_glance.py
+++ b/nova/tests/image/test_glance.py
@@ -16,7 +16,7 @@
 #    under the License.
 
 
-import datetime as dt
+import datetime
 import unittest
 
 from nova.image import glance
@@ -66,7 +66,7 @@ class TestGlanceImageServiceDatetimes(unittest.TestCase):
         self.assertEqual(list(self.service.detail({})), [{'foo': 'bar'}])
 
     def test_show_makes_create_datetimes(self):
-        create_time = dt.datetime.utcnow()
+        create_time = datetime.datetime.utcnow()
         self.client.images = {'xyz': {
             'id': "id",
             'name': "my awesome image",
@@ -76,7 +76,7 @@ class TestGlanceImageServiceDatetimes(unittest.TestCase):
         self.assertEqual(actual['created_at'], create_time)
 
     def test_show_makes_update_datetimes(self):
-        update_time = dt.datetime.utcnow()
+        update_time = datetime.datetime.utcnow()
         self.client.images = {'abc': {
             'id': "id",
             'name': "my okay image",
@@ -86,7 +86,7 @@ class TestGlanceImageServiceDatetimes(unittest.TestCase):
         self.assertEqual(actual['updated_at'], update_time)
 
     def test_show_makes_delete_datetimes(self):
-        delete_time = dt.datetime.utcnow()
+        delete_time = datetime.datetime.utcnow()
         self.client.images = {'123': {
             'id': "123",
             'name': "my lame image",
@@ -105,7 +105,7 @@ class TestGlanceImageServiceDatetimes(unittest.TestCase):
         self.assertEqual(actual['deleted_at'], None)
 
     def test_detail_handles_timestamps(self):
-        now = dt.datetime.utcnow()
+        now = datetime.datetime.utcnow()
         image1 = {
             'id': 1,
             'name': 'image 1',
@@ -126,7 +126,7 @@ class TestGlanceImageServiceDatetimes(unittest.TestCase):
         self.assertEqual(i2['deleted_at'], now)
 
     def test_get_handles_timestamps(self):
-        now = dt.datetime.utcnow()
+        now = datetime.datetime.utcnow()
         self.client.images = {'abcd': {
             'id': 'abcd',
             'name': 'nifty image',
@@ -144,7 +144,7 @@ class TestGlanceImageServiceDatetimes(unittest.TestCase):
         self.assertEqual(actual['deleted_at'], None)
 
     def test_create_handles_timestamps(self):
-        now = dt.datetime.utcnow()
+        now = datetime.datetime.utcnow()
         self.client.add_response = {
             'id': 'abcd',
             'name': 'blah',
@@ -166,7 +166,7 @@ class TestGlanceImageServiceDatetimes(unittest.TestCase):
         self.assertEqual(actual['deleted_at'], None)
 
     def test_update_handles_timestamps(self):
-        now = dt.datetime.utcnow()
+        now = datetime.datetime.utcnow()
         self.client.update_response = {
             'id': 'abcd',
             'name': 'blah',
-- 
cgit 


From 7cc28482a4ebeeb5dfa44c9e1c37bb135c1c66be Mon Sep 17 00:00:00 2001
From: Josh Kearney <josh@jk0.org>
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')

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 <josh@jk0.org>
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')

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 08d06d1219a00b90ae211fb44fc7e33ba71c7a76 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Mon, 21 Mar 2011 18:16:35 -0700
Subject: better comments. First redirect test

---
 nova/scheduler/api.py        | 49 +++++++++++++++++++++++--------
 nova/tests/test_scheduler.py | 70 ++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 107 insertions(+), 12 deletions(-)

(limited to 'nova')

diff --git a/nova/scheduler/api.py b/nova/scheduler/api.py
index aebfe1770..ff7e21679 100644
--- a/nova/scheduler/api.py
+++ b/nova/scheduler/api.py
@@ -84,13 +84,18 @@ def _wrap_method(function, self):
 def _process(func, zone):
     """Worker stub for green thread pool. Give the worker
     an authenticated nova client and zone info."""
+    LOG.debug("*** PROCESS %s/%s" % (func, zone))
     nova = novaclient.OpenStack(zone.username, zone.password, zone.api_url)
     nova.authenticate()
     return func(nova, zone)
 
 
 def child_zone_helper(zone_list, func):
-    """Fire off a command to each zone in the list."""
+    """Fire off a command to each zone in the list.
+    The return is [novaclient return objects] from each child zone.
+    For example, if you are calling server.pause(), the list will
+    be whatever the response from server.pause() is. One entry
+    per child zone called."""
     green_pool = greenpool.GreenPool()
     return [result for result in green_pool.imap(
                     _wrap_method(_process, func), zone_list)]
@@ -103,6 +108,7 @@ def _issue_novaclient_command(nova, zone, collection, method_name, \
     result = None
     try:
         manager = getattr(nova, collection)
+        LOG.debug("***MANAGER %s" % manager)
         if isinstance(item_id, int) or item_id.isdigit():
             result = manager.get(int(item_id))
         else:
@@ -115,9 +121,9 @@ def _issue_novaclient_command(nova, zone, collection, method_name, \
 
     if method_name.lower() not in ['get', 'find']:
         LOG.debug("***CALLING CHILD ZONE")
-        m = getattr(item, method_name)
+        m = getattr(result, method_name)
         LOG.debug("***METHOD ATTR %s" % m)
-        result = getattr(item, method_name)()
+        result = getattr(result, method_name)()
         LOG.debug("***CHILD ZONE GAVE %s", result)
     return result
 
@@ -152,6 +158,7 @@ class reroute_compute(object):
             collection, context, item_id = \
                             self.get_collection_context_and_id(args, kwargs)
             try:
+                # Call the original function ...
                 return f(*args, **kwargs)
             except exception.InstanceNotFound, e:
                 LOG.debug(_("Instance %(item_id)s not found "
@@ -164,32 +171,50 @@ class reroute_compute(object):
                 if not zones:
                     raise
 
+                # Ask the children to provide an answer ...
                 result = child_zone_helper(zones,
                             wrap_novaclient_function(_issue_novaclient_command,
                                    collection, self.method_name, item_id))
                 LOG.debug("***REROUTE: %s" % result)
+                # Scrub the results and raise another exception
+                # so the API layers can bail out gracefully ...
                 raise RedirectResult(self.unmarshall_result(result))
         return wrapped_f
 
     def get_collection_context_and_id(self, args, kwargs):
         """Returns a tuple of (novaclient collection name, security
            context and resource id. Derived class should override this."""
+        LOG.debug("***COLLECT: %s/%s" % (args, kwargs))
         context = kwargs.get('context', None)
         instance_id = kwargs.get('instance_id', None)
         if len(args) > 0 and not context:
             context = args[1]
         if len(args) > 1 and not instance_id:
-            context = args[2]
+            instance_id = args[2]
         return ("servers", context, instance_id)
 
-    def unmarshall_result(self, result):
-        server = result[0].__dict__
-
-        for k in server.keys():
-            if k[0] == '_' or k == 'manager':
-                del server[k]
-
-        return dict(server=server)
+    def unmarshall_result(self, zone_responses):
+        """Result is a list of responses from each child zone.
+        Each decorator derivation is responsible to turning this
+        into a format expected by the calling method. For
+        example, this one is expected to return a single Server
+        dict {'server':{k:v}}. Others may return a list of them, like
+        {'servers':[{k,v}]}"""
+        reduced_response = []
+        for zone_response in zone_responses:
+            if not zone_response:
+                continue
+
+            server = zone_response.__dict__
+
+            for k in server.keys():
+                if k[0] == '_' or k == 'manager':
+                    del server[k]
+
+            reduced_response.append(dict(server=server))
+        if reduced_response: 
+            return reduced_response[0]  # first for now.
+        return {}
 
 
 def redirect_handler(f):
diff --git a/nova/tests/test_scheduler.py b/nova/tests/test_scheduler.py
index 244e43bd9..50e2429ba 100644
--- a/nova/tests/test_scheduler.py
+++ b/nova/tests/test_scheduler.py
@@ -21,6 +21,8 @@ Tests For Scheduler
 
 import datetime
 import mox
+import stubout
+import webob
 
 from mox import IgnoreArg
 from nova import context
@@ -32,6 +34,7 @@ from nova import test
 from nova import rpc
 from nova import utils
 from nova.auth import manager as auth_manager
+from nova.scheduler import api
 from nova.scheduler import manager
 from nova.scheduler import driver
 from nova.compute import power_state
@@ -937,3 +940,70 @@ class SimpleDriverTestCase(test.TestCase):
         db.instance_destroy(self.context, instance_id)
         db.service_destroy(self.context, s_ref['id'])
         db.service_destroy(self.context, s_ref2['id'])
+
+
+class FakeZone(object):
+    def __init__(self, api_url, username, password):
+        self.api_url = api_url
+        self.username = username
+        self.password = password
+
+def zone_get_all(context):
+    return [
+                FakeZone('http://example.com', 'bob', 'xxx'),
+           ]
+
+
+def go_boom(self, context, instance):
+    raise exception.InstanceNotFound("boom message", instance)
+
+
+def fake_openstack_init(self, username, password, api):
+    servers=[]
+
+
+def fake_auth(self):
+    pass
+
+class FakeServer:
+    def foo(self):
+        pass
+
+class FakeManager:
+    def get(self, id):
+        return FakeServer()
+
+class FakeOpenStack:
+
+    def __init__(self, username, api, auth):
+        self.servers = FakeManager()
+
+    def authenticate(self):
+        pass
+
+
+class ZoneRedirectTest(test.TestCase):
+    def setUp(self):
+        super(ZoneRedirectTest, self).setUp()
+        self.stubs = stubout.StubOutForTesting()
+
+        self.stubs.Set(api.novaclient, 'OpenStack', FakeOpenStack)
+        self.stubs.Set(db, 'zone_get_all', zone_get_all)
+
+        self.enable_zone_routing = FLAGS.enable_zone_routing
+        FLAGS.enable_zone_routing = True
+
+    def tearDown(self):
+        self.stubs.UnsetAll()
+        FLAGS.enable_zone_routing = self.enable_zone_routing
+        super(ZoneRedirectTest, self).tearDown()
+
+    def test_trap_found_locally(self):
+        decorator = api.reroute_compute("foo")
+        try:
+            wrapper = decorator(go_boom)
+            result = wrapper(None, None, 1)  # self, context, id
+        except api.RedirectResult, e:
+            pass
+
+
-- 
cgit 


From 380731ce71e8909615da6138bb7d5e7226e375ac Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Mon, 21 Mar 2011 18:56:59 -0700
Subject: better comments. First redirect test

---
 nova/tests/test_scheduler.py | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/test_scheduler.py b/nova/tests/test_scheduler.py
index 50e2429ba..6d55cad04 100644
--- a/nova/tests/test_scheduler.py
+++ b/nova/tests/test_scheduler.py
@@ -958,23 +958,23 @@ def go_boom(self, context, instance):
     raise exception.InstanceNotFound("boom message", instance)
 
 
-def fake_openstack_init(self, username, password, api):
-    servers=[]
+class FakeServer(object):
+    def __init__(self):
+        self.name = 'myserver'
+        self.kvm = 'kvm'
+        self.manager = 100
+        self._hidden = True
 
-
-def fake_auth(self):
-    pass
-
-class FakeServer:
     def foo(self):
-        pass
+        return None
+
 
-class FakeManager:
+class FakeManager(object):
     def get(self, id):
         return FakeServer()
 
-class FakeOpenStack:
 
+class FakeOpenStack:
     def __init__(self, username, api, auth):
         self.servers = FakeManager()
 
@@ -987,7 +987,6 @@ class ZoneRedirectTest(test.TestCase):
         super(ZoneRedirectTest, self).setUp()
         self.stubs = stubout.StubOutForTesting()
 
-        self.stubs.Set(api.novaclient, 'OpenStack', FakeOpenStack)
         self.stubs.Set(db, 'zone_get_all', zone_get_all)
 
         self.enable_zone_routing = FLAGS.enable_zone_routing
@@ -999,11 +998,12 @@ class ZoneRedirectTest(test.TestCase):
         super(ZoneRedirectTest, self).tearDown()
 
     def test_trap_found_locally(self):
+        self.stubs.Set(api.novaclient, 'OpenStack', FakeOpenStack)
         decorator = api.reroute_compute("foo")
         try:
             wrapper = decorator(go_boom)
             result = wrapper(None, None, 1)  # self, context, id
         except api.RedirectResult, e:
-            pass
+            self.assertTrue(e.results, {})
 
 
-- 
cgit 


From 8303d0f280a7bfbc5c5fb128465549b03badc1f1 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Mon, 21 Mar 2011 21:41:41 -0700
Subject: routing test coverage

---
 nova/scheduler/api.py        |  18 +++----
 nova/tests/test_scheduler.py | 121 +++++++++++++++++++++++++++++++++++--------
 2 files changed, 105 insertions(+), 34 deletions(-)

(limited to 'nova')

diff --git a/nova/scheduler/api.py b/nova/scheduler/api.py
index ff7e21679..4f189fe37 100644
--- a/nova/scheduler/api.py
+++ b/nova/scheduler/api.py
@@ -84,7 +84,6 @@ def _wrap_method(function, self):
 def _process(func, zone):
     """Worker stub for green thread pool. Give the worker
     an authenticated nova client and zone info."""
-    LOG.debug("*** PROCESS %s/%s" % (func, zone))
     nova = novaclient.OpenStack(zone.username, zone.password, zone.api_url)
     nova.authenticate()
     return func(nova, zone)
@@ -108,7 +107,6 @@ def _issue_novaclient_command(nova, zone, collection, method_name, \
     result = None
     try:
         manager = getattr(nova, collection)
-        LOG.debug("***MANAGER %s" % manager)
         if isinstance(item_id, int) or item_id.isdigit():
             result = manager.get(int(item_id))
         else:
@@ -117,14 +115,10 @@ def _issue_novaclient_command(nova, zone, collection, method_name, \
         url = zone.api_url
         LOG.debug(_("%(collection)s '%(item_id)s' not found on '%(url)s'" %
                                                 locals()))
-        return
+        return None
 
     if method_name.lower() not in ['get', 'find']:
-        LOG.debug("***CALLING CHILD ZONE")
-        m = getattr(result, method_name)
-        LOG.debug("***METHOD ATTR %s" % m)
         result = getattr(result, method_name)()
-        LOG.debug("***CHILD ZONE GAVE %s", result)
     return result
 
 
@@ -172,19 +166,22 @@ class reroute_compute(object):
                     raise
 
                 # Ask the children to provide an answer ...
-                result = child_zone_helper(zones,
+                result = self._call_child_zones(zones,
                             wrap_novaclient_function(_issue_novaclient_command,
                                    collection, self.method_name, item_id))
-                LOG.debug("***REROUTE: %s" % result)
                 # Scrub the results and raise another exception
                 # so the API layers can bail out gracefully ...
                 raise RedirectResult(self.unmarshall_result(result))
         return wrapped_f
 
+    def _call_child_zones(self, zones, function):
+        """Ask the child zones to perform this operation.
+        Broken out for testing."""
+        return child_zone_helper(zones, function)
+ 
     def get_collection_context_and_id(self, args, kwargs):
         """Returns a tuple of (novaclient collection name, security
            context and resource id. Derived class should override this."""
-        LOG.debug("***COLLECT: %s/%s" % (args, kwargs))
         context = kwargs.get('context', None)
         instance_id = kwargs.get('instance_id', None)
         if len(args) > 0 and not context:
@@ -222,6 +219,5 @@ def redirect_handler(f):
         try:
             return f(*args, **kwargs)
         except RedirectResult, e:
-            LOG.debug("***CAUGHT REROUTE: %s" % e.results)
             return e.results
     return new_f
diff --git a/nova/tests/test_scheduler.py b/nova/tests/test_scheduler.py
index 6d55cad04..0aebd0380 100644
--- a/nova/tests/test_scheduler.py
+++ b/nova/tests/test_scheduler.py
@@ -21,6 +21,7 @@ Tests For Scheduler
 
 import datetime
 import mox
+import novaclient.exceptions
 import stubout
 import webob
 
@@ -954,34 +955,33 @@ def zone_get_all(context):
            ]
 
 
-def go_boom(self, context, instance):
-    raise exception.InstanceNotFound("boom message", instance)
+class FakeRerouteCompute(api.reroute_compute):
+    def _call_child_zones(self, zones, function):
+        return [ ]
+ 
+    def get_collection_context_and_id(self, args, kwargs):
+        return ("servers", None, 1)
 
+    def unmarshall_result(self, zone_responses):
+        return dict(magic="found me")
 
-class FakeServer(object):
-    def __init__(self):
-        self.name = 'myserver'
-        self.kvm = 'kvm'
-        self.manager = 100
-        self._hidden = True
 
-    def foo(self):
-        return None
+def go_boom(self, context, instance):
+    raise exception.InstanceNotFound("boom message", instance)
 
 
-class FakeManager(object):
-    def get(self, id):
-        return FakeServer()
+def found_instance(self, context, instance):
+    return dict(name='myserver')
 
 
-class FakeOpenStack:
-    def __init__(self, username, api, auth):
-        self.servers = FakeManager()
+class FakeResource(object):
+    def __init__(self, attribute_dict):
+        for k, v in attribute_dict.iteritems():
+            setattr(self, k, v)
 
-    def authenticate(self):
+    def pause(self):
         pass
 
-
 class ZoneRedirectTest(test.TestCase):
     def setUp(self):
         super(ZoneRedirectTest, self).setUp()
@@ -998,12 +998,87 @@ class ZoneRedirectTest(test.TestCase):
         super(ZoneRedirectTest, self).tearDown()
 
     def test_trap_found_locally(self):
-        self.stubs.Set(api.novaclient, 'OpenStack', FakeOpenStack)
-        decorator = api.reroute_compute("foo")
+        decorator = FakeRerouteCompute("foo")
         try:
-            wrapper = decorator(go_boom)
-            result = wrapper(None, None, 1)  # self, context, id
+            result = decorator(found_instance)(None, None, 1)
         except api.RedirectResult, e:
-            self.assertTrue(e.results, {})
+            self.fail(_("Successful database hit should succeed"))
 
+    def test_trap_not_found_locally(self):
+        decorator = FakeRerouteCompute("foo")
+        try:
+            result = decorator(go_boom)(None, None, 1)
+        except api.RedirectResult, e:
+            self.assertEquals(e.results['magic'], 'found me')
 
+    def test_get_collection_context_and_id(self):
+        decorator = api.reroute_compute("foo")
+        self.assertEquals(decorator.get_collection_context_and_id(
+            (None, 10, 20), {}), ("servers", 10, 20))       
+        self.assertEquals(decorator.get_collection_context_and_id(
+            (None, 11,),  dict(instance_id=21)), ("servers", 11, 21))       
+        self.assertEquals(decorator.get_collection_context_and_id(
+            (None,), dict(context=12, instance_id=22)), ("servers", 12, 22))
+
+    def test_unmarshal_single_server(self):
+        decorator = api.reroute_compute("foo")
+        self.assertEquals(decorator.unmarshall_result([]), {}) 
+        self.assertEquals(decorator.unmarshall_result(
+                [FakeResource(dict(a=1, b=2)),]), 
+                dict(server=dict(a=1, b=2))) 
+        self.assertEquals(decorator.unmarshall_result(
+                [FakeResource(dict(a=1, _b=2)),]), 
+                dict(server=dict(a=1,))) 
+        self.assertEquals(decorator.unmarshall_result(
+                [FakeResource(dict(a=1, manager=2)),]), 
+                dict(server=dict(a=1,)))                
+        self.assertEquals(decorator.unmarshall_result(
+                [FakeResource(dict(_a=1, manager=2)),]), 
+                dict(server={}))                
+
+class FakeServerCollection(object):
+    def get(self, instance_id):
+        return FakeResource(dict(a=10, b=20))
+
+    def find(self, name):
+        return FakeResource(dict(a=11, b=22))
+
+class FakeEmptyServerCollection(object):
+    def get(self, f):
+        raise novaclient.NotFound(1)
+
+    def find(self, name):
+        raise novaclient.NotFound(2)
+
+class FakeNovaClient(object):
+    def __init__(self, collection):
+        self.servers = collection
+
+class DynamicNovaClientTest(test.TestCase):
+    def test_issue_novaclient_command_found(self):
+        zone = FakeZone('http://example.com', 'bob', 'xxx')
+        self.assertEquals(api._issue_novaclient_command(
+                    FakeNovaClient(FakeServerCollection()),
+                    zone, "servers", "get", 100).a, 10)
+
+        self.assertEquals(api._issue_novaclient_command(
+                    FakeNovaClient(FakeServerCollection()),
+                    zone, "servers", "find", "name").b, 22)
+
+        self.assertEquals(api._issue_novaclient_command(
+                    FakeNovaClient(FakeServerCollection()),
+                    zone, "servers", "pause", 100), None)
+   
+    def test_issue_novaclient_command_not_found(self):
+        zone = FakeZone('http://example.com', 'bob', 'xxx')
+        self.assertEquals(api._issue_novaclient_command(
+                    FakeNovaClient(FakeEmptyServerCollection()),
+                    zone, "servers", "get", 100), None)                   
+
+        self.assertEquals(api._issue_novaclient_command(
+                    FakeNovaClient(FakeEmptyServerCollection()),
+                    zone, "servers", "find", "name"), None)                   
+
+        self.assertEquals(api._issue_novaclient_command(
+                    FakeNovaClient(FakeEmptyServerCollection()),
+                    zone, "servers", "any", "name"), None)                   
-- 
cgit 


From e74482f30c602530313faf15e0d429acefee7bde Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Mon, 21 Mar 2011 21:47:58 -0700
Subject: routing test coverage

---
 nova/tests/test_scheduler.py | 9 +++++++++
 1 file changed, 9 insertions(+)

(limited to 'nova')

diff --git a/nova/tests/test_scheduler.py b/nova/tests/test_scheduler.py
index 0aebd0380..8434f5a43 100644
--- a/nova/tests/test_scheduler.py
+++ b/nova/tests/test_scheduler.py
@@ -1008,9 +1008,18 @@ class ZoneRedirectTest(test.TestCase):
         decorator = FakeRerouteCompute("foo")
         try:
             result = decorator(go_boom)(None, None, 1)
+            self.assertFail(_("Should have rerouted."))
         except api.RedirectResult, e:
             self.assertEquals(e.results['magic'], 'found me')
 
+    def test_routing_flags(self):
+        FLAGS.enable_zone_routing = False
+        decorator = FakeRerouteCompute("foo")
+        try:
+            result = decorator(go_boom)(None, None, 1)
+        except exception.InstanceNotFound, e:
+            self.assertEquals(e.message, 'boom message')
+
     def test_get_collection_context_and_id(self):
         decorator = api.reroute_compute("foo")
         self.assertEquals(decorator.get_collection_context_and_id(
-- 
cgit 


From 65482f5d9513c3dda64171d0460001e299be9673 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Mon, 21 Mar 2011 21:51:14 -0700
Subject: added zone routing flag test

---
 nova/tests/test_scheduler.py | 1 +
 1 file changed, 1 insertion(+)

(limited to 'nova')

diff --git a/nova/tests/test_scheduler.py b/nova/tests/test_scheduler.py
index 8434f5a43..277ffe367 100644
--- a/nova/tests/test_scheduler.py
+++ b/nova/tests/test_scheduler.py
@@ -1017,6 +1017,7 @@ class ZoneRedirectTest(test.TestCase):
         decorator = FakeRerouteCompute("foo")
         try:
             result = decorator(go_boom)(None, None, 1)
+            self.assertFail(_("Should have thrown exception."))
         except exception.InstanceNotFound, e:
             self.assertEquals(e.message, 'boom message')
 
-- 
cgit 


From 4b8ed5afd1fd3e616eda0015f9bf16c7097f5476 Mon Sep 17 00:00:00 2001
From: Todd Willey <todd@ansolabs.com>
Date: Tue, 22 Mar 2011 03:13:12 -0400
Subject: vpn changes

---
 nova/api/ec2/admin.py | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

(limited to 'nova')

diff --git a/nova/api/ec2/admin.py b/nova/api/ec2/admin.py
index d9a4ef999..208fe5c4f 100644
--- a/nova/api/ec2/admin.py
+++ b/nova/api/ec2/admin.py
@@ -28,6 +28,7 @@ from nova import exception
 from nova import flags
 from nova import log as logging
 from nova import utils
+from nova.api.ec2 import ec2utils
 from nova.auth import manager
 
 
@@ -92,15 +93,18 @@ def vpn_dict(project, vpn_instance):
           'public_ip': project.vpn_ip,
           'public_port': project.vpn_port}
     if vpn_instance:
-        rv['instance_id'] = vpn_instance['ec2_id']
+        rv['instance_id'] = ec2utils.id_to_ec2_id(vpn_instance['id'])
         rv['created_at'] = utils.isotime(vpn_instance['created_at'])
         address = vpn_instance.get('fixed_ip', None)
         if address:
             rv['internal_ip'] = address['address']
-        if utils.vpn_ping(project.vpn_ip, project.vpn_port):
-            rv['state'] = 'running'
+        if project.vpn_ip and project.vpn_port:
+            if utils.vpn_ping(project.vpn_ip, project.vpn_port):
+                rv['state'] = 'running'
+            else:
+                rv['state'] = 'down'
         else:
-            rv['state'] = 'down'
+            rv['state'] = 'down - invalid project vpn config'
     else:
         rv['state'] = 'pending'
     return rv
@@ -279,7 +283,7 @@ class AdminController(object):
                                          ", ensure it isn't running, and try "
                                          "again in a few minutes")
             instance = self._vpn_for(context, project)
-        return {'instance_id': instance['ec2_id']}
+        return {'instance_id': ec2utils.id_to_ec2_id(instance['id'])}
 
     def describe_vpns(self, context):
         vpns = []
-- 
cgit 


From d1860ce5d26fbbadb2310e8225e924879cde9a6c Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Tue, 22 Mar 2011 10:35:43 +0100
Subject: Make synchronized support both external (file based) locks as well as
 internal (semaphore based) locks. Attempt to make it native thread safe at
 the expense of never cleaning up semaphores.

---
 nova/tests/test_misc.py | 34 +++++++++++++++++++++++--
 nova/utils.py           | 67 +++++++++++++++++++++++++++++++++++++++++++------
 2 files changed, 92 insertions(+), 9 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/test_misc.py b/nova/tests/test_misc.py
index 1fbaf304f..961499a60 100644
--- a/nova/tests/test_misc.py
+++ b/nova/tests/test_misc.py
@@ -16,8 +16,12 @@
 
 import errno
 import os
+import random
 import select
 
+from eventlet import greenpool
+from eventlet import greenthread
+
 from nova import test
 from nova.utils import parse_mailmap, str_dict_replace, synchronized
 
@@ -72,11 +76,37 @@ class LockTestCase(test.TestCase):
         self.assertEquals(foo.__name__, 'foo', "Wrapped function's name "
                                                "got mangled")
 
-    def test_synchronized(self):
+    def test_synchronized_internally(self):
+        """We can lock across multiple green threads"""
+        seen_threads = list()
+        @synchronized('testlock', external=False)
+        def f(id):
+            for x in range(10):
+                seen_threads.append(id)
+                greenthread.sleep(0)
+
+        threads = []
+        pool = greenpool.GreenPool(10)
+        for i in range(10):
+            threads.append(pool.spawn(f, i))
+
+        for thread in threads:
+            thread.wait()
+
+        self.assertEquals(len(seen_threads), 100)
+        # Looking at the seen threads, split it into chunks of 10, and verify
+        # that the last 9 match the first in each chunk.
+        for i in range(10):
+            for j in range(9):
+                self.assertEquals(seen_threads[i*10], seen_threads[i*10+1+j])
+
+
+    def test_synchronized_externally(self):
+        """We can lock across multiple processes"""
         rpipe1, wpipe1 = os.pipe()
         rpipe2, wpipe2 = os.pipe()
 
-        @synchronized('testlock')
+        @synchronized('testlock', external=True)
         def f(rpipe, wpipe):
             try:
                 os.write(wpipe, "foo")
diff --git a/nova/utils.py b/nova/utils.py
index 499af2039..8936614cc 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -41,6 +41,7 @@ from xml.sax import saxutils
 
 from eventlet import event
 from eventlet import greenthread
+from eventlet import semaphore
 from eventlet.green import subprocess
 None
 from nova import exception
@@ -531,17 +532,69 @@ def loads(s):
     return json.loads(s)
 
 
-def synchronized(name):
+_semaphores_semaphore = semaphore.Semaphore()
+_semaphores = {}
+
+
+class _NoopContextManager(object):
+    def __enter__(self):
+        pass
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        pass
+
+
+def synchronized(name, external=False):
+    """Synchronization decorator
+
+    Decorating a method like so:
+    @synchronized('mylock')
+    def foo(self, *args):
+       ...
+
+    ensures that only one thread will execute the bar method at a time.
+
+    Different methods can share the same lock:
+    @synchronized('mylock')
+    def foo(self, *args):
+       ...
+
+    @synchronized('mylock')
+    def bar(self, *args):
+       ...
+
+    This way only one of either foo or bar can be executing at a time.
+
+    The external keyword argument denotes whether this lock should work across
+    multiple processes. This means that if two different workers both run a
+    a method decorated with @synchronized('mylock', external=True), only one
+    of them will execute at a time.
+    """
+
     def wrap(f):
         @functools.wraps(f)
         def inner(*args, **kwargs):
-            LOG.debug(_("Attempting to grab %(lock)s for method "
-                        "%(method)s..." % {"lock": name,
+            with _semaphores_semaphore:
+                if name not in _semaphores:
+                    _semaphores[name] = semaphore.Semaphore()
+                sem = _semaphores[name]
+            LOG.debug(_('Attempting to grab semaphore "%(lock)s" for method '
+                      '"%(method)s"...' % {"lock": name,
                                            "method": f.__name__}))
-            lock = lockfile.FileLock(os.path.join(FLAGS.lock_path,
-                                                  'nova-%s.lock' % name))
-            with lock:
-                return f(*args, **kwargs)
+            with sem:
+                if external:
+                    LOG.debug(_('Attempting to grab file lock "%(lock)s" for '
+                                'method "%(method)s"...' %
+                                {"lock": name, "method": f.__name__}))
+                    lock_file_path = os.path.join(FLAGS.lock_path,
+                                                  'nova-%s.lock' % name)
+                    lock = lockfile.FileLock(lock_file_path)
+                else:
+                    lock = _NoopContextManager()
+
+                with lock:
+                    return f(*args, **kwargs)
+
         return inner
     return wrap
 
-- 
cgit 


From e827b8dbae1faef2cc070c7e26395979571bcd46 Mon Sep 17 00:00:00 2001
From: Hisaharu Ishii <ishii.hisaharu@lab.ntt.co.jp>
Date: Tue, 22 Mar 2011 20:27:51 +0900
Subject: Wrap update_ra in utils.synchronized.

---
 nova/network/linux_net.py | 1 +
 1 file changed, 1 insertion(+)

(limited to 'nova')

diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index ee36407a6..e283dee37 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -595,6 +595,7 @@ def update_dhcp(context, network_id):
     _execute(*command, addl_env=env)
 
 
+@utils.synchronized('radvd_start')
 def update_ra(context, network_id):
     network_ref = db.network_get(context, network_id)
 
-- 
cgit 


From 60a3aa86db1d0e1ea2f680c9587881e45fa99336 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Tue, 22 Mar 2011 14:14:47 +0100
Subject: Make synchronized decorator not leak semaphores, at the expense of
 not being truly thread safe (but safe enough for Eventlet style green
 threads).

---
 nova/network/linux_net.py |  2 +-
 nova/tests/test_misc.py   |  1 -
 nova/utils.py             | 18 +++++++++++++-----
 3 files changed, 14 insertions(+), 7 deletions(-)

(limited to 'nova')

diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index ee36407a6..9bb1685c0 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -274,7 +274,7 @@ class IptablesManager(object):
 
         self.semaphore = semaphore.Semaphore()
 
-    @utils.synchronized('iptables')
+    @utils.synchronized('iptables', external=True)
     def apply(self):
         """Apply the current in-memory set of iptables rules
 
diff --git a/nova/tests/test_misc.py b/nova/tests/test_misc.py
index 961499a60..c0c72bb12 100644
--- a/nova/tests/test_misc.py
+++ b/nova/tests/test_misc.py
@@ -16,7 +16,6 @@
 
 import errno
 import os
-import random
 import select
 
 from eventlet import greenpool
diff --git a/nova/utils.py b/nova/utils.py
index 8936614cc..c580e805a 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -574,10 +574,12 @@ def synchronized(name, external=False):
     def wrap(f):
         @functools.wraps(f)
         def inner(*args, **kwargs):
-            with _semaphores_semaphore:
-                if name not in _semaphores:
-                    _semaphores[name] = semaphore.Semaphore()
-                sem = _semaphores[name]
+            # NOTE(soren): If we ever go natively threaded, this will be racy.
+            #              See http://stackoverflow.com/questions/5390569/dyn\
+            #              amically-allocating-and-destroying-mutexes
+            if name not in _semaphores:
+                _semaphores[name] = semaphore.Semaphore()
+            sem = _semaphores[name]
             LOG.debug(_('Attempting to grab semaphore "%(lock)s" for method '
                       '"%(method)s"...' % {"lock": name,
                                            "method": f.__name__}))
@@ -593,8 +595,14 @@ def synchronized(name, external=False):
                     lock = _NoopContextManager()
 
                 with lock:
-                    return f(*args, **kwargs)
+                    retval = f(*args, **kwargs)
 
+            # If no-one else is waiting for it, delete it.
+            # See note about possible raciness above.
+            if not sem.balance < 1:
+                del _semaphores[name]
+
+            return retval
         return inner
     return wrap
 
-- 
cgit 


From 62f9cc7cee30332143bf4e6e54fd21335db3c8da Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
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/tests/test_virt.py   |  2 +-
 nova/virt/libvirt_conn.py | 10 ++++------
 2 files changed, 5 insertions(+), 7 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/test_virt.py b/nova/tests/test_virt.py
index b214f5ce7..b9cd30a79 100644
--- a/nova/tests/test_virt.py
+++ b/nova/tests/test_virt.py
@@ -62,7 +62,7 @@ class CacheConcurrencyTestCase(test.TestCase):
         self.stubs.Set(os.path, 'exists', fake_exists)
         self.stubs.Set(utils, 'execute', fake_execute)
 
-    def test_same_fname_concurrency(self):
+    def notest_same_fname_concurrency(self):
         """Ensures that the same fname cache runs at a sequentially"""
         conn = libvirt_conn.LibvirtConnection
         wait1 = eventlet.event.Event()
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 <soren@linux2go.dk>
Date: Tue, 22 Mar 2011 14:39:35 +0100
Subject: Get rid of IptablesManager's explicit semaphore.

---
 nova/network/linux_net.py |  4 ----
 nova/virt/libvirt_conn.py | 11 ++++-------
 2 files changed, 4 insertions(+), 11 deletions(-)

(limited to 'nova')

diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index 9bb1685c0..8cbf8db24 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -21,8 +21,6 @@ import inspect
 import os
 import calendar
 
-from eventlet import semaphore
-
 from nova import db
 from nova import exception
 from nova import flags
@@ -272,8 +270,6 @@ class IptablesManager(object):
         self.ipv4['nat'].add_chain('floating-snat')
         self.ipv4['nat'].add_rule('snat', '-j $floating-snat')
 
-        self.semaphore = semaphore.Semaphore()
-
     @utils.synchronized('iptables', external=True)
     def apply(self):
         """Apply the current in-memory set of iptables rules
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 804083b6ba811834c0bf9d5e2edcdf0130d7d1ce Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Tue, 22 Mar 2011 14:50:53 +0100
Subject: IptablesManager.semaphore is no more.

---
 nova/network/linux_net.py | 37 ++++++++++++++++---------------------
 1 file changed, 16 insertions(+), 21 deletions(-)

(limited to 'nova')

diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index 8cbf8db24..9faa7de07 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -277,28 +277,23 @@ class IptablesManager(object):
         This will blow away any rules left over from previous runs of the
         same component of Nova, and replace them with our current set of
         rules. This happens atomically, thanks to iptables-restore.
-
-        We wrap the call in a semaphore lock, so that we don't race with
-        ourselves. In the event of a race with another component running
-        an iptables-* command at the same time, we retry up to 5 times.
         """
-        with self.semaphore:
-            s = [('iptables', self.ipv4)]
-            if FLAGS.use_ipv6:
-                s += [('ip6tables', self.ipv6)]
-
-            for cmd, tables in s:
-                for table in tables:
-                    current_table, _ = self.execute('sudo',
-                                                    '%s-save' % (cmd,),
-                                                    '-t', '%s' % (table,),
-                                                    attempts=5)
-                    current_lines = current_table.split('\n')
-                    new_filter = self._modify_rules(current_lines,
-                                                    tables[table])
-                    self.execute('sudo', '%s-restore' % (cmd,),
-                                 process_input='\n'.join(new_filter),
-                                 attempts=5)
+        s = [('iptables', self.ipv4)]
+        if FLAGS.use_ipv6:
+            s += [('ip6tables', self.ipv6)]
+
+        for cmd, tables in s:
+            for table in tables:
+                current_table, _ = self.execute('sudo',
+                                                '%s-save' % (cmd,),
+                                                '-t', '%s' % (table,),
+                                                attempts=5)
+                current_lines = current_table.split('\n')
+                new_filter = self._modify_rules(current_lines,
+                                                tables[table])
+                self.execute('sudo', '%s-restore' % (cmd,),
+                             process_input='\n'.join(new_filter),
+                             attempts=5)
 
     def _modify_rules(self, current_lines, table, binary=None):
         unwrapped_chains = table.unwrapped_chains
-- 
cgit 


From 3ae9a489667ed6f4b03a19d5e14bec8e1d4eb20d Mon Sep 17 00:00:00 2001
From: Dan Prince <dan.prince@rackspace.com>
Date: Tue, 22 Mar 2011 09:52:59 -0400
Subject: Add call to unset all stubs.

---
 nova/tests/api/openstack/test_server_metadata.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/test_server_metadata.py b/nova/tests/api/openstack/test_server_metadata.py
index b280ae94c..ed60d4b36 100644
--- a/nova/tests/api/openstack/test_server_metadata.py
+++ b/nova/tests/api/openstack/test_server_metadata.py
@@ -62,7 +62,10 @@ class ServerMetaDataTest(unittest.TestCase):
         fakes.FakeAuthDatabase.data = {}
         fakes.stub_out_auth(self.stubs)
         fakes.stub_out_key_pair_funcs(self.stubs)
-        #self.allow_admin = FLAGS.allow_admin_api
+
+    def tearDown(self):
+        self.stubs.UnsetAll()
+        super(ServerMetaDataTest, self).tearDown()
 
     def test_index(self):
         self.stubs.Set(nova.db.api, 'get_instance_metadata',
-- 
cgit 


From 7aa027b2005ff24f7308e1ec23eddb44bf352628 Mon Sep 17 00:00:00 2001
From: Dan Prince <dan.prince@rackspace.com>
Date: Tue, 22 Mar 2011 10:01:18 -0400
Subject: Add unit test and code updates to ensure that a PUT requests to
 create/update server metadata only contain a single key.

---
 nova/api/openstack/server_metadata.py            |  3 +++
 nova/tests/api/openstack/test_server_metadata.py | 11 +++++++++++
 2 files changed, 14 insertions(+)

(limited to 'nova')

diff --git a/nova/api/openstack/server_metadata.py b/nova/api/openstack/server_metadata.py
index 1408f59a6..45bbac99d 100644
--- a/nova/api/openstack/server_metadata.py
+++ b/nova/api/openstack/server_metadata.py
@@ -55,6 +55,9 @@ class Controller(wsgi.Controller):
         if not id in body:
             expl = _('Request body and URI mismatch')
             raise exc.HTTPBadRequest(explanation=expl)
+        if len(body) > 1:
+            expl = _('Request body contains too many items')
+            raise exc.HTTPBadRequest(explanation=expl)
         self.compute_api.update_or_create_instance_metadata(context,
                                                             server_id,
                                                             body)
diff --git a/nova/tests/api/openstack/test_server_metadata.py b/nova/tests/api/openstack/test_server_metadata.py
index ed60d4b36..97cb57ebd 100644
--- a/nova/tests/api/openstack/test_server_metadata.py
+++ b/nova/tests/api/openstack/test_server_metadata.py
@@ -141,6 +141,17 @@ class ServerMetaDataTest(unittest.TestCase):
         res_dict = json.loads(res.body)
         self.assertEqual('value1', res_dict['key1'])
 
+    def test_update_item_too_many_keys(self):
+        self.stubs.Set(nova.db.api, 'update_or_create_instance_metadata',
+                        return_create_instance_metadata)
+        req = webob.Request.blank('/v1.1/servers/1/meta/key1')
+        req.environ['api.version'] = '1.1'
+        req.method = 'PUT'
+        req.body = '{"key1": "value1", "key2": "value2"}'
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(400, res.status_int)
+
     def test_update_item_body_uri_mismatch(self):
         self.stubs.Set(nova.db.api, 'update_or_create_instance_metadata',
                         return_create_instance_metadata)
-- 
cgit 


From de2ecf115ff0baf43fa530807997513c728ffdaf Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
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')

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 1abd4e6d592fb41d86fa32c3f77fd0e0a43ca5d3 Mon Sep 17 00:00:00 2001
From: Brian Waldon <brian.waldon@rackspace.com>
Date: Tue, 22 Mar 2011 10:23:33 -0400
Subject: making Controller._get_flavors is_detail a keyword argument

---
 nova/api/openstack/flavors.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/flavors.py b/nova/api/openstack/flavors.py
index e9ee9d012..f7b5b722f 100644
--- a/nova/api/openstack/flavors.py
+++ b/nova/api/openstack/flavors.py
@@ -37,15 +37,15 @@ class Controller(wsgi.Controller):
 
     def index(self, req):
         """Return all flavors in brief."""
-        items = self._get_flavors(req, False)
+        items = self._get_flavors(req, is_detail=False)
         return dict(flavors=items)
 
     def detail(self, req):
         """Return all flavors in detail."""
-        items = self._get_flavors(req, True)
+        items = self._get_flavors(req, is_detail=True)
         return dict(flavors=items)
 
-    def _get_flavors(self, req, is_detail):
+    def _get_flavors(self, req, is_detail=True):
         """Helper function that returns a list of flavor dicts."""
         ctxt = req.environ['nova.context']
         flavors = db.api.instance_type_get_all(ctxt)
-- 
cgit 


From 94ef3c04a56427af5b4f3d0405c21d780ac8ff07 Mon Sep 17 00:00:00 2001
From: Dan Prince <dan.prince@rackspace.com>
Date: Tue, 22 Mar 2011 10:48:37 -0400
Subject: When updating or creating set 'delete = 0'. (thus reactivating a
 deleted row) Filter by 'deleted' on delete.

---
 nova/db/sqlalchemy/api.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 9699f6b5c..22c7a22b5 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -2487,6 +2487,7 @@ def delete_instance_metadata(context, instance_id, key):
     session.query(models.InstanceMetadata).\
         filter_by(instance_id=instance_id).\
         filter_by(key=key).\
+        filter_by(deleted=False).\
         update({'deleted': 1,
                 'deleted_at': datetime.datetime.utcnow(),
                 'updated_at': literal_column('updated_at')})
@@ -2519,6 +2520,7 @@ def update_or_create_instance_metadata(context, instance_id, metadata):
         except:
             meta_ref = models.InstanceMetadata()
         meta_ref.update({"key": key, "value": value,
-                            "instance_id": instance_id})
+                            "instance_id": instance_id,
+                            "deleted": 0})
         meta_ref.save(session=session)
     return metadata
-- 
cgit 


From b82d548d0357f73ff446f5bf24e27fbefd98e4b3 Mon Sep 17 00:00:00 2001
From: Brian Waldon <brian.waldon@rackspace.com>
Date: Tue, 22 Mar 2011 10:58:31 -0400
Subject: adding view builder tests

---
 nova/api/openstack/views/versions.py      |  4 +++-
 nova/tests/api/openstack/test_versions.py | 36 +++++++++++++++++++++++++++++++
 2 files changed, 39 insertions(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/api/openstack/views/versions.py b/nova/api/openstack/views/versions.py
index 555d58d5c..d0145c94a 100644
--- a/nova/api/openstack/views/versions.py
+++ b/nova/api/openstack/views/versions.py
@@ -15,6 +15,8 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+import os
+
 
 def get_view_builder(req):
     base_url = req.application_url
@@ -54,4 +56,4 @@ class ViewBuilder(object):
 
     def generate_href(self, version_number):
         """Create an url that refers to a specific version_number."""
-        return "%s/%s" % (self.base_url, version_number)
+        return os.path.join(self.base_url, version_number)
diff --git a/nova/tests/api/openstack/test_versions.py b/nova/tests/api/openstack/test_versions.py
index 330d74dde..f730fc8e4 100644
--- a/nova/tests/api/openstack/test_versions.py
+++ b/nova/tests/api/openstack/test_versions.py
@@ -21,6 +21,7 @@ import webob
 from nova import context
 from nova import test
 from nova.tests.api.openstack import fakes
+from nova.api.openstack import views
 
 
 class VersionsTest(test.TestCase):
@@ -59,3 +60,38 @@ class VersionsTest(test.TestCase):
             },
         ]
         self.assertEqual(versions, expected)
+
+    def test_view_builder(self):
+        base_url = "http://example.org/"
+
+        version_data = {
+            "id": "3.2.1",
+            "status": "CURRENT",
+        }
+
+        expected = {
+            "id": "3.2.1",
+            "status": "CURRENT",
+            "links": [
+                {
+                    "rel": "self",
+                    "href": "http://example.org/3.2.1",
+                },
+            ],
+        }
+
+        builder = views.versions.ViewBuilder(base_url)
+        output = builder.build(version_data)
+
+        self.assertEqual(output, expected)
+
+    def test_generate_href(self):
+        base_url = "http://example.org/app/"
+        version_number = "v1.4.6"
+
+        expected = "http://example.org/app/v1.4.6"
+
+        builder = views.versions.ViewBuilder(base_url)
+        actual = builder.generate_href(version_number)
+
+        self.assertEqual(actual, expected)
-- 
cgit 


From d2494199df440809bbfbc55868b0dd57053868ed Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Tue, 22 Mar 2011 16:23:47 +0100
Subject: Remove checks in _cache_image tests that were too implementation
 specific.

---
 nova/tests/test_virt.py | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/test_virt.py b/nova/tests/test_virt.py
index b9cd30a79..6bafac39f 100644
--- a/nova/tests/test_virt.py
+++ b/nova/tests/test_virt.py
@@ -62,7 +62,7 @@ class CacheConcurrencyTestCase(test.TestCase):
         self.stubs.Set(os.path, 'exists', fake_exists)
         self.stubs.Set(utils, 'execute', fake_execute)
 
-    def notest_same_fname_concurrency(self):
+    def test_same_fname_concurrency(self):
         """Ensures that the same fname cache runs at a sequentially"""
         conn = libvirt_conn.LibvirtConnection
         wait1 = eventlet.event.Event()
@@ -77,13 +77,11 @@ class CacheConcurrencyTestCase(test.TestCase):
         eventlet.sleep(0)
         try:
             self.assertFalse(done2.ready())
-            self.assertTrue('fname' in conn._image_sems)
         finally:
             wait1.send()
         done1.wait()
         eventlet.sleep(0)
         self.assertTrue(done2.ready())
-        self.assertFalse('fname' in conn._image_sems)
 
     def test_different_fname_concurrency(self):
         """Ensures that two different fname caches are concurrent"""
-- 
cgit 


From 9aac55b650e9f39c5771d4683e51af5eac6204bb Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Tue, 22 Mar 2011 16:24:03 +0100
Subject: Add a test for leaked semaphores.

---
 nova/tests/test_misc.py | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/test_misc.py b/nova/tests/test_misc.py
index c0c72bb12..8fc5d67c0 100644
--- a/nova/tests/test_misc.py
+++ b/nova/tests/test_misc.py
@@ -22,7 +22,8 @@ from eventlet import greenpool
 from eventlet import greenthread
 
 from nova import test
-from nova.utils import parse_mailmap, str_dict_replace, synchronized
+from nova import utils
+from nova.utils import parse_mailmap, str_dict_replace
 
 
 class ProjectTestCase(test.TestCase):
@@ -66,7 +67,7 @@ class ProjectTestCase(test.TestCase):
 
 class LockTestCase(test.TestCase):
     def test_synchronized_wrapped_function_metadata(self):
-        @synchronized('whatever')
+        @utils.synchronized('whatever')
         def foo():
             """Bar"""
             pass
@@ -77,8 +78,9 @@ class LockTestCase(test.TestCase):
 
     def test_synchronized_internally(self):
         """We can lock across multiple green threads"""
+        saved_sem_num = len(utils._semaphores)
         seen_threads = list()
-        @synchronized('testlock', external=False)
+        @utils.synchronized('testlock2', external=False)
         def f(id):
             for x in range(10):
                 seen_threads.append(id)
@@ -99,13 +101,15 @@ class LockTestCase(test.TestCase):
             for j in range(9):
                 self.assertEquals(seen_threads[i*10], seen_threads[i*10+1+j])
 
+        self.assertEqual(saved_sem_num, len(utils._semaphores),
+                         "Semaphore leak detected")
 
     def test_synchronized_externally(self):
         """We can lock across multiple processes"""
         rpipe1, wpipe1 = os.pipe()
         rpipe2, wpipe2 = os.pipe()
 
-        @synchronized('testlock', external=True)
+        @utils.synchronized('testlock1', external=True)
         def f(rpipe, wpipe):
             try:
                 os.write(wpipe, "foo")
-- 
cgit 


From b2bdeb82024b1a015ccb2ad14606d6e9ccf80aa8 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Tue, 22 Mar 2011 16:29:37 +0100
Subject: pep8

---
 nova/tests/test_misc.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/tests/test_misc.py b/nova/tests/test_misc.py
index 8fc5d67c0..4e17e1ce0 100644
--- a/nova/tests/test_misc.py
+++ b/nova/tests/test_misc.py
@@ -80,6 +80,7 @@ class LockTestCase(test.TestCase):
         """We can lock across multiple green threads"""
         saved_sem_num = len(utils._semaphores)
         seen_threads = list()
+
         @utils.synchronized('testlock2', external=False)
         def f(id):
             for x in range(10):
@@ -99,7 +100,8 @@ class LockTestCase(test.TestCase):
         # that the last 9 match the first in each chunk.
         for i in range(10):
             for j in range(9):
-                self.assertEquals(seen_threads[i*10], seen_threads[i*10+1+j])
+                self.assertEquals(seen_threads[i * 10],
+                                  seen_threads[i * 10 + 1 + j])
 
         self.assertEqual(saved_sem_num, len(utils._semaphores),
                          "Semaphore leak detected")
-- 
cgit 


From 3c7de6db490a8482f6d1fb5fefc750050cb1e269 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
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/tests/test_virt.py   | 15 ++++++++++++++-
 nova/virt/libvirt_conn.py | 10 +++++++---
 2 files changed, 21 insertions(+), 4 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/test_virt.py b/nova/tests/test_virt.py
index b214f5ce7..a754f451a 100644
--- a/nova/tests/test_virt.py
+++ b/nova/tests/test_virt.py
@@ -429,6 +429,15 @@ class LibvirtConnTestCase(test.TestCase):
         def fake_raise(self):
             raise libvirt.libvirtError('ERR')
 
+        class FakeTime(object):
+            def __init__(self):
+                self.counter = 0
+
+            def sleep(self, t):
+                self.counter += t
+
+        fake_timer = FakeTime()
+
         self.create_fake_libvirt_mock(nwfilterLookupByName=fake_raise)
         instance_ref = db.instance_create(self.context, self.test_instance)
 
@@ -438,11 +447,15 @@ class LibvirtConnTestCase(test.TestCase):
             conn = libvirt_conn.LibvirtConnection(False)
             conn.firewall_driver.setattr('setup_basic_filtering', fake_none)
             conn.firewall_driver.setattr('prepare_instance_filter', fake_none)
-            conn.ensure_filtering_rules_for_instance(instance_ref)
+            conn.ensure_filtering_rules_for_instance(instance_ref,
+                                                     time=fake_timer)
         except exception.Error, e:
             c1 = (0 <= e.message.find('Timeout migrating for'))
         self.assertTrue(c1)
 
+        self.assertEqual(29, fake_timer.counter, "Didn't wait the expected "
+                                                 "amount of time")
+
         db.instance_destroy(self.context, instance_ref['id'])
 
     def test_live_migration_raises_exception(self):
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 4e33ab9fc16d580fbcf57da8e6e2228ad27cc1af Mon Sep 17 00:00:00 2001
From: Naveed Massjouni <naveedm9@gmail.com>
Date: Tue, 22 Mar 2011 11:46:00 -0400
Subject: Adding more docstrings. image_id and instance_type fields of an
 instance will always exist, so no reason to check if keys exist.

---
 nova/api/openstack/__init__.py      |  4 ++++
 nova/api/openstack/views/servers.py | 25 ++++++++++++-------------
 2 files changed, 16 insertions(+), 13 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/__init__.py b/nova/api/openstack/__init__.py
index 35b04f863..21d354f1c 100644
--- a/nova/api/openstack/__init__.py
+++ b/nova/api/openstack/__init__.py
@@ -131,6 +131,8 @@ class APIRouter(wsgi.Router):
 
 
 class APIRouterV10(APIRouter):
+    ''' Defines routes specific to OpenStack API V1.0 '''
+
     def _setup_routes(self, mapper):
         APIRouter._setup_routes(self, mapper)
         mapper.resource("server", "servers",
@@ -140,6 +142,8 @@ class APIRouterV10(APIRouter):
 
 
 class APIRouterV11(APIRouter):
+    ''' Defines routes specific to OpenStack API V1.1 '''
+
     def _setup_routes(self, mapper):
         APIRouter._setup_routes(self, mapper)
         mapper.resource("server", "servers",
diff --git a/nova/api/openstack/views/servers.py b/nova/api/openstack/views/servers.py
index 078d5d484..3100c46b5 100644
--- a/nova/api/openstack/views/servers.py
+++ b/nova/api/openstack/views/servers.py
@@ -34,19 +34,18 @@ class ViewBuilder(object):
         self.addresses_builder = addresses_builder
 
     def build(self, inst, is_detail):
-        """
-        Coerces into dictionary format, mapping everything to
-        Rackspace-like attributes for return
-        """
+        ''' Returns a dict that represenst a server '''
         if is_detail:
             return self._build_detail(inst)
         else:
             return self._build_simple(inst)
 
     def _build_simple(self, inst):
-            return dict(server=dict(id=inst['id'], name=inst['display_name']))
+        ''' Returns a simple model of a server '''
+        return dict(server=dict(id=inst['id'], name=inst['display_name']))
 
     def _build_detail(self, inst):
+        ''' Returns a detailed model of a server '''
         power_mapping = {
             None: 'build',
             power_state.NOSTATE: 'build',
@@ -81,36 +80,36 @@ class ViewBuilder(object):
         return dict(server=inst_dict)
 
     def _build_image(self, response, inst):
+        ''' Returns the image sub-resource of a server '''
         raise NotImplementedError()
 
     def _build_flavor(self, response, inst):
+        ''' Returns the flavor sub-resource of a server '''
         raise NotImplementedError()
 
 
 class ViewBuilderV10(ViewBuilder):
+    ''' Models an Openstack API V1.0 server response '''
+
     def _build_image(self, response, inst):
-        if inst.get('image_id') != None:
-            response['imageId'] = inst['image_id']
+        response['imageId'] = inst['image_id']
 
     def _build_flavor(self, response, inst):
-        if inst.get('instance_type') != None:
-            response['flavorId'] = inst['instance_type']
+        response['flavorId'] = inst['instance_type']
 
 
 class ViewBuilderV11(ViewBuilder):
+    ''' Models an Openstack API V1.0 server response '''
+
     def __init__(self, addresses_builder, flavor_builder, image_builder):
         ViewBuilder.__init__(self, addresses_builder)
         self.flavor_builder = flavor_builder
         self.image_builder = image_builder
 
     def _build_image(self, response, inst):
-        if inst.get('image_id') == None:
-            return
         image_id = inst["image_id"]
         response["imageRef"] = self.image_builder.generate_href(image_id)
 
     def _build_flavor(self, response, inst):
-        if inst.get('instance_type') == None:
-            return
         flavor_id = inst["instance_type"]
         response["flavorRef"] = self.flavor_builder.generate_href(flavor_id)
-- 
cgit 


From 7ae8f5563c42d7c5dc67047dd9c42e982281d80b Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Tue, 22 Mar 2011 16:53:43 +0100
Subject: Apparantly a more common problem than first thought.

---
 nova/compute/manager.py    |  8 ++++++--
 nova/tests/test_compute.py | 14 +++++++++++---
 2 files changed, 17 insertions(+), 5 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 576937cd8..67290c8dc 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -41,9 +41,10 @@ import string
 import socket
 import sys
 import tempfile
-import time
 import functools
 
+from eventlet import greenthread
+
 from nova import exception
 from nova import flags
 from nova import log as logging
@@ -800,7 +801,7 @@ class ComputeManager(manager.Manager):
 
         return self.driver.update_available_resource(context, self.host)
 
-    def pre_live_migration(self, context, instance_id):
+    def pre_live_migration(self, context, instance_id, time=None):
         """Preparations for live migration at dest host.
 
         :param context: security context
@@ -808,6 +809,9 @@ class ComputeManager(manager.Manager):
 
         """
 
+        if not time:
+            time = greenthread
+
         # Getting instance info
         instance_ref = self.db.instance_get(context, instance_id)
         ec2_id = instance_ref['hostname']
diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index 3651f4cef..0209dd9ca 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -44,6 +44,14 @@ flags.DECLARE('stub_network', 'nova.compute.manager')
 flags.DECLARE('live_migration_retry_count', 'nova.compute.manager')
 
 
+class FakeTime(object):
+    def __init__(self):
+        self.counter = 0
+
+    def sleep(self, t):
+        self.counter += t
+
+
 class ComputeTestCase(test.TestCase):
     """Test case for compute"""
     def setUp(self):
@@ -342,7 +350,7 @@ class ComputeTestCase(test.TestCase):
         self.mox.ReplayAll()
         self.assertRaises(exception.NotFound,
                           self.compute.pre_live_migration,
-                          c, instance_ref['id'])
+                          c, instance_ref['id'], time=FakeTime())
 
     def test_pre_live_migration_instance_has_volume(self):
         """Confirm setup_compute_volume is called when volume is mounted."""
@@ -395,7 +403,7 @@ class ComputeTestCase(test.TestCase):
         self.compute.driver = drivermock
 
         self.mox.ReplayAll()
-        ret = self.compute.pre_live_migration(c, i_ref['id'])
+        ret = self.compute.pre_live_migration(c, i_ref['id'], time=FakeTime())
         self.assertEqual(ret, None)
 
     def test_pre_live_migration_setup_compute_node_fail(self):
@@ -428,7 +436,7 @@ class ComputeTestCase(test.TestCase):
         self.mox.ReplayAll()
         self.assertRaises(exception.ProcessExecutionError,
                           self.compute.pre_live_migration,
-                          c, i_ref['id'])
+                          c, i_ref['id'], time=FakeTime())
 
     def test_live_migration_works_correctly_with_volume(self):
         """Confirm check_for_export to confirm volume health check."""
-- 
cgit 


From f4dee61638db068c03edd7fe0ab3488ac4670d89 Mon Sep 17 00:00:00 2001
From: Dan Prince <dan.prince@rackspace.com>
Date: Tue, 22 Mar 2011 11:56:07 -0400
Subject: pep8 fix.

---
 nova/api/openstack/servers.py | 1 +
 1 file changed, 1 insertion(+)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 5f6fbd96c..73843f63e 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -516,6 +516,7 @@ class Controller(wsgi.Controller):
 
         return kernel_id, ramdisk_id
 
+
 class ControllerV10(Controller):
     def _image_id_from_req_data(self, data):
         return data['server']['imageId']
-- 
cgit 


From 06815cb729d8687403fc736ae6125c26867f42b3 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Tue, 22 Mar 2011 17:13:48 +0100
Subject: Remove unused global semaphore.

---
 nova/utils.py | 1 -
 1 file changed, 1 deletion(-)

(limited to 'nova')

diff --git a/nova/utils.py b/nova/utils.py
index c580e805a..8b9ce4734 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -532,7 +532,6 @@ def loads(s):
     return json.loads(s)
 
 
-_semaphores_semaphore = semaphore.Semaphore()
 _semaphores = {}
 
 
-- 
cgit 


From e648698bd171357228881a10d76e7853938e8feb Mon Sep 17 00:00:00 2001
From: "matt.dietz@rackspace.com" <>
Date: Tue, 22 Mar 2011 17:00:36 +0000
Subject: Fix

---
 nova/tests/test_localization.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/test_localization.py b/nova/tests/test_localization.py
index 393d71038..132a308fd 100644
--- a/nova/tests/test_localization.py
+++ b/nova/tests/test_localization.py
@@ -21,9 +21,9 @@ import sys
 import unittest
 
 import nova
+from nova import test
 
-
-class LocalizationTestCase(unittest.TestCase):
+class LocalizationTestCase(test.TestCase):
     def test_multiple_positional_format_placeholders(self):
         pat = re.compile("\W_\(")
         single_pat = re.compile("\W%\W")
-- 
cgit 


From 493e87976b7eb273f4115d46c91ad73671abb796 Mon Sep 17 00:00:00 2001
From: Naveed Massjouni <naveedm9@gmail.com>
Date: Tue, 22 Mar 2011 13:18:08 -0400
Subject: Now using urlparse to parse a url to grab id out of it.

---
 nova/api/openstack/common.py | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/common.py b/nova/api/openstack/common.py
index b224cbfb4..99fba8fef 100644
--- a/nova/api/openstack/common.py
+++ b/nova/api/openstack/common.py
@@ -17,6 +17,7 @@
 
 import re
 from nova import exception
+from urlparse import urlparse
 from webob import exc
 import webob.exc
 
@@ -78,7 +79,7 @@ def get_image_id_from_image_hash(image_service, context, image_hash):
 
 
 def get_id_from_href(href):
-    m = re.match(r'http.+/.+/(\d)+$', href)
-    if not m:
+    try:
+        return int(urlparse(href).path.split('/')[-1])
+    except:
         raise exc.HTTPBadRequest(_('could not parse id from href'))
-    return int(m.group(1))
-- 
cgit 


From 97e8f300af824145c8b92949ccbdfe81c0d7ca95 Mon Sep 17 00:00:00 2001
From: Josh Kleinpeter <josh@kleinpeter.org>
Date: Tue, 22 Mar 2011 12:33:34 -0500
Subject: Changed default for disabled on service_get_all to None. Changed
 calls to service_get_all so that the results should still be as they
 previously were.

---
 nova/api/ec2/admin.py     |  2 +-
 nova/api/ec2/cloud.py     |  4 ++--
 nova/db/api.py            |  2 +-
 nova/db/sqlalchemy/api.py | 13 ++++++++-----
 4 files changed, 12 insertions(+), 9 deletions(-)

(limited to 'nova')

diff --git a/nova/api/ec2/admin.py b/nova/api/ec2/admin.py
index d9a4ef999..3ae29d8ce 100644
--- a/nova/api/ec2/admin.py
+++ b/nova/api/ec2/admin.py
@@ -299,7 +299,7 @@ class AdminController(object):
             * Volume (up, down, None)
             * Volume Count
         """
-        services = db.service_get_all(context)
+        services = db.service_get_all(context, False)
         now = datetime.datetime.utcnow()
         hosts = []
         rv = []
diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index e257e44e7..2afcea77c 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -196,7 +196,7 @@ class CloudController(object):
 
     def _describe_availability_zones(self, context, **kwargs):
         ctxt = context.elevated()
-        enabled_services = db.service_get_all(ctxt)
+        enabled_services = db.service_get_all(ctxt, False)
         disabled_services = db.service_get_all(ctxt, True)
         available_zones = []
         for zone in [service.availability_zone for service
@@ -221,7 +221,7 @@ class CloudController(object):
         rv = {'availabilityZoneInfo': [{'zoneName': 'nova',
                                         'zoneState': 'available'}]}
 
-        services = db.service_get_all(context)
+        services = db.service_get_all(context, False)
         now = datetime.datetime.utcnow()
         hosts = []
         for host in [service['host'] for service in services]:
diff --git a/nova/db/api.py b/nova/db/api.py
index add5bd83e..b3ca861e2 100644
--- a/nova/db/api.py
+++ b/nova/db/api.py
@@ -89,7 +89,7 @@ def service_get_by_host_and_topic(context, host, topic):
     return IMPL.service_get_by_host_and_topic(context, host, topic)
 
 
-def service_get_all(context, disabled=False):
+def service_get_all(context, disabled=None):
     """Get all services."""
     return IMPL.service_get_all(context, disabled)
 
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 3bf4f5eb8..321efe0e5 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -143,12 +143,15 @@ def service_get(context, service_id, session=None):
 
 
 @require_admin_context
-def service_get_all(context, disabled=False):
+def service_get_all(context, disabled=None):
     session = get_session()
-    return session.query(models.Service).\
-                   filter_by(deleted=can_read_deleted(context)).\
-                   filter_by(disabled=disabled).\
-                   all()
+    query = session.query(models.Service).\
+                   filter_by(deleted=can_read_deleted(context))
+
+    if disabled is not None:
+        query = query.filter_by(disabled=disabled)
+
+    return query.all()
 
 
 @require_admin_context
-- 
cgit 


From 2a38aa7583be37ece6c42ba9307c2db0232dbed3 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Tue, 22 Mar 2011 10:37:56 -0700
Subject: Whoops

---
 nova/api/openstack/servers.py | 5 +++--
 nova/scheduler/api.py         | 3 +++
 2 files changed, 6 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index be423c572..199d89c6d 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -92,9 +92,10 @@ class Controller(wsgi.Controller):
         """ Returns server details by server id """
         try:
             LOG.debug(_("***SHOW"))
-            instance = self.compute_api.get(req.environ['nova.context'], id)
-            builder = servers_views.get_view_builder(req)
+            instance = self.compute_api.routing_get(
+                req.environ['nova.context'], id)
             LOG.debug(_("***SHOW OUT %s" % instance))
+            builder = servers_views.get_view_builder(req)
             return builder.build(instance, is_detail=True)
         except exception.NotFound:
             return faults.Fault(exc.HTTPNotFound())
diff --git a/nova/scheduler/api.py b/nova/scheduler/api.py
index 4f189fe37..bd64f9b9b 100644
--- a/nova/scheduler/api.py
+++ b/nova/scheduler/api.py
@@ -149,8 +149,10 @@ class reroute_compute(object):
 
     def __call__(self, f):
         def wrapped_f(*args, **kwargs):
+            LOG.debug(_("IN DECORATOR ..."))
             collection, context, item_id = \
                             self.get_collection_context_and_id(args, kwargs)
+            LOG.debug(_("IN DECORATOR 2..."))
             try:
                 # Call the original function ...
                 return f(*args, **kwargs)
@@ -166,6 +168,7 @@ class reroute_compute(object):
                     raise
 
                 # Ask the children to provide an answer ...
+                LOG.debug(_("Asking child zones ..."))
                 result = self._call_child_zones(zones,
                             wrap_novaclient_function(_issue_novaclient_command,
                                    collection, self.method_name, item_id))
-- 
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/api/openstack/servers.py       | 4 ++--
 nova/api/openstack/views/servers.py | 5 +++--
 nova/compute/api.py                 | 8 ++++----
 nova/db/sqlalchemy/api.py           | 4 ++--
 nova/virt/xenapi/vmops.py           | 4 ++--
 5 files changed, 13 insertions(+), 12 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index db5942e92..f3367e118 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -36,7 +36,7 @@ from nova.api.openstack.views import addresses as addresses_views
 from nova.auth import manager as auth_manager
 from nova.compute import instance_types
 from nova.compute import power_state
-prom nova.quota import QuotaError
+from nova.quota import QuotaError
 import nova.api.openstack
 
 
@@ -44,7 +44,7 @@ LOG = logging.getLogger('server')
 FLAGS = flags.FLAGS
 
 
-plass Controller(wsgi.Controller):
+class Controller(wsgi.Controller):
     """ The Server API controller for the OpenStack API """
 
     _serialization_metadata = {
diff --git a/nova/api/openstack/views/servers.py b/nova/api/openstack/views/servers.py
index 6d54a7a7e..9fd25999a 100644
--- a/nova/api/openstack/views/servers.py
+++ b/nova/api/openstack/views/servers.py
@@ -89,8 +89,9 @@ class ViewBuilder(object):
             migration = db.migration_get_by_instance_and_status(ctxt,
                     inst['id'], 'finished')
             inst_dict['status'] = 'resize-confirm'
-        except Exception, e:
-            inst_dict['status'] = power_mapping[inst_dict['status']]
+        except:
+            pass
+
         inst_dict['addresses'] = self.addresses_builder.build(inst)
 
         # Return the metadata as a dictionary
diff --git a/nova/compute/api.py b/nova/compute/api.py
index dbf99e7c5..748aba004 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -489,15 +489,15 @@ class API(base.Base):
     def resize(self, context, instance_id, flavor_id):
         """Resize a running instance."""
         instance = self.db.instance_get(context, instance_id)
-        LOG.debug(_("Resizing instance %(instance_type['name'] to flavor"
-                "%(flavor_id)") % locals())
         current_instance_type = self.db.instance_type_get_by_name(
             context, instance['instance_type'])
 
         new_instance_type = self.db.instance_type_get_by_flavor_id(
                 context, flavor_id)
-        LOG.debug(_("Old instance type %s -> New instance type %s"),
-                (current_instance_type['name'], new_instance_type['name']))
+        current_instance_type_name = current_instance_type['name']
+        new_instance_type_name = new_instance_type['name']
+        LOG.debug(_("Old instance type %(current_instance_type_name)s, "
+                " new instance type %(new_instance_type_name)s") % locals())
         if not new_instance_type:
             raise exception.ApiError(_("Requested flavor does not exist"))
 
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index ac7f7cbf1..98810cb48 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -2220,8 +2220,8 @@ def migration_get_by_instance_and_status(context, instance_id, status):
                      filter_by(instance_id=instance_id).\
                      filter_by(status=status).first()
     if not result:
-        raise exception.NotFound(_("No migration found for instance %s"
-                "with status %s" % (instance_id, status)))
+        raise exception.NotFound(_("No migration found for instance "
+                "%(instance_id) with status %(status)") % locals())
     return result
 
 
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')

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')

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 186fab6781265b2dc92cb6049c11b390cb38b969 Mon Sep 17 00:00:00 2001
From: Brian Waldon <brian.waldon@rackspace.com>
Date: Tue, 22 Mar 2011 14:09:23 -0400
Subject: fixing copyright

---
 nova/api/openstack/versions.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/versions.py b/nova/api/openstack/versions.py
index 4fa04ebb3..33f1dd628 100644
--- a/nova/api/openstack/versions.py
+++ b/nova/api/openstack/versions.py
@@ -1,7 +1,6 @@
 # vim: tabstop=4 shiftwidth=4 softtabstop=4
 
-# Copyright 2011 United States Government as represented by the
-# Administrator of the National Aeronautics and Space Administration.
+# Copyright 2011 OpenStack LLC.
 # All Rights Reserved.
 #
 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
-- 
cgit 


From 8792383dfbd630388e6a51a76910e73203a3793f Mon Sep 17 00:00:00 2001
From: "matt.dietz@rackspace.com" <>
Date: Tue, 22 Mar 2011 18:24:00 +0000
Subject: Tweak

---
 nova/api/openstack/views/servers.py                                   | 4 ++++
 .../sqlalchemy/migrate_repo/versions/012_add_flavors_to_migrations.py | 1 +
 nova/tests/test_localization.py                                       | 1 +
 3 files changed, 6 insertions(+)

(limited to 'nova')

diff --git a/nova/api/openstack/views/servers.py b/nova/api/openstack/views/servers.py
index 9fd25999a..709052f22 100644
--- a/nova/api/openstack/views/servers.py
+++ b/nova/api/openstack/views/servers.py
@@ -16,7 +16,10 @@
 #    under the License.
 
 import hashlib
+
 from nova.compute import power_state
+import nova.context
+from nova import db
 from nova.api.openstack import common
 from nova.api.openstack.views import addresses as addresses_view
 from nova.api.openstack.views import flavors as flavors_view
@@ -86,6 +89,7 @@ class ViewBuilder(object):
 
         inst_dict['status'] = power_mapping[inst_dict['status']]
         try:
+            ctxt = nova.context.get_admin_context()
             migration = db.migration_get_by_instance_and_status(ctxt,
                     inst['id'], 'finished')
             inst_dict['status'] = 'resize-confirm'
diff --git a/nova/db/sqlalchemy/migrate_repo/versions/012_add_flavors_to_migrations.py b/nova/db/sqlalchemy/migrate_repo/versions/012_add_flavors_to_migrations.py
index e677ba14d..3fb92e85c 100644
--- a/nova/db/sqlalchemy/migrate_repo/versions/012_add_flavors_to_migrations.py
+++ b/nova/db/sqlalchemy/migrate_repo/versions/012_add_flavors_to_migrations.py
@@ -43,6 +43,7 @@ def upgrade(migrate_engine):
     migrations.create_column(old_flavor_id)
     migrations.create_column(new_flavor_id)
 
+
 def downgrade(migrate_engine):
     meta.bind = migrate_engine
     migrations.drop_column(old_flavor_id)
diff --git a/nova/tests/test_localization.py b/nova/tests/test_localization.py
index 132a308fd..a25809a79 100644
--- a/nova/tests/test_localization.py
+++ b/nova/tests/test_localization.py
@@ -23,6 +23,7 @@ import unittest
 import nova
 from nova import test
 
+
 class LocalizationTestCase(test.TestCase):
     def test_multiple_positional_format_placeholders(self):
         pat = re.compile("\W_\(")
-- 
cgit 


From aa4183064e15033ce2cc35773e86809b5f8224fd Mon Sep 17 00:00:00 2001
From: Brian Waldon <brian.waldon@rackspace.com>
Date: Tue, 22 Mar 2011 14:34:46 -0400
Subject: one more copyright fix

---
 nova/tests/api/openstack/test_versions.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/test_versions.py b/nova/tests/api/openstack/test_versions.py
index f730fc8e4..ebb59a9a6 100644
--- a/nova/tests/api/openstack/test_versions.py
+++ b/nova/tests/api/openstack/test_versions.py
@@ -1,6 +1,6 @@
 # vim: tabstop=4 shiftwidth=4 softtabstop=4
 
-# Copyright 2010 OpenStack LLC.
+# Copyright 2010-2011 OpenStack LLC.
 # All Rights Reserved.
 #
 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
-- 
cgit 


From ca37b31d64f9c5cf32ca7e6015176ef36e702dce Mon Sep 17 00:00:00 2001
From: Naveed Massjouni <naveedm9@gmail.com>
Date: Tue, 22 Mar 2011 16:04:27 -0400
Subject: Updating doc strings in accordance with PEP 257. Fixing order of
 imports in common.py.

---
 nova/api/openstack/__init__.py      |  4 ++--
 nova/api/openstack/common.py        | 16 +++++++++++-----
 nova/api/openstack/views/servers.py | 22 ++++++++++++----------
 3 files changed, 25 insertions(+), 17 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/__init__.py b/nova/api/openstack/__init__.py
index 21d354f1c..5f9648210 100644
--- a/nova/api/openstack/__init__.py
+++ b/nova/api/openstack/__init__.py
@@ -131,7 +131,7 @@ class APIRouter(wsgi.Router):
 
 
 class APIRouterV10(APIRouter):
-    ''' Defines routes specific to OpenStack API V1.0 '''
+    """Define routes specific to OpenStack API V1.0."""
 
     def _setup_routes(self, mapper):
         APIRouter._setup_routes(self, mapper)
@@ -142,7 +142,7 @@ class APIRouterV10(APIRouter):
 
 
 class APIRouterV11(APIRouter):
-    ''' Defines routes specific to OpenStack API V1.1 '''
+    """Define routes specific to OpenStack API V1.1."""
 
     def _setup_routes(self, mapper):
         APIRouter._setup_routes(self, mapper)
diff --git a/nova/api/openstack/common.py b/nova/api/openstack/common.py
index 99fba8fef..21ceec45e 100644
--- a/nova/api/openstack/common.py
+++ b/nova/api/openstack/common.py
@@ -15,11 +15,11 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-import re
-from nova import exception
 from urlparse import urlparse
-from webob import exc
-import webob.exc
+
+import webob
+
+from nova import exception
 
 
 def limited(items, request, max_limit=1000):
@@ -79,7 +79,13 @@ def get_image_id_from_image_hash(image_service, context, image_hash):
 
 
 def get_id_from_href(href):
+    """Return the id portion of a url.
+
+    Given: http://www.foo.com/bar/123?q=4
+    Returns: 4
+
+    """
     try:
         return int(urlparse(href).path.split('/')[-1])
     except:
-        raise exc.HTTPBadRequest(_('could not parse id from href'))
+        raise webob.exc.HTTPBadRequest(_('could not parse id from href'))
diff --git a/nova/api/openstack/views/servers.py b/nova/api/openstack/views/servers.py
index 3100c46b5..fad361bd4 100644
--- a/nova/api/openstack/views/servers.py
+++ b/nova/api/openstack/views/servers.py
@@ -25,27 +25,29 @@ from nova import utils
 
 
 class ViewBuilder(object):
-    '''
-    Models a server response as a python dictionary.
+    """Model a server response as a python dictionary.
+
+    Public methods: build
     Abstract methods: _build_image, _build_flavor
-    '''
+
+    """
 
     def __init__(self, addresses_builder):
         self.addresses_builder = addresses_builder
 
     def build(self, inst, is_detail):
-        ''' Returns a dict that represenst a server '''
+        """Return a dict that represenst a server."""
         if is_detail:
             return self._build_detail(inst)
         else:
             return self._build_simple(inst)
 
     def _build_simple(self, inst):
-        ''' Returns a simple model of a server '''
+        """Return a simple model of a server."""
         return dict(server=dict(id=inst['id'], name=inst['display_name']))
 
     def _build_detail(self, inst):
-        ''' Returns a detailed model of a server '''
+        """Returns a detailed model of a server."""
         power_mapping = {
             None: 'build',
             power_state.NOSTATE: 'build',
@@ -80,16 +82,16 @@ class ViewBuilder(object):
         return dict(server=inst_dict)
 
     def _build_image(self, response, inst):
-        ''' Returns the image sub-resource of a server '''
+        """Return the image sub-resource of a server."""
         raise NotImplementedError()
 
     def _build_flavor(self, response, inst):
-        ''' Returns the flavor sub-resource of a server '''
+        """Return the flavor sub-resource of a server."""
         raise NotImplementedError()
 
 
 class ViewBuilderV10(ViewBuilder):
-    ''' Models an Openstack API V1.0 server response '''
+    """Model an Openstack API V1.0 server response."""
 
     def _build_image(self, response, inst):
         response['imageId'] = inst['image_id']
@@ -99,7 +101,7 @@ class ViewBuilderV10(ViewBuilder):
 
 
 class ViewBuilderV11(ViewBuilder):
-    ''' Models an Openstack API V1.0 server response '''
+    """Model an Openstack API V1.0 server response."""
 
     def __init__(self, addresses_builder, flavor_builder, image_builder):
         ViewBuilder.__init__(self, addresses_builder)
-- 
cgit 


From 789fcb46915dce5fa533357ac462040ec6aa8968 Mon Sep 17 00:00:00 2001
From: Rick Harris <rick.harris@rackspace.com>
Date: Tue, 22 Mar 2011 20:26:45 +0000
Subject: Adding BASE_IMAGE_ATTRS to ImageService

---
 nova/api/openstack/images.py            | 57 +++++++++++----------
 nova/image/glance.py                    | 87 ++++++---------------------------
 nova/image/service.py                   | 61 ++++++++++++++++++++++-
 nova/tests/api/openstack/test_images.py | 12 ++---
 nova/utils.py                           | 36 ++++++++++++++
 5 files changed, 145 insertions(+), 108 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/images.py b/nova/api/openstack/images.py
index 0c56b5f0d..97e62c22d 100644
--- a/nova/api/openstack/images.py
+++ b/nova/api/openstack/images.py
@@ -119,43 +119,46 @@ def _translate_s3_like_images(image_metadata):
 def _translate_from_image_service_to_api(image_metadata):
     """Translate from ImageService to OpenStack API style attribute names
 
-    This involves 3 steps:
+    This involves 4 steps:
 
-        1. Translating required keys
+        1. Filter out attributes that the OpenStack API doesn't need
 
-        2. Translating optional keys (ex. progress, serverId)
+        2. Translate from base image attributes from names used by
+           BaseImageService to names used by OpenStack API
 
-        3. Formatting values according to API spec (for example dates must
+        3. Add in any image properties
+
+        4. Format values according to API spec (for example dates must
            look like "2010-08-10T12:00:00Z")
     """
     service_metadata = image_metadata.copy()
-    api_metadata = {}
-
-    # 1. Translate required keys
-    required_image_service2api = {
-        'id': 'id',
-        'name': 'name',
-        'updated_at': 'updated',
-        'created_at': 'created',
-        'status': 'status'}
-    for service_attr, api_attr in required_image_service2api.items():
-        api_metadata[api_attr] = service_metadata[service_attr]
-
-    # 2. Translate optional keys
-    optional_image_service2api = {'instance_id': 'serverId'}
-    for service_attr, api_attr in optional_image_service2api.items():
-        if service_attr in service_metadata:
-            api_metadata[api_attr] = service_metadata[service_attr]
-
-    # 2a. Progress special case
+    properties = service_metadata.pop('properties', {})
+
+    # 1. Filter out unecessary attributes
+    api_keys = ['id', 'name', 'updated_at', 'created_at', 'status']
+    api_metadata = utils.partition_dict(service_metadata, api_keys)[0]
+
+    # 2. Translate base image attributes
+    api_map = {'updated_at': 'updated', 'created_at': 'created'}
+    api_metadata = utils.map_dict_keys(api_metadata, api_map)
+
+    # 3. Add in any image properties
+    # 3a. serverId is used for backups and snapshots
+    try:
+        api_metadata['serverId'] = int(properties['instance_id'])
+    except KeyError:
+        pass  # skip if it's not present
+    except ValueError:
+        pass  # skip if it's not an integer
+
+    # 3b. Progress special case
     # TODO(sirp): ImageService doesn't have a notion of progress yet, so for
     # now just fake it
     if service_metadata['status'] == 'saving':
         api_metadata['progress'] = 0
 
-    # 3. Format values
-
-    # 3a. Format Image Status (API requires uppercase)
+    # 4. Format values
+    # 4a. Format Image Status (API requires uppercase)
     status_service2api = {'queued': 'QUEUED',
                           'preparing': 'PREPARING',
                           'saving': 'SAVING',
@@ -163,7 +166,7 @@ def _translate_from_image_service_to_api(image_metadata):
                           'killed': 'FAILED'}
     api_metadata['status'] = status_service2api[api_metadata['status']]
 
-    # 3b. Format timestamps
+    # 4b. Format timestamps
     def _format_timestamp(dt_str):
         """Return a timestamp formatted for OpenStack API
 
diff --git a/nova/image/glance.py b/nova/image/glance.py
index 2def6fb60..b7bb88002 100644
--- a/nova/image/glance.py
+++ b/nova/image/glance.py
@@ -36,7 +36,14 @@ GlanceClient = utils.import_class('glance.client.Client')
 
 class GlanceImageService(service.BaseImageService):
     """Provides storage and retrieval of disk image objects within Glance."""
-    IMAGE_PROPERTIES = ['instance_id', 'os_type']
+
+    GLANCE_ONLY_ATTRS = ["size", "location", "disk_format",
+                         "container_format"]
+
+    # NOTE(sirp): Overriding to use _translate_to_service provided by
+    # BaseImageService
+    SERVICE_IMAGE_ATTRS = service.BaseImageService.BASE_IMAGE_ATTRS +\
+                          GLANCE_ONLY_ATTRS
 
     def __init__(self):
         self.client = GlanceClient(FLAGS.glance_host, FLAGS.glance_port)
@@ -52,7 +59,7 @@ class GlanceImageService(service.BaseImageService):
         Calls out to Glance for a list of detailed image information
         """
         image_metas = self.client.get_images_detailed()
-        translate = self._translate_from_glance_to_image_service
+        translate = self._translate_to_base
         return [translate(image_meta) for image_meta in image_metas]
 
     def show(self, context, image_id):
@@ -60,11 +67,11 @@ class GlanceImageService(service.BaseImageService):
         Returns a dict containing image data for the given opaque image id.
         """
         try:
-            metadata = self.client.get_image_meta(image_id)
+            image_meta = self.client.get_image_meta(image_id)
         except glance_exception.NotFound:
             raise exception.NotFound
 
-        meta = self._translate_from_glance_to_image_service(metadata)
+        meta = self._translate_to_base(image_meta)
         return meta
 
     def show_by_name(self, context, name):
@@ -88,13 +95,14 @@ class GlanceImageService(service.BaseImageService):
         Calls out to Glance for metadata and data and writes data.
         """
         try:
-            metadata, image_chunks = self.client.get_image(image_id)
+            image_meta, image_chunks = self.client.get_image(image_id)
         except glance_exception.NotFound:
             raise exception.NotFound
+
         for chunk in image_chunks:
             data.write(chunk)
 
-        meta = self._translate_from_glance_to_image_service(metadata)
+        meta = self._translate_to_base(image_meta)
         return meta
 
     def create(self, context, metadata, data=None):
@@ -102,11 +110,10 @@ class GlanceImageService(service.BaseImageService):
         Store the image data and return the new image id.
 
         :raises AlreadyExists if the image already exist.
-
         """
         LOG.debug(_("Creating image in Glance. Metadata passed in %s"),
                   metadata)
-        meta = self._translate_from_image_service_to_glance(metadata)
+        meta = self._translate_to_service(metadata)
         LOG.debug(_("Metadata after formatting for Glance %s"), meta)
         return self.client.add_image(meta, data)
 
@@ -114,7 +121,6 @@ class GlanceImageService(service.BaseImageService):
         """Replace the contents of the given image with the new data.
 
         :raises NotFound if the image does not exist.
-
         """
         try:
             result = self.client.update_image(image_id, metadata, data)
@@ -127,7 +133,6 @@ class GlanceImageService(service.BaseImageService):
         Delete the given image.
 
         :raises NotFound if the image does not exist.
-
         """
         try:
             result = self.client.delete_image(image_id)
@@ -140,65 +145,3 @@ class GlanceImageService(service.BaseImageService):
         Clears out all images
         """
         pass
-
-    @classmethod
-    def _translate_from_image_service_to_glance(cls, metadata):
-        """Return a metadata dict suitable for passing to Glance.
-
-        The ImageService exposes metadata as a flat-dict; however, Glance
-        distinguishes between two different types of metadata:
-
-            1. First-class attributes: These are columns on the image table
-               and represent metadata that is common to all images on all IAAS
-               providers.
-
-            2. Properties: These are entries in the image_properties table and
-               represent image/IAAS-provider specific metadata.
-
-        To reconcile this difference, this function accepts a flat-dict of
-        metadata, figures out which attributes are stored as image properties
-        in Glance, and then adds those to a `properties` dict nested within
-        the metadata.
-
-        """
-        glance_metadata = metadata.copy()
-        properties = {}
-        for property_ in cls.IMAGE_PROPERTIES:
-            if property_ in glance_metadata:
-                value = glance_metadata.pop(property_)
-                properties[property_] = str(value)
-        glance_metadata['properties'] = properties
-        return glance_metadata
-
-    @classmethod
-    def _translate_from_glance_to_image_service(cls, metadata):
-        """Convert Glance-style image metadata to ImageService-style
-
-        The steps in involved are:
-
-            1. Extracting Glance properties and making them ImageService
-               attributes
-
-            2. Converting any strings to appropriate values
-        """
-        service_metadata = metadata.copy()
-
-        # 1. Extract properties
-        if 'properties' in service_metadata:
-            properties = service_metadata.pop('properties')
-            for property_ in cls.IMAGE_PROPERTIES:
-                if ((property_ in properties) and
-                    (property_ not in service_metadata)):
-                    value = properties[property_]
-                    service_metadata[property_] = value
-
-        # 2. Convert values
-        try:
-            service_metadata['instance_id'] = int(
-                service_metadata['instance_id'])
-        except KeyError:
-            pass  # instance_id is not required
-        except TypeError:
-            pass  # instance_id can be None
-
-        return service_metadata
diff --git a/nova/image/service.py b/nova/image/service.py
index c09052cab..ce4954fd1 100644
--- a/nova/image/service.py
+++ b/nova/image/service.py
@@ -16,9 +16,68 @@
 #    under the License.
 
 
+from nova import utils
+
+
 class BaseImageService(object):
+    """Base class for providing image search and retrieval services
+
+    ImageService exposes two concepts of metadata:
+
+        1. First-class attributes: This is metadata that is common to all
+           ImageService subclasses and is shared across all hypervisors. These
+           attributes are defined by IMAGE_ATTRS.
+
+        2. Properties: This is metdata that is specific to an ImageService,
+           and Image, or a particular hypervisor. Any attribute not present in
+           BASE_IMAGE_ATTRS should be considered an image property.
+
+    This means that ImageServices will return BASE_IMAGE_ATTRS as keys in the
+    metadata dict, all other attributes will be returned as keys in the nested
+    'properties' dict.
+    """
+    BASE_IMAGE_ATTRS = ['id', 'name', 'created_at', 'updated_at',
+                        'deleted_at', 'deleted', 'status', 'is_public']
 
-    """Base class for providing image search and retrieval services"""
+    # NOTE(sirp): ImageService subclasses may override this to aid translation
+    # between BaseImageService attributes and additional metadata stored by
+    # the ImageService subclass
+    SERVICE_IMAGE_ATTRS = []
+
+    @classmethod
+    def _translate_to_base(cls, metadata):
+        """Return a metadata dictionary that is BaseImageService compliant.
+
+        This is used by subclasses to expose only a metadata dictionary that
+        is the same across ImageService implementations.
+        """
+        return cls.propertify_metadata(metadata, cls.BASE_IMAGE_ATTRS)
+
+    @classmethod
+    def _translate_to_service(cls, metadata):
+        """Return a metadata dictionary that is usable by the ImageService
+        subclass.
+
+        As an example, Glance has additional attributes (like 'location'); the
+        BaseImageService considers these properties, but we need to translate
+        these back to first-class attrs for sending to Glance. This method
+        handles this by allowing you to specify the attributes an ImageService
+        considers first-class.
+        """
+        if not cls.SERVICE_IMAGE_ATTRS:
+            raise NotImplementedError(_("Cannot use this without specifying "
+                                        "SERVICE_IMAGE_ATTRS for subclass"))
+        return cls.propertify_metadata(metadata, cls.SERVICE_IMAGE_ATTRS)
+
+    @staticmethod
+    def propertify_metadata(metadata, keys):
+        """Return a dict with any unrecognized keys placed in the nested
+        'properties' dict.
+        """
+        flattened = utils.flatten_dict(metadata)
+        attributes, properties = utils.partition_dict(flattened, keys)
+        attributes['properties'] = properties
+        return attributes
 
     def index(self, context):
         """
diff --git a/nova/tests/api/openstack/test_images.py b/nova/tests/api/openstack/test_images.py
index 4604b331e..03f22842b 100644
--- a/nova/tests/api/openstack/test_images.py
+++ b/nova/tests/api/openstack/test_images.py
@@ -185,11 +185,10 @@ class GlanceImageServiceTest(test.TestCase,
         super(GlanceImageServiceTest, self).tearDown()
 
     def test_create_with_instance_id(self):
-        """
-        Ensure that a instance_id is stored in Glance as a image property
-        string and then converted back to an instance_id integer attribute.
-        """
-        fixture = {'instance_id': 42, 'name': 'test image'}
+        """Ensure instance_id is persisted as an image-property"""
+        fixture = {'name': 'test image',
+                   'properties': {'instance_id': '42'}}
+
         image_id = self.service.create(self.context, fixture)['id']
 
         expected = {'id': image_id,
@@ -197,9 +196,6 @@ class GlanceImageServiceTest(test.TestCase,
                     'properties': {'instance_id': '42'}}
         self.assertDictMatch(self.sent_to_glance['metadata'], expected)
 
-        # The ImageService shouldn't leak the fact that the instance_id
-        # happens to be stored as a property in Glance
-        expected = {'id': image_id, 'instance_id': 42, 'name': 'test image'}
         image_meta = self.service.show(self.context, image_id)
         self.assertDictMatch(image_meta, expected)
 
diff --git a/nova/utils.py b/nova/utils.py
index 199ee8701..96a51b425 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -597,3 +597,39 @@ def get_from_path(items, path):
         return results
     else:
         return get_from_path(results, remainder)
+
+
+def flatten_dict(dict_, flattened=None):
+    """Recursively flatten a nested dictionary"""
+    flattened = flattened or {}
+    for key, value in dict_.iteritems():
+        if hasattr(value, 'iteritems'):
+            flatten_dict(value, flattened)
+        else:
+            flattened[key] = value
+    return flattened
+
+
+def partition_dict(dict_, keys):
+    """Return two dicts, one containing only `keys` the other containing
+    everything but `keys`
+    """
+    intersection = {}
+    difference = {}
+    for key, value in dict_.iteritems():
+        if key in keys:
+            intersection[key] = value
+        else:
+            difference[key] = value
+    return intersection, difference
+
+
+def map_dict_keys(dict_, key_map):
+    """Return a dictionary in which the dictionaries keys are mapped to 
+    new keys.
+    """
+    mapped = {}
+    for key, value in dict_.iteritems():
+        mapped_key = key_map[key] if key in key_map else key
+        mapped[mapped_key] = value
+    return mapped
-- 
cgit 


From d8176eda3f31973a8718b98f35e202ff61c48bbc Mon Sep 17 00:00:00 2001
From: Rick Harris <rick.harris@rackspace.com>
Date: Tue, 22 Mar 2011 20:34:00 +0000
Subject: Pep8 fix

---
 nova/utils.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/utils.py b/nova/utils.py
index f43ba2e7e..7b96a0daf 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -621,7 +621,7 @@ def partition_dict(dict_, keys):
 
 
 def map_dict_keys(dict_, key_map):
-    """Return a dictionary in which the dictionaries keys are mapped to 
+    """Return a dictionary in which the dictionaries keys are mapped to
     new keys.
     """
     mapped = {}
-- 
cgit 


From d06bce4b64b57551a722688a4038a4eaffa34278 Mon Sep 17 00:00:00 2001
From: Todd Willey <todd@ansolabs.com>
Date: Tue, 22 Mar 2011 16:34:02 -0400
Subject: typo fix.

---
 nova/api/ec2/admin.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/api/ec2/admin.py b/nova/api/ec2/admin.py
index d9a4ef999..f32d0804f 100644
--- a/nova/api/ec2/admin.py
+++ b/nova/api/ec2/admin.py
@@ -60,7 +60,7 @@ def project_dict(project):
 
 def host_dict(host, compute_service, instances, volume_service, volumes, now):
     """Convert a host model object to a result dict"""
-    rv = {'hostanme': host, 'instance_count': len(instances),
+    rv = {'hostname': host, 'instance_count': len(instances),
           'volume_count': len(volumes)}
     if compute_service:
         latest = compute_service['updated_at'] or compute_service['created_at']
-- 
cgit 


From 7d97f700811468303c21159454db64e84f71a2a0 Mon Sep 17 00:00:00 2001
From: Rick Harris <rick.harris@rackspace.com>
Date: Tue, 22 Mar 2011 23:49:24 +0000
Subject: Refactored out _safe_translate code

---
 nova/api/openstack/images.py | 44 +++++++++++++++++++++++---------------------
 nova/compute/api.py          | 10 ++++++----
 2 files changed, 29 insertions(+), 25 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/images.py b/nova/api/openstack/images.py
index 97e62c22d..2d2f67fe1 100644
--- a/nova/api/openstack/images.py
+++ b/nova/api/openstack/images.py
@@ -193,6 +193,21 @@ def _translate_from_image_service_to_api(image_metadata):
     return api_metadata
 
 
+def _safe_translate(image_metadata):
+    """Translate attributes for OpenStack API, temporary workaround for
+    S3ImageService attribute leakage.
+    """
+    # FIXME(sirp): The S3ImageService appears to be leaking implementation
+    # details, including its internal attribute names, and internal
+    # `status` values. Working around it for now.
+    s3_like_image = ('imageId' in image_metadata)
+    if s3_like_image:
+        translate = _translate_s3_like_images
+    else:
+        translate = _translate_from_image_service_to_api
+    return translate(image_metadata)
+
+
 class Controller(wsgi.Controller):
 
     _serialization_metadata = {
@@ -221,30 +236,18 @@ class Controller(wsgi.Controller):
                 req.environ['nova.context'])
 
         service_image_metas = common.limited(service_image_metas, req)
-
-        # FIXME(sirp): The S3ImageService appears to be leaking implementation
-        # details, including its internal attribute names, and internal
-        # `status` values. Working around it for now.
-        s3_like_image = (service_image_metas and
-                         ('imageId' in service_image_metas[0]))
-        if s3_like_image:
-            translate = _translate_s3_like_images
-        else:
-            translate = _translate_from_image_service_to_api
-
-        api_image_metas = [translate(service_image_meta)
+        api_image_metas = [_safe_translate(service_image_meta)
                            for service_image_meta in service_image_metas]
-
         return dict(images=api_image_metas)
 
     def show(self, req, id):
         """Return data about the given image id"""
         image_id = common.get_image_id_from_image_hash(self._service,
                     req.environ['nova.context'], id)
-
-        image = self._service.show(req.environ['nova.context'], image_id)
-        _convert_image_id_to_hash(image)
-        return dict(image=image)
+        service_image_meta = self._service.show(
+            req.environ['nova.context'], image_id)
+        api_image_meta = _safe_translate(service_image_meta)
+        return dict(image=api_image_meta)
 
     def delete(self, req, id):
         # Only public images are supported for now.
@@ -255,11 +258,10 @@ class Controller(wsgi.Controller):
         env = self._deserialize(req.body, req.get_content_type())
         instance_id = env["image"]["serverId"]
         name = env["image"]["name"]
-
-        image_meta = compute.API().snapshot(
+        service_image_meta = compute.API().snapshot(
             context, instance_id, name)
-
-        return dict(image=image_meta)
+        api_image_meta = _safe_translate(service_image_meta)
+        return dict(image=api_image_meta)
 
     def update(self, req, id):
         # Users may not modify public images, and that's all that
diff --git a/nova/compute/api.py b/nova/compute/api.py
index 2fda9551d..25a533416 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -441,12 +441,14 @@ class API(base.Base):
 
         :retval: A dict containing image metadata
         """
-        data = {'name': name, 'is_public': False, 'instance_id': instance_id}
-        image_meta = self.image_service.create(context, data)
-        params = {'image_id': image_meta['id']}
+        properties = {'instance_id': str(instance_id)}
+        sent_meta = {'name': name, 'is_public': False,
+                     'properties': properties}
+        recv_meta = self.image_service.create(context, sent_meta)
+        params = {'image_id': recv_meta['id']}
         self._cast_compute_message('snapshot_instance', context, instance_id,
                                    params=params)
-        return image_meta
+        return recv_meta
 
     def reboot(self, context, instance_id):
         """Reboot the given instance."""
-- 
cgit 


From 65e8e24b794203de5496182dd089f5512e7313b4 Mon Sep 17 00:00:00 2001
From: Rick Harris <rick.harris@rackspace.com>
Date: Tue, 22 Mar 2011 23:56:52 +0000
Subject: get_all cleanup

---
 nova/compute/api.py | 20 +++++++++++++-------
 1 file changed, 13 insertions(+), 7 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/api.py b/nova/compute/api.py
index 25a533416..3a83f1c6a 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -378,20 +378,26 @@ class API(base.Base):
                 fixed_ip=None):
         """Get all instances, possibly filtered by one of the
         given parameters. If there is no filter and the context is
-        an admin, it will retreive all instances in the system."""
+        an admin, it will retreive all instances in the system.
+        """
         if reservation_id is not None:
-            return self.db.instance_get_all_by_reservation(context,
-                                                             reservation_id)
+            return self.db.instance_get_all_by_reservation(
+                context, reservation_id)
+
         if fixed_ip is not None:
             return self.db.fixed_ip_get_instance(context, fixed_ip)
+
         if project_id or not context.is_admin:
             if not context.project:
-                return self.db.instance_get_all_by_user(context,
-                                                        context.user_id)
+                return self.db.instance_get_all_by_user(
+                    context, context.user_id)
+
             if project_id is None:
                 project_id = context.project_id
-            return self.db.instance_get_all_by_project(context,
-            project_id)
+
+            return self.db.instance_get_all_by_project(
+                context, project_id)
+
         return self.db.instance_get_all(context)
 
     def _cast_compute_message(self, method, context, instance_id, host=None,
-- 
cgit 


From 209da18033a49062bbcfaf7739db5959be87b142 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Tue, 22 Mar 2011 20:36:49 -0700
Subject: pep8 and fixed up zone-list

---
 nova/api/openstack/servers.py  |  2 --
 nova/api/openstack/zones.py    | 18 +++++++-----------
 nova/db/api.py                 |  4 ----
 nova/scheduler/api.py          | 24 ++++++++++++++++++++----
 nova/scheduler/zone_manager.py |  5 +++--
 nova/tests/test_scheduler.py   | 40 +++++++++++++++++++++++-----------------
 6 files changed, 53 insertions(+), 40 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 199d89c6d..db6a1de97 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -91,10 +91,8 @@ class Controller(wsgi.Controller):
     def show(self, req, id):
         """ Returns server details by server id """
         try:
-            LOG.debug(_("***SHOW"))
             instance = self.compute_api.routing_get(
                 req.environ['nova.context'], id)
-            LOG.debug(_("***SHOW OUT %s" % instance))
             builder = servers_views.get_view_builder(req)
             return builder.build(instance, is_detail=True)
         except exception.NotFound:
diff --git a/nova/api/openstack/zones.py b/nova/api/openstack/zones.py
index d129cf34f..6ce27e9a9 100644
--- a/nova/api/openstack/zones.py
+++ b/nova/api/openstack/zones.py
@@ -15,7 +15,6 @@
 
 import common
 
-from nova import db
 from nova import flags
 from nova import log as logging
 from nova import wsgi
@@ -39,7 +38,8 @@ def _exclude_keys(item, keys):
 
 
 def _scrub_zone(zone):
-    return _filter_keys(zone, ('id', 'api_url'))
+    return _exclude_keys(zone, ('username', 'password', 'created_at',
+                    'deleted', 'deleted_at', 'updated_at'))
 
 
 class Controller(wsgi.Controller):
@@ -54,12 +54,8 @@ class Controller(wsgi.Controller):
         # Ask the ZoneManager in the Scheduler for most recent data,
         # or fall-back to the database ...
         items = api.get_zone_list(req.environ['nova.context'])
-        if not items:
-            items = db.zone_get_all(req.environ['nova.context'])
-
         items = common.limited(items, req)
-        items = [_exclude_keys(item, ['username', 'password'])
-                      for item in items]
+        items = [_scrub_zone(item) for item in items]
         return dict(zones=items)
 
     def detail(self, req):
@@ -82,23 +78,23 @@ class Controller(wsgi.Controller):
     def show(self, req, id):
         """Return data about the given zone id"""
         zone_id = int(id)
-        zone = db.zone_get(req.environ['nova.context'], zone_id)
+        zone = api.zone_get(req.environ['nova.context'], zone_id)
         return dict(zone=_scrub_zone(zone))
 
     def delete(self, req, id):
         zone_id = int(id)
-        db.zone_delete(req.environ['nova.context'], zone_id)
+        api.zone_delete(req.environ['nova.context'], zone_id)
         return {}
 
     def create(self, req):
         context = req.environ['nova.context']
         env = self._deserialize(req.body, req.get_content_type())
-        zone = db.zone_create(context, env["zone"])
+        zone = api.zone_create(context, env["zone"])
         return dict(zone=_scrub_zone(zone))
 
     def update(self, req, id):
         context = req.environ['nova.context']
         env = self._deserialize(req.body, req.get_content_type())
         zone_id = int(id)
-        zone = db.zone_update(context, zone_id, env["zone"])
+        zone = api.zone_update(context, zone_id, env["zone"])
         return dict(zone=_scrub_zone(zone))
diff --git a/nova/db/api.py b/nova/db/api.py
index a4cdb2ae2..7aedaa772 100644
--- a/nova/db/api.py
+++ b/nova/db/api.py
@@ -34,7 +34,6 @@ The underlying driver is loaded as a :class:`LazyPluggable`.
 
 from nova import exception
 from nova import flags
-from nova import log as logging
 from nova import utils
 
 
@@ -53,9 +52,6 @@ IMPL = utils.LazyPluggable(FLAGS['db_backend'],
                            sqlalchemy='nova.db.sqlalchemy.api')
 
 
-LOG = logging.getLogger('server')
-
-
 class NoMoreAddresses(exception.Error):
     """No more available addresses."""
     pass
diff --git a/nova/scheduler/api.py b/nova/scheduler/api.py
index bd64f9b9b..c1417dfe4 100644
--- a/nova/scheduler/api.py
+++ b/nova/scheduler/api.py
@@ -55,9 +55,27 @@ def get_zone_list(context):
     items = _call_scheduler('get_zone_list', context)
     for item in items:
         item['api_url'] = item['api_url'].replace('\\/', '/')
+    if not items:
+        items = db.zone_get_all(context)
     return items
 
 
+def zone_get(context, zone_id):
+    return db.zone_get(context, zone_id)
+
+
+def zone_delete(context, zone_id):
+    return db.zone_delete(context, zone_id)
+
+
+def zone_create(context, data):
+    return db.zone_create(context, data)
+
+
+def zone_update(context, zone_id, data):
+    return db.zone_update(context, zone_id, data)
+
+
 def get_zone_capabilities(context, service=None):
     """Returns a dict of key, value capabilities for this zone,
        or for a particular class of services running in this zone."""
@@ -149,10 +167,8 @@ class reroute_compute(object):
 
     def __call__(self, f):
         def wrapped_f(*args, **kwargs):
-            LOG.debug(_("IN DECORATOR ..."))
             collection, context, item_id = \
                             self.get_collection_context_and_id(args, kwargs)
-            LOG.debug(_("IN DECORATOR 2..."))
             try:
                 # Call the original function ...
                 return f(*args, **kwargs)
@@ -181,7 +197,7 @@ class reroute_compute(object):
         """Ask the child zones to perform this operation.
         Broken out for testing."""
         return child_zone_helper(zones, function)
- 
+
     def get_collection_context_and_id(self, args, kwargs):
         """Returns a tuple of (novaclient collection name, security
            context and resource id. Derived class should override this."""
@@ -212,7 +228,7 @@ class reroute_compute(object):
                     del server[k]
 
             reduced_response.append(dict(server=server))
-        if reduced_response: 
+        if reduced_response:
             return reduced_response[0]  # first for now.
         return {}
 
diff --git a/nova/scheduler/zone_manager.py b/nova/scheduler/zone_manager.py
index d32cc2e8f..198f9d4cc 100644
--- a/nova/scheduler/zone_manager.py
+++ b/nova/scheduler/zone_manager.py
@@ -58,8 +58,9 @@ class ZoneState(object):
            child zone."""
         self.last_seen = datetime.now()
         self.attempt = 0
-        self.name = zone_metadata["name"]
-        self.capabilities = zone_metadata["capabilities"]
+        self.name = zone_metadata.get("name", "n/a")
+        self.capabilities = ", ".join(["%s=%s" % (k, v)
+                        for k, v in zone_metadata.iteritems() if k != 'name'])
         self.is_active = True
 
     def to_dict(self):
diff --git a/nova/tests/test_scheduler.py b/nova/tests/test_scheduler.py
index 277ffe367..6df74dd61 100644
--- a/nova/tests/test_scheduler.py
+++ b/nova/tests/test_scheduler.py
@@ -949,6 +949,7 @@ class FakeZone(object):
         self.username = username
         self.password = password
 
+
 def zone_get_all(context):
     return [
                 FakeZone('http://example.com', 'bob', 'xxx'),
@@ -957,8 +958,8 @@ def zone_get_all(context):
 
 class FakeRerouteCompute(api.reroute_compute):
     def _call_child_zones(self, zones, function):
-        return [ ]
- 
+        return []
+
     def get_collection_context_and_id(self, args, kwargs):
         return ("servers", None, 1)
 
@@ -982,6 +983,7 @@ class FakeResource(object):
     def pause(self):
         pass
 
+
 class ZoneRedirectTest(test.TestCase):
     def setUp(self):
         super(ZoneRedirectTest, self).setUp()
@@ -1024,27 +1026,28 @@ class ZoneRedirectTest(test.TestCase):
     def test_get_collection_context_and_id(self):
         decorator = api.reroute_compute("foo")
         self.assertEquals(decorator.get_collection_context_and_id(
-            (None, 10, 20), {}), ("servers", 10, 20))       
+            (None, 10, 20), {}), ("servers", 10, 20))
         self.assertEquals(decorator.get_collection_context_and_id(
-            (None, 11,),  dict(instance_id=21)), ("servers", 11, 21))       
+            (None, 11,),  dict(instance_id=21)), ("servers", 11, 21))
         self.assertEquals(decorator.get_collection_context_and_id(
             (None,), dict(context=12, instance_id=22)), ("servers", 12, 22))
 
     def test_unmarshal_single_server(self):
         decorator = api.reroute_compute("foo")
-        self.assertEquals(decorator.unmarshall_result([]), {}) 
+        self.assertEquals(decorator.unmarshall_result([]), {})
         self.assertEquals(decorator.unmarshall_result(
-                [FakeResource(dict(a=1, b=2)),]), 
-                dict(server=dict(a=1, b=2))) 
+                [FakeResource(dict(a=1, b=2)), ]),
+                dict(server=dict(a=1, b=2)))
         self.assertEquals(decorator.unmarshall_result(
-                [FakeResource(dict(a=1, _b=2)),]), 
-                dict(server=dict(a=1,))) 
+                [FakeResource(dict(a=1, _b=2)), ]),
+                dict(server=dict(a=1,)))
         self.assertEquals(decorator.unmarshall_result(
-                [FakeResource(dict(a=1, manager=2)),]), 
-                dict(server=dict(a=1,)))                
+                [FakeResource(dict(a=1, manager=2)), ]),
+                dict(server=dict(a=1,)))
         self.assertEquals(decorator.unmarshall_result(
-                [FakeResource(dict(_a=1, manager=2)),]), 
-                dict(server={}))                
+                [FakeResource(dict(_a=1, manager=2)), ]),
+                dict(server={}))
+
 
 class FakeServerCollection(object):
     def get(self, instance_id):
@@ -1053,6 +1056,7 @@ class FakeServerCollection(object):
     def find(self, name):
         return FakeResource(dict(a=11, b=22))
 
+
 class FakeEmptyServerCollection(object):
     def get(self, f):
         raise novaclient.NotFound(1)
@@ -1060,10 +1064,12 @@ class FakeEmptyServerCollection(object):
     def find(self, name):
         raise novaclient.NotFound(2)
 
+
 class FakeNovaClient(object):
     def __init__(self, collection):
         self.servers = collection
 
+
 class DynamicNovaClientTest(test.TestCase):
     def test_issue_novaclient_command_found(self):
         zone = FakeZone('http://example.com', 'bob', 'xxx')
@@ -1078,17 +1084,17 @@ class DynamicNovaClientTest(test.TestCase):
         self.assertEquals(api._issue_novaclient_command(
                     FakeNovaClient(FakeServerCollection()),
                     zone, "servers", "pause", 100), None)
-   
+
     def test_issue_novaclient_command_not_found(self):
         zone = FakeZone('http://example.com', 'bob', 'xxx')
         self.assertEquals(api._issue_novaclient_command(
                     FakeNovaClient(FakeEmptyServerCollection()),
-                    zone, "servers", "get", 100), None)                   
+                    zone, "servers", "get", 100), None)
 
         self.assertEquals(api._issue_novaclient_command(
                     FakeNovaClient(FakeEmptyServerCollection()),
-                    zone, "servers", "find", "name"), None)                   
+                    zone, "servers", "find", "name"), None)
 
         self.assertEquals(api._issue_novaclient_command(
                     FakeNovaClient(FakeEmptyServerCollection()),
-                    zone, "servers", "any", "name"), None)                   
+                    zone, "servers", "any", "name"), None)
-- 
cgit 


From 0dc2140d645d94d585fa8e3e5d189cd776574d28 Mon Sep 17 00:00:00 2001
From: Koji Iida <iida.koji@lab.ntt.co.jp>
Date: Wed, 23 Mar 2011 13:14:54 +0900
Subject: Fix to avoid db migration failure in virtualenv

---
 nova/db/sqlalchemy/migrate_repo/versions/012_add_ipv6_flatmanager.py | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/migrate_repo/versions/012_add_ipv6_flatmanager.py b/nova/db/sqlalchemy/migrate_repo/versions/012_add_ipv6_flatmanager.py
index 8c9cf3377..e87085668 100644
--- a/nova/db/sqlalchemy/migrate_repo/versions/012_add_ipv6_flatmanager.py
+++ b/nova/db/sqlalchemy/migrate_repo/versions/012_add_ipv6_flatmanager.py
@@ -26,6 +26,9 @@ meta = MetaData()
 # Just for the ForeignKey and column creation to succeed, these are not the
 # actual definitions of instances or services.
 #
+instances = Table('instances', meta,
+        Column('id', Integer(),  primary_key=True, nullable=False),
+        )
 
 #
 # Tables to alter
-- 
cgit 


From 3796b5a8fc2baa9a35ebbc721735f22e952e6aa3 Mon Sep 17 00:00:00 2001
From: Todd Willey <todd@ansolabs.com>
Date: Wed, 23 Mar 2011 00:31:50 -0400
Subject: Fix some crypto strangeness (\n in file_name field of certificates,
 wrong IMPL method for certificate_update).

---
 nova/crypto.py | 3 ++-
 nova/db/api.py | 2 +-
 2 files changed, 3 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/crypto.py b/nova/crypto.py
index 2a8d4abca..b112e5b92 100644
--- a/nova/crypto.py
+++ b/nova/crypto.py
@@ -26,6 +26,7 @@ import gettext
 import hashlib
 import os
 import shutil
+import string
 import struct
 import tempfile
 import time
@@ -267,7 +268,7 @@ def _sign_csr(csr_text, ca_folder):
                   './openssl.cnf', '-infiles', inbound)
     out, _err = utils.execute('openssl', 'x509', '-in', outbound,
                               '-serial', '-noout')
-    serial = out.rpartition("=")[2]
+    serial = string.strip(out.rpartition("=")[2])
     os.chdir(start)
     with open(outbound, "r") as crtfile:
         return (serial, crtfile.read())
diff --git a/nova/db/api.py b/nova/db/api.py
index add5bd83e..afc1bff2f 100644
--- a/nova/db/api.py
+++ b/nova/db/api.py
@@ -214,7 +214,7 @@ def certificate_update(context, certificate_id, values):
     Raises NotFound if service does not exist.
 
     """
-    return IMPL.service_update(context, certificate_id, values)
+    return IMPL.certificate_update(context, certificate_id, values)
 
 
 ###################
-- 
cgit 


From 365b98f4d52740ef85f8a8f098a32e441d7ac168 Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Tue, 22 Mar 2011 21:42:17 -0700
Subject: Renamed check_instance -> check_isinstance to make intent clearer

---
 nova/utils.py           | 2 +-
 nova/virt/connection.py | 2 +-
 nova/virt/fake.py       | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/utils.py b/nova/utils.py
index e93f489be..2e653bda0 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -587,7 +587,7 @@ def get_from_path(items, path):
         return get_from_path(results, remainder)
 
 
-def check_instance(obj, cls):
+def check_isinstance(obj, cls):
     """Checks that obj is of type cls, and lets PyLint infer types"""
     if isinstance(obj, cls):
         return obj
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 c8e8b44ef27e49b3986659ee0cb6bd77b38430d8 Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Tue, 22 Mar 2011 22:01:39 -0700
Subject: Forgot this in the rename of check_instance -> check_isinstance

---
 nova/compute/manager.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 019bb3c89..b21f0b836 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -117,7 +117,7 @@ class ComputeManager(manager.Manager):
         #             and redocument the module docstring
         if not compute_driver:
             compute_driver = FLAGS.compute_driver
-        self.driver = utils.check_instance(utils.import_object(
+        self.driver = utils.check_isinstance(utils.import_object(
                                                             compute_driver),
                                            driver.ComputeDriver)
         self.network_manager = utils.import_object(FLAGS.network_manager)
-- 
cgit 


From 19da125805eedbfcfd202abac4a90c57e6c538c4 Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Tue, 22 Mar 2011 22:38:37 -0700
Subject: Filled out the base-driver contract, so it's not a false-promise

---
 nova/compute/driver.py  |  38 --------
 nova/compute/manager.py |   3 +-
 nova/virt/driver.py     | 228 ++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 230 insertions(+), 39 deletions(-)
 delete mode 100644 nova/compute/driver.py
 create mode 100644 nova/virt/driver.py

(limited to 'nova')

diff --git a/nova/compute/driver.py b/nova/compute/driver.py
deleted file mode 100644
index bda82c60a..000000000
--- a/nova/compute/driver.py
+++ /dev/null
@@ -1,38 +0,0 @@
-# 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):
-    def list_instances_detail(self):
-        """Return a list of InstanceInfo for all registered VMs"""
-        raise NotImplementedError()
diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index b21f0b836..f37651ea6 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -52,7 +52,7 @@ from nova import manager
 from nova import rpc
 from nova import utils
 from nova.compute import power_state
-from nova.compute import driver
+from nova.virt import driver
 
 FLAGS = flags.FLAGS
 flags.DEFINE_string('instances_path', '$state_path/instances',
@@ -441,6 +441,7 @@ class ComputeManager(manager.Manager):
 
         #TODO(mdietz): we may want to split these into separate methods.
         if migration_ref['source_compute'] == FLAGS.host:
+            #NOTE(justinsb): Naughty calling of internal method
             self.driver._start(instance_ref)
             self.db.migration_update(context, migration_id,
                     {'status': 'reverted'})
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 a0432e417a13fd9579c40bdd54f0201b06470f45 Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Tue, 22 Mar 2011 22:42:12 -0700
Subject: Added note about the advantages of using a type vs using a set of
 global constants

---
 nova/compute/power_state.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/compute/power_state.py b/nova/compute/power_state.py
index 145362f97..d304285b2 100644
--- a/nova/compute/power_state.py
+++ b/nova/compute/power_state.py
@@ -31,7 +31,9 @@ CRASHED = 0x06
 SUSPENDED = 0x07
 FAILED = 0x08
 
-#TODO(justinsb): Power state really needs to be a proper class...
+#TODO(justinsb): Power state really needs to be a proper class,
+# so that we're not locked into the libvirt status codes and can put mapping
+# logic here rather than spread throughout the code
 _STATE_MAP = {
         NOSTATE: 'pending',
         RUNNING: 'running',
-- 
cgit 


From a4d78e44d7ca35a6cca4454667cab743409fd95a Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Tue, 22 Mar 2011 22:45:15 -0700
Subject: Added space in between # and TODO in #TODO

---
 nova/compute/manager.py     | 2 +-
 nova/compute/power_state.py | 2 +-
 nova/utils.py               | 2 +-
 nova/virt/hyperv.py         | 2 +-
 nova/virt/xenapi/vmops.py   | 4 ++--
 5 files changed, 6 insertions(+), 6 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index f37651ea6..cfd2b0ac4 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -1032,6 +1032,6 @@ class ComputeManager(manager.Manager):
         # Are there VMs not in the DB?
         for vm_not_found_in_db in vms_not_found_in_db:
             name = vm_not_found_in_db
-            #TODO(justinsb): What to do here?  Adopt it?  Shut it down?
+            # TODO(justinsb): What to do here?  Adopt it?  Shut it down?
             LOG.warning(_("Found VM not in DB: '%(name)s'.  Ignoring")
                         % locals())
diff --git a/nova/compute/power_state.py b/nova/compute/power_state.py
index d304285b2..ed50e492e 100644
--- a/nova/compute/power_state.py
+++ b/nova/compute/power_state.py
@@ -31,7 +31,7 @@ CRASHED = 0x06
 SUSPENDED = 0x07
 FAILED = 0x08
 
-#TODO(justinsb): Power state really needs to be a proper class,
+# TODO(justinsb): Power state really needs to be a proper class,
 # so that we're not locked into the libvirt status codes and can put mapping
 # logic here rather than spread throughout the code
 _STATE_MAP = {
diff --git a/nova/utils.py b/nova/utils.py
index 2e653bda0..36b384f4f 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -592,5 +592,5 @@ def check_isinstance(obj, cls):
     if isinstance(obj, cls):
         return obj
     raise Exception(_("Expected object of type: %s") % (str(cls)))
-    #TODO(justinsb): Can we make this better??
+    # TODO(justinsb): Can we make this better??
     return cls()  # Ugly PyLint hack
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 <justin@fathomdb.com>
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')

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 <justin@fathomdb.com>
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')

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 a7c9ad393f72b49515a445504a5bc87f8a26932c Mon Sep 17 00:00:00 2001
From: Rick Harris <rick.harris@rackspace.com>
Date: Wed, 23 Mar 2011 05:50:53 +0000
Subject: Filtering images by user_id now

---
 nova/compute/api.py                     |  3 +-
 nova/image/glance.py                    | 46 +++++++++++++++--
 nova/image/local.py                     |  9 +++-
 nova/tests/api/openstack/test_images.py | 91 ++++++++++++++++-----------------
 nova/utils.py                           |  6 +++
 5 files changed, 101 insertions(+), 54 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/api.py b/nova/compute/api.py
index 3a83f1c6a..0d51be336 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -447,7 +447,8 @@ class API(base.Base):
 
         :retval: A dict containing image metadata
         """
-        properties = {'instance_id': str(instance_id)}
+        properties = {'instance_id': str(instance_id),
+                      'user_id': str(context.user_id)}
         sent_meta = {'name': name, 'is_public': False,
                      'properties': properties}
         recv_meta = self.image_service.create(context, sent_meta)
diff --git a/nova/image/glance.py b/nova/image/glance.py
index b7bb88002..ec6e9e094 100644
--- a/nova/image/glance.py
+++ b/nova/image/glance.py
@@ -52,15 +52,28 @@ class GlanceImageService(service.BaseImageService):
         """
         Calls out to Glance for a list of images available
         """
-        return self.client.get_images()
+        # NOTE(sirp): We need to use get_images_detailed and not get_images
+        # here because we need `is_public` and properties included so we can
+        # filter by user
+        filtered = []
+        image_metas = self.client.get_images_detailed()
+        for image_meta in image_metas:
+            if self._is_image_available(context, image_meta):
+                meta = utils.subset_dict(image_meta, ('id', 'name'))
+                filtered.append(meta)
+        return filtered
 
     def detail(self, context):
         """
         Calls out to Glance for a list of detailed image information
         """
+        filtered = []
         image_metas = self.client.get_images_detailed()
-        translate = self._translate_to_base
-        return [translate(image_meta) for image_meta in image_metas]
+        for image_meta in image_metas:
+            if self._is_image_available(context, image_meta):
+                meta = self._translate_to_base(image_meta)
+                filtered.append(meta)
+        return filtered
 
     def show(self, context, image_id):
         """
@@ -145,3 +158,30 @@ class GlanceImageService(service.BaseImageService):
         Clears out all images
         """
         pass
+
+    @staticmethod
+    def _is_image_available(context, image_meta):
+        """
+        Images are always available if they are public or if the user is an
+        admin.
+
+        Otherwise, we filter by project_id (if present) and then fall-back to
+        images owned by user.
+        """
+        # FIXME(sirp): We should be filtering by user_id on the Glance side
+        # for security; however, we can't do that until we get authn/authz
+        # sorted out. Until then, filtering in Nova.
+        if image_meta['is_public'] or context.is_admin:
+            return True
+
+        properties = image_meta['properties']
+
+        if context.project_id and ('project_id' in properties):
+            return str(properties['project_id']) == str(project_id)
+
+        try:
+            user_id = properties['user_id']
+        except KeyError:
+            return False
+
+        return (str(user_id) == str(context.user_id))
diff --git a/nova/image/local.py b/nova/image/local.py
index 609d6c42a..1fb6e1f13 100644
--- a/nova/image/local.py
+++ b/nova/image/local.py
@@ -24,6 +24,7 @@ from nova import exception
 from nova import flags
 from nova import log as logging
 from nova.image import service
+from nova import utils
 
 
 FLAGS = flags.FLAGS
@@ -63,8 +64,12 @@ class LocalImageService(service.BaseImageService):
         return images
 
     def index(self, context):
-        return [dict(image_id=i['id'], name=i.get('name'))
-                for i in self.detail(context)]
+        filtered = []
+        image_metas = self.detail(context)
+        for image_meta in image_metas:
+            meta = utils.subset_dict(image_meta, ('id', 'name'))
+            filtered.append(meta)
+        return filtered
 
     def detail(self, context):
         images = []
diff --git a/nova/tests/api/openstack/test_images.py b/nova/tests/api/openstack/test_images.py
index 57a9819e8..797bbef8f 100644
--- a/nova/tests/api/openstack/test_images.py
+++ b/nova/tests/api/openstack/test_images.py
@@ -44,18 +44,10 @@ FLAGS = flags.FLAGS
 
 
 class BaseImageServiceTests(object):
-
     """Tasks to test for all image services"""
 
     def test_create(self):
-
-        fixture = {'name': 'test image',
-                   'updated': None,
-                   'created': None,
-                   'status': None,
-                   'instance_id': None,
-                   'progress': None}
-
+        fixture = self._make_fixture('test image')
         num_images = len(self.service.index(self.context))
 
         id = self.service.create(self.context, fixture)['id']
@@ -65,14 +57,7 @@ class BaseImageServiceTests(object):
                           len(self.service.index(self.context)))
 
     def test_create_and_show_non_existing_image(self):
-
-        fixture = {'name': 'test image',
-                   'updated': None,
-                   'created': None,
-                   'status': None,
-                   'instance_id': None,
-                   'progress': None}
-
+        fixture = self._make_fixture('test image')
         num_images = len(self.service.index(self.context))
 
         id = self.service.create(self.context, fixture)['id']
@@ -85,14 +70,7 @@ class BaseImageServiceTests(object):
                           'bad image id')
 
     def test_update(self):
-
-        fixture = {'name': 'test image',
-                   'updated': None,
-                   'created': None,
-                   'status': None,
-                   'instance_id': None,
-                   'progress': None}
-
+        fixture = self._make_fixture('test image')
         id = self.service.create(self.context, fixture)['id']
 
         fixture['status'] = 'in progress'
@@ -102,20 +80,9 @@ class BaseImageServiceTests(object):
         self.assertEquals('in progress', new_image_data['status'])
 
     def test_delete(self):
-
-        fixtures = [
-                    {'name': 'test image 1',
-                     'updated': None,
-                     'created': None,
-                     'status': None,
-                     'instance_id': None,
-                     'progress': None},
-                    {'name': 'test image 2',
-                     'updated': None,
-                     'created': None,
-                     'status': None,
-                     'instance_id': None,
-                     'progress': None}]
+        fixture1 = self._make_fixture('test image 1')
+        fixture2 = self._make_fixture('test image 2')
+        fixtures = [fixture1, fixture2]
 
         num_images = len(self.service.index(self.context))
         self.assertEquals(0, num_images, str(self.service.index(self.context)))
@@ -133,6 +100,24 @@ class BaseImageServiceTests(object):
         num_images = len(self.service.index(self.context))
         self.assertEquals(1, num_images)
 
+    def test_index(self):
+        fixture = self._make_fixture('test image')
+        image_id = self.service.create(self.context, fixture)['id']
+        image_metas = self.service.index(self.context)
+        expected = [{'id': 'DONTCARE', 'name': 'test image'}]
+        self.assertDictListMatch(image_metas, expected)
+
+    @staticmethod
+    def _make_fixture(name):
+        fixture = {'name': 'test image',
+                   'updated': None,
+                   'created': None,
+                   'status': None,
+                   'is_public': True,
+                   'instance_id': None,
+                   'progress': None}
+        return fixture
+
 
 class LocalImageServiceTest(test.TestCase,
                             BaseImageServiceTests):
@@ -187,7 +172,7 @@ class GlanceImageServiceTest(test.TestCase,
         fakes.stub_out_compute_api_snapshot(self.stubs)
         service_class = 'nova.image.glance.GlanceImageService'
         self.service = utils.import_object(service_class)
-        self.context = context.RequestContext(None, None)
+        self.context = context.RequestContext(1, None)
         self.service.delete_all()
         self.sent_to_glance = {}
         fakes.stub_out_glance_add_image(self.stubs, self.sent_to_glance)
@@ -199,13 +184,15 @@ class GlanceImageServiceTest(test.TestCase,
     def test_create_with_instance_id(self):
         """Ensure instance_id is persisted as an image-property"""
         fixture = {'name': 'test image',
-                   'properties': {'instance_id': '42'}}
+                   'is_public': False,
+                   'properties': {'instance_id': '42', 'user_id': '1'}}
 
         image_id = self.service.create(self.context, fixture)['id']
 
         expected = {'id': image_id,
                     'name': 'test image',
-                    'properties': {'instance_id': '42'}}
+                    'is_public': False,
+                    'properties': {'instance_id': '42', 'user_id': '1'}}
         self.assertDictMatch(self.sent_to_glance['metadata'], expected)
 
         image_meta = self.service.show(self.context, image_id)
@@ -301,38 +288,46 @@ class ImageControllerWithGlanceServiceTest(test.TestCase):
         public_image = {'id': 123,
                         'name': 'public image',
                         'is_public': True,
-                        'status': 'active'}
+                        'status': 'active',
+                        'properties': {}}
         fixtures.append(public_image)
 
         queued_backup = {'id': 124,
                          'name': 'queued backup',
                          'is_public': False,
                          'status': 'queued',
-                         'instance_id': 42}
+                         'properties': {'instance_id': 42, 'user_id': 1}}
         fixtures.append(queued_backup)
 
         saving_backup = {'id': 125,
                          'name': 'saving backup',
                          'is_public': False,
                          'status': 'saving',
-                         'instance_id': 42,
-                         'progress': 0}
+                         'properties': {'instance_id': 42, 'user_id': 1}}
         fixtures.append(saving_backup)
 
         active_backup = {'id': 126,
                          'name': 'active backup',
                          'is_public': False,
                          'status': 'active',
-                         'instance_id': 42}
+                         'properties': {'instance_id': 42, 'user_id': 1}}
         fixtures.append(active_backup)
 
         killed_backup = {'id': 127,
                          'name': 'killed backup',
                          'is_public': False,
                          'status': 'killed',
-                         'instance_id': 42}
+                         'properties': {'instance_id': 42, 'user_id': 1}}
         fixtures.append(killed_backup)
 
+        someone_elses_backup = {'id': 127,
+                                'name': 'somone elses backup',
+                                'is_public': False,
+                                'status': 'active',
+                                'properties': {'instance_id': 43, 
+                                               'user_id': 2}}
+        fixtures.append(someone_elses_backup)
+
         base_attrs = {'created_at': cls.NOW_SERVICE_STR,
                       'updated_at': cls.NOW_SERVICE_STR,
                       'deleted_at': None,
diff --git a/nova/utils.py b/nova/utils.py
index 7b96a0daf..d114cb14f 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -629,3 +629,9 @@ def map_dict_keys(dict_, key_map):
         mapped_key = key_map[key] if key in key_map else key
         mapped[mapped_key] = value
     return mapped
+
+
+def subset_dict(dict_, keys):
+    """Return a dict that only contains a subset of keys"""
+    subset = partition_dict(dict_, keys)[0]
+    return subset
-- 
cgit 


From 846b09925da07c2858052143d5fff4766a782cf1 Mon Sep 17 00:00:00 2001
From: Anthony Young <sleepsonthefloor@gmail.com>
Date: Tue, 22 Mar 2011 22:54:34 -0700
Subject: Fix for lp740742 - format describe_instance_output correctly to
 prevent errors in dashboard

---
 nova/api/ec2/admin.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/api/ec2/admin.py b/nova/api/ec2/admin.py
index 037184b40..d8d90ad83 100644
--- a/nova/api/ec2/admin.py
+++ b/nova/api/ec2/admin.py
@@ -120,7 +120,8 @@ class AdminController(object):
 
     def describe_instance_types(self, context, **_kwargs):
         """Returns all active instance types data (vcpus, memory, etc.)"""
-        return {'instanceTypeSet': [db.instance_type_get_all(context)]}
+        return {'instanceTypeSet': [instance_dict(v) for v in
+                                   db.instance_type_get_all(context).values()]}
 
     def describe_user(self, _context, name, **_kwargs):
         """Returns user data, including access and secret keys."""
-- 
cgit 


From b69a63c5d7458610b6e8931b4955c0b5b2b468f5 Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
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')

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 ac475d05e6807804a74bca665563c7260523a733 Mon Sep 17 00:00:00 2001
From: Rick Harris <rick.harris@rackspace.com>
Date: Wed, 23 Mar 2011 06:00:04 +0000
Subject: Small cleanup of openstack/images.py

---
 nova/api/openstack/images.py | 38 +++++++++++++++++---------------------
 1 file changed, 17 insertions(+), 21 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/images.py b/nova/api/openstack/images.py
index 2d2f67fe1..d914f5196 100644
--- a/nova/api/openstack/images.py
+++ b/nova/api/openstack/images.py
@@ -221,32 +221,28 @@ class Controller(wsgi.Controller):
 
     def index(self, req):
         """Return all public images in brief"""
-        items = self._service.index(req.environ['nova.context'])
-        items = common.limited(items, req)
-        items = [_filter_keys(item, ('id', 'name')) for item in items]
-        return dict(images=items)
+        context = req.environ['nova.context']
+        image_metas = self._service.index(context)
+        image_metas = common.limited(image_metas, req)
+        return dict(images=image_metas)
 
     def detail(self, req):
         """Return all public images in detail"""
-        try:
-            service_image_metas = self._service.detail(
-                req.environ['nova.context'])
-        except NotImplementedError:
-            service_image_metas = self._service.index(
-                req.environ['nova.context'])
-
-        service_image_metas = common.limited(service_image_metas, req)
-        api_image_metas = [_safe_translate(service_image_meta)
-                           for service_image_meta in service_image_metas]
+        context = req.environ['nova.context']
+        image_metas = self._service.detail(context)
+        image_metas = common.limited(image_metas, req)
+        api_image_metas = [_safe_translate(image_meta)
+                           for image_meta in image_metas]
         return dict(images=api_image_metas)
 
     def show(self, req, id):
         """Return data about the given image id"""
-        image_id = common.get_image_id_from_image_hash(self._service,
-                    req.environ['nova.context'], id)
-        service_image_meta = self._service.show(
-            req.environ['nova.context'], image_id)
-        api_image_meta = _safe_translate(service_image_meta)
+        context = req.environ['nova.context']
+        image_id = common.get_image_id_from_image_hash(
+            self._service, req.environ['nova.context'], id)
+
+        image_meta = self._service.show(context, image_id)
+        api_image_meta = _safe_translate(image_meta)
         return dict(image=api_image_meta)
 
     def delete(self, req, id):
@@ -258,9 +254,9 @@ class Controller(wsgi.Controller):
         env = self._deserialize(req.body, req.get_content_type())
         instance_id = env["image"]["serverId"]
         name = env["image"]["name"]
-        service_image_meta = compute.API().snapshot(
+        image_meta = compute.API().snapshot(
             context, instance_id, name)
-        api_image_meta = _safe_translate(service_image_meta)
+        api_image_meta = _safe_translate(image_meta)
         return dict(image=api_image_meta)
 
     def update(self, req, id):
-- 
cgit 


From 1f02ec1df57acfd06b2c241d1d9c18b936509b3c Mon Sep 17 00:00:00 2001
From: Rick Harris <rick.harris@rackspace.com>
Date: Wed, 23 Mar 2011 06:20:24 +0000
Subject: Cleaning up make_image_fixutres

---
 nova/tests/api/openstack/test_images.py | 72 +++++++++++----------------------
 1 file changed, 24 insertions(+), 48 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/test_images.py b/nova/tests/api/openstack/test_images.py
index 797bbef8f..2c0c75104 100644
--- a/nova/tests/api/openstack/test_images.py
+++ b/nova/tests/api/openstack/test_images.py
@@ -282,58 +282,34 @@ class ImageControllerWithGlanceServiceTest(test.TestCase):
 
     @classmethod
     def _make_image_fixtures(cls):
-        """
-        """
-        fixtures = []
-        public_image = {'id': 123,
-                        'name': 'public image',
-                        'is_public': True,
-                        'status': 'active',
-                        'properties': {}}
-        fixtures.append(public_image)
-
-        queued_backup = {'id': 124,
-                         'name': 'queued backup',
-                         'is_public': False,
-                         'status': 'queued',
-                         'properties': {'instance_id': 42, 'user_id': 1}}
-        fixtures.append(queued_backup)
-
-        saving_backup = {'id': 125,
-                         'name': 'saving backup',
-                         'is_public': False,
-                         'status': 'saving',
-                         'properties': {'instance_id': 42, 'user_id': 1}}
-        fixtures.append(saving_backup)
-
-        active_backup = {'id': 126,
-                         'name': 'active backup',
-                         'is_public': False,
-                         'status': 'active',
-                         'properties': {'instance_id': 42, 'user_id': 1}}
-        fixtures.append(active_backup)
-
-        killed_backup = {'id': 127,
-                         'name': 'killed backup',
-                         'is_public': False,
-                         'status': 'killed',
-                         'properties': {'instance_id': 42, 'user_id': 1}}
-        fixtures.append(killed_backup)
-
-        someone_elses_backup = {'id': 127,
-                                'name': 'somone elses backup',
-                                'is_public': False,
-                                'status': 'active',
-                                'properties': {'instance_id': 43, 
-                                               'user_id': 2}}
-        fixtures.append(someone_elses_backup)
-
+        image_id = 123
         base_attrs = {'created_at': cls.NOW_SERVICE_STR,
                       'updated_at': cls.NOW_SERVICE_STR,
                       'deleted_at': None,
                       'deleted': False}
 
-        for fixture in fixtures:
-            fixture.update(base_attrs)
+        fixtures = []
+        def add_fixture(**kwargs):
+            kwargs.update(base_attrs)
+            fixtures.append(kwargs)
+
+        # Public image
+        add_fixture(id=image_id, name='public image', is_public=True,
+                    status='active', properties={})
+        image_id += 1
+
+        # Backup for User 1
+        backup_properties = {'instance_id': '42', 'user_id': '1'}
+        for status in ('queued', 'saving', 'active', 'killed'):
+            add_fixture(id=image_id, name='%s backup' % status,
+                        is_public=False, status=status,
+                        properties=backup_properties)
+            image_id += 1
+
+        # Backup for User 2
+        other_backup_properties = {'instance_id': '43', 'user_id': '2'}
+        add_fixture(id=image_id, name='someone elses backup', is_public=False,
+                    status='active', properties=other_backup_properties)
+        image_id += 1
 
         return fixtures
-- 
cgit 


From dfa1e6eec0da81d5eedd303ef32442dc5c2a09d7 Mon Sep 17 00:00:00 2001
From: Rick Harris <rick.harris@rackspace.com>
Date: Wed, 23 Mar 2011 06:26:36 +0000
Subject: More small cleanups

---
 nova/tests/api/openstack/test_images.py | 21 +++++++++------------
 1 file changed, 9 insertions(+), 12 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/test_images.py b/nova/tests/api/openstack/test_images.py
index 2c0c75104..785e104dc 100644
--- a/nova/tests/api/openstack/test_images.py
+++ b/nova/tests/api/openstack/test_images.py
@@ -50,9 +50,9 @@ class BaseImageServiceTests(object):
         fixture = self._make_fixture('test image')
         num_images = len(self.service.index(self.context))
 
-        id = self.service.create(self.context, fixture)['id']
+        image_id = self.service.create(self.context, fixture)['id']
 
-        self.assertNotEquals(None, id)
+        self.assertNotEquals(None, image_id)
         self.assertEquals(num_images + 1,
                           len(self.service.index(self.context)))
 
@@ -60,10 +60,9 @@ class BaseImageServiceTests(object):
         fixture = self._make_fixture('test image')
         num_images = len(self.service.index(self.context))
 
-        id = self.service.create(self.context, fixture)['id']
-
-        self.assertNotEquals(None, id)
+        image_id = self.service.create(self.context, fixture)['id']
 
+        self.assertNotEquals(None, image_id)
         self.assertRaises(exception.NotFound,
                           self.service.show,
                           self.context,
@@ -71,12 +70,12 @@ class BaseImageServiceTests(object):
 
     def test_update(self):
         fixture = self._make_fixture('test image')
-        id = self.service.create(self.context, fixture)['id']
-
+        image_id = self.service.create(self.context, fixture)['id']
         fixture['status'] = 'in progress'
 
-        self.service.update(self.context, id, fixture)
-        new_image_data = self.service.show(self.context, id)
+        self.service.update(self.context, image_id, fixture)
+
+        new_image_data = self.service.show(self.context, image_id)
         self.assertEquals('in progress', new_image_data['status'])
 
     def test_delete(self):
@@ -113,9 +112,7 @@ class BaseImageServiceTests(object):
                    'updated': None,
                    'created': None,
                    'status': None,
-                   'is_public': True,
-                   'instance_id': None,
-                   'progress': None}
+                   'is_public': True}
         return fixture
 
 
-- 
cgit 


From 32e1c38ef9539be6f914adc69f30e409b159a9e6 Mon Sep 17 00:00:00 2001
From: Rick Harris <rick.harris@rackspace.com>
Date: Wed, 23 Mar 2011 06:55:28 +0000
Subject: Adding tests for owned and non-existent images

---
 nova/api/openstack/images.py            |  8 ++++++--
 nova/tests/api/openstack/test_images.py | 22 ++++++++++++++++++++++
 2 files changed, 28 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/images.py b/nova/api/openstack/images.py
index d914f5196..ab286bb45 100644
--- a/nova/api/openstack/images.py
+++ b/nova/api/openstack/images.py
@@ -20,6 +20,7 @@ import datetime
 from webob import exc
 
 from nova import compute
+from nova import exception
 from nova import flags
 from nova import log
 from nova import utils
@@ -238,8 +239,11 @@ class Controller(wsgi.Controller):
     def show(self, req, id):
         """Return data about the given image id"""
         context = req.environ['nova.context']
-        image_id = common.get_image_id_from_image_hash(
-            self._service, req.environ['nova.context'], id)
+        try:
+            image_id = common.get_image_id_from_image_hash(
+                self._service, context, id)
+        except exception.NotFound:
+            raise faults.Fault(exc.HTTPNotFound())
 
         image_meta = self._service.show(context, image_id)
         api_image_meta = _safe_translate(image_meta)
diff --git a/nova/tests/api/openstack/test_images.py b/nova/tests/api/openstack/test_images.py
index 785e104dc..817778e1e 100644
--- a/nova/tests/api/openstack/test_images.py
+++ b/nova/tests/api/openstack/test_images.py
@@ -277,6 +277,28 @@ class ImageControllerWithGlanceServiceTest(test.TestCase):
 
         self.assertDictListMatch(image_metas, expected)
 
+    def test_get_image_found(self):
+        req = webob.Request.blank('/v1.0/images/123')
+        res = req.get_response(fakes.wsgi_app())
+        image_meta = json.loads(res.body)['image']
+        expected = {'id': 123, 'name': 'public image',
+                    'updated': self.NOW_API_STR, 'created': self.NOW_API_STR,
+                    'status': 'ACTIVE'}
+        self.assertDictMatch(image_meta, expected)
+
+    def test_get_image_non_existent(self):
+        req = webob.Request.blank('/v1.0/images/4242')
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 404)
+
+    def test_get_image_not_owned(self):
+        """We should return a 404 if we request an image that doesn't belong
+        to us
+        """
+        req = webob.Request.blank('/v1.0/images/128')
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 404)
+
     @classmethod
     def _make_image_fixtures(cls):
         image_id = 123
-- 
cgit 


From 07c9626d91c217ad63e866d41b49db672887022e Mon Sep 17 00:00:00 2001
From: Rick Harris <rick.harris@rackspace.com>
Date: Wed, 23 Mar 2011 06:59:26 +0000
Subject: Pep8 fixes

---
 nova/image/glance.py                    | 2 +-
 nova/tests/api/openstack/test_images.py | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/image/glance.py b/nova/image/glance.py
index ec6e9e094..d7aed4ef0 100644
--- a/nova/image/glance.py
+++ b/nova/image/glance.py
@@ -184,4 +184,4 @@ class GlanceImageService(service.BaseImageService):
         except KeyError:
             return False
 
-        return (str(user_id) == str(context.user_id))
+        return str(user_id) == str(context.user_id)
diff --git a/nova/tests/api/openstack/test_images.py b/nova/tests/api/openstack/test_images.py
index 817778e1e..ea8d96ea7 100644
--- a/nova/tests/api/openstack/test_images.py
+++ b/nova/tests/api/openstack/test_images.py
@@ -308,6 +308,7 @@ class ImageControllerWithGlanceServiceTest(test.TestCase):
                       'deleted': False}
 
         fixtures = []
+
         def add_fixture(**kwargs):
             kwargs.update(base_attrs)
             fixtures.append(kwargs)
-- 
cgit 


From 3aba77c34a507bf8b7cae0ff87cf18a75bed11a8 Mon Sep 17 00:00:00 2001
From: Rick Harris <rick.harris@rackspace.com>
Date: Wed, 23 Mar 2011 07:18:01 +0000
Subject: Touching up comment

---
 nova/image/glance.py | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'nova')

diff --git a/nova/image/glance.py b/nova/image/glance.py
index d7aed4ef0..e138b34ab 100644
--- a/nova/image/glance.py
+++ b/nova/image/glance.py
@@ -22,12 +22,12 @@ from glance.common import exception as glance_exception
 
 from nova import exception
 from nova import flags
-from nova import log
+from nova import log as logging
 from nova import utils
 from nova.image import service
 
 
-LOG = log.getLogger('nova.image.glance')
+LOG = logging.getLogger('nova.image.glance')
 
 FLAGS = flags.FLAGS
 
@@ -52,9 +52,9 @@ class GlanceImageService(service.BaseImageService):
         """
         Calls out to Glance for a list of images available
         """
-        # NOTE(sirp): We need to use get_images_detailed and not get_images
-        # here because we need `is_public` and properties included so we can
-        # filter by user
+        # NOTE(sirp): We need to use `get_images_detailed` and not
+        # `get_images` here because we need `is_public` and `properties`
+        # included so we can filter by user
         filtered = []
         image_metas = self.client.get_images_detailed()
         for image_meta in image_metas:
-- 
cgit 


From 9902daf888ad369eb38e381d255eebda76aab106 Mon Sep 17 00:00:00 2001
From: Rick Harris <rick.harris@rackspace.com>
Date: Wed, 23 Mar 2011 07:27:04 +0000
Subject: Removing dead code

---
 nova/tests/api/openstack/fakes.py | 8 --------
 1 file changed, 8 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/fakes.py b/nova/tests/api/openstack/fakes.py
index b81a09971..190efad0c 100644
--- a/nova/tests/api/openstack/fakes.py
+++ b/nova/tests/api/openstack/fakes.py
@@ -174,10 +174,6 @@ def stub_out_glance(stubs, initial_fixtures=None):
             raise glance_exc.NotFound
 
         def fake_add_image(self, image_meta, data=None):
-            if 'id' in image_meta:
-                raise Exception(
-                    _("Cannot set id attribute for Glance image: %s")
-                    % image_meta)
             image_id = ''.join(random.choice(string.letters)
                                for _ in range(20))
             image_meta['id'] = image_id
@@ -199,9 +195,6 @@ def stub_out_glance(stubs, initial_fixtures=None):
 
             self.fixtures.remove(f)
 
-        ##def fake_delete_all(self):
-        ##    self.fixtures = []
-
     GlanceClient = glance_client.Client
     fake = FakeGlanceClient(initial_fixtures)
 
@@ -212,7 +205,6 @@ def stub_out_glance(stubs, initial_fixtures=None):
     stubs.Set(GlanceClient, 'add_image', fake.fake_add_image)
     stubs.Set(GlanceClient, 'update_image', fake.fake_update_image)
     stubs.Set(GlanceClient, 'delete_image', fake.fake_delete_image)
-    #stubs.Set(GlanceClient, 'delete_all', fake.fake_delete_all)
 
 
 class FakeToken(object):
-- 
cgit 


From 07af0c9653863575600986158b89ff6afa48996e Mon Sep 17 00:00:00 2001
From: Rick Harris <rick.harris@rackspace.com>
Date: Wed, 23 Mar 2011 07:30:01 +0000
Subject: Use subset_dict

---
 nova/api/openstack/images.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/api/openstack/images.py b/nova/api/openstack/images.py
index ab286bb45..19edcf194 100644
--- a/nova/api/openstack/images.py
+++ b/nova/api/openstack/images.py
@@ -137,7 +137,7 @@ def _translate_from_image_service_to_api(image_metadata):
 
     # 1. Filter out unecessary attributes
     api_keys = ['id', 'name', 'updated_at', 'created_at', 'status']
-    api_metadata = utils.partition_dict(service_metadata, api_keys)[0]
+    api_metadata = utils.subset_dict(service_metadata, api_keys)
 
     # 2. Translate base image attributes
     api_map = {'updated_at': 'updated', 'created_at': 'created'}
-- 
cgit 


From a822941d1fbfcfff7d52e2e42f2a50cb8aca6f0d Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Wed, 23 Mar 2011 01:02:13 -0700
Subject: Report the exception (happens when can't import libvirt)

---
 nova/compute/manager.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 576937cd8..4f338135b 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -118,8 +118,8 @@ class ComputeManager(manager.Manager):
 
         try:
             self.driver = utils.import_object(compute_driver)
-        except ImportError:
-            LOG.error("Unable to load the virtualization driver.")
+        except ImportError as e:
+            LOG.error(_("Unable to load the virtualization driver: %s") % (e))
             sys.exit(1)
 
         self.network_manager = utils.import_object(FLAGS.network_manager)
-- 
cgit 


From 02db94dc33d72182201fd78651e5e5e82ab411c2 Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
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')

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 72c5735e1f77c764fc96e063ea848bac8e1ab810 Mon Sep 17 00:00:00 2001
From: Salvatore Orlando <salvatore.orlando@eu.citrix.com>
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')

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 <salvatore.orlando@eu.citrix.com>
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')

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 327938fd67bb033597945bdabddaa155ae4bced6 Mon Sep 17 00:00:00 2001
From: Brian Lamar <brian.lamar@rackspace.com>
Date: Wed, 23 Mar 2011 09:19:15 -0400
Subject: id -> instance_id

---
 nova/db/sqlalchemy/api.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 98e6f938a..6f08307be 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -2216,7 +2216,7 @@ def migration_get_by_instance_and_status(context, instance_id, status):
                      filter_by(status=status).first()
     if not result:
         raise exception.NotFound(_("No migration found with instance id %s")
-                % id)
+                % instance_id)
     return result
 
 
-- 
cgit 


From f5dada1e0193f9fff89735f169aafffbac1cbd4a Mon Sep 17 00:00:00 2001
From: Ilya Alekseyev <ialekseev@griddynamics.com>
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')

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 1f90c7c6555e042cda1371a22c9891713a3f6430 Mon Sep 17 00:00:00 2001
From: Dan Prince <dan.prince@rackspace.com>
Date: Wed, 23 Mar 2011 13:01:59 -0400
Subject: Implement v1.1 image metadata.

---
 nova/api/openstack/__init__.py                  |   6 +-
 nova/api/openstack/image_metadata.py            |  95 ++++++++++++++
 nova/tests/api/openstack/test_image_metadata.py | 166 ++++++++++++++++++++++++
 3 files changed, 266 insertions(+), 1 deletion(-)
 create mode 100644 nova/api/openstack/image_metadata.py
 create mode 100644 nova/tests/api/openstack/test_image_metadata.py

(limited to 'nova')

diff --git a/nova/api/openstack/__init__.py b/nova/api/openstack/__init__.py
index 21d354f1c..c12aa7e89 100644
--- a/nova/api/openstack/__init__.py
+++ b/nova/api/openstack/__init__.py
@@ -33,6 +33,7 @@ from nova.api.openstack import backup_schedules
 from nova.api.openstack import consoles
 from nova.api.openstack import flavors
 from nova.api.openstack import images
+from nova.api.openstack import image_metadata
 from nova.api.openstack import limits
 from nova.api.openstack import servers
 from nova.api.openstack import shared_ip_groups
@@ -150,7 +151,10 @@ class APIRouterV11(APIRouter):
                         controller=servers.ControllerV11(),
                         collection={'detail': 'GET'},
                         member=self.server_members)
-
+        mapper.resource("image_meta", "meta",
+                        controller=image_metadata.Controller(),
+                        parent_resource=dict(member_name='image',
+                        collection_name='images'))
 
 class Versions(wsgi.Application):
     @webob.dec.wsgify(RequestClass=wsgi.Request)
diff --git a/nova/api/openstack/image_metadata.py b/nova/api/openstack/image_metadata.py
new file mode 100644
index 000000000..5ca349af1
--- /dev/null
+++ b/nova/api/openstack/image_metadata.py
@@ -0,0 +1,95 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# 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.
+
+from webob import exc
+
+from nova import flags
+from nova import utils
+from nova import wsgi
+from nova.api.openstack import faults
+
+
+FLAGS = flags.FLAGS
+
+
+class Controller(wsgi.Controller):
+    """ The image metadata API controller for the Openstack API """
+
+    def __init__(self):
+        self.image_service = utils.import_object(FLAGS.image_service)
+        super(Controller, self).__init__()
+
+    def _get_metadata(self, context, image_id, image=None):
+        if not image:
+            image = self.image_service.show(context, image_id)
+        metadata = {}
+        if 'properties' in image:
+            metadata = image['properties']
+        return metadata
+
+    def index(self, req, image_id):
+        """ Returns the list of metadata for a given instance """
+        context = req.environ['nova.context']
+        metadata = self._get_metadata(context, image_id)
+        return dict(metadata=metadata)
+
+    def show(self, req, image_id, id):
+        context = req.environ['nova.context']
+        metadata = self._get_metadata(context, image_id)
+        if id in metadata:
+            return {id: metadata[id]}
+        else:
+            return faults.Fault(exc.HTTPNotFound())
+
+    def create(self, req, image_id):
+        context = req.environ['nova.context']
+        body = self._deserialize(req.body, req.get_content_type())
+        img = self.image_service.show(context, image_id)
+        metadata = self._get_metadata(context, image_id, img)
+        if 'metadata' in body:
+            for key, value in body['metadata'].iteritems():
+                metadata[key] = value
+        img['properties'] = metadata
+        self.image_service.update(context, image_id, img, None)
+        return dict(metadata=metadata)
+
+    def update(self, req, image_id, id):
+        context = req.environ['nova.context']
+        body = self._deserialize(req.body, req.get_content_type())
+        if not id in body:
+            expl = _('Request body and URI mismatch')
+            raise exc.HTTPBadRequest(explanation=expl)
+        if len(body) > 1:
+            expl = _('Request body contains too many items')
+            raise exc.HTTPBadRequest(explanation=expl)
+        img = self.image_service.show(context, image_id)
+        metadata = self._get_metadata(context, image_id, img)
+        metadata[id] = body[id]
+        img['properties'] = metadata
+        self.image_service.update(context, image_id, img, None)
+
+        return req.body
+
+    def delete(self, req, image_id, id):
+        context = req.environ['nova.context']
+        img = self.image_service.show(context, image_id)
+        metadata = self._get_metadata(context, image_id)
+        if not id in metadata:
+            return faults.Fault(exc.HTTPNotFound())
+        metadata.pop(id)
+        img['properties'] = metadata
+        self.image_service.update(context, image_id, img, None)
diff --git a/nova/tests/api/openstack/test_image_metadata.py b/nova/tests/api/openstack/test_image_metadata.py
new file mode 100644
index 000000000..81280bd97
--- /dev/null
+++ b/nova/tests/api/openstack/test_image_metadata.py
@@ -0,0 +1,166 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# 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.
+
+import json
+import stubout
+import unittest
+import webob
+
+
+from nova import flags
+from nova.api import openstack
+from nova.tests.api.openstack import fakes
+import nova.wsgi
+
+
+FLAGS = flags.FLAGS
+
+
+class ImageMetaDataTest(unittest.TestCase):
+
+    IMAGE_FIXTURES = [
+        {'status': 'active',
+        'name': 'image1',
+        'deleted': False,
+        'container_format': None,
+        'created_at': '2011-03-22T17: 40: 15.492626',
+        'disk_format': None,
+        'updated_at': '2011-03-22T17: 40: 15.591556',
+        'id': '1',
+        'location': 'file: ///var/lib/glance/images/1',
+        'is_public': True,
+        'deleted_at': None,
+        'properties': {
+            'type': 'ramdisk',
+            'key1': 'value1',
+            'key2': 'value2'
+        },
+        'size': 5882349},
+        {'status': 'active',
+        'name': 'image2',
+        'deleted': False,
+        'container_format': None,
+        'created_at': '2011-03-22T17: 40: 15.492626',
+        'disk_format': None,
+        'updated_at': '2011-03-22T17: 40: 15.591556',
+        'id': '2',
+        'location': 'file: ///var/lib/glance/images/2',
+        'is_public': True,
+        'deleted_at': None,
+        'properties': {
+            'type': 'ramdisk',
+            'key1': 'value1',
+            'key2': 'value2'
+        },
+        'size': 5882349}
+        ]
+
+    def setUp(self):
+        super(ImageMetaDataTest, self).setUp()
+        self.stubs = stubout.StubOutForTesting()
+        self.orig_image_service = FLAGS.image_service
+        FLAGS.image_service = 'nova.image.glance.GlanceImageService'
+        fakes.FakeAuthManager.auth_data = {}
+        fakes.FakeAuthDatabase.data = {}
+        fakes.stub_out_auth(self.stubs)
+        fakes.stub_out_glance(self.stubs, self.IMAGE_FIXTURES)
+
+    def tearDown(self):
+        self.stubs.UnsetAll()
+        FLAGS.image_service = self.orig_image_service
+        super(ImageMetaDataTest, self).tearDown()
+
+    def test_index(self):
+        req = webob.Request.blank('/v1.1/images/1/meta')
+        req.environ['api.version'] = '1.1'
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+        self.assertEqual(200, res.status_int)
+        self.assertEqual('value1', res_dict['metadata']['key1'])
+
+    def test_show(self):
+        req = webob.Request.blank('/v1.1/images/1/meta/key1')
+        req.environ['api.version'] = '1.1'
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+        self.assertEqual(200, res.status_int)
+        self.assertEqual('value1', res_dict['key1'])
+
+    def test_show_not_found(self):
+        req = webob.Request.blank('/v1.1/images/1/meta/key9')
+        req.environ['api.version'] = '1.1'
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+        self.assertEqual(404, res.status_int)
+
+    def test_create(self):
+        req = webob.Request.blank('/v1.1/images/2/meta')
+        req.environ['api.version'] = '1.1'
+        req.method = 'POST'
+        req.body = '{"metadata": {"key9": "value9"}}'
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+        self.assertEqual(200, res.status_int)
+        self.assertEqual('value9', res_dict['metadata']['key9'])
+        # other items should not be modified
+        self.assertEqual('value1', res_dict['metadata']['key1'])
+        self.assertEqual('value2', res_dict['metadata']['key2'])
+        self.assertEqual(1, len(res_dict))
+
+    def test_update_item(self):
+        req = webob.Request.blank('/v1.1/images/1/meta/key1')
+        req.environ['api.version'] = '1.1'
+        req.method = 'PUT'
+        req.body = '{"key1": "zz"}'
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(200, res.status_int)
+        res_dict = json.loads(res.body)
+        self.assertEqual('zz', res_dict['key1'])
+
+    def test_update_item_too_many_keys(self):
+        req = webob.Request.blank('/v1.1/images/1/meta/key1')
+        req.environ['api.version'] = '1.1'
+        req.method = 'PUT'
+        req.body = '{"key1": "value1", "key2": "value2"}'
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(400, res.status_int)
+
+    def test_update_item_body_uri_mismatch(self):
+        req = webob.Request.blank('/v1.1/images/1/meta/bad')
+        req.environ['api.version'] = '1.1'
+        req.method = 'PUT'
+        req.body = '{"key1": "value1"}'
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(400, res.status_int)
+
+    def test_delete(self):
+        req = webob.Request.blank('/v1.1/images/2/meta/key1')
+        req.environ['api.version'] = '1.1'
+        req.method = 'DELETE'
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(200, res.status_int)
+
+    def test_delete_not_found(self):
+        req = webob.Request.blank('/v1.1/images/2/meta/blah')
+        req.environ['api.version'] = '1.1'
+        req.method = 'DELETE'
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(404, res.status_int)
-- 
cgit 


From b49ac333df4de61ca632666cca85f6e9baf788b0 Mon Sep 17 00:00:00 2001
From: Dan Prince <dan.prince@rackspace.com>
Date: Wed, 23 Mar 2011 13:04:44 -0400
Subject: pep8 fix.

---
 nova/api/openstack/__init__.py | 1 +
 1 file changed, 1 insertion(+)

(limited to 'nova')

diff --git a/nova/api/openstack/__init__.py b/nova/api/openstack/__init__.py
index c12aa7e89..efb10eb1b 100644
--- a/nova/api/openstack/__init__.py
+++ b/nova/api/openstack/__init__.py
@@ -156,6 +156,7 @@ class APIRouterV11(APIRouter):
                         parent_resource=dict(member_name='image',
                         collection_name='images'))
 
+
 class Versions(wsgi.Application):
     @webob.dec.wsgify(RequestClass=wsgi.Request)
     def __call__(self, req):
-- 
cgit 


From ea92a88b727814698dbc4ebf5dc705677d636445 Mon Sep 17 00:00:00 2001
From: Naveed Massjouni <naveedm9@gmail.com>
Date: Wed, 23 Mar 2011 14:05:21 -0400
Subject: Using super to call parent _setup_routes in APIRouter subclasses.

---
 nova/api/openstack/__init__.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/__init__.py b/nova/api/openstack/__init__.py
index 5f9648210..e68110bc4 100644
--- a/nova/api/openstack/__init__.py
+++ b/nova/api/openstack/__init__.py
@@ -134,7 +134,7 @@ class APIRouterV10(APIRouter):
     """Define routes specific to OpenStack API V1.0."""
 
     def _setup_routes(self, mapper):
-        APIRouter._setup_routes(self, mapper)
+        super(APIRouterV10, self)._setup_routes(mapper)
         mapper.resource("server", "servers",
                         controller=servers.ControllerV10(),
                         collection={'detail': 'GET'},
@@ -145,7 +145,7 @@ class APIRouterV11(APIRouter):
     """Define routes specific to OpenStack API V1.1."""
 
     def _setup_routes(self, mapper):
-        APIRouter._setup_routes(self, mapper)
+        super(APIRouterV11, self)._setup_routes(mapper)
         mapper.resource("server", "servers",
                         controller=servers.ControllerV11(),
                         collection={'detail': 'GET'},
-- 
cgit 


From a8a345630bd90a74bae00e11dbaf013c60dc7d84 Mon Sep 17 00:00:00 2001
From: Ilya Alekseyev <ialekseev@griddynamics.com>
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')

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 c3d47689a762bfa4aa38c7d4700bb1969d37d1d1 Mon Sep 17 00:00:00 2001
From: "matt.dietz@rackspace.com" <>
Date: Wed, 23 Mar 2011 18:56:23 +0000
Subject: merge prop changes

---
 nova/api/openstack/views/servers.py |  9 +++------
 nova/compute/api.py                 | 13 ++++++++++++-
 nova/compute/manager.py             |  8 ++++----
 3 files changed, 19 insertions(+), 11 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/views/servers.py b/nova/api/openstack/views/servers.py
index 709052f22..a21a6e7ff 100644
--- a/nova/api/openstack/views/servers.py
+++ b/nova/api/openstack/views/servers.py
@@ -18,6 +18,7 @@
 import hashlib
 
 from nova.compute import power_state
+import nova.compute.api
 import nova.context
 from nova import db
 from nova.api.openstack import common
@@ -87,14 +88,10 @@ class ViewBuilder(object):
         for k, v in mapped_keys.iteritems():
             inst_dict[k] = inst[v]
 
+        ctxt = nova.context.get_admin_context()
         inst_dict['status'] = power_mapping[inst_dict['status']]
-        try:
-            ctxt = nova.context.get_admin_context()
-            migration = db.migration_get_by_instance_and_status(ctxt,
-                    inst['id'], 'finished')
+        if nova.compute.api.has_finished_migration(ctxt, inst['id']):
             inst_dict['status'] = 'resize-confirm'
-        except:
-            pass
 
         inst_dict['addresses'] = self.addresses_builder.build(inst)
 
diff --git a/nova/compute/api.py b/nova/compute/api.py
index 748aba004..78110c048 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -253,6 +253,16 @@ class API(base.Base):
 
         return [dict(x.iteritems()) for x in instances]
 
+    def has_finished_migration(self, context, instance_id):
+        """Retrieves whether or not a finished migration exists for
+        an instance"""
+        try:
+            db.migration_get_by_instance_and_status(ctxt, inst['id'],
+                    'finished')
+            return True
+        except Exception, e:
+            return False
+
     def ensure_default_security_group(self, context):
         """ Create security group for the security context if it
         does not already exist
@@ -499,7 +509,8 @@ class API(base.Base):
         LOG.debug(_("Old instance type %(current_instance_type_name)s, "
                 " new instance type %(new_instance_type_name)s") % locals())
         if not new_instance_type:
-            raise exception.ApiError(_("Requested flavor does not exist"))
+            raise exception.ApiError(_("Requested flavor %(flavor_id)d "
+                    "does not exist") % locals())
 
         if current_instance_type['memory_mb'] >= \
                     new_instance_type['memory_mb']:
diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 78ef33ac2..ac63f68ea 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -458,8 +458,8 @@ class ComputeManager(manager.Manager):
         instance_type = self.db.instance_type_get_by_flavor_id(context,
                 migration_ref['old_flavor_id'])
 
-        #Just roll back the record. There's no need to resize down since
-        #the 'old' VM already has the preferred attributes
+        # Just roll back the record. There's no need to resize down since
+        # the 'old' VM already has the preferred attributes
         self.db.instance_update(context, instance_id,
            dict(memory_mb=instance_type['memory_mb'],
                 vcpus=instance_type['vcpus'],
@@ -536,8 +536,8 @@ class ComputeManager(manager.Manager):
         migration_ref = self.db.migration_get(context, migration_id)
         instance_ref = self.db.instance_get(context,
                 migration_ref['instance_id'])
-        #TODO(mdietz): apply the rest of the instance_type attributes going
-        #after they're supported
+        # TODO(mdietz): apply the rest of the instance_type attributes going
+        # after they're supported
         instance_type = self.db.instance_type_get_by_flavor_id(context,
                 migration_ref['new_flavor_id'])
         self.db.instance_update(context, instance_id,
-- 
cgit 


From 683fcb5da6e742e2b9f1750939dc6a17776d59de Mon Sep 17 00:00:00 2001
From: Ilya Alekseyev <ialekseev@griddynamics.com>
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')

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)
-                <parameter name="RASERVER" value="${gateway_v6}" />
+                <parameter name="RASERVER" value="${nic.gateway_v6}" />
 #end if
             </filterref>
         </interface>
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 1aa576ee43cdf6520df6b5c8429f8d426bafc72a Mon Sep 17 00:00:00 2001
From: "matt.dietz@rackspace.com" <>
Date: Wed, 23 Mar 2011 18:59:24 +0000
Subject: Moving the migration yet again

---
 .../versions/012_add_flavors_to_migrations.py      | 50 ----------------------
 .../versions/013_add_flavors_to_migrations.py      | 50 ++++++++++++++++++++++
 2 files changed, 50 insertions(+), 50 deletions(-)
 delete mode 100644 nova/db/sqlalchemy/migrate_repo/versions/012_add_flavors_to_migrations.py
 create mode 100644 nova/db/sqlalchemy/migrate_repo/versions/013_add_flavors_to_migrations.py

(limited to 'nova')

diff --git a/nova/db/sqlalchemy/migrate_repo/versions/012_add_flavors_to_migrations.py b/nova/db/sqlalchemy/migrate_repo/versions/012_add_flavors_to_migrations.py
deleted file mode 100644
index 3fb92e85c..000000000
--- a/nova/db/sqlalchemy/migrate_repo/versions/012_add_flavors_to_migrations.py
+++ /dev/null
@@ -1,50 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2011 OpenStack LLC.
-# 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.from sqlalchemy import *
-
-from sqlalchemy import *
-from migrate import *
-
-from nova import log as logging
-
-
-meta = MetaData()
-
-migrations = Table('migrations', meta,
-        Column('id', Integer(), primary_key=True, nullable=False),
-        )
-
-#
-# Tables to alter
-#
-#
-
-old_flavor_id = Column('old_flavor_id', Integer())
-new_flavor_id = Column('new_flavor_id', Integer())
-
-
-def upgrade(migrate_engine):
-    # Upgrade operations go here. Don't create your own engine;
-    # bind migrate_engine to your metadata
-    meta.bind = migrate_engine
-    migrations.create_column(old_flavor_id)
-    migrations.create_column(new_flavor_id)
-
-
-def downgrade(migrate_engine):
-    meta.bind = migrate_engine
-    migrations.drop_column(old_flavor_id)
-    migrations.drop_column(new_flavor_id)
diff --git a/nova/db/sqlalchemy/migrate_repo/versions/013_add_flavors_to_migrations.py b/nova/db/sqlalchemy/migrate_repo/versions/013_add_flavors_to_migrations.py
new file mode 100644
index 000000000..3fb92e85c
--- /dev/null
+++ b/nova/db/sqlalchemy/migrate_repo/versions/013_add_flavors_to_migrations.py
@@ -0,0 +1,50 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# 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.from sqlalchemy import *
+
+from sqlalchemy import *
+from migrate import *
+
+from nova import log as logging
+
+
+meta = MetaData()
+
+migrations = Table('migrations', meta,
+        Column('id', Integer(), primary_key=True, nullable=False),
+        )
+
+#
+# Tables to alter
+#
+#
+
+old_flavor_id = Column('old_flavor_id', Integer())
+new_flavor_id = Column('new_flavor_id', Integer())
+
+
+def upgrade(migrate_engine):
+    # Upgrade operations go here. Don't create your own engine;
+    # bind migrate_engine to your metadata
+    meta.bind = migrate_engine
+    migrations.create_column(old_flavor_id)
+    migrations.create_column(new_flavor_id)
+
+
+def downgrade(migrate_engine):
+    meta.bind = migrate_engine
+    migrations.drop_column(old_flavor_id)
+    migrations.drop_column(new_flavor_id)
-- 
cgit 


From 514e748e3000f97a9d1c03ba3b5ab6faff79abfd Mon Sep 17 00:00:00 2001
From: Ilya Alekseyev <ialekseev@griddynamics.com>
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')

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 5a5c7d22e7a00c9a3b34f8c08db70b644eee2d92 Mon Sep 17 00:00:00 2001
From: "matt.dietz@rackspace.com" <>
Date: Wed, 23 Mar 2011 19:16:03 +0000
Subject: Unit test cleanup

---
 nova/api/openstack/views/servers.py | 5 +++--
 nova/compute/api.py                 | 2 +-
 nova/db/sqlalchemy/api.py           | 2 +-
 3 files changed, 5 insertions(+), 4 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/views/servers.py b/nova/api/openstack/views/servers.py
index a21a6e7ff..18d31a29d 100644
--- a/nova/api/openstack/views/servers.py
+++ b/nova/api/openstack/views/servers.py
@@ -18,7 +18,7 @@
 import hashlib
 
 from nova.compute import power_state
-import nova.compute.api
+import nova.compute
 import nova.context
 from nova import db
 from nova.api.openstack import common
@@ -90,7 +90,8 @@ class ViewBuilder(object):
 
         ctxt = nova.context.get_admin_context()
         inst_dict['status'] = power_mapping[inst_dict['status']]
-        if nova.compute.api.has_finished_migration(ctxt, inst['id']):
+        compute_api = nova.compute.API()
+        if compute_api.has_finished_migration(ctxt, inst['id']):
             inst_dict['status'] = 'resize-confirm'
 
         inst_dict['addresses'] = self.addresses_builder.build(inst)
diff --git a/nova/compute/api.py b/nova/compute/api.py
index 78110c048..c2738f6f5 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -257,7 +257,7 @@ class API(base.Base):
         """Retrieves whether or not a finished migration exists for
         an instance"""
         try:
-            db.migration_get_by_instance_and_status(ctxt, inst['id'],
+            db.migration_get_by_instance_and_status(context, instance_id,
                     'finished')
             return True
         except Exception, e:
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 98810cb48..d7b5aff46 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -2221,7 +2221,7 @@ def migration_get_by_instance_and_status(context, instance_id, status):
                      filter_by(status=status).first()
     if not result:
         raise exception.NotFound(_("No migration found for instance "
-                "%(instance_id) with status %(status)") % locals())
+                "%(instance_id)s with status %(status)s") % locals())
     return result
 
 
-- 
cgit 


From db6aaa666dc1deaeead7f32fd22a4f6b2d40ed25 Mon Sep 17 00:00:00 2001
From: Brian Waldon <brian.waldon@rackspace.com>
Date: Wed, 23 Mar 2011 15:17:34 -0400
Subject: fixing some dictionary get calls

---
 nova/api/openstack/views/servers.py | 21 ++++++++++-----------
 1 file changed, 10 insertions(+), 11 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/views/servers.py b/nova/api/openstack/views/servers.py
index 5f4c0f740..6b5dc7c16 100644
--- a/nova/api/openstack/views/servers.py
+++ b/nova/api/openstack/views/servers.py
@@ -71,7 +71,7 @@ class ViewBuilder(object):
 
         # Return the metadata as a dictionary
         metadata = {}
-        if 'metadata' in inst:
+        if 'metadata' in dict(inst):
             for item in inst['metadata']:
                 metadata[item['key']] = item['value']
         inst_dict['metadata'] = metadata
@@ -97,11 +97,11 @@ class ViewBuilder(object):
 
 class ViewBuilderV10(ViewBuilder):
     def _build_image(self, response, inst):
-        if inst.get('image_id') != None:
+        if 'image_id' in dict(inst):
             response['imageId'] = inst['image_id']
 
     def _build_flavor(self, response, inst):
-        if inst.get('instance_type') != None:
+        if 'instance_type' in dict(inst):
             response['flavorId'] = inst['instance_type']
 
 
@@ -114,16 +114,15 @@ class ViewBuilderV11(ViewBuilder):
         self.base_url = base_url
 
     def _build_image(self, response, inst):
-        image_id = inst.get("image_id", None)
-        if image_id == None:
-            return
-        response["imageRef"] = self.image_builder.generate_href(image_id)
+        if "image_id" in dict(inst):
+            image_id = inst.get("image_id")
+            response["imageRef"] = self.image_builder.generate_href(image_id)
 
     def _build_flavor(self, response, inst):
-        flavor_id = inst.get("instance_type", None)
-        if flavor_id == None:
-            return
-        response["flavorRef"] = self.flavor_builder.generate_href(flavor_id)
+        if "instance_type" in dict(inst):
+            flavor_id = inst["instance_type"]
+            flavor_ref = self.flavor_builder.generate_href(flavor_id)
+            response["flavorRef"] = flavor_ref
 
     def _build_extra(self, response, inst):
         self._build_links(response, inst)
-- 
cgit 


From 05e6f82aa971606f7d33fb1de8f2c1c170d030de Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Wed, 23 Mar 2011 12:31:15 -0700
Subject: indenting cleanup

---
 nova/api/openstack/zones.py | 5 ++---
 nova/compute/manager.py     | 2 +-
 nova/flags.py               | 2 +-
 nova/manager.py             | 5 ++++-
 nova/rpc.py                 | 4 ++--
 nova/scheduler/api.py       | 2 +-
 nova/tests/test_zones.py    | 2 +-
 7 files changed, 12 insertions(+), 10 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/zones.py b/nova/api/openstack/zones.py
index d129cf34f..d4a59993b 100644
--- a/nova/api/openstack/zones.py
+++ b/nova/api/openstack/zones.py
@@ -17,7 +17,6 @@ import common
 
 from nova import db
 from nova import flags
-from nova import log as logging
 from nova import wsgi
 from nova.scheduler import api
 
@@ -73,8 +72,8 @@ class Controller(wsgi.Controller):
         zone = dict(name=FLAGS.zone_name)
         caps = FLAGS.zone_capabilities
         for cap in caps:
-            key_values = cap.split('=')
-            zone[key_values[0]] = key_values[1]
+            key, value = cap.split('=')
+            zone[key] = value
         for item, (min_value, max_value) in items.iteritems():
             zone[item] = "%s,%s" % (min_value, max_value)
         return dict(zone=zone)
diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index eae1fee68..289c91d8a 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -118,7 +118,7 @@ class ComputeManager(manager.SchedulerDependentManager):
         self.network_manager = utils.import_object(FLAGS.network_manager)
         self.volume_manager = utils.import_object(FLAGS.volume_manager)
         super(ComputeManager, self).__init__(service_name="compute",
-                                                        *args, **kwargs)
+                                             *args, **kwargs)
 
     def init_host(self):
         """Do any initialization that needs to be run if this is a
diff --git a/nova/flags.py b/nova/flags.py
index 3a8ec1a39..bf83b8e0f 100644
--- a/nova/flags.py
+++ b/nova/flags.py
@@ -360,4 +360,4 @@ DEFINE_string('node_availability_zone', 'nova',
 DEFINE_string('zone_name', 'nova', 'name of this zone')
 DEFINE_list('zone_capabilities',
                 ['hypervisor=xenserver;kvm', 'os=linux;windows'],
-                'Key/Multi-value list representng capabilities of this zone')
+                 'Key/Multi-value list representng capabilities of this zone')
diff --git a/nova/manager.py b/nova/manager.py
index 508f133ca..804a50479 100644
--- a/nova/manager.py
+++ b/nova/manager.py
@@ -59,6 +59,8 @@ from nova.scheduler import api
 
 FLAGS = flags.FLAGS
 
+LOG = logging.getLogger('nova.manager')
+
 
 class Manager(base.Base):
     def __init__(self, host=None, db_driver=None):
@@ -83,6 +85,7 @@ class SchedulerDependentManager(Manager):
        should derive from this class. Otherwise they can derive from
        manager.Manager directly. Updates are only sent after
        update_service_capabilities is called with non-None values."""
+
     def __init__(self, host=None, db_driver=None, service_name="undefined"):
         self.last_capabilities = None
         self.service_name = service_name
@@ -95,7 +98,7 @@ class SchedulerDependentManager(Manager):
     def periodic_tasks(self, context=None):
         """Pass data back to the scheduler at a periodic interval"""
         if self.last_capabilities:
-            logging.debug(_("Notifying Schedulers of capabilities ..."))
+            LOG.debug(_("Notifying Schedulers of capabilities ..."))
             api.update_service_capabilities(context, self.service_name,
                                 self.host, self.last_capabilities)
 
diff --git a/nova/rpc.py b/nova/rpc.py
index 6ddaea092..388f78d69 100644
--- a/nova/rpc.py
+++ b/nova/rpc.py
@@ -219,8 +219,8 @@ class FanoutAdapterConsumer(AdapterConsumer):
         self.queue = "%s_fanout_%s" % (topic, unique)
         self.durable = False
         LOG.info(_("Created '%(exchange)s' fanout exchange "
-                                        "with '%(key)s' routing key"),
-                            dict(exchange=self.exchange, key=self.routing_key))
+                   "with '%(key)s' routing key"),
+                dict(exchange=self.exchange, key=self.routing_key))
         super(FanoutAdapterConsumer, self).__init__(connection=connection,
                                     topic=topic, proxy=proxy)
 
diff --git a/nova/scheduler/api.py b/nova/scheduler/api.py
index e2cf3b6a3..19a05b716 100644
--- a/nova/scheduler/api.py
+++ b/nova/scheduler/api.py
@@ -52,7 +52,7 @@ def get_zone_capabilities(context, service=None):
     """Returns a dict of key, value capabilities for this zone,
        or for a particular class of services running in this zone."""
     return _call_scheduler('get_zone_capabilities', context=context,
-                        params=dict(service=service))
+                          params=dict(service=service))
 
 
 def update_service_capabilities(context, service_name, host, capabilities):
diff --git a/nova/tests/test_zones.py b/nova/tests/test_zones.py
index 48e1442cf..688dc704d 100644
--- a/nova/tests/test_zones.py
+++ b/nova/tests/test_zones.py
@@ -96,7 +96,7 @@ class ZoneManagerTestCase(test.TestCase):
         zm.update_service_capabilities("svc10", "host1", dict(a=99, b=99))
         caps = zm.get_zone_capabilities(self, None)
         self.assertEquals(caps, dict(svc1_a=(2, 20), svc1_b=(3, 30),
-                                        svc10_a=(99, 99), svc10_b=(99, 99)))
+                                     svc10_a=(99, 99), svc10_b=(99, 99)))
 
         zm.update_service_capabilities("svc1", "host3", dict(c=5))
         caps = zm.get_zone_capabilities(self, None)
-- 
cgit 


From abb764f51385a0b811b23379d78f7db027d4cca5 Mon Sep 17 00:00:00 2001
From: Josh Kearney <josh@jk0.org>
Date: Wed, 23 Mar 2011 14:41:35 -0500
Subject: Automatically unrescue instances after a given timeout

---
 nova/compute/manager.py   | 12 +++++-
 nova/utils.py             |  7 ++++
 nova/virt/libvirt_conn.py |  4 ++
 nova/virt/xenapi/vmops.py | 95 +++++++++++++++++++++++++++++++++++------------
 nova/virt/xenapi_conn.py  |  4 ++
 5 files changed, 96 insertions(+), 26 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 576937cd8..3834c33ab 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -65,8 +65,11 @@ flags.DEFINE_string('console_host', socket.gethostname(),
                     'Console proxy host to use to connect to instances on'
                     'this host.')
 flags.DEFINE_integer('live_migration_retry_count', 30,
-                    ("Retry count needed in live_migration."
-                     " sleep 1 sec for each count"))
+                     "Retry count needed in live_migration."
+                     " sleep 1 sec for each count")
+flags.DEFINE_integer("rescue_timeout", 0,
+                     "Automatically unrescue an instance after N hours."
+                     " Set to 0 to disable.")
 
 LOG = logging.getLogger('nova.compute.manager')
 
@@ -132,6 +135,11 @@ class ComputeManager(manager.Manager):
         """
         self.driver.init_host(host=self.host)
 
+    def periodic_tasks(self, context=None):
+        """Tasks to be run at a periodic interval."""
+        super(ComputeManager, self).periodic_tasks(context)
+        self.driver.poll_rescued_instances(FLAGS.rescue_timeout)
+
     def _update_state(self, context, instance_id):
         """Update the state of an instance from the driver info."""
         # FIXME(ja): include other fields from state?
diff --git a/nova/utils.py b/nova/utils.py
index 499af2039..38cdb8021 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -334,6 +334,13 @@ def utcnow():
 utcnow.override_time = None
 
 
+def is_then_greater(then, seconds):
+    if utcnow() - then > datetime.timedelta(seconds=seconds):
+        return True
+    else:
+        return False
+
+
 def utcnow_ts():
     """Timestamp version of our utcnow function."""
     return time.mktime(utcnow().timetuple())
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 8eab4f6ecaf51221b335e76d9e532a1f159c2f2d Mon Sep 17 00:00:00 2001
From: "matt.dietz@rackspace.com" <>
Date: Wed, 23 Mar 2011 19:44:32 +0000
Subject: Forgot extraneous module import

---
 nova/api/openstack/servers.py | 1 -
 1 file changed, 1 deletion(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index f3367e118..d392ab57f 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -23,7 +23,6 @@ from webob import exc
 
 from nova import compute
 from nova import context
-from nova import db
 from nova import exception
 from nova import flags
 from nova import log as logging
-- 
cgit 


From 0218a11bb1d5275d5b99c98aea1edba0f45f56e2 Mon Sep 17 00:00:00 2001
From: "matt.dietz@rackspace.com" <>
Date: Wed, 23 Mar 2011 19:48:26 +0000
Subject: Forgot extraneous module import again

---
 nova/api/openstack/views/servers.py | 1 -
 1 file changed, 1 deletion(-)

(limited to 'nova')

diff --git a/nova/api/openstack/views/servers.py b/nova/api/openstack/views/servers.py
index 18d31a29d..68f712e56 100644
--- a/nova/api/openstack/views/servers.py
+++ b/nova/api/openstack/views/servers.py
@@ -20,7 +20,6 @@ import hashlib
 from nova.compute import power_state
 import nova.compute
 import nova.context
-from nova import db
 from nova.api.openstack import common
 from nova.api.openstack.views import addresses as addresses_view
 from nova.api.openstack.views import flavors as flavors_view
-- 
cgit 


From a291e68fef876080d7984a1d7192e939808596bf Mon Sep 17 00:00:00 2001
From: Josh Kearney <josh@jk0.org>
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')

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 83e519b734078d8214fa0dc1d518607c7c0b244a Mon Sep 17 00:00:00 2001
From: Josh Kearney <josh@jk0.org>
Date: Wed, 23 Mar 2011 15:21:18 -0500
Subject: Only run periodic task when rescue_timeout is greater than 0

---
 nova/compute/manager.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 3834c33ab..9cb210c77 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -138,7 +138,8 @@ class ComputeManager(manager.Manager):
     def periodic_tasks(self, context=None):
         """Tasks to be run at a periodic interval."""
         super(ComputeManager, self).periodic_tasks(context)
-        self.driver.poll_rescued_instances(FLAGS.rescue_timeout)
+        if FLAGS.rescue_timeout > 0:
+            self.driver.poll_rescued_instances(FLAGS.rescue_timeout)
 
     def _update_state(self, context, instance_id):
         """Update the state of an instance from the driver info."""
-- 
cgit 


From 05c4257545fb598222cb472d59d9b8be7ba9535a Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
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')

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 <justin@fathomdb.com>
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')

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 3c0fcc47be08ac4f3d508fd46f3b95036899aaad Mon Sep 17 00:00:00 2001
From: termie <github@anarkystic.com>
Date: Wed, 23 Mar 2011 13:39:01 -0700
Subject: fix utils.execute retries for osx

also some minor misc cleanups
---
 nova/network/linux_net.py | 13 ++++++-------
 nova/tests/test_volume.py |  4 ++--
 nova/utils.py             |  9 +++++----
 3 files changed, 13 insertions(+), 13 deletions(-)

(limited to 'nova')

diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index 0a273588f..46158bbc0 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -1,3 +1,5 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
 # Copyright 2010 United States Government as represented by the
 # Administrator of the National Aeronautics and Space Administration.
 # All Rights Reserved.
@@ -212,10 +214,7 @@ class IptablesManager(object):
     """
     def __init__(self, execute=None):
         if not execute:
-            if FLAGS.fake_network:
-                self.execute = lambda *args, **kwargs: ('', '')
-            else:
-                self.execute = utils.execute
+            self.execute = _execute
         else:
             self.execute = execute
 
@@ -361,9 +360,6 @@ class IptablesManager(object):
         return new_filter
 
 
-iptables_manager = IptablesManager()
-
-
 def metadata_forward():
     """Create forwarding rule for metadata"""
     iptables_manager.ipv4['nat'].add_rule("PREROUTING",
@@ -776,3 +772,6 @@ def _ip_bridge_cmd(action, params, device):
     cmd.extend(params)
     cmd.extend(['dev', device])
     return cmd
+
+
+iptables_manager = IptablesManager()
diff --git a/nova/tests/test_volume.py b/nova/tests/test_volume.py
index 5d68ca2ae..d71b75f3f 100644
--- a/nova/tests/test_volume.py
+++ b/nova/tests/test_volume.py
@@ -356,8 +356,8 @@ class ISCSITestCase(DriverTestCase):
         tid = db.volume_get_iscsi_target_num(self.context, volume_id_list[0])
         self.mox.StubOutWithMock(self.volume.driver, '_execute')
         self.volume.driver._execute("sudo", "ietadm", "--op", "show",
-                                    "--tid=%(tid)d" % locals()
-                                 ).AndRaise(exception.ProcessExecutionError())
+                                    "--tid=%(tid)d" % locals()).AndRaise(
+                                            exception.ProcessExecutionError())
 
         self.mox.ReplayAll()
         self.assertRaises(exception.ProcessExecutionError,
diff --git a/nova/utils.py b/nova/utils.py
index 499af2039..249470636 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -170,10 +170,6 @@ def execute(*cmd, **kwargs):
                                                 stdout=stdout,
                                                 stderr=stderr,
                                                 cmd=' '.join(cmd))
-            # NOTE(termie): this appears to be necessary to let the subprocess
-            #               call clean something up in between calls, without
-            #               it two execute calls in a row hangs the second one
-            greenthread.sleep(0)
             return result
         except ProcessExecutionError:
             if not attempts:
@@ -182,6 +178,11 @@ def execute(*cmd, **kwargs):
                 LOG.debug(_("%r failed. Retrying."), cmd)
                 if delay_on_retry:
                     greenthread.sleep(random.randint(20, 200) / 100.0)
+        finally:
+            # NOTE(termie): this appears to be necessary to let the subprocess
+            #               call clean something up in between calls, without
+            #               it two execute calls in a row hangs the second one
+            greenthread.sleep(0)
 
 
 def ssh_execute(ssh, cmd, process_input=None,
-- 
cgit 


From 0d677a9b63ed9b4612379494bf8a58af1c090331 Mon Sep 17 00:00:00 2001
From: Naveed Massjouni <naveedm9@gmail.com>
Date: Wed, 23 Mar 2011 16:51:30 -0400
Subject: Should not call super __init__ twice in APIRouter

---
 nova/api/openstack/__init__.py | 2 --
 1 file changed, 2 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/__init__.py b/nova/api/openstack/__init__.py
index e68110bc4..143b1d2b2 100644
--- a/nova/api/openstack/__init__.py
+++ b/nova/api/openstack/__init__.py
@@ -127,8 +127,6 @@ class APIRouter(wsgi.Router):
         _limits = limits.LimitsController()
         mapper.resource("limit", "limits", controller=_limits)
 
-        super(APIRouter, self).__init__(mapper)
-
 
 class APIRouterV10(APIRouter):
     """Define routes specific to OpenStack API V1.0."""
-- 
cgit 


From 98b4f0924257dcfa12e4881950472e983f08ef1d Mon Sep 17 00:00:00 2001
From: "matt.dietz@rackspace.com" <>
Date: Wed, 23 Mar 2011 21:04:42 +0000
Subject: merge prop fixes

---
 nova/compute/api.py        | 10 +++++++---
 nova/tests/test_compute.py | 14 +++++++++++++-
 2 files changed, 20 insertions(+), 4 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/api.py b/nova/compute/api.py
index c2738f6f5..01eead4ac 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -260,7 +260,7 @@ class API(base.Base):
             db.migration_get_by_instance_and_status(context, instance_id,
                     'finished')
             return True
-        except Exception, e:
+        except exception.NotFound:
             return False
 
     def ensure_default_security_group(self, context):
@@ -512,10 +512,14 @@ class API(base.Base):
             raise exception.ApiError(_("Requested flavor %(flavor_id)d "
                     "does not exist") % locals())
 
-        if current_instance_type['memory_mb'] >= \
-                    new_instance_type['memory_mb']:
+        current_memory_mb = current_instance_type['memory_mb']
+        new_memory_mb = new_instance_type['memory_mb']
+        if current_memory_mb > new_memory_mb:
             raise exception.ApiError(_("Invalid flavor: cannot downsize"
                     "instances"))
+        if current_memory_mb == new_memory_mb:
+            raise exception.ApiError(_("Invalid flavor: cannot use"
+                    "the same flavor. "))
 
         self._cast_scheduler_message(context,
                     {"method": "prep_resize",
diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index 444be5dd8..44d04a12f 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -336,7 +336,7 @@ class ComputeTestCase(test.TestCase):
         self.compute.terminate_instance(context, instance_id)
 
     def test_resize_down_fails(self):
-        """Ensure invalid flavors raise"""
+        """Ensure resizing down raises and fails"""
         context = self.context.elevated()
         instance_id = self._create_instance()
 
@@ -349,6 +349,18 @@ class ComputeTestCase(test.TestCase):
 
         self.compute.terminate_instance(context, instance_id)
 
+    def test_resize_same_size_fails(self):
+        """Ensure invalid flavors raise"""
+        context = self.context.elevated()
+        instance_id = self._create_instance()
+
+        self.compute.run_instance(self.context, instance_id)
+
+        self.assertRaises(exception.ApiError, self.compute_api.resize,
+                context, instance_id, 1)
+
+        self.compute.terminate_instance(context, instance_id)
+
     def test_get_by_flavor_id(self):
         type = instance_types.get_by_flavor_id(1)
         self.assertEqual(type, 'm1.tiny')
-- 
cgit 


From 95fa499f1a7718694e37a747a6a5a0e309ce877d Mon Sep 17 00:00:00 2001
From: Eldar Nugaev <enugaev@griddynamics.com>
Date: Thu, 24 Mar 2011 00:36:07 +0300
Subject: migration gateway_v6 to network_info

---
 nova/tests/test_virt.py   |  3 ++-
 nova/utils.py             | 14 ++++++++-----
 nova/virt/libvirt_conn.py | 53 +++++++----------------------------------------
 3 files changed, 19 insertions(+), 51 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/test_virt.py b/nova/tests/test_virt.py
index b214f5ce7..98bb11526 100644
--- a/nova/tests/test_virt.py
+++ b/nova/tests/test_virt.py
@@ -785,7 +785,8 @@ class NWFilterTestCase(test.TestCase):
 
         instance_ref = db.instance_create(self.context,
                                           {'user_id': 'fake',
-                                          'project_id': 'fake'})
+                                          'project_id': 'fake',
+                                          'mac_address': '00:A0:C9:14:C8:29'})
         inst_id = instance_ref['id']
 
         ip = '10.11.12.13'
diff --git a/nova/utils.py b/nova/utils.py
index 499af2039..44234813f 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -309,11 +309,15 @@ def  get_my_linklocal(interface):
 
 
 def to_global_ipv6(prefix, mac):
-    mac64 = netaddr.EUI(mac).eui64().words
-    int_addr = int(''.join(['%02x' % i for i in mac64]), 16)
-    mac64_addr = netaddr.IPAddress(int_addr)
-    maskIP = netaddr.IPNetwork(prefix).ip
-    return (mac64_addr ^ netaddr.IPAddress('::0200:0:0:0') | maskIP).format()
+    try:
+        mac64 = netaddr.EUI(mac).eui64().words
+        int_addr = int(''.join(['%02x' % i for i in mac64]), 16)
+        mac64_addr = netaddr.IPAddress(int_addr)
+        maskIP = netaddr.IPNetwork(prefix).ip
+        return (mac64_addr ^ netaddr.IPAddress('::0200:0:0:0') | maskIP).\
+        format()
+    except TypeError:
+        raise TypeError(_("Bad mac for to_global_ipv6: %s" % mac))
 
 
 def to_mac(ipv6_address):
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 b3a8c70304672abe9b461c6cfeed3e8b517ca0b6 Mon Sep 17 00:00:00 2001
From: Josh Kearney <josh@jk0.org>
Date: Wed, 23 Mar 2011 16:56:54 -0500
Subject: Added docstring

---
 nova/utils.py | 1 +
 1 file changed, 1 insertion(+)

(limited to 'nova')

diff --git a/nova/utils.py b/nova/utils.py
index 38cdb8021..bf1aa4a91 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -335,6 +335,7 @@ utcnow.override_time = None
 
 
 def is_then_greater(then, seconds):
+    """Return True of 'then' is greater than 'seconds'"""
     if utcnow() - then > datetime.timedelta(seconds=seconds):
         return True
     else:
-- 
cgit 


From 5170e8b5dd96cf8c7bb91e84203cfaebb099af46 Mon Sep 17 00:00:00 2001
From: Eldar Nugaev <enugaev@griddynamics.com>
Date: Thu, 24 Mar 2011 00:56:56 +0300
Subject: small fix

---
 nova/utils.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/utils.py b/nova/utils.py
index 44234813f..fabc01532 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -317,7 +317,7 @@ def to_global_ipv6(prefix, mac):
         return (mac64_addr ^ netaddr.IPAddress('::0200:0:0:0') | maskIP).\
         format()
     except TypeError:
-        raise TypeError(_("Bad mac for to_global_ipv6: %s" % mac))
+        raise TypeError(_("Bad mac for to_global_ipv6: %s") % mac)
 
 
 def to_mac(ipv6_address):
-- 
cgit 


From a12b6f0a0808fba5541723a537118447b55b69ad Mon Sep 17 00:00:00 2001
From: Josh Kearney <josh@jk0.org>
Date: Wed, 23 Mar 2011 17:15:41 -0500
Subject: Better method name

---
 nova/utils.py             | 6 +++---
 nova/virt/xenapi/vmops.py | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

(limited to 'nova')

diff --git a/nova/utils.py b/nova/utils.py
index bf1aa4a91..04b6c9778 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -334,9 +334,9 @@ def utcnow():
 utcnow.override_time = None
 
 
-def is_then_greater(then, seconds):
-    """Return True of 'then' is greater than 'seconds'"""
-    if utcnow() - then > datetime.timedelta(seconds=seconds):
+def is_older_than(before, seconds):
+    """Return True if before is older than 'seconds'"""
+    if utcnow() - before > datetime.timedelta(seconds=seconds):
         return True
     else:
         return False
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 e19b12f668fb6cd693df6834f8895fb5487953d7 Mon Sep 17 00:00:00 2001
From: Josh Kearney <josh@jk0.org>
Date: Wed, 23 Mar 2011 18:34:47 -0500
Subject: Review feedback

---
 nova/compute/manager.py   |  2 +-
 nova/virt/xenapi/vmops.py | 30 +++++++++++++++---------------
 2 files changed, 16 insertions(+), 16 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 9cb210c77..ce1ae87e3 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -68,7 +68,7 @@ flags.DEFINE_integer('live_migration_retry_count', 30,
                      "Retry count needed in live_migration."
                      " sleep 1 sec for each count")
 flags.DEFINE_integer("rescue_timeout", 0,
-                     "Automatically unrescue an instance after N hours."
+                     "Automatically unrescue an instance after N seconds."
                      " Set to 0 to disable.")
 
 LOG = logging.getLogger('nova.compute.manager')
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 <justin@fathomdb.com>
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')

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 <justin@fathomdb.com>
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/compute/manager.py     | 2 +-
 nova/compute/power_state.py | 2 +-
 nova/virt/driver.py         | 9 ++++-----
 nova/virt/libvirt_conn.py   | 2 +-
 4 files changed, 7 insertions(+), 8 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index d85ead88b..b67b27dd0 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -1001,7 +1001,7 @@ class ComputeManager(manager.Manager):
         vm_instances = dict((vm.name, vm) for vm in vm_instances)
 
         # Keep a list of VMs not in the DB, cross them off as we find them
-        vms_not_found_in_db = [vm.name for vm in vm_instances]
+        vms_not_found_in_db = list(vm_instances.keys())
 
         db_instances = self.db.instance_get_all_by_host(context, self.host)
 
diff --git a/nova/compute/power_state.py b/nova/compute/power_state.py
index ed50e492e..ef013b2ef 100644
--- a/nova/compute/power_state.py
+++ b/nova/compute/power_state.py
@@ -51,4 +51,4 @@ def name(code):
 
 
 def valid_states():
-    return _STATE_MAP.values()
+    return _STATE_MAP.keys()
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 <salvatore.orlando@eu.citrix.com>
Date: Thu, 24 Mar 2011 02:01:46 +0000
Subject: Addressing Rick Clark's comments.

---
 nova/tests/db/fakes.py       |   4 +-
 nova/tests/fake_utils.py     |  16 +++---
 nova/tests/test_xenapi.py    |   4 +-
 nova/tests/xenapi/stubs.py   |   4 +-
 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 +++----
 9 files changed, 95 insertions(+), 89 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/db/fakes.py b/nova/tests/db/fakes.py
index 62c7cd794..c46b75aa2 100644
--- a/nova/tests/db/fakes.py
+++ b/nova/tests/db/fakes.py
@@ -99,9 +99,7 @@ def stub_out_db_instance_api(stubs, injected=True):
         return FakeModel(network_fields)
 
     def fake_network_get_all_by_instance(context, instance_id):
-        l = []
-        l.append(FakeModel(network_fields))
-        return l
+        return [FakeModel(network_fields)]
 
     def fake_instance_get_fixed_address(context, instance_id):
         return FakeModel(fixed_ip_fields).address
diff --git a/nova/tests/fake_utils.py b/nova/tests/fake_utils.py
index 8982f50be..823c775cb 100644
--- a/nova/tests/fake_utils.py
+++ b/nova/tests/fake_utils.py
@@ -33,7 +33,6 @@ _fake_execute_log = []
 
 
 def fake_execute_get_log():
-    global _fake_execute_log
     return _fake_execute_log
 
 
@@ -55,7 +54,7 @@ def fake_execute_default_reply_handler(*ignore_args, **ignore_kwargs):
     return '', ''
 
 
-def fake_execute(*cmd, **kwargs):
+def fake_execute(*cmd_parts, **kwargs):
     """This function stubs out execute, optionally executing
     a preconfigued function to return expected data
     """
@@ -64,8 +63,7 @@ def fake_execute(*cmd, **kwargs):
     process_input = kwargs.get('process_input', None)
     addl_env = kwargs.get('addl_env', None)
     check_exit_code = kwargs.get('check_exit_code', 0)
-    cmd_map = map(str, cmd)
-    cmd_str = ' '.join(cmd_map)
+    cmd_str = ' '.join(str(part) for part in cmd_parts)
 
     LOG.debug(_("Faking execution of cmd (subprocess): %s"), cmd_str)
     _fake_execute_log.append(cmd_str)
@@ -78,13 +76,13 @@ def fake_execute(*cmd, **kwargs):
             LOG.debug(_('Faked command matched %s') % fake_replier[0])
             break
 
-    if isinstance(reply_handler, types.StringTypes):
+    if isinstance(reply_handler, basestring):
         # If the reply handler is a string, return it as stdout
         reply = reply_handler, ''
     else:
         try:
             # Alternative is a function, so call it
-            reply = reply_handler(cmd,
+            reply = reply_handler(cmd_parts,
                                   process_input=process_input,
                                   addl_env=addl_env,
                                   check_exit_code=check_exit_code)
@@ -92,8 +90,10 @@ def fake_execute(*cmd, **kwargs):
             LOG.debug(_('Faked command raised an exception %s' % str(e)))
             raise
 
-    LOG.debug(_("Reply to faked command is stdout='%(0)s' stderr='%(1)s'") %
-        {'0': reply[0], '1': reply[1]})
+    stdout = reply[0]
+    stderr = reply[1]
+    LOG.debug(_("Reply to faked command is stdout='%(stdout)s' "
+                "stderr='%(stderr)s'") % locals())
 
     # Replicate the sleep call in the real function
     greenthread.sleep(0)
diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index b22163e9b..d31fa27ac 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -76,7 +76,6 @@ class XenAPIVolumeTestCase(test.TestCase):
         FLAGS.xenapi_connection_url = 'test_url'
         FLAGS.xenapi_connection_password = 'test_pass'
         db_fakes.stub_out_db_instance_api(self.stubs)
-        #db_fakes.stub_out_db_network_api(self.stubs)
         stubs.stub_out_get_target(self.stubs)
         xenapi_fake.reset()
         self.values = {'id': 1,
@@ -333,7 +332,8 @@ class XenAPIVMTestCase(test.TestCase):
         self.assertEquals(self.vm['HVM_boot_policy'], '')
 
     def _test_spawn(self, image_id, kernel_id, ramdisk_id,
-        instance_type="m1.large", os_type="linux", check_injection=False):
+                    instance_type="m1.large", os_type="linux",
+                    check_injection=False):
         stubs.stubout_loopingcall_start(self.stubs)
         values = {'id': 1,
                   'project_id': self.project.id,
diff --git a/nova/tests/xenapi/stubs.py b/nova/tests/xenapi/stubs.py
index d278934c6..0f559b7f9 100644
--- a/nova/tests/xenapi/stubs.py
+++ b/nova/tests/xenapi/stubs.py
@@ -139,9 +139,9 @@ def stubout_is_vdi_pv(stubs):
 
 
 def stubout_loopingcall_start(stubs):
-    def f_1(self, interval, now=True):
+    def fake_start(self, interval, now=True):
         self.f(*self.args, **self.kw)
-    stubs.Set(utils.LoopingCall, 'start', f_1)
+    stubs.Set(utils.LoopingCall, 'start', fake_start)
 
 
 class FakeSessionForVMTests(fake.SessionBase):
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 <justin@fathomdb.com>
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')

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 e7da101fcf40319a3011048832c70fbedf5c1c81 Mon Sep 17 00:00:00 2001
From: Muneyuki Noguchi <noguchimn@nttdata.co.jp>
Date: Thu, 24 Mar 2011 11:09:15 +0900
Subject: Split arguments of _execute in the iSCSI driver.

---
 nova/volume/driver.py | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

(limited to 'nova')

diff --git a/nova/volume/driver.py b/nova/volume/driver.py
index 779b46755..9d9257bb7 100644
--- a/nova/volume/driver.py
+++ b/nova/volume/driver.py
@@ -422,18 +422,18 @@ class ISCSIDriver(VolumeDriver):
         return properties
 
     def _run_iscsiadm(self, iscsi_properties, iscsi_command):
-        command = ("sudo iscsiadm -m node -T %s -p %s %s" %
-                   (iscsi_properties['target_iqn'],
-                    iscsi_properties['target_portal'],
-                    iscsi_command))
-        (out, err) = self._execute(command)
+        (out, err) = self._execute('sudo', 'iscsiadm', '-m', 'node', '-T',
+                                   iscsi_properties['target_iqn'],
+                                   '-p', iscsi_properties['target_portal'],
+                                   iscsi_command)
+
         LOG.debug("iscsiadm %s: stdout=%s stderr=%s" %
                   (iscsi_command, out, err))
         return (out, err)
 
     def _iscsiadm_update(self, iscsi_properties, property_key, property_value):
-        iscsi_command = ("--op update -n %s -v %s" %
-                         (property_key, property_value))
+        iscsi_command = ('--op', 'update', '-n', property_key,
+                         '-v', property_value)
         return self._run_iscsiadm(iscsi_properties, iscsi_command)
 
     def discover_volume(self, context, volume):
@@ -441,7 +441,7 @@ class ISCSIDriver(VolumeDriver):
         iscsi_properties = self._get_iscsi_properties(volume)
 
         if not iscsi_properties['target_discovered']:
-            self._run_iscsiadm(iscsi_properties, "--op new")
+            self._run_iscsiadm(iscsi_properties, ('--op', 'new'))
 
         if iscsi_properties.get('auth_method'):
             self._iscsiadm_update(iscsi_properties,
@@ -493,7 +493,7 @@ class ISCSIDriver(VolumeDriver):
         iscsi_properties = self._get_iscsi_properties(volume)
         self._iscsiadm_update(iscsi_properties, "node.startup", "manual")
         self._run_iscsiadm(iscsi_properties, "--logout")
-        self._run_iscsiadm(iscsi_properties, "--op delete")
+        self._run_iscsiadm(iscsi_properties, ('--op', 'delete'))
 
     def check_for_export(self, context, volume_id):
         """Make sure volume is exported."""
-- 
cgit 


From 3cde42aaac50e32f2c8fcd4493c40a2eaf1a0d4d Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
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')

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 678fd691f9809184b10db42e263a69e63b027ee7 Mon Sep 17 00:00:00 2001
From: Muneyuki Noguchi <noguchimn@nttdata.co.jp>
Date: Thu, 24 Mar 2011 11:54:08 +0900
Subject: Remove a blank line.

---
 nova/volume/driver.py | 1 -
 1 file changed, 1 deletion(-)

(limited to 'nova')

diff --git a/nova/volume/driver.py b/nova/volume/driver.py
index 9d9257bb7..28d08201b 100644
--- a/nova/volume/driver.py
+++ b/nova/volume/driver.py
@@ -426,7 +426,6 @@ class ISCSIDriver(VolumeDriver):
                                    iscsi_properties['target_iqn'],
                                    '-p', iscsi_properties['target_portal'],
                                    iscsi_command)
-
         LOG.debug("iscsiadm %s: stdout=%s stderr=%s" %
                   (iscsi_command, out, err))
         return (out, err)
-- 
cgit 


From 16372d3bc0181a57958ce185e89f1f21126b9e77 Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Wed, 23 Mar 2011 20:21:44 -0700
Subject: Don't try to parse a datetime if it is the empty string (or None)

---
 nova/image/glance.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/image/glance.py b/nova/image/glance.py
index 171b28fde..9984a3ba1 100644
--- a/nova/image/glance.py
+++ b/nova/image/glance.py
@@ -73,7 +73,7 @@ class GlanceImageService(service.BaseImageService):
         Returns image with known timestamp fields converted to datetime objects
         """
         for attr in ['created_at', 'updated_at', 'deleted_at']:
-            if image.get(attr) is not None:
+            if image.get(attr):
                 image[attr] = self._parse_glance_iso8601_timestamp(image[attr])
         return image
 
-- 
cgit 


From 10e61af8a23c126c15fcfcf25156d32facf19ec2 Mon Sep 17 00:00:00 2001
From: Josh Kearney <josh@jk0.org>
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')

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 f52a2a8a440b303e5289815ab4f6c2d24bfdc59f Mon Sep 17 00:00:00 2001
From: Naveed Massjouni <naveedm9@gmail.com>
Date: Thu, 24 Mar 2011 01:41:38 -0400
Subject: Fixed the docstring for common.get_id_from_href

---
 nova/api/openstack/common.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/common.py b/nova/api/openstack/common.py
index 21ceec45e..bff050347 100644
--- a/nova/api/openstack/common.py
+++ b/nova/api/openstack/common.py
@@ -79,10 +79,10 @@ def get_image_id_from_image_hash(image_service, context, image_hash):
 
 
 def get_id_from_href(href):
-    """Return the id portion of a url.
+    """Return the id portion of a url as an int.
 
     Given: http://www.foo.com/bar/123?q=4
-    Returns: 4
+    Returns: 123
 
     """
     try:
-- 
cgit 


From d8052812cb5b9d3d3578c0e6651e56b4313d5f85 Mon Sep 17 00:00:00 2001
From: Salvatore Orlando <salvatore.orlando@eu.citrix.com>
Date: Thu, 24 Mar 2011 10:32:22 +0000
Subject: Sorted out a problem occurred with units tests for VM migration

---
 nova/tests/test_xenapi.py | 1 +
 1 file changed, 1 insertion(+)

(limited to 'nova')

diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index d31fa27ac..fd8ed39d8 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -553,6 +553,7 @@ class XenAPIMigrateInstance(test.TestCase):
                   'image_id': 1,
                   'kernel_id': None,
                   'ramdisk_id': None,
+                  'local_gb': 5,
                   'instance_type': 'm1.large',
                   'mac_address': 'aa:bb:cc:dd:ee:ff',
                   'os_type': 'linux'}
-- 
cgit 


From f640d32bd8698fc2c30b2ca0454672d691f9b296 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Thu, 24 Mar 2011 05:02:54 -0700
Subject: fix based on sirp's comments

---
 nova/scheduler/api.py | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

(limited to 'nova')

diff --git a/nova/scheduler/api.py b/nova/scheduler/api.py
index c1417dfe4..a4f304c62 100644
--- a/nova/scheduler/api.py
+++ b/nova/scheduler/api.py
@@ -118,16 +118,15 @@ def child_zone_helper(zone_list, func):
                     _wrap_method(_process, func), zone_list)]
 
 
-def _issue_novaclient_command(nova, zone, collection, method_name, \
-                                                        item_id):
+def _issue_novaclient_command(nova, zone, collection, method_name, item_id):
     """Use novaclient to issue command to a single child zone.
        One of these will be run in parallel for each child zone."""
+    manager = getattr(nova, collection)
     result = None
     try:
-        manager = getattr(nova, collection)
-        if isinstance(item_id, int) or item_id.isdigit():
+        try:
             result = manager.get(int(item_id))
-        else:
+        except ValueError, e:
             result = manager.find(name=item_id)
     except novaclient.NotFound:
         url = zone.api_url
-- 
cgit 


From 4e5b511b422501167161c3bbe4dd755c0370c93f Mon Sep 17 00:00:00 2001
From: Ilya Alekseyev <ialekseev@griddynamics.com>
Date: Thu, 24 Mar 2011 16:53:32 +0300
Subject: couple of bugs fixed

---
 nova/tests/test_virt.py   |  3 +-
 nova/virt/libvirt_conn.py | 75 ++++++++++++++++++++++++++++++-----------------
 2 files changed, 50 insertions(+), 28 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/test_virt.py b/nova/tests/test_virt.py
index 98bb11526..12f97383e 100644
--- a/nova/tests/test_virt.py
+++ b/nova/tests/test_virt.py
@@ -803,7 +803,8 @@ class NWFilterTestCase(test.TestCase):
                                             'instance_id': instance_ref['id']})
 
         def _ensure_all_called():
-            instance_filter = 'nova-instance-%s' % instance_ref['name']
+            instance_filter = 'nova-instance-%s-%s' % (instance_ref['name'],
+                                                       '00A0C914C829')
             secgroup_filter = 'nova-secgroup-%s' % self.security_group['id']
             for required in [secgroup_filter, 'allow-dhcp-server',
                              'no-arp-spoofing', 'no-ip-spoofing',
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</filter>" % 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 3b8f1f54136a67ba4c306e47b25b686328ec23b5 Mon Sep 17 00:00:00 2001
From: Brian Waldon <brian.waldon@rackspace.com>
Date: Thu, 24 Mar 2011 10:15:50 -0400
Subject: making servers.generate_href more robust

---
 nova/api/openstack/views/servers.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'nova')

diff --git a/nova/api/openstack/views/servers.py b/nova/api/openstack/views/servers.py
index 08b53177b..4e7f62eb3 100644
--- a/nova/api/openstack/views/servers.py
+++ b/nova/api/openstack/views/servers.py
@@ -16,6 +16,7 @@
 #    under the License.
 
 import hashlib
+import os
 
 from nova.compute import power_state
 import nova.compute
@@ -164,4 +165,4 @@ class ViewBuilderV11(ViewBuilder):
 
     def generate_href(self, server_id):
         """Create an url that refers to a specific server id."""
-        return "%s/servers/%s" % (self.base_url, server_id)
+        return os.path.join(self.base_url, "servers", str(server_id))
-- 
cgit 


From fa582b2e10e43bbb81e0e5c3baf4560300711271 Mon Sep 17 00:00:00 2001
From: Eldar Nugaev <enugaev@griddynamics.com>
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')

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 96e8ef1049848563b60e457ab88adfb37b2dc473 Mon Sep 17 00:00:00 2001
From: Dan Prince <dan.prince@rackspace.com>
Date: Thu, 24 Mar 2011 10:25:36 -0400
Subject: Couple of pep8 fixes.

---
 nova/tests/api/openstack/test_image_metadata.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/test_image_metadata.py b/nova/tests/api/openstack/test_image_metadata.py
index 81280bd97..46f7e5490 100644
--- a/nova/tests/api/openstack/test_image_metadata.py
+++ b/nova/tests/api/openstack/test_image_metadata.py
@@ -41,7 +41,7 @@ class ImageMetaDataTest(unittest.TestCase):
         'disk_format': None,
         'updated_at': '2011-03-22T17: 40: 15.591556',
         'id': '1',
-        'location': 'file: ///var/lib/glance/images/1',
+        'location': 'file:///var/lib/glance/images/1',
         'is_public': True,
         'deleted_at': None,
         'properties': {
@@ -58,7 +58,7 @@ class ImageMetaDataTest(unittest.TestCase):
         'disk_format': None,
         'updated_at': '2011-03-22T17: 40: 15.591556',
         'id': '2',
-        'location': 'file: ///var/lib/glance/images/2',
+        'location': 'file:///var/lib/glance/images/2',
         'is_public': True,
         'deleted_at': None,
         'properties': {
@@ -66,7 +66,7 @@ class ImageMetaDataTest(unittest.TestCase):
             'key1': 'value1',
             'key2': 'value2'
         },
-        'size': 5882349}
+        'size': 5882349},
         ]
 
     def setUp(self):
-- 
cgit 


From cf70a1a76dfa0456ea6230eaa014fa98e7ddd464 Mon Sep 17 00:00:00 2001
From: Josh Kearney <josh@jk0.org>
Date: Thu, 24 Mar 2011 10:30:09 -0500
Subject: Small refactor

---
 nova/utils.py             |  7 ++-----
 nova/virt/xenapi/vmops.py | 18 +++++++++---------
 2 files changed, 11 insertions(+), 14 deletions(-)

(limited to 'nova')

diff --git a/nova/utils.py b/nova/utils.py
index 03a6e8095..6042a5332 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -336,11 +336,8 @@ utcnow.override_time = None
 
 
 def is_older_than(before, seconds):
-    """Return True if before is older than 'seconds'"""
-    if utcnow() - before > datetime.timedelta(seconds=seconds):
-        return True
-    else:
-        return False
+    """Return True if before is older than seconds"""
+    return utcnow() - before > datetime.timedelta(seconds=seconds)
 
 
 def utcnow_ts():
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 f5b2167c3a18097a0de0c5b26a63baad7c1904a1 Mon Sep 17 00:00:00 2001
From: Brian Waldon <brian.waldon@rackspace.com>
Date: Thu, 24 Mar 2011 12:16:06 -0400
Subject: removing old Versions application and correcting fakes to use new
 controller

---
 nova/api/openstack/__init__.py    | 18 ------------------
 nova/tests/api/openstack/fakes.py |  2 +-
 2 files changed, 1 insertion(+), 19 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/__init__.py b/nova/api/openstack/__init__.py
index 143b1d2b2..a9dbde6ce 100644
--- a/nova/api/openstack/__init__.py
+++ b/nova/api/openstack/__init__.py
@@ -148,21 +148,3 @@ class APIRouterV11(APIRouter):
                         controller=servers.ControllerV11(),
                         collection={'detail': 'GET'},
                         member=self.server_members)
-
-
-class Versions(wsgi.Application):
-    @webob.dec.wsgify(RequestClass=wsgi.Request)
-    def __call__(self, req):
-        """Respond to a request for all OpenStack API versions."""
-        response = {
-            "versions": [
-                dict(status="DEPRECATED", id="v1.0"),
-                dict(status="CURRENT", id="v1.1"),
-            ],
-        }
-        metadata = {
-            "application/xml": {
-                "attributes": dict(version=["status", "id"])}}
-
-        content_type = req.best_match_content_type()
-        return wsgi.Serializer(metadata).serialize(response, content_type)
diff --git a/nova/tests/api/openstack/fakes.py b/nova/tests/api/openstack/fakes.py
index 39e6db165..285f89efc 100644
--- a/nova/tests/api/openstack/fakes.py
+++ b/nova/tests/api/openstack/fakes.py
@@ -86,7 +86,7 @@ def wsgi_app(inner_app10=None, inner_app11=None):
               limits.RateLimitingMiddleware(inner_app11)))
     mapper['/v1.0'] = api10
     mapper['/v1.1'] = api11
-    mapper['/'] = openstack.FaultWrapper(openstack.Versions())
+    mapper['/'] = openstack.FaultWrapper(versions.Versions())
     return mapper
 
 
-- 
cgit 


From 7baaace446c441fdd699018912ef7604265000ce Mon Sep 17 00:00:00 2001
From: Salvatore Orlando <salvatore.orlando@eu.citrix.com>
Date: Thu, 24 Mar 2011 16:36:37 +0000
Subject: Stubbing out utils.execute for migrate tests

---
 nova/tests/test_xenapi.py | 1 +
 1 file changed, 1 insertion(+)

(limited to 'nova')

diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index fd8ed39d8..2ee385cff 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -558,6 +558,7 @@ class XenAPIMigrateInstance(test.TestCase):
                   'mac_address': 'aa:bb:cc:dd:ee:ff',
                   'os_type': 'linux'}
 
+        fake_utils.stub_out_utils_execute(self.stubs)
         stubs.stub_out_migration_methods(self.stubs)
         stubs.stubout_get_this_vm_uuid(self.stubs)
         glance_stubs.stubout_glance_client(self.stubs,
-- 
cgit 


From b7150a461ab2aaee3c0a0f7e2b6588ddd4324b52 Mon Sep 17 00:00:00 2001
From: Armando Migliaccio <armando.migliaccio@citrix.com>
Date: Thu, 24 Mar 2011 16:38:31 +0000
Subject: Addressed issues raised by Rick Harris' review

---
 nova/network/vmwareapi_net.py          |  14 +-
 nova/tests/test_vmwareapi.py           |  50 +++++++-
 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 +++-
 12 files changed, 243 insertions(+), 204 deletions(-)

(limited to 'nova')

diff --git a/nova/network/vmwareapi_net.py b/nova/network/vmwareapi_net.py
index f1232dada..93e6584f0 100644
--- a/nova/network/vmwareapi_net.py
+++ b/nova/network/vmwareapi_net.py
@@ -25,7 +25,7 @@ from nova import flags
 from nova import log as logging
 from nova import utils
 from nova.virt.vmwareapi_conn import VMWareAPISession
-from nova.virt.vmwareapi.network_utils import NetworkHelper
+from nova.virt.vmwareapi import network_utils
 
 LOG = logging.getLogger("nova.network.vmwareapi_net")
 
@@ -50,13 +50,13 @@ def ensure_vlan_bridge(vlan_num, bridge, net_attrs=None):
                                FLAGS.vmwareapi_api_retry_count)
     vlan_interface = FLAGS.vlan_interface
     # Check if the vlan_interface physical network adapter exists on the host
-    if not NetworkHelper.check_if_vlan_interface_exists(session,
+    if not network_utils.check_if_vlan_interface_exists(session,
                                                         vlan_interface):
         raise exception.NotFound(_("There is no physical network adapter with "
                           "the name %s on the ESX host") % vlan_interface)
 
     # Get the vSwitch associated with the Physical Adapter
-    vswitch_associated = NetworkHelper.get_vswitch_for_vlan_interface(
+    vswitch_associated = network_utils.get_vswitch_for_vlan_interface(
                                         session, vlan_interface)
     if vswitch_associated is None:
         raise exception.NotFound(_("There is no virtual switch associated "
@@ -64,16 +64,16 @@ def ensure_vlan_bridge(vlan_num, bridge, net_attrs=None):
             vlan_interface)
     # Check whether bridge already exists and retrieve the the ref of the
     # network whose name_label is "bridge"
-    network_ref = NetworkHelper.get_network_with_the_name(session, bridge)
-    if network_ref == None:
+    network_ref = network_utils.get_network_with_the_name(session, bridge)
+    if network_ref is None:
         # Create a port group on the vSwitch associated with the vlan_interface
         # corresponding physical network adapter on the ESX host
-        NetworkHelper.create_port_group(session, bridge, vswitch_associated,
+        network_utils.create_port_group(session, bridge, vswitch_associated,
                                 vlan_num)
     else:
         # Get the vlan id and vswitch corresponding to the port group
         pg_vlanid, pg_vswitch = \
-            NetworkHelper.get_vlanid_and_vswitch_for_portgroup(session, bridge)
+            network_utils.get_vlanid_and_vswitch_for_portgroup(session, bridge)
 
         # Check if the vsiwtch associated is proper
         if pg_vswitch != vswitch_associated:
diff --git a/nova/tests/test_vmwareapi.py b/nova/tests/test_vmwareapi.py
index b31ac11f1..22b66010a 100644
--- a/nova/tests/test_vmwareapi.py
+++ b/nova/tests/test_vmwareapi.py
@@ -59,8 +59,7 @@ class VMWareAPIVMTestCase(test.TestCase):
                                            glance_stubs.FakeGlance)
         self.conn = vmwareapi_conn.get_connection(False)
 
-    def _create_vm(self):
-        """Create and spawn the VM."""
+    def _create_instance_in_the_db(self):
         values = {'name': 1,
                   'id': 1,
                   'project_id': self.project.id,
@@ -72,6 +71,10 @@ class VMWareAPIVMTestCase(test.TestCase):
                   'mac_address': 'aa:bb:cc:dd:ee:ff',
                   }
         self.instance = db.instance_create(values)
+
+    def _create_vm(self):
+        """Create and spawn the VM."""
+        self._create_instance_in_the_db()
         self.type_data = db.instance_type_get_by_name(None, 'm1.large')
         self.conn.spawn(self.instance)
         self._check_vm_record()
@@ -139,6 +142,11 @@ class VMWareAPIVMTestCase(test.TestCase):
         info = self.conn.get_info(1)
         self._check_vm_info(info, power_state.RUNNING)
 
+    def test_snapshot_non_existent(self):
+        self._create_instance_in_the_db()
+        self.assertRaises(Exception, self.conn.snapshot, self.instance,
+                          "Test-Snapshot")
+
     def test_reboot(self):
         self._create_vm()
         info = self.conn.get_info(1)
@@ -147,6 +155,19 @@ class VMWareAPIVMTestCase(test.TestCase):
         info = self.conn.get_info(1)
         self._check_vm_info(info, power_state.RUNNING)
 
+    def test_reboot_non_existent(self):
+        self._create_instance_in_the_db()
+        self.assertRaises(Exception, self.conn.reboot, self.instance)
+
+    def test_reboot_not_poweredon(self):
+        self._create_vm()
+        info = self.conn.get_info(1)
+        self._check_vm_info(info, power_state.RUNNING)
+        self.conn.suspend(self.instance, self.dummy_callback_handler)
+        info = self.conn.get_info(1)
+        self._check_vm_info(info, power_state.PAUSED)
+        self.assertRaises(Exception, self.conn.reboot, self.instance)
+
     def test_suspend(self):
         self._create_vm()
         info = self.conn.get_info(1)
@@ -155,6 +176,11 @@ class VMWareAPIVMTestCase(test.TestCase):
         info = self.conn.get_info(1)
         self._check_vm_info(info, power_state.PAUSED)
 
+    def test_suspend_non_existent(self):
+        self._create_instance_in_the_db()
+        self.assertRaises(Exception, self.conn.suspend, self.instance,
+                          self.dummy_callback_handler)
+
     def test_resume(self):
         self._create_vm()
         info = self.conn.get_info(1)
@@ -166,6 +192,18 @@ class VMWareAPIVMTestCase(test.TestCase):
         info = self.conn.get_info(1)
         self._check_vm_info(info, power_state.RUNNING)
 
+    def test_resume_non_existent(self):
+        self._create_instance_in_the_db()
+        self.assertRaises(Exception, self.conn.resume, self.instance,
+                          self.dummy_callback_handler)
+
+    def test_resume_not_suspended(self):
+        self._create_vm()
+        info = self.conn.get_info(1)
+        self._check_vm_info(info, power_state.RUNNING)
+        self.assertRaises(Exception, self.conn.resume, self.instance,
+                          self.dummy_callback_handler)
+
     def test_get_info(self):
         self._create_vm()
         info = self.conn.get_info(1)
@@ -176,10 +214,14 @@ class VMWareAPIVMTestCase(test.TestCase):
         info = self.conn.get_info(1)
         self._check_vm_info(info, power_state.RUNNING)
         instances = self.conn.list_instances()
-        self.assertTrue(len(instances) == 1)
+        self.assertEquals(len(instances), 1)
         self.conn.destroy(self.instance)
         instances = self.conn.list_instances()
-        self.assertTrue(len(instances) == 0)
+        self.assertEquals(len(instances), 0)
+
+    def test_destroy_non_existent(self):
+        self._create_instance_in_the_db()
+        self.assertEquals(self.conn.destroy(self.instance), None)
 
     def test_pause(self):
         pass
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 fbb8291263ae49521bbe02aa7f75c000c7f2db8d Mon Sep 17 00:00:00 2001
From: Brian Waldon <brian.waldon@rackspace.com>
Date: Thu, 24 Mar 2011 12:46:39 -0400
Subject: adding versioned controllers

---
 nova/api/openstack/__init__.py | 11 ++++++++---
 nova/api/openstack/flavors.py  | 17 ++++++++++++++---
 2 files changed, 22 insertions(+), 6 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/__init__.py b/nova/api/openstack/__init__.py
index 143b1d2b2..f47422359 100644
--- a/nova/api/openstack/__init__.py
+++ b/nova/api/openstack/__init__.py
@@ -117,9 +117,6 @@ class APIRouter(wsgi.Router):
         mapper.resource("image", "images", controller=images.Controller(),
                         collection={'detail': 'GET'})
 
-        mapper.resource("flavor", "flavors", controller=flavors.Controller(),
-                        collection={'detail': 'GET'})
-
         mapper.resource("shared_ip_group", "shared_ip_groups",
                         collection={'detail': 'GET'},
                         controller=shared_ip_groups.Controller())
@@ -138,6 +135,10 @@ class APIRouterV10(APIRouter):
                         collection={'detail': 'GET'},
                         member=self.server_members)
 
+        mapper.resource("flavor", "flavors",
+                        controller=flavors.ControllerV10(),
+                        collection={'detail': 'GET'})
+
 
 class APIRouterV11(APIRouter):
     """Define routes specific to OpenStack API V1.1."""
@@ -149,6 +150,10 @@ class APIRouterV11(APIRouter):
                         collection={'detail': 'GET'},
                         member=self.server_members)
 
+        mapper.resource("flavor", "flavors",
+                        controller=flavors.ControllerV11(),
+                        collection={'detail': 'GET'})
+
 
 class Versions(wsgi.Application):
     @webob.dec.wsgify(RequestClass=wsgi.Request)
diff --git a/nova/api/openstack/flavors.py b/nova/api/openstack/flavors.py
index f7b5b722f..5b99b5a6f 100644
--- a/nova/api/openstack/flavors.py
+++ b/nova/api/openstack/flavors.py
@@ -20,7 +20,7 @@ import webob
 from nova import db
 from nova import exception
 from nova import wsgi
-from nova.api.openstack.views import flavors as flavors_views
+from nova.api.openstack import views
 
 
 class Controller(wsgi.Controller):
@@ -49,7 +49,7 @@ class Controller(wsgi.Controller):
         """Helper function that returns a list of flavor dicts."""
         ctxt = req.environ['nova.context']
         flavors = db.api.instance_type_get_all(ctxt)
-        builder = flavors_views.get_view_builder(req)
+        builder = self._get_view_builder(req)
         items = [builder.build(flavor, is_detail=is_detail)
                  for flavor in flavors.values()]
         return items
@@ -62,6 +62,17 @@ class Controller(wsgi.Controller):
         except exception.NotFound:
             return webob.exc.HTTPNotFound()
 
-        builder = flavors_views.get_view_builder(req)
+        builder = self._get_view_builder(req)
         values = builder.build(flavor, is_detail=True)
         return dict(flavor=values)
+
+
+class ControllerV10(Controller):
+    def _get_view_builder(self, req):
+        return views.flavors.ViewBuilder()
+
+
+class ControllerV11(Controller):
+    def _get_view_builder(self, req):
+        base_url = req.application_url
+        return views.flavors.ViewBuilderV11(base_url)
-- 
cgit 


From d91102e1ce73b5b2e1f5fbcc380814f1673cefa3 Mon Sep 17 00:00:00 2001
From: Mark Washenberger <mark.washenberger@rackspace.com>
Date: Thu, 24 Mar 2011 12:46:41 -0400
Subject: get image metadata tests working after the datetime interface change
 in image services

---
 nova/tests/api/openstack/fakes.py               | 8 ++++++--
 nova/tests/api/openstack/test_image_metadata.py | 8 ++++----
 2 files changed, 10 insertions(+), 6 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/fakes.py b/nova/tests/api/openstack/fakes.py
index 56143114d..7002c3a74 100644
--- a/nova/tests/api/openstack/fakes.py
+++ b/nova/tests/api/openstack/fakes.py
@@ -168,15 +168,19 @@ def stub_out_glance(stubs, initial_fixtures=None):
             id = ''.join(random.choice(string.letters) for _ in range(20))
             image_meta['id'] = id
             self.fixtures.append(image_meta)
-            return image_meta
+            return copy.deepcopy(image_meta)
 
         def fake_update_image(self, image_id, image_meta, data=None):
+            for attr in ('created_at', 'updated_at', 'deleted_at', 'deleted'):
+                if attr in image_meta:
+                    del image_meta[attr]
+
             f = self._find_image(image_id)
             if not f:
                 raise glance_exc.NotFound
 
             f.update(image_meta)
-            return f
+            return copy.deepcopy(f)
 
         def fake_delete_image(self, image_id):
             f = self._find_image(image_id)
diff --git a/nova/tests/api/openstack/test_image_metadata.py b/nova/tests/api/openstack/test_image_metadata.py
index 46f7e5490..33ef1a0a3 100644
--- a/nova/tests/api/openstack/test_image_metadata.py
+++ b/nova/tests/api/openstack/test_image_metadata.py
@@ -37,9 +37,9 @@ class ImageMetaDataTest(unittest.TestCase):
         'name': 'image1',
         'deleted': False,
         'container_format': None,
-        'created_at': '2011-03-22T17: 40: 15.492626',
+        'created_at': '2011-03-22T17:40:15.492626',
         'disk_format': None,
-        'updated_at': '2011-03-22T17: 40: 15.591556',
+        'updated_at': '2011-03-22T17:40:15.591556',
         'id': '1',
         'location': 'file:///var/lib/glance/images/1',
         'is_public': True,
@@ -54,9 +54,9 @@ class ImageMetaDataTest(unittest.TestCase):
         'name': 'image2',
         'deleted': False,
         'container_format': None,
-        'created_at': '2011-03-22T17: 40: 15.492626',
+        'created_at': '2011-03-22T17:40:15.492626',
         'disk_format': None,
-        'updated_at': '2011-03-22T17: 40: 15.591556',
+        'updated_at': '2011-03-22T17:40:15.591556',
         'id': '2',
         'location': 'file:///var/lib/glance/images/2',
         'is_public': True,
-- 
cgit 


From a69f6ef093805d74832a9dd531e55dd614dfa71c Mon Sep 17 00:00:00 2001
From: Dan Prince <dan.prince@rackspace.com>
Date: Thu, 24 Mar 2011 12:57:49 -0400
Subject: Docstring fixes.

---
 nova/api/openstack/image_metadata.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/image_metadata.py b/nova/api/openstack/image_metadata.py
index 5ca349af1..e09952967 100644
--- a/nova/api/openstack/image_metadata.py
+++ b/nova/api/openstack/image_metadata.py
@@ -27,7 +27,7 @@ FLAGS = flags.FLAGS
 
 
 class Controller(wsgi.Controller):
-    """ The image metadata API controller for the Openstack API """
+    """The image metadata API controller for the Openstack API"""
 
     def __init__(self):
         self.image_service = utils.import_object(FLAGS.image_service)
@@ -42,7 +42,7 @@ class Controller(wsgi.Controller):
         return metadata
 
     def index(self, req, image_id):
-        """ Returns the list of metadata for a given instance """
+        """Returns the list of metadata for a given instance"""
         context = req.environ['nova.context']
         metadata = self._get_metadata(context, image_id)
         return dict(metadata=metadata)
-- 
cgit 


From 12184874da4369891b2eae49982623fc6c9315e3 Mon Sep 17 00:00:00 2001
From: Dan Prince <dan.prince@rackspace.com>
Date: Thu, 24 Mar 2011 13:26:57 -0400
Subject: Updated to use new APIRouterV11 class in tests.

---
 nova/tests/api/openstack/test_extensions.py | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/test_extensions.py b/nova/tests/api/openstack/test_extensions.py
index d1f8c659e..4bc823d15 100644
--- a/nova/tests/api/openstack/test_extensions.py
+++ b/nova/tests/api/openstack/test_extensions.py
@@ -81,14 +81,14 @@ class StubExtensionManager(object):
 class ExtensionControllerTest(unittest.TestCase):
 
     def test_index(self):
-        app = openstack.APIRouter()
+        app = openstack.APIRouterV11()
         ext_midware = extensions.ExtensionMiddleware(app)
         request = webob.Request.blank("/extensions")
         response = request.get_response(ext_midware)
         self.assertEqual(200, response.status_int)
 
     def test_get_by_alias(self):
-        app = openstack.APIRouter()
+        app = openstack.APIRouterV11()
         ext_midware = extensions.ExtensionMiddleware(app)
         request = webob.Request.blank("/extensions/FOXNSOX")
         response = request.get_response(ext_midware)
@@ -99,7 +99,7 @@ class ResourceExtensionTest(unittest.TestCase):
 
     def test_no_extension_present(self):
         manager = StubExtensionManager(None)
-        app = openstack.APIRouter()
+        app = openstack.APIRouterV11()
         ext_midware = extensions.ExtensionMiddleware(app, manager)
         request = webob.Request.blank("/blah")
         response = request.get_response(ext_midware)
@@ -109,7 +109,7 @@ class ResourceExtensionTest(unittest.TestCase):
         res_ext = extensions.ResourceExtension('tweedles',
                                                StubController(response_body))
         manager = StubExtensionManager(res_ext)
-        app = openstack.APIRouter()
+        app = openstack.APIRouterV11()
         ext_midware = extensions.ExtensionMiddleware(app, manager)
         request = webob.Request.blank("/tweedles")
         response = request.get_response(ext_midware)
@@ -120,7 +120,7 @@ class ResourceExtensionTest(unittest.TestCase):
         res_ext = extensions.ResourceExtension('tweedles',
                                                StubController(response_body))
         manager = StubExtensionManager(res_ext)
-        app = openstack.APIRouter()
+        app = openstack.APIRouterV11()
         ext_midware = extensions.ExtensionMiddleware(app, manager)
         request = webob.Request.blank("/tweedles")
         response = request.get_response(ext_midware)
@@ -137,7 +137,7 @@ class ExtensionManagerTest(unittest.TestCase):
                                                     "extensions")
 
     def test_get_resources(self):
-        app = openstack.APIRouter()
+        app = openstack.APIRouterV11()
         ext_midware = extensions.ExtensionMiddleware(app)
         request = webob.Request.blank("/foxnsocks")
         response = request.get_response(ext_midware)
@@ -152,7 +152,7 @@ class ActionExtensionTest(unittest.TestCase):
                                                     "extensions")
 
     def _send_server_action_request(self, url, body):
-        app = openstack.APIRouter()
+        app = openstack.APIRouterV11()
         ext_midware = extensions.ExtensionMiddleware(app)
         request = webob.Request.blank(url)
         request.method = 'POST'
-- 
cgit 


From 1ad0faf980ac89e904a246f1dfeddf51a21fd740 Mon Sep 17 00:00:00 2001
From: Naveed Massjouni <naveedm9@gmail.com>
Date: Thu, 24 Mar 2011 13:48:04 -0400
Subject: Paginated results should not include the item starting at marker.
 Improved implementation of common.limited_by_marker as suggested by Matt
 Dietz. Added flag osapi_max_limit.

---
 nova/api/openstack/common.py             | 28 ++++++++++++++++------------
 nova/flags.py                            |  2 ++
 nova/tests/api/openstack/test_servers.py |  3 +--
 3 files changed, 19 insertions(+), 14 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/common.py b/nova/api/openstack/common.py
index f85d1df9d..f598ac824 100644
--- a/nova/api/openstack/common.py
+++ b/nova/api/openstack/common.py
@@ -20,9 +20,11 @@ from urlparse import urlparse
 import webob
 
 from nova import exception
+from nova import flags
 
+FLAGS = flags.FLAGS
 
-def limited(items, request, max_limit=1000):
+def limited(items, request, max_limit=FLAGS.osapi_max_limit):
     """
     Return a slice of items according to requested offset and limit.
 
@@ -56,10 +58,13 @@ def limited(items, request, max_limit=1000):
     return items[offset:range_end]
 
 
-def limited_by_marker(items, request, max_limit=1000):
-    ''' Return a slice of items according to requested marker and limit. '''
+def limited_by_marker(items, request, max_limit=FLAGS.osapi_max_limit):
+    """Return a slice of items according to the requested marker and limit."""
 
-    marker = request.GET.get('marker')
+    try:
+        marker = int(request.GET.get('marker', 0))
+    except ValueError:
+        raise webob.exc.HTTPBadRequest(_('marker param must be an integer'))
 
     try:
         limit = int(request.GET.get('limit', max_limit))
@@ -69,17 +74,16 @@ def limited_by_marker(items, request, max_limit=1000):
     if limit < 0:
         raise webob.exc.HTTPBadRequest(_('limit param must be positive'))
 
-    limit = min(max_limit, limit or max_limit)
+    limit = min(max_limit, limit)
     start_index = 0
-    if marker != None:
-        found_it = False
+    if marker:
+        start_index = -1
         for i, item in enumerate(items):
-            if str(item['id']) == marker:
-                start_index = i
-                found_it = True
+            if item['id'] == marker:
+                start_index = i + 1
                 break
-        if not found_it:
-            raise webob.exc.HTTPBadRequest(_('marker not found'))
+        if start_index < 0:
+            raise webob.exc.HTTPBadRequest(_('marker [%s] not found' % marker))
     range_end = start_index + limit
     return items[start_index:range_end]
 
diff --git a/nova/flags.py b/nova/flags.py
index 9123e9ac7..d1817dc3b 100644
--- a/nova/flags.py
+++ b/nova/flags.py
@@ -302,6 +302,8 @@ DEFINE_string('osapi_host', '$my_ip', 'ip of api server')
 DEFINE_string('osapi_scheme', 'http', 'prefix for openstack')
 DEFINE_integer('osapi_port', 8774, 'OpenStack API port')
 DEFINE_string('osapi_path', '/v1.0/', 'suffix for openstack')
+DEFINE_integer('osapi_max_limit', 1000,
+               'max number of items returned in a collection response')
 
 DEFINE_string('default_project', 'openstack', 'default project for openstack')
 DEFINE_string('default_image', 'ami-11111',
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 09b08ce8d..cfed78b90 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -242,9 +242,8 @@ class ServersTest(test.TestCase):
     def test_get_servers_with_marker(self):
         req = webob.Request.blank('/v1.1/servers?marker=2')
         res = req.get_response(fakes.wsgi_app())
-        print 'body:', res.body
         servers = json.loads(res.body)['servers']
-        self.assertEqual([s['id'] for s in servers], [2, 3, 4])
+        self.assertEqual([s['id'] for s in servers], [3, 4])
 
     def _setup_for_create_instance(self):
         """Shared implementation for tests below that create instance"""
-- 
cgit 


From 6254069cdf0262e128bfa877f0c56e5aeba2b4c2 Mon Sep 17 00:00:00 2001
From: Mark Washenberger <mark.washenberger@rackspace.com>
Date: Thu, 24 Mar 2011 13:52:20 -0400
Subject: change names for consistency with existing db api

---
 nova/compute/api.py                              |  6 +++---
 nova/db/api.py                                   | 14 +++++++-------
 nova/db/sqlalchemy/api.py                        | 10 +++++-----
 nova/tests/api/openstack/test_server_metadata.py | 18 +++++++++---------
 4 files changed, 24 insertions(+), 24 deletions(-)

(limited to 'nova')

diff --git a/nova/compute/api.py b/nova/compute/api.py
index 1fbaa399d..825b50e48 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -651,15 +651,15 @@ class API(base.Base):
 
     def get_instance_metadata(self, context, instance_id):
         """Get all metadata associated with an instance."""
-        rv = self.db.get_instance_metadata(context, instance_id)
+        rv = self.db.instance_metadata_get(context, instance_id)
         return dict(rv.iteritems())
 
     def delete_instance_metadata(self, context, instance_id, key):
         """Delete the given metadata item"""
-        self.db.delete_instance_metadata(context, instance_id, key)
+        self.db.instance_metadata_delete(context, instance_id, key)
 
     def update_or_create_instance_metadata(self, context, instance_id,
                                             metadata):
         """Updates or creates instance metadata"""
-        self.db.update_or_create_instance_metadata(context, instance_id,
+        self.db.instance_metadata_update_or_create(context, instance_id,
                                                     metadata)
diff --git a/nova/db/api.py b/nova/db/api.py
index 1856e6bcb..300723c62 100644
--- a/nova/db/api.py
+++ b/nova/db/api.py
@@ -1176,16 +1176,16 @@ def zone_get_all(context):
 ####################
 
 
-def get_instance_metadata(context, instance_id):
+def instance_metadata_get(context, instance_id):
     """Get all metadata for an instance"""
-    return IMPL.get_instance_metadata(context, instance_id)
+    return IMPL.instance_metadata_get(context, instance_id)
 
 
-def delete_instance_metadata(context, instance_id, key):
+def instance_metadata_delete(context, instance_id, key):
     """Delete the given metadata item"""
-    IMPL.delete_instance_metadata(context, instance_id, key)
+    IMPL.instance_metadata_delete(context, instance_id, key)
 
 
-def update_or_create_instance_metadata(context, instance_id, metadata):
-    """Creates or updates instance metadata"""
-    IMPL.update_or_create_instance_metadata(context, instance_id, metadata)
+def instance_metadata_update_or_create(context, instance_id, metadata):
+    """Create or update instance metadata"""
+    IMPL.instance_metadata_update_or_create(context, instance_id, metadata)
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 5fe18b65c..57c05623b 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -2467,7 +2467,7 @@ def zone_get_all(context):
 ####################
 
 @require_context
-def get_instance_metadata(context, instance_id):
+def instance_metadata_get(context, instance_id):
     session = get_session()
 
     meta_results = session.query(models.InstanceMetadata).\
@@ -2482,7 +2482,7 @@ def get_instance_metadata(context, instance_id):
 
 
 @require_context
-def delete_instance_metadata(context, instance_id, key):
+def instance_metadata_delete(context, instance_id, key):
     session = get_session()
     session.query(models.InstanceMetadata).\
         filter_by(instance_id=instance_id).\
@@ -2494,7 +2494,7 @@ def delete_instance_metadata(context, instance_id, key):
 
 
 @require_context
-def get_instance_metadata_item(context, instance_id, key):
+def instance_metadata_get_item(context, instance_id, key):
     session = get_session()
 
     meta_result = session.query(models.InstanceMetadata).\
@@ -2510,12 +2510,12 @@ def get_instance_metadata_item(context, instance_id, key):
 
 
 @require_context
-def update_or_create_instance_metadata(context, instance_id, metadata):
+def instance_metadata_update_or_create(context, instance_id, metadata):
     session = get_session()
     meta_ref = None
     for key, value in metadata.iteritems():
         try:
-            meta_ref = get_instance_metadata_item(context, instance_id, key,
+            meta_ref = instance_metadata_get_item(context, instance_id, key,
                                                         session)
         except:
             meta_ref = models.InstanceMetadata()
diff --git a/nova/tests/api/openstack/test_server_metadata.py b/nova/tests/api/openstack/test_server_metadata.py
index 97cb57ebd..c8d456472 100644
--- a/nova/tests/api/openstack/test_server_metadata.py
+++ b/nova/tests/api/openstack/test_server_metadata.py
@@ -68,7 +68,7 @@ class ServerMetaDataTest(unittest.TestCase):
         super(ServerMetaDataTest, self).tearDown()
 
     def test_index(self):
-        self.stubs.Set(nova.db.api, 'get_instance_metadata',
+        self.stubs.Set(nova.db.api, 'instance_metadata_get',
                         return_server_metadata)
         req = webob.Request.blank('/v1.1/servers/1/meta')
         req.environ['api.version'] = '1.1'
@@ -78,7 +78,7 @@ class ServerMetaDataTest(unittest.TestCase):
         self.assertEqual('value1', res_dict['metadata']['key1'])
 
     def test_index_no_data(self):
-        self.stubs.Set(nova.db.api, 'get_instance_metadata',
+        self.stubs.Set(nova.db.api, 'instance_metadata_get',
                         return_empty_server_metadata)
         req = webob.Request.blank('/v1.1/servers/1/meta')
         req.environ['api.version'] = '1.1'
@@ -88,7 +88,7 @@ class ServerMetaDataTest(unittest.TestCase):
         self.assertEqual(0, len(res_dict['metadata']))
 
     def test_show(self):
-        self.stubs.Set(nova.db.api, 'get_instance_metadata',
+        self.stubs.Set(nova.db.api, 'instance_metadata_get',
                         return_server_metadata)
         req = webob.Request.blank('/v1.1/servers/1/meta/key5')
         req.environ['api.version'] = '1.1'
@@ -98,7 +98,7 @@ class ServerMetaDataTest(unittest.TestCase):
         self.assertEqual('value5', res_dict['key5'])
 
     def test_show_meta_not_found(self):
-        self.stubs.Set(nova.db.api, 'get_instance_metadata',
+        self.stubs.Set(nova.db.api, 'instance_metadata_get',
                         return_empty_server_metadata)
         req = webob.Request.blank('/v1.1/servers/1/meta/key6')
         req.environ['api.version'] = '1.1'
@@ -107,7 +107,7 @@ class ServerMetaDataTest(unittest.TestCase):
         self.assertEqual(404, res.status_int)
 
     def test_delete(self):
-        self.stubs.Set(nova.db.api, 'delete_instance_metadata',
+        self.stubs.Set(nova.db.api, 'instance_metadata_delete',
                         delete_server_metadata)
         req = webob.Request.blank('/v1.1/servers/1/meta/key5')
         req.environ['api.version'] = '1.1'
@@ -116,7 +116,7 @@ class ServerMetaDataTest(unittest.TestCase):
         self.assertEqual(200, res.status_int)
 
     def test_create(self):
-        self.stubs.Set(nova.db.api, 'update_or_create_instance_metadata',
+        self.stubs.Set(nova.db.api, 'instance_metadata_update_or_create',
                         return_create_instance_metadata)
         req = webob.Request.blank('/v1.1/servers/1/meta')
         req.environ['api.version'] = '1.1'
@@ -129,7 +129,7 @@ class ServerMetaDataTest(unittest.TestCase):
         self.assertEqual('value1', res_dict['metadata']['key1'])
 
     def test_update_item(self):
-        self.stubs.Set(nova.db.api, 'update_or_create_instance_metadata',
+        self.stubs.Set(nova.db.api, 'instance_metadata_update_or_create',
                         return_create_instance_metadata)
         req = webob.Request.blank('/v1.1/servers/1/meta/key1')
         req.environ['api.version'] = '1.1'
@@ -142,7 +142,7 @@ class ServerMetaDataTest(unittest.TestCase):
         self.assertEqual('value1', res_dict['key1'])
 
     def test_update_item_too_many_keys(self):
-        self.stubs.Set(nova.db.api, 'update_or_create_instance_metadata',
+        self.stubs.Set(nova.db.api, 'instance_metadata_update_or_create',
                         return_create_instance_metadata)
         req = webob.Request.blank('/v1.1/servers/1/meta/key1')
         req.environ['api.version'] = '1.1'
@@ -153,7 +153,7 @@ class ServerMetaDataTest(unittest.TestCase):
         self.assertEqual(400, res.status_int)
 
     def test_update_item_body_uri_mismatch(self):
-        self.stubs.Set(nova.db.api, 'update_or_create_instance_metadata',
+        self.stubs.Set(nova.db.api, 'instance_metadata_update_or_create',
                         return_create_instance_metadata)
         req = webob.Request.blank('/v1.1/servers/1/meta/bad')
         req.environ['api.version'] = '1.1'
-- 
cgit 


From e5069f27cd9e6551a6b035d6fff1b02a6bf0b492 Mon Sep 17 00:00:00 2001
From: Dan Prince <dan.prince@rackspace.com>
Date: Thu, 24 Mar 2011 13:56:25 -0400
Subject: Reconcile tests with latest trunk merges.

---
 nova/tests/api/openstack/extensions/foxinsocks.py |  4 ++--
 nova/tests/api/openstack/test_extensions.py       | 13 +++++++++----
 2 files changed, 11 insertions(+), 6 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/extensions/foxinsocks.py b/nova/tests/api/openstack/extensions/foxinsocks.py
index 249dd81bf..0860b51ac 100644
--- a/nova/tests/api/openstack/extensions/foxinsocks.py
+++ b/nova/tests/api/openstack/extensions/foxinsocks.py
@@ -73,7 +73,7 @@ class Foxinsocks(object):
             data['flavor']['googoose'] = "Gooey goo for chewy chewing!"
             return data
 
-        resp_ext = extensions.ResponseExtension('GET', '/v1.0/flavors/:(id)',
+        resp_ext = extensions.ResponseExtension('GET', '/v1.1/flavors/:(id)',
                                                 _goose_handler)
         response_exts.append(resp_ext)
 
@@ -84,7 +84,7 @@ class Foxinsocks(object):
             data['big_bands'] = 'Pig Bands!'
             return data
 
-        resp_ext2 = extensions.ResponseExtension('GET', '/v1.0/flavors/:(id)',
+        resp_ext2 = extensions.ResponseExtension('GET', '/v1.1/flavors/:(id)',
                                                 _bands_handler)
         response_exts.append(resp_ext2)
         return response_exts
diff --git a/nova/tests/api/openstack/test_extensions.py b/nova/tests/api/openstack/test_extensions.py
index 4bc823d15..481d34ed1 100644
--- a/nova/tests/api/openstack/test_extensions.py
+++ b/nova/tests/api/openstack/test_extensions.py
@@ -193,6 +193,10 @@ class ResponseExtensionTest(unittest.TestCase):
         fakes.stub_out_auth(self.stubs)
         self.context = context.get_admin_context()
 
+    def tearDown(self):
+        self.stubs.UnsetAll()
+        super(ResponseExtensionTest, self).tearDown()
+
     def test_get_resources_with_stub_mgr(self):
 
         test_resp = "Gooey goo for chewy chewing!"
@@ -204,13 +208,14 @@ class ResponseExtensionTest(unittest.TestCase):
             return data
 
         resp_ext = extensions.ResponseExtension('GET',
-                                                '/v1.0/flavors/:(id)',
+                                                '/v1.1/flavors/:(id)',
                                                 _resp_handler)
 
         manager = StubExtensionManager(None, None, resp_ext)
         app = fakes.wsgi_app()
         ext_midware = extensions.ExtensionMiddleware(app, manager)
-        request = webob.Request.blank("/v1.0/flavors/1")
+        request = webob.Request.blank("/v1.1/flavors/1")
+        request.environ['api.version'] = '1.1'
         response = request.get_response(ext_midware)
         self.assertEqual(200, response.status_int)
         response_data = json.loads(response.body)
@@ -222,10 +227,10 @@ class ResponseExtensionTest(unittest.TestCase):
 
         app = fakes.wsgi_app()
         ext_midware = extensions.ExtensionMiddleware(app)
-        request = webob.Request.blank("/v1.0/flavors/1")
+        request = webob.Request.blank("/v1.1/flavors/1")
+        request.environ['api.version'] = '1.1'
         response = request.get_response(ext_midware)
         self.assertEqual(200, response.status_int)
         response_data = json.loads(response.body)
-        print response_data
         self.assertEqual(test_resp, response_data['flavor']['googoose'])
         self.assertEqual("Pig Bands!", response_data['big_bands'])
-- 
cgit 


From c7ccbd7a16a546cbd0717427772691ce7d8b4da6 Mon Sep 17 00:00:00 2001
From: termie <github@anarkystic.com>
Date: Thu, 24 Mar 2011 12:42:46 -0700
Subject: support volume and network in the direct api

---
 nova/api/ec2/cloud.py     | 20 +++++++++++---------
 nova/compute/api.py       |  9 +++++----
 nova/tests/test_direct.py | 14 ++++++++++++--
 nova/volume/api.py        |  3 ++-
 4 files changed, 30 insertions(+), 16 deletions(-)

(limited to 'nova')

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 2afcea77c..5d31d71d3 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -541,7 +541,7 @@ class CloudController(object):
             volumes = []
             for ec2_id in volume_id:
                 internal_id = ec2utils.ec2_id_to_id(ec2_id)
-                volume = self.volume_api.get(context, internal_id)
+                volume = self.volume_api.get(context, volume_id=internal_id)
                 volumes.append(volume)
         else:
             volumes = self.volume_api.get_all(context)
@@ -585,9 +585,11 @@ class CloudController(object):
 
     def create_volume(self, context, size, **kwargs):
         LOG.audit(_("Create volume of %s GB"), size, context=context)
-        volume = self.volume_api.create(context, size,
-                                        kwargs.get('display_name'),
-                                        kwargs.get('display_description'))
+        volume = self.volume_api.create(
+                context,
+                size=size,
+                name=kwargs.get('display_name'),
+                description=kwargs.get('display_description'))
         # TODO(vish): Instance should be None at db layer instead of
         #             trying to lazy load, but for now we turn it into
         #             a dict to avoid an error.
@@ -606,7 +608,7 @@ class CloudController(object):
             if field in kwargs:
                 changes[field] = kwargs[field]
         if changes:
-            self.volume_api.update(context, volume_id, kwargs)
+            self.volume_api.update(context, volume_id=volume_id, fields=changes)
         return True
 
     def attach_volume(self, context, volume_id, instance_id, device, **kwargs):
@@ -619,7 +621,7 @@ class CloudController(object):
                                        instance_id=instance_id,
                                        volume_id=volume_id,
                                        device=device)
-        volume = self.volume_api.get(context, volume_id)
+        volume = self.volume_api.get(context, volume_id=volume_id)
         return {'attachTime': volume['attach_time'],
                 'device': volume['mountpoint'],
                 'instanceId': ec2utils.id_to_ec2_id(instance_id),
@@ -630,7 +632,7 @@ class CloudController(object):
     def detach_volume(self, context, volume_id, **kwargs):
         volume_id = ec2utils.ec2_id_to_id(volume_id)
         LOG.audit(_("Detach volume %s"), volume_id, context=context)
-        volume = self.volume_api.get(context, volume_id)
+        volume = self.volume_api.get(context, volume_id=volume_id)
         instance = self.compute_api.detach_volume(context, volume_id=volume_id)
         return {'attachTime': volume['attach_time'],
                 'device': volume['mountpoint'],
@@ -768,7 +770,7 @@ class CloudController(object):
 
     def release_address(self, context, public_ip, **kwargs):
         LOG.audit(_("Release address %s"), public_ip, context=context)
-        self.network_api.release_floating_ip(context, public_ip)
+        self.network_api.release_floating_ip(context, address=public_ip)
         return {'releaseResponse': ["Address released."]}
 
     def associate_address(self, context, instance_id, public_ip, **kwargs):
@@ -782,7 +784,7 @@ class CloudController(object):
 
     def disassociate_address(self, context, public_ip, **kwargs):
         LOG.audit(_("Disassociate address %s"), public_ip, context=context)
-        self.network_api.disassociate_floating_ip(context, public_ip)
+        self.network_api.disassociate_floating_ip(context, address=public_ip)
         return {'disassociateResponse': ["Address disassociated."]}
 
     def run_instances(self, context, **kwargs):
diff --git a/nova/compute/api.py b/nova/compute/api.py
index 309847156..f4aab97de 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -636,7 +636,7 @@ class API(base.Base):
         if not re.match("^/dev/[a-z]d[a-z]+$", device):
             raise exception.ApiError(_("Invalid device specified: %s. "
                                      "Example device: /dev/vdb") % device)
-        self.volume_api.check_attach(context, volume_id)
+        self.volume_api.check_attach(context, volume_id=volume_id)
         instance = self.get(context, instance_id)
         host = instance['host']
         rpc.cast(context,
@@ -650,7 +650,7 @@ class API(base.Base):
         instance = self.db.volume_get_instance(context.elevated(), volume_id)
         if not instance:
             raise exception.ApiError(_("Volume isn't attached to anything!"))
-        self.volume_api.check_detach(context, volume_id)
+        self.volume_api.check_detach(context, volume_id=volume_id)
         host = instance['host']
         rpc.cast(context,
                  self.db.queue_get_for(context, FLAGS.compute_topic, host),
@@ -661,5 +661,6 @@ class API(base.Base):
 
     def associate_floating_ip(self, context, instance_id, address):
         instance = self.get(context, instance_id)
-        self.network_api.associate_floating_ip(context, address,
-                                               instance['fixed_ip'])
+        self.network_api.associate_floating_ip(context,
+                                               floating_ip=address,
+                                               fixed_ip=instance['fixed_ip'])
diff --git a/nova/tests/test_direct.py b/nova/tests/test_direct.py
index 80e4d2e1f..001246fc4 100644
--- a/nova/tests/test_direct.py
+++ b/nova/tests/test_direct.py
@@ -25,7 +25,9 @@ import webob
 from nova import compute
 from nova import context
 from nova import exception
+from nova import network
 from nova import test
+from nova import volume
 from nova import utils
 from nova.api import direct
 from nova.tests import test_cloud
@@ -93,12 +95,20 @@ class DirectTestCase(test.TestCase):
 class DirectCloudTestCase(test_cloud.CloudTestCase):
     def setUp(self):
         super(DirectCloudTestCase, self).setUp()
-        compute_handle = compute.API(network_api=self.cloud.network_api,
-                                     volume_api=self.cloud.volume_api)
+        compute_handle = compute.API(image_service=self.cloud.image_service)
+        volume_handle = volume.API()
+        network_handle = network.API()
         direct.register_service('compute', compute_handle)
+        direct.register_service('volume', volume_handle)
+        direct.register_service('network', network_handle)
+
         self.router = direct.JsonParamsMiddleware(direct.Router())
         proxy = direct.Proxy(self.router)
         self.cloud.compute_api = proxy.compute
+        self.cloud.volume_api = proxy.volume
+        self.cloud.network_api = proxy.network
+        compute_handle.volume_api = proxy.volume
+        compute_handle.network_api = proxy.network
 
     def tearDown(self):
         super(DirectCloudTestCase, self).tearDown()
diff --git a/nova/volume/api.py b/nova/volume/api.py
index 2f4494845..4b4bb9dc5 100644
--- a/nova/volume/api.py
+++ b/nova/volume/api.py
@@ -82,7 +82,8 @@ class API(base.Base):
         self.db.volume_update(context, volume_id, fields)
 
     def get(self, context, volume_id):
-        return self.db.volume_get(context, volume_id)
+        rv = self.db.volume_get(context, volume_id)
+        return dict(rv.iteritems())
 
     def get_all(self, context):
         if context.is_admin:
-- 
cgit 


From ef5c9e11595a00de468783adbb60cfbc2cbbf13d Mon Sep 17 00:00:00 2001
From: termie <github@anarkystic.com>
Date: Thu, 24 Mar 2011 12:42:46 -0700
Subject: add Limited, an API limiting/versioning wrapper

---
 nova/api/direct.py | 36 ++++++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)

(limited to 'nova')

diff --git a/nova/api/direct.py b/nova/api/direct.py
index dfca250e0..1011091a6 100644
--- a/nova/api/direct.py
+++ b/nova/api/direct.py
@@ -211,6 +211,42 @@ class ServiceWrapper(wsgi.Controller):
             return result
 
 
+class Limited(object):
+    __notdoc = """Limit the available methods on a given object.
+
+    (Not a docstring so that the docstring can be conditionally overriden.)
+
+    Useful when defining a public API that only exposes a subset of an
+    internal API.
+
+    Expected usage of this class is to define a subclass that lists the allowed
+    methods in the 'allowed' variable.
+
+    Additionally where appropriate methods can be added or overwritten, for
+    example to provide backwards compatibility.
+
+    """
+
+    _allowed = None
+
+    def __init__(self, proxy):
+        self._proxy = proxy
+        if not self.__doc__:
+            self.__doc__ = proxy.__doc__
+        if not self._allowed:
+            self._allowed = []
+
+    def __getattr__(self, key):
+        """Only return methods that are named in self._allowed."""
+        if key not in self._allowed:
+            raise AttributeError()
+        return getattr(self._proxy, key)
+
+    def __dir__(self):
+        """Only return methods that are named in self._allowed."""
+        return [x for x in dir(self._proxy) if x in self._allowed]
+
+
 class Proxy(object):
     """Pretend a Direct API endpoint is an object."""
     def __init__(self, app, prefix=None):
-- 
cgit 


From 5c03ade2ee82350d845c8306d5aab9eda3073137 Mon Sep 17 00:00:00 2001
From: termie <github@anarkystic.com>
Date: Thu, 24 Mar 2011 12:42:47 -0700
Subject: add some more docs to direct.py

---
 nova/api/direct.py | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'nova')

diff --git a/nova/api/direct.py b/nova/api/direct.py
index 1011091a6..2e158e89e 100644
--- a/nova/api/direct.py
+++ b/nova/api/direct.py
@@ -225,6 +225,10 @@ class Limited(object):
     Additionally where appropriate methods can be added or overwritten, for
     example to provide backwards compatibility.
 
+    The wrapping approach has been chosen so that the wrapped API can maintain
+    its own internal consistency, for example if it calls "self.create" it
+    should get its own create method rather than anything we do here.
+
     """
 
     _allowed = None
-- 
cgit 


From 4a6db815b01c71076bae96c155396e5adbe8af90 Mon Sep 17 00:00:00 2001
From: termie <github@anarkystic.com>
Date: Thu, 24 Mar 2011 12:42:47 -0700
Subject: better error handling and serialization

---
 nova/api/direct.py        |  9 ++++++---
 nova/tests/test_direct.py | 12 ++++++++++++
 2 files changed, 18 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/api/direct.py b/nova/api/direct.py
index 2e158e89e..bb2ace1c9 100644
--- a/nova/api/direct.py
+++ b/nova/api/direct.py
@@ -38,6 +38,7 @@ import routes
 import webob
 
 from nova import context
+from nova import exception
 from nova import flags
 from nova import utils
 from nova import wsgi
@@ -205,10 +206,12 @@ class ServiceWrapper(wsgi.Controller):
         # NOTE(vish): make sure we have no unicode keys for py2.6.
         params = dict([(str(k), v) for (k, v) in params.iteritems()])
         result = method(context, **params)
-        if type(result) is dict or type(result) is list:
-            return self._serialize(result, req.best_match_content_type())
-        else:
+        if result is None or type(result) is str or type(result) is unicode:
             return result
+        try:
+            return self._serialize(result, req.best_match_content_type())
+        except:
+            raise exception.Error("returned non-serializable type: %s" % result)
 
 
 class Limited(object):
diff --git a/nova/tests/test_direct.py b/nova/tests/test_direct.py
index 001246fc4..383840234 100644
--- a/nova/tests/test_direct.py
+++ b/nova/tests/test_direct.py
@@ -33,6 +33,9 @@ from nova.api import direct
 from nova.tests import test_cloud
 
 
+class ArbitraryObject(object):
+    pass
+
 class FakeService(object):
     def echo(self, context, data):
         return {'data': data}
@@ -41,6 +44,9 @@ class FakeService(object):
         return {'user': context.user_id,
                 'project': context.project_id}
 
+    def invalid_return(self, context):
+        return ArbitraryObject()
+
 
 class DirectTestCase(test.TestCase):
     def setUp(self):
@@ -86,6 +92,12 @@ class DirectTestCase(test.TestCase):
         resp_parsed = json.loads(resp.body)
         self.assertEqual(resp_parsed['data'], 'foo')
 
+    def test_invalid(self):
+        req = webob.Request.blank('/fake/invalid_return')
+        req.environ['openstack.context'] = self.context
+        req.method = 'POST'
+        self.assertRaises(exception.Error, req.get_response, self.router)
+
     def test_proxy(self):
         proxy = direct.Proxy(self.router)
         rv = proxy.fake.echo(self.context, data='baz')
-- 
cgit 


From c3b98443263de944aa54ae4948330b6cfb9a02a6 Mon Sep 17 00:00:00 2001
From: Ilya Alekseyev <ialekseev@griddynamics.com>
Date: Thu, 24 Mar 2011 23:00:16 +0300
Subject: style and spacing  fixed

---
 nova/utils.py             | 2 +-
 nova/virt/libvirt_conn.py | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/utils.py b/nova/utils.py
index d3375abc3..29e33ad9e 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -316,7 +316,7 @@ def to_global_ipv6(prefix, mac):
         mac64_addr = netaddr.IPAddress(int_addr)
         maskIP = netaddr.IPNetwork(prefix).ip
         return (mac64_addr ^ netaddr.IPAddress('::0200:0:0:0') | maskIP).\
-        format()
+                                                                    format()
     except TypeError:
         raise TypeError(_("Bad mac for to_global_ipv6: %s") % mac)
 
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 c50e6c3879109d2e2e0c2f6b9c42195e9559993d Mon Sep 17 00:00:00 2001
From: Naveed Massjouni <naveedm9@gmail.com>
Date: Thu, 24 Mar 2011 16:18:50 -0400
Subject: Added test_get_servers_with_limit_and_marker to test pagination with
 marker and limit request params.

---
 nova/tests/api/openstack/test_servers.py | 6 ++++++
 1 file changed, 6 insertions(+)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index cfed78b90..c3ece939e 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -245,6 +245,12 @@ class ServersTest(test.TestCase):
         servers = json.loads(res.body)['servers']
         self.assertEqual([s['id'] for s in servers], [3, 4])
 
+    def test_get_servers_with_limit_and_marker(self):
+        req = webob.Request.blank('/v1.1/servers?limit=2&marker=1')
+        res = req.get_response(fakes.wsgi_app())
+        servers = json.loads(res.body)['servers']
+        self.assertEqual([s['id'] for s in servers], [2, 3])
+
     def _setup_for_create_instance(self):
         """Shared implementation for tests below that create instance"""
         def instance_create(context, inst):
-- 
cgit 


From c5cbec20d2785d3060d57b55a264fbf936709500 Mon Sep 17 00:00:00 2001
From: termie <github@anarkystic.com>
Date: Thu, 24 Mar 2011 13:20:15 -0700
Subject: pep8 cleanups

---
 nova/api/direct.py        | 3 ++-
 nova/api/ec2/cloud.py     | 4 +++-
 nova/tests/test_direct.py | 1 +
 3 files changed, 6 insertions(+), 2 deletions(-)

(limited to 'nova')

diff --git a/nova/api/direct.py b/nova/api/direct.py
index bb2ace1c9..e5f33cee4 100644
--- a/nova/api/direct.py
+++ b/nova/api/direct.py
@@ -211,7 +211,8 @@ class ServiceWrapper(wsgi.Controller):
         try:
             return self._serialize(result, req.best_match_content_type())
         except:
-            raise exception.Error("returned non-serializable type: %s" % result)
+            raise exception.Error("returned non-serializable type: %s"
+                                  % result)
 
 
 class Limited(object):
diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 5d31d71d3..0da642318 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -608,7 +608,9 @@ class CloudController(object):
             if field in kwargs:
                 changes[field] = kwargs[field]
         if changes:
-            self.volume_api.update(context, volume_id=volume_id, fields=changes)
+            self.volume_api.update(context,
+                                   volume_id=volume_id,
+                                   fields=changes)
         return True
 
     def attach_volume(self, context, volume_id, instance_id, device, **kwargs):
diff --git a/nova/tests/test_direct.py b/nova/tests/test_direct.py
index 383840234..588a24b35 100644
--- a/nova/tests/test_direct.py
+++ b/nova/tests/test_direct.py
@@ -36,6 +36,7 @@ from nova.tests import test_cloud
 class ArbitraryObject(object):
     pass
 
+
 class FakeService(object):
     def echo(self, context, data):
         return {'data': data}
-- 
cgit 


From a6174e64b541560989c305b50787c96fb5890679 Mon Sep 17 00:00:00 2001
From: Naveed Massjouni <naveedm9@gmail.com>
Date: Thu, 24 Mar 2011 16:31:04 -0400
Subject: Added test_get_servers_with_bad_limit,
 test_get_servers_with_bad_offset and test_get_servers_with_bad_marker.

---
 nova/tests/api/openstack/test_servers.py | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index c3ece939e..c48cc5179 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -239,6 +239,18 @@ class ServersTest(test.TestCase):
         servers = json.loads(res.body)['servers']
         self.assertEqual([s['id'] for s in servers], [1, 2])
 
+    def test_get_servers_with_bad_limit(self):
+        req = webob.Request.blank('/v1.0/servers?limit=asdf&offset=1')
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 400)
+        self.assertTrue(res.body.find('limit param') > -1)
+
+    def test_get_servers_with_bad_offset(self):
+        req = webob.Request.blank('/v1.0/servers?limit=2&offset=asdf')
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 400)
+        self.assertTrue(res.body.find('offset param') > -1)
+
     def test_get_servers_with_marker(self):
         req = webob.Request.blank('/v1.1/servers?marker=2')
         res = req.get_response(fakes.wsgi_app())
@@ -251,6 +263,12 @@ class ServersTest(test.TestCase):
         servers = json.loads(res.body)['servers']
         self.assertEqual([s['id'] for s in servers], [2, 3])
 
+    def test_get_servers_with_bad_marker(self):
+        req = webob.Request.blank('/v1.1/servers?limit=2&marker=asdf')
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 400)
+        self.assertTrue(res.body.find('marker param') > -1)
+
     def _setup_for_create_instance(self):
         """Shared implementation for tests below that create instance"""
         def instance_create(context, inst):
-- 
cgit 


From 3426a9296c6f7d249a9c57ba9e614045ffe2f3c7 Mon Sep 17 00:00:00 2001
From: Josh Kearney <josh@jk0.org>
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')

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 <salvatore.orlando@eu.citrix.com>
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')

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 47592e504cca5c4b36868412720ca1ff443de4d8 Mon Sep 17 00:00:00 2001
From: termie <github@anarkystic.com>
Date: Thu, 24 Mar 2011 16:37:34 -0700
Subject: add s3server, pre-modifications

---
 nova/objectstore/s3server.py | 255 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 255 insertions(+)
 create mode 100644 nova/objectstore/s3server.py

(limited to 'nova')

diff --git a/nova/objectstore/s3server.py b/nova/objectstore/s3server.py
new file mode 100644
index 000000000..b739c6c3b
--- /dev/null
+++ b/nova/objectstore/s3server.py
@@ -0,0 +1,255 @@
+#!/usr/bin/env python
+#
+# Copyright 2009 Facebook
+#
+# 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.
+
+"""Implementation of an S3-like storage server based on local files.
+
+Useful to test features that will eventually run on S3, or if you want to
+run something locally that was once running on S3.
+
+We don't support all the features of S3, but it does work with the
+standard S3 client for the most basic semantics. To use the standard
+S3 client with this module:
+
+    c = S3.AWSAuthConnection("", "", server="localhost", port=8888,
+                             is_secure=False)
+    c.create_bucket("mybucket")
+    c.put("mybucket", "mykey", "a value")
+    print c.get("mybucket", "mykey").body
+
+"""
+
+import bisect
+import datetime
+import hashlib
+import os
+import os.path
+import urllib
+
+from tornado import escape
+from tornado import httpserver
+from tornado import ioloop
+from tornado import web
+
+def start(port, root_directory="/tmp/s3", bucket_depth=0):
+    """Starts the mock S3 server on the given port at the given path."""
+    application = S3Application(root_directory, bucket_depth)
+    http_server = httpserver.HTTPServer(application)
+    http_server.listen(port)
+    ioloop.IOLoop.instance().start()
+
+
+class S3Application(web.Application):
+    """Implementation of an S3-like storage server based on local files.
+
+    If bucket depth is given, we break files up into multiple directories
+    to prevent hitting file system limits for number of files in each
+    directories. 1 means one level of directories, 2 means 2, etc.
+    """
+    def __init__(self, root_directory, bucket_depth=0):
+        web.Application.__init__(self, [
+            (r"/", RootHandler),
+            (r"/([^/]+)/(.+)", ObjectHandler),
+            (r"/([^/]+)/", BucketHandler),
+        ])
+        self.directory = os.path.abspath(root_directory)
+        if not os.path.exists(self.directory):
+            os.makedirs(self.directory)
+        self.bucket_depth = bucket_depth
+
+
+class BaseRequestHandler(web.RequestHandler):
+    SUPPORTED_METHODS = ("PUT", "GET", "DELETE")
+
+    def render_xml(self, value):
+        assert isinstance(value, dict) and len(value) == 1
+        self.set_header("Content-Type", "application/xml; charset=UTF-8")
+        name = value.keys()[0]
+        parts = []
+        parts.append('<' + escape.utf8(name) +
+                     ' xmlns="http://doc.s3.amazonaws.com/2006-03-01">')
+        self._render_parts(value.values()[0], parts)
+        parts.append('</' + escape.utf8(name) + '>')
+        self.finish('<?xml version="1.0" encoding="UTF-8"?>\n' +
+                    ''.join(parts))
+
+    def _render_parts(self, value, parts=[]):
+        if isinstance(value, basestring):
+            parts.append(escape.xhtml_escape(value))
+        elif isinstance(value, int) or isinstance(value, long):
+            parts.append(str(value))
+        elif isinstance(value, datetime.datetime):
+            parts.append(value.strftime("%Y-%m-%dT%H:%M:%S.000Z"))
+        elif isinstance(value, dict):
+            for name, subvalue in value.iteritems():
+                if not isinstance(subvalue, list):
+                    subvalue = [subvalue]
+                for subsubvalue in subvalue:
+                    parts.append('<' + escape.utf8(name) + '>')
+                    self._render_parts(subsubvalue, parts)
+                    parts.append('</' + escape.utf8(name) + '>')
+        else:
+            raise Exception("Unknown S3 value type %r", value)
+
+    def _object_path(self, bucket, object_name):
+        if self.application.bucket_depth < 1:
+            return os.path.abspath(os.path.join(
+                self.application.directory, bucket, object_name))
+        hash = hashlib.md5(object_name).hexdigest()
+        path = os.path.abspath(os.path.join(
+            self.application.directory, bucket))
+        for i in range(self.application.bucket_depth):
+            path = os.path.join(path, hash[:2 * (i + 1)])
+        return os.path.join(path, object_name)
+
+
+class RootHandler(BaseRequestHandler):
+    def get(self):
+        names = os.listdir(self.application.directory)
+        buckets = []
+        for name in names:
+            path = os.path.join(self.application.directory, name)
+            info = os.stat(path)
+            buckets.append({
+                "Name": name,
+                "CreationDate": datetime.datetime.utcfromtimestamp(
+                    info.st_ctime),
+            })
+        self.render_xml({"ListAllMyBucketsResult": {
+            "Buckets": {"Bucket": buckets},
+        }})
+
+
+class BucketHandler(BaseRequestHandler):
+    def get(self, bucket_name):
+        prefix = self.get_argument("prefix", u"")
+        marker = self.get_argument("marker", u"")
+        max_keys = int(self.get_argument("max-keys", 50000))
+        path = os.path.abspath(os.path.join(self.application.directory,
+                                            bucket_name))
+        terse = int(self.get_argument("terse", 0))
+        if not path.startswith(self.application.directory) or \
+           not os.path.isdir(path):
+            raise web.HTTPError(404)
+        object_names = []
+        for root, dirs, files in os.walk(path):
+            for file_name in files:
+                object_names.append(os.path.join(root, file_name))
+        skip = len(path) + 1
+        for i in range(self.application.bucket_depth):
+            skip += 2 * (i + 1) + 1
+        object_names = [n[skip:] for n in object_names]
+        object_names.sort()
+        contents = []
+
+        start_pos = 0
+        if marker:
+            start_pos = bisect.bisect_right(object_names, marker, start_pos)
+        if prefix:
+            start_pos = bisect.bisect_left(object_names, prefix, start_pos)
+
+        truncated = False
+        for object_name in object_names[start_pos:]:
+            if not object_name.startswith(prefix):
+                break
+            if len(contents) >= max_keys:
+                truncated = True
+                break
+            object_path = self._object_path(bucket_name, object_name)
+            c = {"Key": object_name}
+            if not terse:
+                info = os.stat(object_path)
+                c.update({
+                    "LastModified": datetime.datetime.utcfromtimestamp(
+                        info.st_mtime),
+                    "Size": info.st_size,
+                })
+            contents.append(c)
+            marker = object_name
+        self.render_xml({"ListBucketResult": {
+            "Name": bucket_name,
+            "Prefix": prefix,
+            "Marker": marker,
+            "MaxKeys": max_keys,
+            "IsTruncated": truncated,
+            "Contents": contents,
+        }})
+
+    def put(self, bucket_name):
+        path = os.path.abspath(os.path.join(
+            self.application.directory, bucket_name))
+        if not path.startswith(self.application.directory) or \
+           os.path.exists(path):
+            raise web.HTTPError(403)
+        os.makedirs(path)
+        self.finish()
+
+    def delete(self, bucket_name):
+        path = os.path.abspath(os.path.join(
+            self.application.directory, bucket_name))
+        if not path.startswith(self.application.directory) or \
+           not os.path.isdir(path):
+            raise web.HTTPError(404)
+        if len(os.listdir(path)) > 0:
+            raise web.HTTPError(403)
+        os.rmdir(path)
+        self.set_status(204)
+        self.finish()
+
+
+class ObjectHandler(BaseRequestHandler):
+    def get(self, bucket, object_name):
+        object_name = urllib.unquote(object_name)
+        path = self._object_path(bucket, object_name)
+        if not path.startswith(self.application.directory) or \
+           not os.path.isfile(path):
+            raise web.HTTPError(404)
+        info = os.stat(path)
+        self.set_header("Content-Type", "application/unknown")
+        self.set_header("Last-Modified", datetime.datetime.utcfromtimestamp(
+            info.st_mtime))
+        object_file = open(path, "r")
+        try:
+            self.finish(object_file.read())
+        finally:
+            object_file.close()
+
+    def put(self, bucket, object_name):
+        object_name = urllib.unquote(object_name)
+        bucket_dir = os.path.abspath(os.path.join(
+            self.application.directory, bucket))
+        if not bucket_dir.startswith(self.application.directory) or \
+           not os.path.isdir(bucket_dir):
+            raise web.HTTPError(404)
+        path = self._object_path(bucket, object_name)
+        if not path.startswith(bucket_dir) or os.path.isdir(path):
+            raise web.HTTPError(403)
+        directory = os.path.dirname(path)
+        if not os.path.exists(directory):
+            os.makedirs(directory)
+        object_file = open(path, "w")
+        object_file.write(self.request.body)
+        object_file.close()
+        self.finish()
+
+    def delete(self, bucket, object_name):
+        object_name = urllib.unquote(object_name)
+        path = self._object_path(bucket, object_name)
+        if not path.startswith(self.application.directory) or \
+           not os.path.isfile(path):
+            raise web.HTTPError(404)
+        os.unlink(path)
+        self.set_status(204)
+        self.finish()
-- 
cgit 


From d7835f81c46d880d5ba8e67cdcdc9d0bc977f86e Mon Sep 17 00:00:00 2001
From: termie <github@anarkystic.com>
Date: Thu, 24 Mar 2011 16:37:35 -0700
Subject: port s3server to eventlet/wsgi

---
 nova/objectstore/s3server.py | 105 +++++++++++++++++++++++++++++--------------
 1 file changed, 72 insertions(+), 33 deletions(-)

(limited to 'nova')

diff --git a/nova/objectstore/s3server.py b/nova/objectstore/s3server.py
index b739c6c3b..7a7317af2 100644
--- a/nova/objectstore/s3server.py
+++ b/nova/objectstore/s3server.py
@@ -1,5 +1,8 @@
-#!/usr/bin/env python
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
 #
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# Copyright 2010 OpenStack LLC.
 # Copyright 2009 Facebook
 #
 # Licensed under the Apache License, Version 2.0 (the "License"); you may
@@ -38,56 +41,92 @@ import os
 import os.path
 import urllib
 
-from tornado import escape
-from tornado import httpserver
-from tornado import ioloop
-from tornado import web
+import routes
+import webob
 
-def start(port, root_directory="/tmp/s3", bucket_depth=0):
-    """Starts the mock S3 server on the given port at the given path."""
-    application = S3Application(root_directory, bucket_depth)
-    http_server = httpserver.HTTPServer(application)
-    http_server.listen(port)
-    ioloop.IOLoop.instance().start()
+from nova import flags
+from nova import log as logging
+from nova import utils
+from nova import wsgi
 
 
-class S3Application(web.Application):
+FLAGS = flags.FLAGS
+flags.DEFINE_string('buckets_path', '$state_path/buckets',
+                    'path to s3 buckets')
+
+
+class S3Application(wsgi.Router):
     """Implementation of an S3-like storage server based on local files.
 
     If bucket depth is given, we break files up into multiple directories
     to prevent hitting file system limits for number of files in each
     directories. 1 means one level of directories, 2 means 2, etc.
+
     """
-    def __init__(self, root_directory, bucket_depth=0):
-        web.Application.__init__(self, [
-            (r"/", RootHandler),
-            (r"/([^/]+)/(.+)", ObjectHandler),
-            (r"/([^/]+)/", BucketHandler),
-        ])
+
+    def __init__(self, root_directory, bucket_depth=0, mapper=None):
+        if mapper is None:
+            mapper = routes.Mapper()
+
+        mapper.connect('/', controller=RootHandler(self))
+                #controller=lambda *a, **kw: RootHandler(self)(*a, **kw))
+        mapper.connect('/{bucket_name}/{object_name}',
+                controller=lambda *a, **kw: ObjectHandler(self)(*a, **kw))
+        mapper.connect('/{bucket_name}/',
+                controller=lambda *a, **kw: BucketHandler(self)(*a, **kw))
         self.directory = os.path.abspath(root_directory)
         if not os.path.exists(self.directory):
             os.makedirs(self.directory)
         self.bucket_depth = bucket_depth
+        super(S3Application, self).__init__(mapper)
+
+
+class BaseRequestHandler(wsgi.Controller):
+    def __init__(self, application):
+        self.application = application
+
+    @webob.dec.wsgify
+    def __call__(self, request):
+        logging.debug('GOT HERE')
+        method = request.method.lower()
+        f = getattr(self, method, self.invalid)
+        self.request = request
+        self.response = webob.Response()
+        params = request.environ['wsgiorg.routing_args'][1]
+        del params['controller']
+        f(**params)
+        return self.response
+
+    def get_argument(self, arg, default):
+        return self.request.str_params.get(arg, default)
+
+    def set_header(self, header, value):
+        self.response.headers[header] = value
+
+    def set_status(self, status_code):
+        self.response.status = status_code
 
+    def finish(self, body=''):
+        self.response.body = utils.utf8(body)
 
-class BaseRequestHandler(web.RequestHandler):
-    SUPPORTED_METHODS = ("PUT", "GET", "DELETE")
+    def invalid(self, request, **kwargs):
+        pass
 
     def render_xml(self, value):
         assert isinstance(value, dict) and len(value) == 1
         self.set_header("Content-Type", "application/xml; charset=UTF-8")
         name = value.keys()[0]
         parts = []
-        parts.append('<' + escape.utf8(name) +
+        parts.append('<' + utils.utf8(name) +
                      ' xmlns="http://doc.s3.amazonaws.com/2006-03-01">')
         self._render_parts(value.values()[0], parts)
-        parts.append('</' + escape.utf8(name) + '>')
+        parts.append('</' + utils.utf8(name) + '>')
         self.finish('<?xml version="1.0" encoding="UTF-8"?>\n' +
                     ''.join(parts))
 
     def _render_parts(self, value, parts=[]):
         if isinstance(value, basestring):
-            parts.append(escape.xhtml_escape(value))
+            parts.append(utils.xhtml_escape(value))
         elif isinstance(value, int) or isinstance(value, long):
             parts.append(str(value))
         elif isinstance(value, datetime.datetime):
@@ -97,9 +136,9 @@ class BaseRequestHandler(web.RequestHandler):
                 if not isinstance(subvalue, list):
                     subvalue = [subvalue]
                 for subsubvalue in subvalue:
-                    parts.append('<' + escape.utf8(name) + '>')
+                    parts.append('<' + utils.utf8(name) + '>')
                     self._render_parts(subsubvalue, parts)
-                    parts.append('</' + escape.utf8(name) + '>')
+                    parts.append('</' + utils.utf8(name) + '>')
         else:
             raise Exception("Unknown S3 value type %r", value)
 
@@ -142,7 +181,7 @@ class BucketHandler(BaseRequestHandler):
         terse = int(self.get_argument("terse", 0))
         if not path.startswith(self.application.directory) or \
            not os.path.isdir(path):
-            raise web.HTTPError(404)
+            raise webob.exc.HTTPError(404)
         object_names = []
         for root, dirs, files in os.walk(path):
             for file_name in files:
@@ -192,7 +231,7 @@ class BucketHandler(BaseRequestHandler):
             self.application.directory, bucket_name))
         if not path.startswith(self.application.directory) or \
            os.path.exists(path):
-            raise web.HTTPError(403)
+            raise webob.exc.HTTPError(403)
         os.makedirs(path)
         self.finish()
 
@@ -201,9 +240,9 @@ class BucketHandler(BaseRequestHandler):
             self.application.directory, bucket_name))
         if not path.startswith(self.application.directory) or \
            not os.path.isdir(path):
-            raise web.HTTPError(404)
+            raise webob.exc.HTTPError(404)
         if len(os.listdir(path)) > 0:
-            raise web.HTTPError(403)
+            raise webob.exc.HTTPError(403)
         os.rmdir(path)
         self.set_status(204)
         self.finish()
@@ -215,7 +254,7 @@ class ObjectHandler(BaseRequestHandler):
         path = self._object_path(bucket, object_name)
         if not path.startswith(self.application.directory) or \
            not os.path.isfile(path):
-            raise web.HTTPError(404)
+            raise webob.exc.HTTPError(404)
         info = os.stat(path)
         self.set_header("Content-Type", "application/unknown")
         self.set_header("Last-Modified", datetime.datetime.utcfromtimestamp(
@@ -232,10 +271,10 @@ class ObjectHandler(BaseRequestHandler):
             self.application.directory, bucket))
         if not bucket_dir.startswith(self.application.directory) or \
            not os.path.isdir(bucket_dir):
-            raise web.HTTPError(404)
+            raise webob.exc.HTTPError(404)
         path = self._object_path(bucket, object_name)
         if not path.startswith(bucket_dir) or os.path.isdir(path):
-            raise web.HTTPError(403)
+            raise webob.exc.HTTPError(403)
         directory = os.path.dirname(path)
         if not os.path.exists(directory):
             os.makedirs(directory)
@@ -249,7 +288,7 @@ class ObjectHandler(BaseRequestHandler):
         path = self._object_path(bucket, object_name)
         if not path.startswith(self.application.directory) or \
            not os.path.isfile(path):
-            raise web.HTTPError(404)
+            raise webob.exc.HTTPError(404)
         os.unlink(path)
         self.set_status(204)
         self.finish()
-- 
cgit 


From acad7a627b92ffffb6bc76d9d72640e1d43f7e26 Mon Sep 17 00:00:00 2001
From: termie <github@anarkystic.com>
Date: Thu, 24 Mar 2011 16:37:35 -0700
Subject: rename objectstore tests

---
 nova/tests/objectstore_unittest.py | 315 -------------------------------------
 nova/tests/test_objectstore.py     | 315 +++++++++++++++++++++++++++++++++++++
 2 files changed, 315 insertions(+), 315 deletions(-)
 delete mode 100644 nova/tests/objectstore_unittest.py
 create mode 100644 nova/tests/test_objectstore.py

(limited to 'nova')

diff --git a/nova/tests/objectstore_unittest.py b/nova/tests/objectstore_unittest.py
deleted file mode 100644
index 4e2ac205e..000000000
--- a/nova/tests/objectstore_unittest.py
+++ /dev/null
@@ -1,315 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 United States Government as represented by the
-# Administrator of the National Aeronautics and Space Administration.
-# 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.
-
-"""
-Unittets for S3 objectstore clone.
-"""
-
-import boto
-import glob
-import hashlib
-import os
-import shutil
-import tempfile
-
-from boto.s3.connection import S3Connection, OrdinaryCallingFormat
-from twisted.internet import reactor, threads, defer
-from twisted.web import http, server
-
-from nova import context
-from nova import flags
-from nova import objectstore
-from nova import test
-from nova.auth import manager
-from nova.exception import NotEmpty, NotFound
-from nova.objectstore import image
-from nova.objectstore.handler import S3
-
-
-FLAGS = flags.FLAGS
-
-# Create a unique temporary directory. We don't delete after test to
-# allow checking the contents after running tests. Users and/or tools
-# running the tests need to remove the tests directories.
-OSS_TEMPDIR = tempfile.mkdtemp(prefix='test_oss-')
-
-# Create bucket/images path
-os.makedirs(os.path.join(OSS_TEMPDIR, 'images'))
-os.makedirs(os.path.join(OSS_TEMPDIR, 'buckets'))
-
-
-class ObjectStoreTestCase(test.TestCase):
-    """Test objectstore API directly."""
-
-    def setUp(self):
-        """Setup users and projects."""
-        super(ObjectStoreTestCase, self).setUp()
-        self.flags(buckets_path=os.path.join(OSS_TEMPDIR, 'buckets'),
-                   images_path=os.path.join(OSS_TEMPDIR, 'images'),
-                   ca_path=os.path.join(os.path.dirname(__file__), 'CA'))
-
-        self.auth_manager = manager.AuthManager()
-        self.auth_manager.create_user('user1')
-        self.auth_manager.create_user('user2')
-        self.auth_manager.create_user('admin_user', admin=True)
-        self.auth_manager.create_project('proj1', 'user1', 'a proj', ['user1'])
-        self.auth_manager.create_project('proj2', 'user2', 'a proj', ['user2'])
-        self.context = context.RequestContext('user1', 'proj1')
-
-    def tearDown(self):
-        """Tear down users and projects."""
-        self.auth_manager.delete_project('proj1')
-        self.auth_manager.delete_project('proj2')
-        self.auth_manager.delete_user('user1')
-        self.auth_manager.delete_user('user2')
-        self.auth_manager.delete_user('admin_user')
-        super(ObjectStoreTestCase, self).tearDown()
-
-    def test_buckets(self):
-        """Test the bucket API."""
-        objectstore.bucket.Bucket.create('new_bucket', self.context)
-        bucket = objectstore.bucket.Bucket('new_bucket')
-
-        # creator is authorized to use bucket
-        self.assert_(bucket.is_authorized(self.context))
-
-        # another user is not authorized
-        context2 = context.RequestContext('user2', 'proj2')
-        self.assertFalse(bucket.is_authorized(context2))
-
-        # admin is authorized to use bucket
-        admin_context = context.RequestContext('admin_user', None)
-        self.assertTrue(bucket.is_authorized(admin_context))
-
-        # new buckets are empty
-        self.assertTrue(bucket.list_keys()['Contents'] == [])
-
-        # storing keys works
-        bucket['foo'] = "bar"
-
-        self.assertEquals(len(bucket.list_keys()['Contents']), 1)
-
-        self.assertEquals(bucket['foo'].read(), 'bar')
-
-        # md5 of key works
-        self.assertEquals(bucket['foo'].md5, hashlib.md5('bar').hexdigest())
-
-        # deleting non-empty bucket should throw a NotEmpty exception
-        self.assertRaises(NotEmpty, bucket.delete)
-
-        # deleting key
-        del bucket['foo']
-
-        # deleting empty bucket
-        bucket.delete()
-
-        # accessing deleted bucket throws exception
-        self.assertRaises(NotFound, objectstore.bucket.Bucket, 'new_bucket')
-
-    def test_images(self):
-        self.do_test_images('1mb.manifest.xml', True,
-                            'image_bucket1', 'i-testing1')
-
-    def test_images_no_kernel_or_ramdisk(self):
-        self.do_test_images('1mb.no_kernel_or_ramdisk.manifest.xml',
-                            False, 'image_bucket2', 'i-testing2')
-
-    def do_test_images(self, manifest_file, expect_kernel_and_ramdisk,
-                             image_bucket, image_name):
-        "Test the image API."
-
-        # create a bucket for our bundle
-        objectstore.bucket.Bucket.create(image_bucket, self.context)
-        bucket = objectstore.bucket.Bucket(image_bucket)
-
-        # upload an image manifest/parts
-        bundle_path = os.path.join(os.path.dirname(__file__), 'bundle')
-        for path in glob.glob(bundle_path + '/*'):
-            bucket[os.path.basename(path)] = open(path, 'rb').read()
-
-        # register an image
-        image.Image.register_aws_image(image_name,
-                                       '%s/%s' % (image_bucket, manifest_file),
-                                       self.context)
-
-        # verify image
-        my_img = image.Image(image_name)
-        result_image_file = os.path.join(my_img.path, 'image')
-        self.assertEqual(os.stat(result_image_file).st_size, 1048576)
-
-        sha = hashlib.sha1(open(result_image_file).read()).hexdigest()
-        self.assertEqual(sha, '3b71f43ff30f4b15b5cd85dd9e95ebc7e84eb5a3')
-
-        if expect_kernel_and_ramdisk:
-            # Verify the default kernel and ramdisk are set
-            self.assertEqual(my_img.metadata['kernelId'], 'aki-test')
-            self.assertEqual(my_img.metadata['ramdiskId'], 'ari-test')
-        else:
-            # Verify that the default kernel and ramdisk (the one from FLAGS)
-            # doesn't get embedded in the metadata
-            self.assertFalse('kernelId' in my_img.metadata)
-            self.assertFalse('ramdiskId' in my_img.metadata)
-
-        # verify image permissions
-        context2 = context.RequestContext('user2', 'proj2')
-        self.assertFalse(my_img.is_authorized(context2))
-
-        # change user-editable fields
-        my_img.update_user_editable_fields({'display_name': 'my cool image'})
-        self.assertEqual('my cool image', my_img.metadata['displayName'])
-        my_img.update_user_editable_fields({'display_name': ''})
-        self.assert_(not my_img.metadata['displayName'])
-
-
-class TestHTTPChannel(http.HTTPChannel):
-    """Dummy site required for twisted.web"""
-
-    def checkPersistence(self, _, __):  # pylint: disable=C0103
-        """Otherwise we end up with an unclean reactor."""
-        return False
-
-
-class TestSite(server.Site):
-    """Dummy site required for twisted.web"""
-    protocol = TestHTTPChannel
-
-
-class S3APITestCase(test.TestCase):
-    """Test objectstore through S3 API."""
-
-    def setUp(self):
-        """Setup users, projects, and start a test server."""
-        super(S3APITestCase, self).setUp()
-
-        FLAGS.auth_driver = 'nova.auth.ldapdriver.FakeLdapDriver'
-        FLAGS.buckets_path = os.path.join(OSS_TEMPDIR, 'buckets')
-
-        self.auth_manager = manager.AuthManager()
-        self.admin_user = self.auth_manager.create_user('admin', admin=True)
-        self.admin_project = self.auth_manager.create_project('admin',
-                                                              self.admin_user)
-
-        shutil.rmtree(FLAGS.buckets_path)
-        os.mkdir(FLAGS.buckets_path)
-
-        root = S3()
-        self.site = TestSite(root)
-        # pylint: disable=E1101
-        self.listening_port = reactor.listenTCP(0, self.site,
-                                                interface='127.0.0.1')
-        # pylint: enable=E1101
-        self.tcp_port = self.listening_port.getHost().port
-
-        if not boto.config.has_section('Boto'):
-            boto.config.add_section('Boto')
-        boto.config.set('Boto', 'num_retries', '0')
-        self.conn = S3Connection(aws_access_key_id=self.admin_user.access,
-                                 aws_secret_access_key=self.admin_user.secret,
-                                 host='127.0.0.1',
-                                 port=self.tcp_port,
-                                 is_secure=False,
-                                 calling_format=OrdinaryCallingFormat())
-
-        def get_http_connection(host, is_secure):
-            """Get a new S3 connection, don't attempt to reuse connections."""
-            return self.conn.new_http_connection(host, is_secure)
-
-        self.conn.get_http_connection = get_http_connection
-
-    def _ensure_no_buckets(self, buckets):  # pylint: disable=C0111
-        self.assertEquals(len(buckets), 0, "Bucket list was not empty")
-        return True
-
-    def _ensure_one_bucket(self, buckets, name):  # pylint: disable=C0111
-        self.assertEquals(len(buckets), 1,
-                          "Bucket list didn't have exactly one element in it")
-        self.assertEquals(buckets[0].name, name, "Wrong name")
-        return True
-
-    def test_000_list_buckets(self):
-        """Make sure we are starting with no buckets."""
-        deferred = threads.deferToThread(self.conn.get_all_buckets)
-        deferred.addCallback(self._ensure_no_buckets)
-        return deferred
-
-    def test_001_create_and_delete_bucket(self):
-        """Test bucket creation and deletion."""
-        bucket_name = 'testbucket'
-
-        deferred = threads.deferToThread(self.conn.create_bucket, bucket_name)
-        deferred.addCallback(lambda _:
-                             threads.deferToThread(self.conn.get_all_buckets))
-
-        deferred.addCallback(self._ensure_one_bucket, bucket_name)
-
-        deferred.addCallback(lambda _:
-                             threads.deferToThread(self.conn.delete_bucket,
-                                                   bucket_name))
-        deferred.addCallback(lambda _:
-                             threads.deferToThread(self.conn.get_all_buckets))
-        deferred.addCallback(self._ensure_no_buckets)
-        return deferred
-
-    def test_002_create_bucket_and_key_and_delete_key_again(self):
-        """Test key operations on buckets."""
-        bucket_name = 'testbucket'
-        key_name = 'somekey'
-        key_contents = 'somekey'
-
-        deferred = threads.deferToThread(self.conn.create_bucket, bucket_name)
-        deferred.addCallback(lambda b:
-                             threads.deferToThread(b.new_key, key_name))
-        deferred.addCallback(lambda k:
-                             threads.deferToThread(k.set_contents_from_string,
-                                                   key_contents))
-
-        def ensure_key_contents(bucket_name, key_name, contents):
-            """Verify contents for a key in the given bucket."""
-            bucket = self.conn.get_bucket(bucket_name)
-            key = bucket.get_key(key_name)
-            self.assertEquals(key.get_contents_as_string(), contents,
-                              "Bad contents")
-
-        deferred.addCallback(lambda _:
-                             threads.deferToThread(ensure_key_contents,
-                                                   bucket_name, key_name,
-                                                   key_contents))
-
-        def delete_key(bucket_name, key_name):
-            """Delete a key for the given bucket."""
-            bucket = self.conn.get_bucket(bucket_name)
-            key = bucket.get_key(key_name)
-            key.delete()
-
-        deferred.addCallback(lambda _:
-                             threads.deferToThread(delete_key, bucket_name,
-                                                   key_name))
-        deferred.addCallback(lambda _:
-                             threads.deferToThread(self.conn.get_bucket,
-                                                   bucket_name))
-        deferred.addCallback(lambda b: threads.deferToThread(b.get_all_keys))
-        deferred.addCallback(self._ensure_no_buckets)
-        return deferred
-
-    def tearDown(self):
-        """Tear down auth and test server."""
-        self.auth_manager.delete_user('admin')
-        self.auth_manager.delete_project('admin')
-        stop_listening = defer.maybeDeferred(self.listening_port.stopListening)
-        super(S3APITestCase, self).tearDown()
-        return defer.DeferredList([stop_listening])
diff --git a/nova/tests/test_objectstore.py b/nova/tests/test_objectstore.py
new file mode 100644
index 000000000..4e2ac205e
--- /dev/null
+++ b/nova/tests/test_objectstore.py
@@ -0,0 +1,315 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# 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.
+
+"""
+Unittets for S3 objectstore clone.
+"""
+
+import boto
+import glob
+import hashlib
+import os
+import shutil
+import tempfile
+
+from boto.s3.connection import S3Connection, OrdinaryCallingFormat
+from twisted.internet import reactor, threads, defer
+from twisted.web import http, server
+
+from nova import context
+from nova import flags
+from nova import objectstore
+from nova import test
+from nova.auth import manager
+from nova.exception import NotEmpty, NotFound
+from nova.objectstore import image
+from nova.objectstore.handler import S3
+
+
+FLAGS = flags.FLAGS
+
+# Create a unique temporary directory. We don't delete after test to
+# allow checking the contents after running tests. Users and/or tools
+# running the tests need to remove the tests directories.
+OSS_TEMPDIR = tempfile.mkdtemp(prefix='test_oss-')
+
+# Create bucket/images path
+os.makedirs(os.path.join(OSS_TEMPDIR, 'images'))
+os.makedirs(os.path.join(OSS_TEMPDIR, 'buckets'))
+
+
+class ObjectStoreTestCase(test.TestCase):
+    """Test objectstore API directly."""
+
+    def setUp(self):
+        """Setup users and projects."""
+        super(ObjectStoreTestCase, self).setUp()
+        self.flags(buckets_path=os.path.join(OSS_TEMPDIR, 'buckets'),
+                   images_path=os.path.join(OSS_TEMPDIR, 'images'),
+                   ca_path=os.path.join(os.path.dirname(__file__), 'CA'))
+
+        self.auth_manager = manager.AuthManager()
+        self.auth_manager.create_user('user1')
+        self.auth_manager.create_user('user2')
+        self.auth_manager.create_user('admin_user', admin=True)
+        self.auth_manager.create_project('proj1', 'user1', 'a proj', ['user1'])
+        self.auth_manager.create_project('proj2', 'user2', 'a proj', ['user2'])
+        self.context = context.RequestContext('user1', 'proj1')
+
+    def tearDown(self):
+        """Tear down users and projects."""
+        self.auth_manager.delete_project('proj1')
+        self.auth_manager.delete_project('proj2')
+        self.auth_manager.delete_user('user1')
+        self.auth_manager.delete_user('user2')
+        self.auth_manager.delete_user('admin_user')
+        super(ObjectStoreTestCase, self).tearDown()
+
+    def test_buckets(self):
+        """Test the bucket API."""
+        objectstore.bucket.Bucket.create('new_bucket', self.context)
+        bucket = objectstore.bucket.Bucket('new_bucket')
+
+        # creator is authorized to use bucket
+        self.assert_(bucket.is_authorized(self.context))
+
+        # another user is not authorized
+        context2 = context.RequestContext('user2', 'proj2')
+        self.assertFalse(bucket.is_authorized(context2))
+
+        # admin is authorized to use bucket
+        admin_context = context.RequestContext('admin_user', None)
+        self.assertTrue(bucket.is_authorized(admin_context))
+
+        # new buckets are empty
+        self.assertTrue(bucket.list_keys()['Contents'] == [])
+
+        # storing keys works
+        bucket['foo'] = "bar"
+
+        self.assertEquals(len(bucket.list_keys()['Contents']), 1)
+
+        self.assertEquals(bucket['foo'].read(), 'bar')
+
+        # md5 of key works
+        self.assertEquals(bucket['foo'].md5, hashlib.md5('bar').hexdigest())
+
+        # deleting non-empty bucket should throw a NotEmpty exception
+        self.assertRaises(NotEmpty, bucket.delete)
+
+        # deleting key
+        del bucket['foo']
+
+        # deleting empty bucket
+        bucket.delete()
+
+        # accessing deleted bucket throws exception
+        self.assertRaises(NotFound, objectstore.bucket.Bucket, 'new_bucket')
+
+    def test_images(self):
+        self.do_test_images('1mb.manifest.xml', True,
+                            'image_bucket1', 'i-testing1')
+
+    def test_images_no_kernel_or_ramdisk(self):
+        self.do_test_images('1mb.no_kernel_or_ramdisk.manifest.xml',
+                            False, 'image_bucket2', 'i-testing2')
+
+    def do_test_images(self, manifest_file, expect_kernel_and_ramdisk,
+                             image_bucket, image_name):
+        "Test the image API."
+
+        # create a bucket for our bundle
+        objectstore.bucket.Bucket.create(image_bucket, self.context)
+        bucket = objectstore.bucket.Bucket(image_bucket)
+
+        # upload an image manifest/parts
+        bundle_path = os.path.join(os.path.dirname(__file__), 'bundle')
+        for path in glob.glob(bundle_path + '/*'):
+            bucket[os.path.basename(path)] = open(path, 'rb').read()
+
+        # register an image
+        image.Image.register_aws_image(image_name,
+                                       '%s/%s' % (image_bucket, manifest_file),
+                                       self.context)
+
+        # verify image
+        my_img = image.Image(image_name)
+        result_image_file = os.path.join(my_img.path, 'image')
+        self.assertEqual(os.stat(result_image_file).st_size, 1048576)
+
+        sha = hashlib.sha1(open(result_image_file).read()).hexdigest()
+        self.assertEqual(sha, '3b71f43ff30f4b15b5cd85dd9e95ebc7e84eb5a3')
+
+        if expect_kernel_and_ramdisk:
+            # Verify the default kernel and ramdisk are set
+            self.assertEqual(my_img.metadata['kernelId'], 'aki-test')
+            self.assertEqual(my_img.metadata['ramdiskId'], 'ari-test')
+        else:
+            # Verify that the default kernel and ramdisk (the one from FLAGS)
+            # doesn't get embedded in the metadata
+            self.assertFalse('kernelId' in my_img.metadata)
+            self.assertFalse('ramdiskId' in my_img.metadata)
+
+        # verify image permissions
+        context2 = context.RequestContext('user2', 'proj2')
+        self.assertFalse(my_img.is_authorized(context2))
+
+        # change user-editable fields
+        my_img.update_user_editable_fields({'display_name': 'my cool image'})
+        self.assertEqual('my cool image', my_img.metadata['displayName'])
+        my_img.update_user_editable_fields({'display_name': ''})
+        self.assert_(not my_img.metadata['displayName'])
+
+
+class TestHTTPChannel(http.HTTPChannel):
+    """Dummy site required for twisted.web"""
+
+    def checkPersistence(self, _, __):  # pylint: disable=C0103
+        """Otherwise we end up with an unclean reactor."""
+        return False
+
+
+class TestSite(server.Site):
+    """Dummy site required for twisted.web"""
+    protocol = TestHTTPChannel
+
+
+class S3APITestCase(test.TestCase):
+    """Test objectstore through S3 API."""
+
+    def setUp(self):
+        """Setup users, projects, and start a test server."""
+        super(S3APITestCase, self).setUp()
+
+        FLAGS.auth_driver = 'nova.auth.ldapdriver.FakeLdapDriver'
+        FLAGS.buckets_path = os.path.join(OSS_TEMPDIR, 'buckets')
+
+        self.auth_manager = manager.AuthManager()
+        self.admin_user = self.auth_manager.create_user('admin', admin=True)
+        self.admin_project = self.auth_manager.create_project('admin',
+                                                              self.admin_user)
+
+        shutil.rmtree(FLAGS.buckets_path)
+        os.mkdir(FLAGS.buckets_path)
+
+        root = S3()
+        self.site = TestSite(root)
+        # pylint: disable=E1101
+        self.listening_port = reactor.listenTCP(0, self.site,
+                                                interface='127.0.0.1')
+        # pylint: enable=E1101
+        self.tcp_port = self.listening_port.getHost().port
+
+        if not boto.config.has_section('Boto'):
+            boto.config.add_section('Boto')
+        boto.config.set('Boto', 'num_retries', '0')
+        self.conn = S3Connection(aws_access_key_id=self.admin_user.access,
+                                 aws_secret_access_key=self.admin_user.secret,
+                                 host='127.0.0.1',
+                                 port=self.tcp_port,
+                                 is_secure=False,
+                                 calling_format=OrdinaryCallingFormat())
+
+        def get_http_connection(host, is_secure):
+            """Get a new S3 connection, don't attempt to reuse connections."""
+            return self.conn.new_http_connection(host, is_secure)
+
+        self.conn.get_http_connection = get_http_connection
+
+    def _ensure_no_buckets(self, buckets):  # pylint: disable=C0111
+        self.assertEquals(len(buckets), 0, "Bucket list was not empty")
+        return True
+
+    def _ensure_one_bucket(self, buckets, name):  # pylint: disable=C0111
+        self.assertEquals(len(buckets), 1,
+                          "Bucket list didn't have exactly one element in it")
+        self.assertEquals(buckets[0].name, name, "Wrong name")
+        return True
+
+    def test_000_list_buckets(self):
+        """Make sure we are starting with no buckets."""
+        deferred = threads.deferToThread(self.conn.get_all_buckets)
+        deferred.addCallback(self._ensure_no_buckets)
+        return deferred
+
+    def test_001_create_and_delete_bucket(self):
+        """Test bucket creation and deletion."""
+        bucket_name = 'testbucket'
+
+        deferred = threads.deferToThread(self.conn.create_bucket, bucket_name)
+        deferred.addCallback(lambda _:
+                             threads.deferToThread(self.conn.get_all_buckets))
+
+        deferred.addCallback(self._ensure_one_bucket, bucket_name)
+
+        deferred.addCallback(lambda _:
+                             threads.deferToThread(self.conn.delete_bucket,
+                                                   bucket_name))
+        deferred.addCallback(lambda _:
+                             threads.deferToThread(self.conn.get_all_buckets))
+        deferred.addCallback(self._ensure_no_buckets)
+        return deferred
+
+    def test_002_create_bucket_and_key_and_delete_key_again(self):
+        """Test key operations on buckets."""
+        bucket_name = 'testbucket'
+        key_name = 'somekey'
+        key_contents = 'somekey'
+
+        deferred = threads.deferToThread(self.conn.create_bucket, bucket_name)
+        deferred.addCallback(lambda b:
+                             threads.deferToThread(b.new_key, key_name))
+        deferred.addCallback(lambda k:
+                             threads.deferToThread(k.set_contents_from_string,
+                                                   key_contents))
+
+        def ensure_key_contents(bucket_name, key_name, contents):
+            """Verify contents for a key in the given bucket."""
+            bucket = self.conn.get_bucket(bucket_name)
+            key = bucket.get_key(key_name)
+            self.assertEquals(key.get_contents_as_string(), contents,
+                              "Bad contents")
+
+        deferred.addCallback(lambda _:
+                             threads.deferToThread(ensure_key_contents,
+                                                   bucket_name, key_name,
+                                                   key_contents))
+
+        def delete_key(bucket_name, key_name):
+            """Delete a key for the given bucket."""
+            bucket = self.conn.get_bucket(bucket_name)
+            key = bucket.get_key(key_name)
+            key.delete()
+
+        deferred.addCallback(lambda _:
+                             threads.deferToThread(delete_key, bucket_name,
+                                                   key_name))
+        deferred.addCallback(lambda _:
+                             threads.deferToThread(self.conn.get_bucket,
+                                                   bucket_name))
+        deferred.addCallback(lambda b: threads.deferToThread(b.get_all_keys))
+        deferred.addCallback(self._ensure_no_buckets)
+        return deferred
+
+    def tearDown(self):
+        """Tear down auth and test server."""
+        self.auth_manager.delete_user('admin')
+        self.auth_manager.delete_project('admin')
+        stop_listening = defer.maybeDeferred(self.listening_port.stopListening)
+        super(S3APITestCase, self).tearDown()
+        return defer.DeferredList([stop_listening])
-- 
cgit 


From 0deaa854d1854c0edaf2b8ba903ee79638c7b2d0 Mon Sep 17 00:00:00 2001
From: termie <github@anarkystic.com>
Date: Thu, 24 Mar 2011 16:38:28 -0700
Subject: update test base class to monkey patch wsgi

---
 nova/test.py | 37 ++++++++++++++++++++++++++++++++-----
 1 file changed, 32 insertions(+), 5 deletions(-)

(limited to 'nova')

diff --git a/nova/test.py b/nova/test.py
index e0fef6101..5170775d0 100644
--- a/nova/test.py
+++ b/nova/test.py
@@ -24,6 +24,7 @@ and some black magic for inline callbacks.
 
 
 import datetime
+import functools
 import os
 import shutil
 import uuid
@@ -32,6 +33,8 @@ import unittest
 import mox
 import shutil
 import stubout
+from eventlet import greenpool
+from eventlet import greenthread
 
 from nova import context
 from nova import db
@@ -39,6 +42,7 @@ from nova import fakerabbit
 from nova import flags
 from nova import rpc
 from nova import service
+from nova import wsgi
 
 
 FLAGS = flags.FLAGS
@@ -79,6 +83,7 @@ class TestCase(unittest.TestCase):
         self.injected = []
         self._services = []
         self._monkey_patch_attach()
+        self._monkey_patch_wsgi()
         self._original_flags = FLAGS.FlagValuesDict()
 
     def tearDown(self):
@@ -99,7 +104,8 @@ class TestCase(unittest.TestCase):
             self.reset_flags()
 
             # Reset our monkey-patches
-            rpc.Consumer.attach_to_eventlet = self.originalAttach
+            rpc.Consumer.attach_to_eventlet = self.original_attach
+            wsgi.Server.start = self.original_start
 
             # Stop any timers
             for x in self.injected:
@@ -141,16 +147,37 @@ class TestCase(unittest.TestCase):
         return svc
 
     def _monkey_patch_attach(self):
-        self.originalAttach = rpc.Consumer.attach_to_eventlet
+        self.original_attach = rpc.Consumer.attach_to_eventlet
 
-        def _wrapped(innerSelf):
-            rv = self.originalAttach(innerSelf)
+        def _wrapped(inner_self):
+            rv = self.original_attach(inner_self)
             self.injected.append(rv)
             return rv
 
-        _wrapped.func_name = self.originalAttach.func_name
+        _wrapped.func_name = self.original_attach.func_name
         rpc.Consumer.attach_to_eventlet = _wrapped
 
+    def _monkey_patch_wsgi(self):
+        """Allow us to kill servers spawned by wsgi.Server."""
+        # TODO(termie): change these patterns to use functools
+        self.original_start = wsgi.Server.start
+
+        @functools.wraps(self.original_start)
+        def _wrapped_start(inner_self, *args, **kwargs):
+            original_spawn_n = inner_self.pool.spawn_n
+
+            @functools.wraps(original_spawn_n)
+            def _wrapped_spawn_n(*args, **kwargs):
+                rv = greenthread.spawn(*args, **kwargs)
+                self._services.append(rv)
+
+            inner_self.pool.spawn_n = _wrapped_spawn_n
+            self.original_start(inner_self, *args, **kwargs)
+            inner_self.pool.spawn_n = original_spawn_n
+
+        _wrapped_start.func_name = self.original_start.func_name
+        wsgi.Server.start = _wrapped_start
+
     # Useful assertions
     def assertDictMatch(self, d1, d2):
         """Assert two dicts are equivalent.
-- 
cgit 


From 2b243dbb2e12a7f510a7c6c01298884fa8927c12 Mon Sep 17 00:00:00 2001
From: termie <github@anarkystic.com>
Date: Thu, 24 Mar 2011 16:38:30 -0700
Subject: port the objectstore tests to the new tests

---
 nova/objectstore/bucket.py     |   3 +-
 nova/objectstore/s3server.py   |  35 +++---
 nova/test.py                   |   1 -
 nova/tests/test_objectstore.py | 247 +++++++----------------------------------
 4 files changed, 64 insertions(+), 222 deletions(-)

(limited to 'nova')

diff --git a/nova/objectstore/bucket.py b/nova/objectstore/bucket.py
index b213e18e8..017b933a9 100644
--- a/nova/objectstore/bucket.py
+++ b/nova/objectstore/bucket.py
@@ -33,8 +33,7 @@ from nova.objectstore import stored
 
 
 FLAGS = flags.FLAGS
-flags.DEFINE_string('buckets_path', '$state_path/buckets',
-                    'path to s3 buckets')
+flags.DECLARE('buckets_path', 'nova.objectstore.s3server')
 
 
 class Bucket(object):
diff --git a/nova/objectstore/s3server.py b/nova/objectstore/s3server.py
index 7a7317af2..83ca5bfa3 100644
--- a/nova/objectstore/s3server.py
+++ b/nova/objectstore/s3server.py
@@ -68,9 +68,9 @@ class S3Application(wsgi.Router):
         if mapper is None:
             mapper = routes.Mapper()
 
-        mapper.connect('/', controller=RootHandler(self))
-                #controller=lambda *a, **kw: RootHandler(self)(*a, **kw))
-        mapper.connect('/{bucket_name}/{object_name}',
+        mapper.connect('/',
+                controller=lambda *a, **kw: RootHandler(self)(*a, **kw))
+        mapper.connect('/{bucket}/{object_name}',
                 controller=lambda *a, **kw: ObjectHandler(self)(*a, **kw))
         mapper.connect('/{bucket_name}/',
                 controller=lambda *a, **kw: BucketHandler(self)(*a, **kw))
@@ -87,7 +87,6 @@ class BaseRequestHandler(wsgi.Controller):
 
     @webob.dec.wsgify
     def __call__(self, request):
-        logging.debug('GOT HERE')
         method = request.method.lower()
         f = getattr(self, method, self.invalid)
         self.request = request
@@ -109,7 +108,7 @@ class BaseRequestHandler(wsgi.Controller):
     def finish(self, body=''):
         self.response.body = utils.utf8(body)
 
-    def invalid(self, request, **kwargs):
+    def invalid(self, **kwargs):
         pass
 
     def render_xml(self, value):
@@ -181,7 +180,8 @@ class BucketHandler(BaseRequestHandler):
         terse = int(self.get_argument("terse", 0))
         if not path.startswith(self.application.directory) or \
            not os.path.isdir(path):
-            raise webob.exc.HTTPError(404)
+            self.set_status(404)
+            return
         object_names = []
         for root, dirs, files in os.walk(path):
             for file_name in files:
@@ -231,7 +231,8 @@ class BucketHandler(BaseRequestHandler):
             self.application.directory, bucket_name))
         if not path.startswith(self.application.directory) or \
            os.path.exists(path):
-            raise webob.exc.HTTPError(403)
+            self.set_status(403)
+            return
         os.makedirs(path)
         self.finish()
 
@@ -240,9 +241,11 @@ class BucketHandler(BaseRequestHandler):
             self.application.directory, bucket_name))
         if not path.startswith(self.application.directory) or \
            not os.path.isdir(path):
-            raise webob.exc.HTTPError(404)
+            self.set_status(404)
+            return
         if len(os.listdir(path)) > 0:
-            raise webob.exc.HTTPError(403)
+            self.set_status(403)
+            return
         os.rmdir(path)
         self.set_status(204)
         self.finish()
@@ -254,7 +257,8 @@ class ObjectHandler(BaseRequestHandler):
         path = self._object_path(bucket, object_name)
         if not path.startswith(self.application.directory) or \
            not os.path.isfile(path):
-            raise webob.exc.HTTPError(404)
+            self.set_status(404)
+            return
         info = os.stat(path)
         self.set_header("Content-Type", "application/unknown")
         self.set_header("Last-Modified", datetime.datetime.utcfromtimestamp(
@@ -271,16 +275,20 @@ class ObjectHandler(BaseRequestHandler):
             self.application.directory, bucket))
         if not bucket_dir.startswith(self.application.directory) or \
            not os.path.isdir(bucket_dir):
-            raise webob.exc.HTTPError(404)
+            self.set_status(404)
+            return
         path = self._object_path(bucket, object_name)
         if not path.startswith(bucket_dir) or os.path.isdir(path):
-            raise webob.exc.HTTPError(403)
+            self.set_status(403)
+            return
         directory = os.path.dirname(path)
         if not os.path.exists(directory):
             os.makedirs(directory)
         object_file = open(path, "w")
         object_file.write(self.request.body)
         object_file.close()
+        self.set_header('ETag',
+                        '"%s"' % hashlib.md5(self.request.body).hexdigest())
         self.finish()
 
     def delete(self, bucket, object_name):
@@ -288,7 +296,8 @@ class ObjectHandler(BaseRequestHandler):
         path = self._object_path(bucket, object_name)
         if not path.startswith(self.application.directory) or \
            not os.path.isfile(path):
-            raise webob.exc.HTTPError(404)
+            self.set_status(404)
+            return
         os.unlink(path)
         self.set_status(204)
         self.finish()
diff --git a/nova/test.py b/nova/test.py
index 5170775d0..3b608520a 100644
--- a/nova/test.py
+++ b/nova/test.py
@@ -33,7 +33,6 @@ import unittest
 import mox
 import shutil
 import stubout
-from eventlet import greenpool
 from eventlet import greenthread
 
 from nova import context
diff --git a/nova/tests/test_objectstore.py b/nova/tests/test_objectstore.py
index 4e2ac205e..c4d344503 100644
--- a/nova/tests/test_objectstore.py
+++ b/nova/tests/test_objectstore.py
@@ -27,18 +27,18 @@ import os
 import shutil
 import tempfile
 
-from boto.s3.connection import S3Connection, OrdinaryCallingFormat
-from twisted.internet import reactor, threads, defer
-from twisted.web import http, server
+from boto import exception as boto_exception
+from boto.s3 import connection as s3
 
 from nova import context
+from nova import exception
 from nova import flags
 from nova import objectstore
+from nova import wsgi
 from nova import test
 from nova.auth import manager
-from nova.exception import NotEmpty, NotFound
-from nova.objectstore import image
-from nova.objectstore.handler import S3
+#from nova.exception import NotEmpty, NotFound
+from nova.objectstore import s3server
 
 
 FLAGS = flags.FLAGS
@@ -53,151 +53,15 @@ os.makedirs(os.path.join(OSS_TEMPDIR, 'images'))
 os.makedirs(os.path.join(OSS_TEMPDIR, 'buckets'))
 
 
-class ObjectStoreTestCase(test.TestCase):
-    """Test objectstore API directly."""
-
-    def setUp(self):
-        """Setup users and projects."""
-        super(ObjectStoreTestCase, self).setUp()
-        self.flags(buckets_path=os.path.join(OSS_TEMPDIR, 'buckets'),
-                   images_path=os.path.join(OSS_TEMPDIR, 'images'),
-                   ca_path=os.path.join(os.path.dirname(__file__), 'CA'))
-
-        self.auth_manager = manager.AuthManager()
-        self.auth_manager.create_user('user1')
-        self.auth_manager.create_user('user2')
-        self.auth_manager.create_user('admin_user', admin=True)
-        self.auth_manager.create_project('proj1', 'user1', 'a proj', ['user1'])
-        self.auth_manager.create_project('proj2', 'user2', 'a proj', ['user2'])
-        self.context = context.RequestContext('user1', 'proj1')
-
-    def tearDown(self):
-        """Tear down users and projects."""
-        self.auth_manager.delete_project('proj1')
-        self.auth_manager.delete_project('proj2')
-        self.auth_manager.delete_user('user1')
-        self.auth_manager.delete_user('user2')
-        self.auth_manager.delete_user('admin_user')
-        super(ObjectStoreTestCase, self).tearDown()
-
-    def test_buckets(self):
-        """Test the bucket API."""
-        objectstore.bucket.Bucket.create('new_bucket', self.context)
-        bucket = objectstore.bucket.Bucket('new_bucket')
-
-        # creator is authorized to use bucket
-        self.assert_(bucket.is_authorized(self.context))
-
-        # another user is not authorized
-        context2 = context.RequestContext('user2', 'proj2')
-        self.assertFalse(bucket.is_authorized(context2))
-
-        # admin is authorized to use bucket
-        admin_context = context.RequestContext('admin_user', None)
-        self.assertTrue(bucket.is_authorized(admin_context))
-
-        # new buckets are empty
-        self.assertTrue(bucket.list_keys()['Contents'] == [])
-
-        # storing keys works
-        bucket['foo'] = "bar"
-
-        self.assertEquals(len(bucket.list_keys()['Contents']), 1)
-
-        self.assertEquals(bucket['foo'].read(), 'bar')
-
-        # md5 of key works
-        self.assertEquals(bucket['foo'].md5, hashlib.md5('bar').hexdigest())
-
-        # deleting non-empty bucket should throw a NotEmpty exception
-        self.assertRaises(NotEmpty, bucket.delete)
-
-        # deleting key
-        del bucket['foo']
-
-        # deleting empty bucket
-        bucket.delete()
-
-        # accessing deleted bucket throws exception
-        self.assertRaises(NotFound, objectstore.bucket.Bucket, 'new_bucket')
-
-    def test_images(self):
-        self.do_test_images('1mb.manifest.xml', True,
-                            'image_bucket1', 'i-testing1')
-
-    def test_images_no_kernel_or_ramdisk(self):
-        self.do_test_images('1mb.no_kernel_or_ramdisk.manifest.xml',
-                            False, 'image_bucket2', 'i-testing2')
-
-    def do_test_images(self, manifest_file, expect_kernel_and_ramdisk,
-                             image_bucket, image_name):
-        "Test the image API."
-
-        # create a bucket for our bundle
-        objectstore.bucket.Bucket.create(image_bucket, self.context)
-        bucket = objectstore.bucket.Bucket(image_bucket)
-
-        # upload an image manifest/parts
-        bundle_path = os.path.join(os.path.dirname(__file__), 'bundle')
-        for path in glob.glob(bundle_path + '/*'):
-            bucket[os.path.basename(path)] = open(path, 'rb').read()
-
-        # register an image
-        image.Image.register_aws_image(image_name,
-                                       '%s/%s' % (image_bucket, manifest_file),
-                                       self.context)
-
-        # verify image
-        my_img = image.Image(image_name)
-        result_image_file = os.path.join(my_img.path, 'image')
-        self.assertEqual(os.stat(result_image_file).st_size, 1048576)
-
-        sha = hashlib.sha1(open(result_image_file).read()).hexdigest()
-        self.assertEqual(sha, '3b71f43ff30f4b15b5cd85dd9e95ebc7e84eb5a3')
-
-        if expect_kernel_and_ramdisk:
-            # Verify the default kernel and ramdisk are set
-            self.assertEqual(my_img.metadata['kernelId'], 'aki-test')
-            self.assertEqual(my_img.metadata['ramdiskId'], 'ari-test')
-        else:
-            # Verify that the default kernel and ramdisk (the one from FLAGS)
-            # doesn't get embedded in the metadata
-            self.assertFalse('kernelId' in my_img.metadata)
-            self.assertFalse('ramdiskId' in my_img.metadata)
-
-        # verify image permissions
-        context2 = context.RequestContext('user2', 'proj2')
-        self.assertFalse(my_img.is_authorized(context2))
-
-        # change user-editable fields
-        my_img.update_user_editable_fields({'display_name': 'my cool image'})
-        self.assertEqual('my cool image', my_img.metadata['displayName'])
-        my_img.update_user_editable_fields({'display_name': ''})
-        self.assert_(not my_img.metadata['displayName'])
-
-
-class TestHTTPChannel(http.HTTPChannel):
-    """Dummy site required for twisted.web"""
-
-    def checkPersistence(self, _, __):  # pylint: disable=C0103
-        """Otherwise we end up with an unclean reactor."""
-        return False
-
-
-class TestSite(server.Site):
-    """Dummy site required for twisted.web"""
-    protocol = TestHTTPChannel
-
-
 class S3APITestCase(test.TestCase):
     """Test objectstore through S3 API."""
 
     def setUp(self):
         """Setup users, projects, and start a test server."""
         super(S3APITestCase, self).setUp()
-
-        FLAGS.auth_driver = 'nova.auth.ldapdriver.FakeLdapDriver'
-        FLAGS.buckets_path = os.path.join(OSS_TEMPDIR, 'buckets')
+        self.flags(auth_driver='nova.auth.ldapdriver.FakeLdapDriver',
+                   buckets_path=os.path.join(OSS_TEMPDIR, 'buckets'),
+                   s3_host='127.0.0.1')
 
         self.auth_manager = manager.AuthManager()
         self.admin_user = self.auth_manager.create_user('admin', admin=True)
@@ -207,23 +71,20 @@ class S3APITestCase(test.TestCase):
         shutil.rmtree(FLAGS.buckets_path)
         os.mkdir(FLAGS.buckets_path)
 
-        root = S3()
-        self.site = TestSite(root)
-        # pylint: disable=E1101
-        self.listening_port = reactor.listenTCP(0, self.site,
-                                                interface='127.0.0.1')
-        # pylint: enable=E1101
-        self.tcp_port = self.listening_port.getHost().port
+        router = s3server.S3Application(FLAGS.buckets_path)
+        server = wsgi.Server()
+        server.start(router, FLAGS.s3_port, host=FLAGS.s3_host)
 
         if not boto.config.has_section('Boto'):
             boto.config.add_section('Boto')
         boto.config.set('Boto', 'num_retries', '0')
-        self.conn = S3Connection(aws_access_key_id=self.admin_user.access,
-                                 aws_secret_access_key=self.admin_user.secret,
-                                 host='127.0.0.1',
-                                 port=self.tcp_port,
-                                 is_secure=False,
-                                 calling_format=OrdinaryCallingFormat())
+        conn = s3.S3Connection(aws_access_key_id=self.admin_user.access,
+                               aws_secret_access_key=self.admin_user.secret,
+                               host=FLAGS.s3_host,
+                               port=FLAGS.s3_port,
+                               is_secure=False,
+                               calling_format=s3.OrdinaryCallingFormat())
+        self.conn = conn
 
         def get_http_connection(host, is_secure):
             """Get a new S3 connection, don't attempt to reuse connections."""
@@ -243,27 +104,16 @@ class S3APITestCase(test.TestCase):
 
     def test_000_list_buckets(self):
         """Make sure we are starting with no buckets."""
-        deferred = threads.deferToThread(self.conn.get_all_buckets)
-        deferred.addCallback(self._ensure_no_buckets)
-        return deferred
+        self._ensure_no_buckets(self.conn.get_all_buckets())
 
     def test_001_create_and_delete_bucket(self):
         """Test bucket creation and deletion."""
         bucket_name = 'testbucket'
 
-        deferred = threads.deferToThread(self.conn.create_bucket, bucket_name)
-        deferred.addCallback(lambda _:
-                             threads.deferToThread(self.conn.get_all_buckets))
-
-        deferred.addCallback(self._ensure_one_bucket, bucket_name)
-
-        deferred.addCallback(lambda _:
-                             threads.deferToThread(self.conn.delete_bucket,
-                                                   bucket_name))
-        deferred.addCallback(lambda _:
-                             threads.deferToThread(self.conn.get_all_buckets))
-        deferred.addCallback(self._ensure_no_buckets)
-        return deferred
+        self.conn.create_bucket(bucket_name)
+        self._ensure_one_bucket(self.conn.get_all_buckets(), bucket_name)
+        self.conn.delete_bucket(bucket_name)
+        self._ensure_no_buckets(self.conn.get_all_buckets())
 
     def test_002_create_bucket_and_key_and_delete_key_again(self):
         """Test key operations on buckets."""
@@ -271,45 +121,30 @@ class S3APITestCase(test.TestCase):
         key_name = 'somekey'
         key_contents = 'somekey'
 
-        deferred = threads.deferToThread(self.conn.create_bucket, bucket_name)
-        deferred.addCallback(lambda b:
-                             threads.deferToThread(b.new_key, key_name))
-        deferred.addCallback(lambda k:
-                             threads.deferToThread(k.set_contents_from_string,
-                                                   key_contents))
+        b = self.conn.create_bucket(bucket_name)
+        k = b.new_key(key_name)
+        k.set_contents_from_string(key_contents)
+
+        bucket = self.conn.get_bucket(bucket_name)
 
-        def ensure_key_contents(bucket_name, key_name, contents):
-            """Verify contents for a key in the given bucket."""
-            bucket = self.conn.get_bucket(bucket_name)
-            key = bucket.get_key(key_name)
-            self.assertEquals(key.get_contents_as_string(), contents,
-                              "Bad contents")
+        # make sure the contents are correct
+        key = bucket.get_key(key_name)
+        self.assertEquals(key.get_contents_as_string(), key_contents,
+                          "Bad contents")
 
-        deferred.addCallback(lambda _:
-                             threads.deferToThread(ensure_key_contents,
-                                                   bucket_name, key_name,
-                                                   key_contents))
+        # delete the key
+        key.delete()
 
-        def delete_key(bucket_name, key_name):
-            """Delete a key for the given bucket."""
-            bucket = self.conn.get_bucket(bucket_name)
-            key = bucket.get_key(key_name)
-            key.delete()
+        self._ensure_no_buckets(bucket.get_all_keys())
 
-        deferred.addCallback(lambda _:
-                             threads.deferToThread(delete_key, bucket_name,
-                                                   key_name))
-        deferred.addCallback(lambda _:
-                             threads.deferToThread(self.conn.get_bucket,
-                                                   bucket_name))
-        deferred.addCallback(lambda b: threads.deferToThread(b.get_all_keys))
-        deferred.addCallback(self._ensure_no_buckets)
-        return deferred
+    def test_unknown_bucket(self):
+        bucket_name = 'falalala'
+        self.assertRaises(boto_exception.S3ResponseError,
+                          self.conn.get_bucket,
+                          bucket_name)
 
     def tearDown(self):
         """Tear down auth and test server."""
         self.auth_manager.delete_user('admin')
         self.auth_manager.delete_project('admin')
-        stop_listening = defer.maybeDeferred(self.listening_port.stopListening)
         super(S3APITestCase, self).tearDown()
-        return defer.DeferredList([stop_listening])
-- 
cgit 


From bab306061618e911971c4f7275824df60d1b42fd Mon Sep 17 00:00:00 2001
From: termie <github@anarkystic.com>
Date: Thu, 24 Mar 2011 16:38:30 -0700
Subject: remove twisted objectstore

---
 nova/objectstore/bucket.py     | 180 ----------------
 nova/objectstore/handler.py    | 478 -----------------------------------------
 nova/objectstore/image.py      | 296 -------------------------
 nova/objectstore/stored.py     |  63 ------
 nova/tests/test_cloud.py       |  49 +----
 nova/tests/test_objectstore.py |   2 -
 6 files changed, 3 insertions(+), 1065 deletions(-)
 delete mode 100644 nova/objectstore/bucket.py
 delete mode 100644 nova/objectstore/handler.py
 delete mode 100644 nova/objectstore/image.py
 delete mode 100644 nova/objectstore/stored.py

(limited to 'nova')

diff --git a/nova/objectstore/bucket.py b/nova/objectstore/bucket.py
deleted file mode 100644
index 017b933a9..000000000
--- a/nova/objectstore/bucket.py
+++ /dev/null
@@ -1,180 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 United States Government as represented by the
-# Administrator of the National Aeronautics and Space Administration.
-# 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.
-
-"""
-Simple object store using Blobs and JSON files on disk.
-"""
-
-import bisect
-import datetime
-import glob
-import json
-import os
-
-from nova import exception
-from nova import flags
-from nova import utils
-from nova.objectstore import stored
-
-
-FLAGS = flags.FLAGS
-flags.DECLARE('buckets_path', 'nova.objectstore.s3server')
-
-
-class Bucket(object):
-    def __init__(self, name):
-        self.name = name
-        self.path = os.path.abspath(os.path.join(FLAGS.buckets_path, name))
-        if not self.path.startswith(os.path.abspath(FLAGS.buckets_path)) or \
-           not os.path.isdir(self.path):
-            raise exception.NotFound()
-
-        self.ctime = os.path.getctime(self.path)
-
-    def __repr__(self):
-        return "<Bucket: %s>" % self.name
-
-    @staticmethod
-    def all():
-        """ list of all buckets """
-        buckets = []
-        for fn in glob.glob("%s/*.json" % FLAGS.buckets_path):
-            try:
-                json.load(open(fn))
-                name = os.path.split(fn)[-1][:-5]
-                buckets.append(Bucket(name))
-            except:
-                pass
-
-        return buckets
-
-    @staticmethod
-    def create(bucket_name, context):
-        """Create a new bucket owned by a project.
-
-        @bucket_name: a string representing the name of the bucket to create
-        @context: a nova.auth.api.ApiContext object representing who owns the
-                  bucket.
-
-        Raises:
-            NotAuthorized: if the bucket is already exists or has invalid name
-        """
-        path = os.path.abspath(os.path.join(
-            FLAGS.buckets_path, bucket_name))
-        if not path.startswith(os.path.abspath(FLAGS.buckets_path)) or \
-        os.path.exists(path):
-            raise exception.NotAuthorized()
-
-        os.makedirs(path)
-
-        with open(path + '.json', 'w') as f:
-            json.dump({'ownerId': context.project_id}, f)
-
-    @property
-    def metadata(self):
-        """ dictionary of metadata around bucket,
-        keys are 'Name' and 'CreationDate'
-        """
-
-        return {
-            "Name": self.name,
-            "CreationDate": datetime.datetime.utcfromtimestamp(self.ctime),
-        }
-
-    @property
-    def owner_id(self):
-        try:
-            with open(self.path + '.json') as f:
-                return json.load(f)['ownerId']
-        except:
-            return None
-
-    def is_authorized(self, context):
-        try:
-            return context.is_admin or \
-                   self.owner_id == context.project_id
-        except Exception, e:
-            return False
-
-    def list_keys(self, prefix='', marker=None, max_keys=1000, terse=False):
-        object_names = []
-        path_length = len(self.path)
-        for root, dirs, files in os.walk(self.path):
-            for file_name in files:
-                object_name = os.path.join(root, file_name)[path_length + 1:]
-                object_names.append(object_name)
-        object_names.sort()
-        contents = []
-
-        start_pos = 0
-        if marker:
-            start_pos = bisect.bisect_right(object_names, marker, start_pos)
-        if prefix:
-            start_pos = bisect.bisect_left(object_names, prefix, start_pos)
-
-        truncated = False
-        for object_name in object_names[start_pos:]:
-            if not object_name.startswith(prefix):
-                break
-            if len(contents) >= max_keys:
-                truncated = True
-                break
-            object_path = self._object_path(object_name)
-            c = {"Key": object_name}
-            if not terse:
-                info = os.stat(object_path)
-                c.update({
-                    "LastModified": datetime.datetime.utcfromtimestamp(
-                        info.st_mtime),
-                    "Size": info.st_size,
-                })
-            contents.append(c)
-            marker = object_name
-
-        return {
-            "Name": self.name,
-            "Prefix": prefix,
-            "Marker": marker,
-            "MaxKeys": max_keys,
-            "IsTruncated": truncated,
-            "Contents": contents,
-        }
-
-    def _object_path(self, object_name):
-        fn = os.path.join(self.path, object_name)
-
-        if not fn.startswith(self.path):
-            raise exception.NotAuthorized()
-
-        return fn
-
-    def delete(self):
-        if len(os.listdir(self.path)) > 0:
-            raise exception.NotEmpty()
-        os.rmdir(self.path)
-        os.remove(self.path + '.json')
-
-    def __getitem__(self, key):
-        return stored.Object(self, key)
-
-    def __setitem__(self, key, value):
-        with open(self._object_path(key), 'wb') as f:
-            f.write(value)
-
-    def __delitem__(self, key):
-        stored.Object(self, key).delete()
diff --git a/nova/objectstore/handler.py b/nova/objectstore/handler.py
deleted file mode 100644
index 554c72848..000000000
--- a/nova/objectstore/handler.py
+++ /dev/null
@@ -1,478 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-#
-#    Copyright 2010 OpenStack LLC.
-#    Copyright 2010 United States Government as represented by the
-#    Administrator of the National Aeronautics and Space Administration.
-#    All Rights Reserved.
-#
-#    Copyright 2009 Facebook
-#
-#    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.
-
-"""
-Implementation of an S3-like storage server based on local files.
-
-Useful to test features that will eventually run on S3, or if you want to
-run something locally that was once running on S3.
-
-We don't support all the features of S3, but it does work with the
-standard S3 client for the most basic semantics. To use the standard
-S3 client with this module::
-
-    c = S3.AWSAuthConnection("", "", server="localhost", port=8888,
-                             is_secure=False)
-    c.create_bucket("mybucket")
-    c.put("mybucket", "mykey", "a value")
-    print c.get("mybucket", "mykey").body
-
-"""
-
-import datetime
-import json
-import multiprocessing
-import os
-import urllib
-
-from twisted.application import internet
-from twisted.application import service
-from twisted.web import error
-from twisted.web import resource
-from twisted.web import server
-from twisted.web import static
-
-from nova import context
-from nova import exception
-from nova import flags
-from nova import log as logging
-from nova import utils
-from nova.auth import manager
-from nova.objectstore import bucket
-from nova.objectstore import image
-
-
-LOG = logging.getLogger('nova.objectstore.handler')
-FLAGS = flags.FLAGS
-flags.DEFINE_string('s3_listen_host', '', 'Host to listen on.')
-
-
-def render_xml(request, value):
-    """Writes value as XML string to request"""
-    assert isinstance(value, dict) and len(value) == 1
-    request.setHeader("Content-Type", "application/xml; charset=UTF-8")
-
-    name = value.keys()[0]
-    request.write('<?xml version="1.0" encoding="UTF-8"?>\n')
-    request.write('<' + utils.utf8(name) +
-                 ' xmlns="http://doc.s3.amazonaws.com/2006-03-01">')
-    _render_parts(value.values()[0], request.write)
-    request.write('</' + utils.utf8(name) + '>')
-    request.finish()
-
-
-def finish(request, content=None):
-    """Finalizer method for request"""
-    if content:
-        request.write(content)
-    request.finish()
-
-
-def _render_parts(value, write_cb):
-    """Helper method to render different Python objects to XML"""
-    if isinstance(value, basestring):
-        write_cb(utils.xhtml_escape(value))
-    elif isinstance(value, int) or isinstance(value, long):
-        write_cb(str(value))
-    elif isinstance(value, datetime.datetime):
-        write_cb(value.strftime("%Y-%m-%dT%H:%M:%S.000Z"))
-    elif isinstance(value, dict):
-        for name, subvalue in value.iteritems():
-            if not isinstance(subvalue, list):
-                subvalue = [subvalue]
-            for subsubvalue in subvalue:
-                write_cb('<' + utils.utf8(name) + '>')
-                _render_parts(subsubvalue, write_cb)
-                write_cb('</' + utils.utf8(name) + '>')
-    else:
-        raise Exception(_("Unknown S3 value type %r"), value)
-
-
-def get_argument(request, key, default_value):
-    """Returns the request's value at key, or default_value
-    if not found
-    """
-    if key in request.args:
-        return request.args[key][0]
-    return default_value
-
-
-def get_context(request):
-    """Returns the supplied request's context object"""
-    try:
-        # Authorization Header format: 'AWS <access>:<secret>'
-        authorization_header = request.getHeader('Authorization')
-        if not authorization_header:
-            raise exception.NotAuthorized()
-        auth_header_value = authorization_header.split(' ')[1]
-        access, _ignored, secret = auth_header_value.rpartition(':')
-        am = manager.AuthManager()
-        (user, project) = am.authenticate(access,
-                                          secret,
-                                          {},
-                                          request.method,
-                                          request.getRequestHostname(),
-                                          request.uri,
-                                          headers=request.getAllHeaders(),
-                                          check_type='s3')
-        rv = context.RequestContext(user, project)
-        LOG.audit(_("Authenticated request"), context=rv)
-        return rv
-    except exception.Error as ex:
-        LOG.debug(_("Authentication Failure: %s"), ex)
-        raise exception.NotAuthorized()
-
-
-class ErrorHandlingResource(resource.Resource):
-    """Maps exceptions to 404 / 401 codes.  Won't work for
-    exceptions thrown after NOT_DONE_YET is returned.
-    """
-    # TODO(unassigned) (calling-all-twisted-experts): This needs to be
-    #                   plugged in to the right place in twisted...
-    #                   This doesn't look like it's the right place
-    #                   (consider exceptions in getChild; or after
-    #                   NOT_DONE_YET is returned
-    def render(self, request):
-        """Renders the response as XML"""
-        try:
-            return resource.Resource.render(self, request)
-        except exception.NotFound:
-            request.setResponseCode(404)
-            return ''
-        except exception.NotAuthorized:
-            request.setResponseCode(403)
-            return ''
-
-
-class S3(ErrorHandlingResource):
-    """Implementation of an S3-like storage server based on local files."""
-    def __init__(self):
-        ErrorHandlingResource.__init__(self)
-
-    def getChild(self, name, request):  # pylint: disable=C0103
-        """Returns either the image or bucket resource"""
-        request.context = get_context(request)
-        if name == '':
-            return self
-        elif name == '_images':
-            return ImagesResource()
-        else:
-            return BucketResource(name)
-
-    def render_GET(self, request):  # pylint: disable=R0201
-        """Renders the GET request for a list of buckets as XML"""
-        LOG.debug(_('List of buckets requested'), context=request.context)
-        buckets = [b for b in bucket.Bucket.all()
-                   if b.is_authorized(request.context)]
-
-        render_xml(request, {"ListAllMyBucketsResult": {
-            "Buckets": {"Bucket": [b.metadata for b in buckets]},
-        }})
-        return server.NOT_DONE_YET
-
-
-class BucketResource(ErrorHandlingResource):
-    """A web resource containing an S3-like bucket"""
-    def __init__(self, name):
-        resource.Resource.__init__(self)
-        self.name = name
-
-    def getChild(self, name, request):
-        """Returns the bucket resource itself, or the object resource
-        the bucket contains if a name is supplied
-        """
-        if name == '':
-            return self
-        else:
-            return ObjectResource(bucket.Bucket(self.name), name)
-
-    def render_GET(self, request):
-        "Returns the keys for the bucket resource"""
-        LOG.debug(_("List keys for bucket %s"), self.name)
-
-        try:
-            bucket_object = bucket.Bucket(self.name)
-        except exception.NotFound:
-            return error.NoResource(message="No such bucket").render(request)
-
-        if not bucket_object.is_authorized(request.context):
-            LOG.audit(_("Unauthorized attempt to access bucket %s"),
-                      self.name, context=request.context)
-            raise exception.NotAuthorized()
-
-        prefix = get_argument(request, "prefix", u"")
-        marker = get_argument(request, "marker", u"")
-        max_keys = int(get_argument(request, "max-keys", 1000))
-        terse = int(get_argument(request, "terse", 0))
-
-        results = bucket_object.list_keys(prefix=prefix,
-                                          marker=marker,
-                                          max_keys=max_keys,
-                                          terse=terse)
-        render_xml(request, {"ListBucketResult": results})
-        return server.NOT_DONE_YET
-
-    def render_PUT(self, request):
-        "Creates the bucket resource"""
-        LOG.debug(_("Creating bucket %s"), self.name)
-        LOG.debug("calling bucket.Bucket.create(%r, %r)",
-                      self.name,
-                      request.context)
-        bucket.Bucket.create(self.name, request.context)
-        request.finish()
-        return server.NOT_DONE_YET
-
-    def render_DELETE(self, request):
-        """Deletes the bucket resource"""
-        LOG.debug(_("Deleting bucket %s"), self.name)
-        bucket_object = bucket.Bucket(self.name)
-
-        if not bucket_object.is_authorized(request.context):
-            LOG.audit(_("Unauthorized attempt to delete bucket %s"),
-                      self.name, context=request.context)
-            raise exception.NotAuthorized()
-
-        bucket_object.delete()
-        request.setResponseCode(204)
-        return ''
-
-
-class ObjectResource(ErrorHandlingResource):
-    """The resource returned from a bucket"""
-    def __init__(self, bucket, name):
-        resource.Resource.__init__(self)
-        self.bucket = bucket
-        self.name = name
-
-    def render_GET(self, request):
-        """Returns the object
-
-        Raises NotAuthorized if user in request context is not
-        authorized to delete the object.
-        """
-        bname = self.bucket.name
-        nm = self.name
-        LOG.debug(_("Getting object: %(bname)s / %(nm)s") % locals())
-
-        if not self.bucket.is_authorized(request.context):
-            LOG.audit(_("Unauthorized attempt to get object %(nm)s"
-                    " from bucket %(bname)s") % locals(),
-                    context=request.context)
-            raise exception.NotAuthorized()
-
-        obj = self.bucket[urllib.unquote(self.name)]
-        request.setHeader("Content-Type", "application/unknown")
-        request.setHeader("Last-Modified",
-                          datetime.datetime.utcfromtimestamp(obj.mtime))
-        request.setHeader("Etag", '"' + obj.md5 + '"')
-        return static.File(obj.path).render_GET(request)
-
-    def render_PUT(self, request):
-        """Modifies/inserts the object and returns a result code
-
-        Raises NotAuthorized if user in request context is not
-        authorized to delete the object.
-        """
-        nm = self.name
-        bname = self.bucket.name
-        LOG.debug(_("Putting object: %(bname)s / %(nm)s") % locals())
-
-        if not self.bucket.is_authorized(request.context):
-            LOG.audit(_("Unauthorized attempt to upload object %(nm)s to"
-                    " bucket %(bname)s") % locals(), context=request.context)
-            raise exception.NotAuthorized()
-
-        key = urllib.unquote(self.name)
-        request.content.seek(0, 0)
-        self.bucket[key] = request.content.read()
-        request.setHeader("Etag", '"' + self.bucket[key].md5 + '"')
-        finish(request)
-        return server.NOT_DONE_YET
-
-    def render_DELETE(self, request):
-        """Deletes the object and returns a result code
-
-        Raises NotAuthorized if user in request context is not
-        authorized to delete the object.
-        """
-        nm = self.name
-        bname = self.bucket.name
-        LOG.debug(_("Deleting object: %(bname)s / %(nm)s") % locals(),
-                  context=request.context)
-
-        if not self.bucket.is_authorized(request.context):
-            LOG.audit(_("Unauthorized attempt to delete object %(nm)s from "
-                      "bucket %(bname)s") % locals(), context=request.context)
-            raise exception.NotAuthorized()
-
-        del self.bucket[urllib.unquote(self.name)]
-        request.setResponseCode(204)
-        return ''
-
-
-class ImageResource(ErrorHandlingResource):
-    """A web resource representing a single image"""
-    isLeaf = True
-
-    def __init__(self, name):
-        resource.Resource.__init__(self)
-        self.img = image.Image(name)
-
-    def render_GET(self, request):
-        """Returns the image file"""
-        if not self.img.is_authorized(request.context, True):
-            raise exception.NotAuthorized()
-        return static.File(self.img.image_path,
-                           defaultType='application/octet-stream').\
-                           render_GET(request)
-
-
-class ImagesResource(resource.Resource):
-    """A web resource representing a list of images"""
-
-    def getChild(self, name, _request):
-        """Returns itself or an ImageResource if no name given"""
-        if name == '':
-            return self
-        else:
-            return ImageResource(name)
-
-    def render_GET(self, request):  # pylint: disable=R0201
-        """ returns a json listing of all images
-            that a user has permissions to see """
-
-        images = [i for i in image.Image.all() \
-                  if i.is_authorized(request.context, readonly=True)]
-
-        # Bug #617776:
-        # We used to have 'type' in the image metadata, but this field
-        # should be called 'imageType', as per the EC2 specification.
-        # For compat with old metadata files we copy type to imageType if
-        # imageType is not present.
-        # For compat with euca2ools (and any other clients using the
-        # incorrect name) we copy imageType to type.
-        # imageType is primary if we end up with both in the metadata file
-        # (which should never happen).
-        def decorate(m):
-            if 'imageType' not in m and 'type' in m:
-                m[u'imageType'] = m['type']
-            elif 'imageType' in m:
-                m[u'type'] = m['imageType']
-            if 'displayName' not in m:
-                m[u'displayName'] = u''
-            return m
-
-        request.write(json.dumps([decorate(i.metadata) for i in images]))
-        request.finish()
-        return server.NOT_DONE_YET
-
-    def render_PUT(self, request):  # pylint: disable=R0201
-        """ create a new registered image """
-
-        image_id = get_argument(request, 'image_id', u'')
-        image_location = get_argument(request, 'image_location', u'')
-
-        image_path = os.path.join(FLAGS.images_path, image_id)
-        if ((not image_path.startswith(FLAGS.images_path)) or
-                os.path.exists(image_path)):
-            LOG.audit(_("Not authorized to upload image: invalid directory "
-                      "%s"),
-                      image_path, context=request.context)
-            raise exception.NotAuthorized()
-
-        bucket_object = bucket.Bucket(image_location.split("/")[0])
-
-        if not bucket_object.is_authorized(request.context):
-            LOG.audit(_("Not authorized to upload image: unauthorized "
-                      "bucket %s"), bucket_object.name,
-                      context=request.context)
-            raise exception.NotAuthorized()
-
-        LOG.audit(_("Starting image upload: %s"), image_id,
-                  context=request.context)
-        p = multiprocessing.Process(target=image.Image.register_aws_image,
-                args=(image_id, image_location, request.context))
-        p.start()
-        return ''
-
-    def render_POST(self, request):  # pylint: disable=R0201
-        """Update image attributes: public/private"""
-
-        # image_id required for all requests
-        image_id = get_argument(request, 'image_id', u'')
-        image_object = image.Image(image_id)
-        if not image_object.is_authorized(request.context):
-            LOG.audit(_("Not authorized to update attributes of image %s"),
-                      image_id, context=request.context)
-            raise exception.NotAuthorized()
-
-        operation = get_argument(request, 'operation', u'')
-        if operation:
-            # operation implies publicity toggle
-            newstatus = (operation == 'add')
-            LOG.audit(_("Toggling publicity flag of image %(image_id)s"
-                    " %(newstatus)r") % locals(), context=request.context)
-            image_object.set_public(newstatus)
-        else:
-            # other attributes imply update
-            LOG.audit(_("Updating user fields on image %s"), image_id,
-                     context=request.context)
-            clean_args = {}
-            for arg in request.args.keys():
-                clean_args[arg] = request.args[arg][0]
-            image_object.update_user_editable_fields(clean_args)
-        return ''
-
-    def render_DELETE(self, request):  # pylint: disable=R0201
-        """Delete a registered image"""
-        image_id = get_argument(request, "image_id", u"")
-        image_object = image.Image(image_id)
-
-        if not image_object.is_authorized(request.context):
-            LOG.audit(_("Unauthorized attempt to delete image %s"),
-                      image_id, context=request.context)
-            raise exception.NotAuthorized()
-
-        image_object.delete()
-        LOG.audit(_("Deleted image: %s"), image_id, context=request.context)
-
-        request.setResponseCode(204)
-        return ''
-
-
-def get_site():
-    """Support for WSGI-like interfaces"""
-    root = S3()
-    site = server.Site(root)
-    return site
-
-
-def get_application():
-    """Support WSGI-like interfaces"""
-    factory = get_site()
-    application = service.Application("objectstore")
-    # Disabled because of lack of proper introspection in Twisted
-    # or possibly different versions of twisted?
-    # pylint: disable=E1101
-    objectStoreService = internet.TCPServer(FLAGS.s3_port, factory,
-                                            interface=FLAGS.s3_listen_host)
-    objectStoreService.setServiceParent(application)
-    return application
diff --git a/nova/objectstore/image.py b/nova/objectstore/image.py
deleted file mode 100644
index c90b5b54b..000000000
--- a/nova/objectstore/image.py
+++ /dev/null
@@ -1,296 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 United States Government as represented by the
-# Administrator of the National Aeronautics and Space Administration.
-# 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.
-
-"""
-Take uploaded bucket contents and register them as disk images (AMIs).
-Requires decryption using keys in the manifest.
-"""
-
-
-import binascii
-import glob
-import json
-import os
-import shutil
-import tarfile
-from xml.etree import ElementTree
-
-from nova import exception
-from nova import flags
-from nova import utils
-from nova.objectstore import bucket
-
-
-FLAGS = flags.FLAGS
-flags.DECLARE('images_path', 'nova.image.local')
-
-
-class Image(object):
-    def __init__(self, image_id):
-        self.image_id = image_id
-        self.path = os.path.abspath(os.path.join(FLAGS.images_path, image_id))
-        if not self.path.startswith(os.path.abspath(FLAGS.images_path)) or \
-        not os.path.isdir(self.path):
-            raise exception.NotFound
-
-    @property
-    def image_path(self):
-        return os.path.join(self.path, 'image')
-
-    def delete(self):
-        for fn in ['info.json', 'image']:
-            try:
-                os.unlink(os.path.join(self.path, fn))
-            except:
-                pass
-        try:
-            os.rmdir(self.path)
-        except:
-            pass
-
-    def is_authorized(self, context, readonly=False):
-        # NOTE(devcamcar): Public images can be read by anyone,
-        #                  but only modified by admin or owner.
-        try:
-            return (self.metadata['isPublic'] and readonly) or \
-                   context.is_admin or \
-                   self.metadata['imageOwnerId'] == context.project_id
-        except:
-            return False
-
-    def set_public(self, state):
-        md = self.metadata
-        md['isPublic'] = state
-        with open(os.path.join(self.path, 'info.json'), 'w') as f:
-            json.dump(md, f)
-
-    def update_user_editable_fields(self, args):
-        """args is from the request parameters, so requires extra cleaning"""
-        fields = {'display_name': 'displayName', 'description': 'description'}
-        info = self.metadata
-        for field in fields.keys():
-            if field in args:
-                info[fields[field]] = args[field]
-        with open(os.path.join(self.path, 'info.json'), 'w') as f:
-            json.dump(info, f)
-
-    @staticmethod
-    def all():
-        images = []
-        for fn in glob.glob("%s/*/info.json" % FLAGS.images_path):
-            try:
-                image_id = fn.split('/')[-2]
-                images.append(Image(image_id))
-            except:
-                pass
-        return images
-
-    @property
-    def owner_id(self):
-        return self.metadata['imageOwnerId']
-
-    @property
-    def metadata(self):
-        with open(os.path.join(self.path, 'info.json')) as f:
-            return json.load(f)
-
-    @staticmethod
-    def add(src, description, kernel=None, ramdisk=None, public=True):
-        """adds an image to imagestore
-
-        @type src: str
-        @param src: location of the partition image on disk
-
-        @type description: str
-        @param description: string describing the image contents
-
-        @type kernel: bool or str
-        @param kernel: either TRUE meaning this partition is a kernel image or
-                       a string of the image id for the kernel
-
-        @type ramdisk: bool or str
-        @param ramdisk: either TRUE meaning this partition is a ramdisk image
-                        or a string of the image id for the ramdisk
-
-
-        @type public: bool
-        @param public: determine if this is a public image or private
-
-        @rtype: str
-        @return: a string with the image id
-        """
-
-        image_type = 'machine'
-        image_id = utils.generate_uid('ami')
-
-        if kernel is True:
-            image_type = 'kernel'
-            image_id = utils.generate_uid('aki')
-        if ramdisk is True:
-            image_type = 'ramdisk'
-            image_id = utils.generate_uid('ari')
-
-        image_path = os.path.join(FLAGS.images_path, image_id)
-        os.makedirs(image_path)
-
-        shutil.copyfile(src, os.path.join(image_path, 'image'))
-
-        info = {
-            'imageId': image_id,
-            'imageLocation': description,
-            'imageOwnerId': 'system',
-            'isPublic': public,
-            'architecture': 'x86_64',
-            'imageType': image_type,
-            'state': 'available'}
-
-        if type(kernel) is str and len(kernel) > 0:
-            info['kernelId'] = kernel
-
-        if type(ramdisk) is str and len(ramdisk) > 0:
-            info['ramdiskId'] = ramdisk
-
-        with open(os.path.join(image_path, 'info.json'), "w") as f:
-            json.dump(info, f)
-
-        return image_id
-
-    @staticmethod
-    def register_aws_image(image_id, image_location, context):
-        image_path = os.path.join(FLAGS.images_path, image_id)
-        os.makedirs(image_path)
-
-        bucket_name = image_location.split("/")[0]
-        manifest_path = image_location[len(bucket_name) + 1:]
-        bucket_object = bucket.Bucket(bucket_name)
-
-        manifest = ElementTree.fromstring(bucket_object[manifest_path].read())
-        image_type = 'machine'
-
-        try:
-            kernel_id = manifest.find("machine_configuration/kernel_id").text
-            if kernel_id == 'true':
-                image_type = 'kernel'
-        except:
-            kernel_id = None
-
-        try:
-            ramdisk_id = manifest.find("machine_configuration/ramdisk_id").text
-            if ramdisk_id == 'true':
-                image_type = 'ramdisk'
-        except:
-            ramdisk_id = None
-
-        try:
-            arch = manifest.find("machine_configuration/architecture").text
-        except:
-            arch = 'x86_64'
-
-        info = {
-            'imageId': image_id,
-            'imageLocation': image_location,
-            'imageOwnerId': context.project_id,
-            'isPublic': False,  # FIXME: grab public from manifest
-            'architecture': arch,
-            'imageType': image_type}
-
-        if kernel_id:
-            info['kernelId'] = kernel_id
-
-        if ramdisk_id:
-            info['ramdiskId'] = ramdisk_id
-
-        def write_state(state):
-            info['imageState'] = state
-            with open(os.path.join(image_path, 'info.json'), "w") as f:
-                json.dump(info, f)
-
-        write_state('pending')
-
-        encrypted_filename = os.path.join(image_path, 'image.encrypted')
-        with open(encrypted_filename, 'w') as f:
-            for filename in manifest.find("image").getiterator("filename"):
-                shutil.copyfileobj(bucket_object[filename.text].file, f)
-
-        write_state('decrypting')
-
-        # FIXME: grab kernelId and ramdiskId from bundle manifest
-        hex_key = manifest.find("image/ec2_encrypted_key").text
-        encrypted_key = binascii.a2b_hex(hex_key)
-        hex_iv = manifest.find("image/ec2_encrypted_iv").text
-        encrypted_iv = binascii.a2b_hex(hex_iv)
-        cloud_private_key = os.path.join(FLAGS.ca_path, "private/cakey.pem")
-
-        decrypted_filename = os.path.join(image_path, 'image.tar.gz')
-        Image.decrypt_image(encrypted_filename, encrypted_key, encrypted_iv,
-                            cloud_private_key, decrypted_filename)
-
-        write_state('untarring')
-
-        image_file = Image.untarzip_image(image_path, decrypted_filename)
-        shutil.move(os.path.join(image_path, image_file),
-                    os.path.join(image_path, 'image'))
-
-        write_state('available')
-        os.unlink(decrypted_filename)
-        os.unlink(encrypted_filename)
-
-    @staticmethod
-    def decrypt_image(encrypted_filename, encrypted_key, encrypted_iv,
-                      cloud_private_key, decrypted_filename):
-        key, err = utils.execute('openssl',
-                                 'rsautl',
-                                 '-decrypt',
-                                 '-inkey', '%s' % cloud_private_key,
-                                 process_input=encrypted_key,
-                                 check_exit_code=False)
-        if err:
-            raise exception.Error(_("Failed to decrypt private key: %s")
-                                  % err)
-        iv, err = utils.execute('openssl',
-                                'rsautl',
-                                '-decrypt',
-                                '-inkey', '%s' % cloud_private_key,
-                                process_input=encrypted_iv,
-                                check_exit_code=False)
-        if err:
-            raise exception.Error(_("Failed to decrypt initialization "
-                                    "vector: %s") % err)
-
-        _out, err = utils.execute('openssl',
-                                  'enc',
-                                  '-d',
-                                  '-aes-128-cbc',
-                                  '-in', '%s' % (encrypted_filename,),
-                                  '-K', '%s' % (key,),
-                                  '-iv', '%s' % (iv,),
-                                  '-out', '%s' % (decrypted_filename,),
-                                  check_exit_code=False)
-        if err:
-            raise exception.Error(_("Failed to decrypt image file "
-                                    "%(image_file)s: %(err)s") %
-                                    {'image_file': encrypted_filename,
-                                     'err': err})
-
-    @staticmethod
-    def untarzip_image(path, filename):
-        tar_file = tarfile.open(filename, "r|gz")
-        tar_file.extractall(path)
-        image_file = tar_file.getnames()[0]
-        tar_file.close()
-        return image_file
diff --git a/nova/objectstore/stored.py b/nova/objectstore/stored.py
deleted file mode 100644
index a3f6e9c0b..000000000
--- a/nova/objectstore/stored.py
+++ /dev/null
@@ -1,63 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 United States Government as represented by the
-# Administrator of the National Aeronautics and Space Administration.
-# 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.
-
-"""
-Properties of an object stored within a bucket.
-"""
-
-import os
-
-import nova.crypto
-from nova import exception
-
-
-class Object(object):
-    def __init__(self, bucket, key):
-        """ wrapper class of an existing key """
-        self.bucket = bucket
-        self.key = key
-        self.path = bucket._object_path(key)
-        if not os.path.isfile(self.path):
-            raise exception.NotFound
-
-    def __repr__(self):
-        return "<Object %s/%s>" % (self.bucket, self.key)
-
-    @property
-    def md5(self):
-        """ computes the MD5 of the contents of file """
-        with open(self.path, "r") as f:
-            return nova.crypto.compute_md5(f)
-
-    @property
-    def mtime(self):
-        """ mtime of file """
-        return os.path.getmtime(self.path)
-
-    def read(self):
-        """ read all contents of key into memory and return """
-        return self.file.read()
-
-    @property
-    def file(self):
-        """ return a file object for the key """
-        return open(self.path, 'rb')
-
-    def delete(self):
-        """ deletes the file """
-        os.unlink(self.path)
diff --git a/nova/tests/test_cloud.py b/nova/tests/test_cloud.py
index cf8ee7eff..00803d0ad 100644
--- a/nova/tests/test_cloud.py
+++ b/nova/tests/test_cloud.py
@@ -35,31 +35,22 @@ from nova import log as logging
 from nova import rpc
 from nova import service
 from nova import test
+from nova import utils
 from nova.auth import manager
 from nova.compute import power_state
 from nova.api.ec2 import cloud
 from nova.api.ec2 import ec2utils
 from nova.image import local
-from nova.objectstore import image
 
 
 FLAGS = flags.FLAGS
 LOG = logging.getLogger('nova.tests.cloud')
 
-# Temp dirs for working with image attributes through the cloud controller
-# (stole this from objectstore_unittest.py)
-OSS_TEMPDIR = tempfile.mkdtemp(prefix='test_oss-')
-IMAGES_PATH = os.path.join(OSS_TEMPDIR, 'images')
-os.makedirs(IMAGES_PATH)
 
-
-# TODO(termie): these tests are rather fragile, they should at the lest be
-#               wiping database state after each run
 class CloudTestCase(test.TestCase):
     def setUp(self):
         super(CloudTestCase, self).setUp()
-        self.flags(connection_type='fake',
-                   images_path=IMAGES_PATH)
+        self.flags(connection_type='fake')
 
         self.conn = rpc.Connection.instance()
 
@@ -70,6 +61,7 @@ class CloudTestCase(test.TestCase):
         self.compute = self.start_service('compute')
         self.scheduter = self.start_service('scheduler')
         self.network = self.start_service('network')
+        self.image_service = utils.import_object(FLAGS.image_service)
 
         self.manager = manager.AuthManager()
         self.user = self.manager.create_user('admin', 'admin', 'admin', True)
@@ -318,41 +310,6 @@ class CloudTestCase(test.TestCase):
                 LOG.debug(_("Terminating instance %s"), instance_id)
                 rv = self.compute.terminate_instance(instance_id)
 
-    @staticmethod
-    def _fake_set_image_description(ctxt, image_id, description):
-        from nova.objectstore import handler
-
-        class req:
-            pass
-
-        request = req()
-        request.context = ctxt
-        request.args = {'image_id': [image_id],
-                        'description': [description]}
-
-        resource = handler.ImagesResource()
-        resource.render_POST(request)
-
-    def test_user_editable_image_endpoint(self):
-        pathdir = os.path.join(FLAGS.images_path, 'ami-testing')
-        os.mkdir(pathdir)
-        info = {'isPublic': False}
-        with open(os.path.join(pathdir, 'info.json'), 'w') as f:
-            json.dump(info, f)
-        img = image.Image('ami-testing')
-        # self.cloud.set_image_description(self.context, 'ami-testing',
-        #                                  'Foo Img')
-        # NOTE(vish): Above won't work unless we start objectstore or create
-        #             a fake version of api/ec2/images.py conn that can
-        #             call methods directly instead of going through boto.
-        #             for now, just cheat and call the method directly
-        self._fake_set_image_description(self.context, 'ami-testing',
-                                         'Foo Img')
-        self.assertEqual('Foo Img', img.metadata['description'])
-        self._fake_set_image_description(self.context, 'ami-testing', '')
-        self.assertEqual('', img.metadata['description'])
-        shutil.rmtree(pathdir)
-
     def test_update_of_instance_display_fields(self):
         inst = db.instance_create(self.context, {})
         ec2_id = ec2utils.id_to_ec2_id(inst['id'])
diff --git a/nova/tests/test_objectstore.py b/nova/tests/test_objectstore.py
index c4d344503..c78772f27 100644
--- a/nova/tests/test_objectstore.py
+++ b/nova/tests/test_objectstore.py
@@ -33,11 +33,9 @@ from boto.s3 import connection as s3
 from nova import context
 from nova import exception
 from nova import flags
-from nova import objectstore
 from nova import wsgi
 from nova import test
 from nova.auth import manager
-#from nova.exception import NotEmpty, NotFound
 from nova.objectstore import s3server
 
 
-- 
cgit 


From 9da833ff9298a00ba33ca67885a7a663a3b9e35f Mon Sep 17 00:00:00 2001
From: termie <github@anarkystic.com>
Date: Thu, 24 Mar 2011 16:38:31 -0700
Subject: don't require integrated tests to recycle connections

---
 nova/tests/integrated/integrated_helpers.py | 42 -----------------------------
 nova/tests/integrated/test_login.py         |  6 ++---
 2 files changed, 3 insertions(+), 45 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/integrated/integrated_helpers.py b/nova/tests/integrated/integrated_helpers.py
index 47093636e..cc7326e73 100644
--- a/nova/tests/integrated/integrated_helpers.py
+++ b/nova/tests/integrated/integrated_helpers.py
@@ -75,8 +75,6 @@ class TestUser(object):
 
 
 class IntegratedUnitTestContext(object):
-    __INSTANCE = None
-
     def __init__(self):
         self.auth_manager = manager.AuthManager()
 
@@ -92,7 +90,6 @@ class IntegratedUnitTestContext(object):
 
     def setup(self):
         self._start_services()
-
         self._create_test_user()
 
     def _create_test_user(self):
@@ -109,14 +106,6 @@ class IntegratedUnitTestContext(object):
             self._start_api_service()
 
     def cleanup(self):
-        for service in self.services:
-            service.kill()
-        self.services = []
-        # TODO(justinsb): Shutdown WSGI & anything else we startup
-        # bug731668
-        # WSGI shutdown broken :-(
-        # self.wsgi_server.terminate()
-        # self.wsgi_server = None
         self.test_user = None
 
     def _create_unittest_user(self):
@@ -150,39 +139,8 @@ class IntegratedUnitTestContext(object):
         if not api_service:
             raise Exception("API Service was None")
 
-        # WSGI shutdown broken :-(
-        #self.services.append(volume_service)
         self.api_service = api_service
 
         self.auth_url = 'http://localhost:8774/v1.0'
 
         return api_service
-
-    # WSGI shutdown broken :-(
-    # bug731668
-    #@staticmethod
-    #def get():
-    #    if not IntegratedUnitTestContext.__INSTANCE:
-    #        IntegratedUnitTestContext.startup()
-    #        #raise Error("Must call IntegratedUnitTestContext::startup")
-    #    return IntegratedUnitTestContext.__INSTANCE
-
-    @staticmethod
-    def startup():
-        # Because WSGI shutdown is broken at the moment, we have to recycle
-        # bug731668
-        if IntegratedUnitTestContext.__INSTANCE:
-            #raise Error("Multiple calls to IntegratedUnitTestContext.startup")
-            IntegratedUnitTestContext.__INSTANCE.setup()
-        else:
-            IntegratedUnitTestContext.__INSTANCE = IntegratedUnitTestContext()
-        return IntegratedUnitTestContext.__INSTANCE
-
-    @staticmethod
-    def shutdown():
-        if not IntegratedUnitTestContext.__INSTANCE:
-            raise Error("Must call IntegratedUnitTestContext::startup")
-        IntegratedUnitTestContext.__INSTANCE.cleanup()
-        # WSGI shutdown broken :-(
-        # bug731668
-        #IntegratedUnitTestContext.__INSTANCE = None
diff --git a/nova/tests/integrated/test_login.py b/nova/tests/integrated/test_login.py
index 501f8c919..6b241f240 100644
--- a/nova/tests/integrated/test_login.py
+++ b/nova/tests/integrated/test_login.py
@@ -33,12 +33,12 @@ FLAGS.verbose = True
 class LoginTest(test.TestCase):
     def setUp(self):
         super(LoginTest, self).setUp()
-        context = integrated_helpers.IntegratedUnitTestContext.startup()
-        self.user = context.test_user
+        self.context = integrated_helpers.IntegratedUnitTestContext()
+        self.user = self.context.test_user
         self.api = self.user.openstack_api
 
     def tearDown(self):
-        integrated_helpers.IntegratedUnitTestContext.shutdown()
+        self.context.cleanup()
         super(LoginTest, self).tearDown()
 
     def test_login(self):
-- 
cgit 


From e3dfae1bba0e4f9ff5d64ff5fadb43485e494453 Mon Sep 17 00:00:00 2001
From: termie <github@anarkystic.com>
Date: Thu, 24 Mar 2011 16:38:31 -0700
Subject: add descriptive docstring

---
 nova/objectstore/s3server.py | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

(limited to 'nova')

diff --git a/nova/objectstore/s3server.py b/nova/objectstore/s3server.py
index 83ca5bfa3..dd6327c8f 100644
--- a/nova/objectstore/s3server.py
+++ b/nova/objectstore/s3server.py
@@ -82,6 +82,38 @@ class S3Application(wsgi.Router):
 
 
 class BaseRequestHandler(wsgi.Controller):
+    """Base class emulating Tornado's web framework pattern in WSGI.
+
+    This is a direct port of Tornado's implementation, so some key decisions
+    about how the code interacts have already been chosen.
+
+    The two most common ways of designing web frameworks can be
+    classified as async object-oriented and sync functional.
+
+    Tornado's is on the OO side because a response is built up in and using
+    the shared state of an object and one of the object's methods will
+    eventually trigger the "finishing" of the response asynchronously.
+
+    Most WSGI stuff is in the functional side, we pass a request object to
+    every call down a chain and the eventual return value will be a response.
+
+    Part of the function of the routing code in S3Application as well as the
+    code in BaseRequestHandler's __call__ method is to merge those two styles
+    together enough that the Tornado code can work without extensive
+    modifications.
+
+    To do that it needs to give the Tornado-style code clean objects that it
+    can modify the state of for each request that is processed, so we use a
+    very simple factory lambda to create new state for each request, that's
+    the stuff in the router, and when we let the Tornado code modify that
+    object to handle the request, then we return the response it generated.
+    This wouldn't work the same if Tornado was being more async'y and doing
+    other callbacks throughout the process, but since Tornado is being
+    relatively simple here we can be satisfied that the response will be
+    complete by the end of the get/post method.
+
+    """
+
     def __init__(self, application):
         self.application = application
 
-- 
cgit 


From 73df3e0cd54dc3b5409fba7b38ada6ee07bd911d Mon Sep 17 00:00:00 2001
From: Salvatore Orlando <salvatore.orlando@eu.citrix.com>
Date: Fri, 25 Mar 2011 01:23:33 +0000
Subject: minor pep8 fix in db/fakes.py

---
 nova/tests/db/fakes.py | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/db/fakes.py b/nova/tests/db/fakes.py
index c46b75aa2..21a5481bd 100644
--- a/nova/tests/db/fakes.py
+++ b/nova/tests/db/fakes.py
@@ -108,9 +108,7 @@ def stub_out_db_instance_api(stubs, injected=True):
         return FakeModel(fixed_ip_fields).address
 
     def fake_fixed_ip_get_all_by_instance(context, instance_id):
-        l = []
-        l.append(FakeModel(fixed_ip_fields))
-        return l
+        return [FakeModel(fixed_ip_fields)]
 
     stubs.Set(db, 'network_get_by_instance', fake_network_get_by_instance)
     stubs.Set(db, 'instance_type_get_all', fake_instance_type_get_all)
-- 
cgit 


From ccf4727ca16d7a67c6a35950ab378ab4615dbdad Mon Sep 17 00:00:00 2001
From: Rick Harris <rick.harris@rackspace.com>
Date: Fri, 25 Mar 2011 04:41:47 +0000
Subject: disk_format is now an ImageService property

---
 nova/api/openstack/servers.py            | 34 +++++++++++--------
 nova/tests/api/openstack/test_servers.py | 57 ++++++++++++++++++++++++++++++++
 2 files changed, 78 insertions(+), 13 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 144d14536..ac9e29f07 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -502,33 +502,41 @@ class Controller(wsgi.Controller):
         return dict(actions=actions)
 
     def _get_kernel_ramdisk_from_image(self, req, image_id):
-        """Retrevies kernel and ramdisk IDs from Glance
-
-        Only 'machine' (ami) type use kernel and ramdisk outside of the
-        image.
+        """Fetch an image from the ImageService, then if present, return the
+        associated kernel and ramdisk image IDs.
         """
-        # FIXME(sirp): Since we're retrieving the kernel_id from an
-        # image_property, this means only Glance is supported.
-        # The BaseImageService needs to expose a consistent way of accessing
-        # kernel_id and ramdisk_id
-        image = self._image_service.show(req.environ['nova.context'], image_id)
+        context = req.environ['nova.context']
+        image_meta = self._image_service.show(context, image_id)
+        # NOTE(sirp): extracted to a separate method to aid unit-testing, the
+        # new method doesn't need a request obj or an ImageService stub
+        kernel_id, ramdisk_id = self._do_get_kernel_ramdisk_from_image(
+            image_meta)
+        return kernel_id, ramdisk_id
 
-        if image['status'] != 'active':
+    @staticmethod
+    def  _do_get_kernel_ramdisk_from_image(image_meta):
+        """Given an ImageService image_meta, return kernel and ramdisk image
+        ids if present.
+
+        This is only valid for `ami` style images.
+        """
+        image_id = image_meta['id']
+        if image_meta['status'] != 'active':
             raise exception.Invalid(
                 _("Cannot build from image %(image_id)s, status not active") %
                   locals())
 
-        if image['disk_format'] != 'ami':
+        if image_meta['properties']['disk_format'] != 'ami':
             return None, None
 
         try:
-            kernel_id = image['properties']['kernel_id']
+            kernel_id = image_meta['properties']['kernel_id']
         except KeyError:
             raise exception.NotFound(
                 _("Kernel not found for image %(image_id)s") % locals())
 
         try:
-            ramdisk_id = image['properties']['ramdisk_id']
+            ramdisk_id = image_meta['properties']['ramdisk_id']
         except KeyError:
             raise exception.NotFound(
                 _("Ramdisk not found for image %(image_id)s") % locals())
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index c48cc5179..3c117f10c 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -26,6 +26,7 @@ import webob
 
 from nova import context
 from nova import db
+from nova import exception
 from nova import flags
 from nova import test
 import nova.api.openstack
@@ -1260,3 +1261,59 @@ class TestServerInstanceCreation(test.TestCase):
         server = dom.childNodes[0]
         self.assertEquals(server.nodeName, 'server')
         self.assertTrue(server.getAttribute('adminPass').startswith('fake'))
+
+
+class TestGetKernelRamdiskFromImage(test.TestCase):
+    """
+    If we're building from an AMI-style image, we need to be able to fetch the
+    kernel and ramdisk associated with the machine image. This information is
+    stored with the image metadata and return via the ImageService.
+
+    These tests ensure that we parse the metadata return the ImageService
+    correctly and that we handle failure modes appropriately.
+    """
+
+    def test_status_not_active(self):
+        """We should only allow fetching of kernel and ramdisk information if
+        we have a 'fully-formed' image, aka 'active'
+        """
+        image_meta = {'id': 1, 'status': 'queued'}
+        self.assertRaises(exception.Invalid, self._get_k_r, image_meta)
+
+    def test_not_ami(self):
+        """Anything other than ami should return no kernel and no ramdisk"""
+        image_meta = {'id': 1, 'status': 'active',
+                      'properties': {'disk_format': 'vhd'}}
+        kernel_id, ramdisk_id = self._get_k_r(image_meta)
+        self.assertEqual(kernel_id, None)
+        self.assertEqual(ramdisk_id, None)
+
+    def test_ami_no_kernel(self):
+        """If an ami is missing a kernel it should raise NotFound"""
+        image_meta = {'id': 1, 'status': 'active',
+                      'properties': {'disk_format': 'ami', 'ramdisk_id': 1}}
+        self.assertRaises(exception.NotFound, self._get_k_r, image_meta)
+
+    def test_ami_no_ramdisk(self):
+        """If an ami is missing a ramdisk it should raise NotFound"""
+        image_meta = {'id': 1, 'status': 'active',
+                      'properties': {'disk_format': 'ami', 'kernel_id': 1}}
+        self.assertRaises(exception.NotFound, self._get_k_r, image_meta)
+
+    def test_ami_kernel_ramdisk_present(self):
+        """Return IDs if both kernel and ramdisk are present"""
+        image_meta = {'id': 1, 'status': 'active',
+                      'properties': {'disk_format': 'ami', 'kernel_id': 1,
+                                     'ramdisk_id': 2}}
+        kernel_id, ramdisk_id = self._get_k_r(image_meta)
+        self.assertEqual(kernel_id, 1)
+        self.assertEqual(ramdisk_id, 2)
+
+    @staticmethod
+    def _get_k_r(image_meta):
+        """Rebinding function to a shorter name for convenience"""
+        kernel_id, ramdisk_id = \
+            servers.Controller._do_get_kernel_ramdisk_from_image(image_meta)
+        return kernel_id, ramdisk_id
+
+
-- 
cgit 


From b6745341ec06cb0a0de7963f6b4606f4ad6f8c89 Mon Sep 17 00:00:00 2001
From: Rick Harris <rick.harris@rackspace.com>
Date: Thu, 24 Mar 2011 23:49:14 -0500
Subject: pep8 fix

---
 nova/tests/api/openstack/test_servers.py | 2 --
 1 file changed, 2 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 3c117f10c..3dac7a1b1 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -1315,5 +1315,3 @@ class TestGetKernelRamdiskFromImage(test.TestCase):
         kernel_id, ramdisk_id = \
             servers.Controller._do_get_kernel_ramdisk_from_image(image_meta)
         return kernel_id, ramdisk_id
-
-
-- 
cgit 


From f533c441c0062d05c7c361208016e56ca8f5e9df Mon Sep 17 00:00:00 2001
From: Dan Prince <dan.prince@rackspace.com>
Date: Fri, 25 Mar 2011 09:28:36 -0400
Subject: Fix unit tests w/ latest trunk merge.

---
 nova/tests/api/openstack/test_image_metadata.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'nova')

diff --git a/nova/tests/api/openstack/test_image_metadata.py b/nova/tests/api/openstack/test_image_metadata.py
index 33ef1a0a3..9be753f84 100644
--- a/nova/tests/api/openstack/test_image_metadata.py
+++ b/nova/tests/api/openstack/test_image_metadata.py
@@ -37,9 +37,9 @@ class ImageMetaDataTest(unittest.TestCase):
         'name': 'image1',
         'deleted': False,
         'container_format': None,
-        'created_at': '2011-03-22T17:40:15.492626',
+        'created_at': '2011-03-22T17:40:15',
         'disk_format': None,
-        'updated_at': '2011-03-22T17:40:15.591556',
+        'updated_at': '2011-03-22T17:40:15',
         'id': '1',
         'location': 'file:///var/lib/glance/images/1',
         'is_public': True,
@@ -54,9 +54,9 @@ class ImageMetaDataTest(unittest.TestCase):
         'name': 'image2',
         'deleted': False,
         'container_format': None,
-        'created_at': '2011-03-22T17:40:15.492626',
+        'created_at': '2011-03-22T17:40:15',
         'disk_format': None,
-        'updated_at': '2011-03-22T17:40:15.591556',
+        'updated_at': '2011-03-22T17:40:15',
         'id': '2',
         'location': 'file:///var/lib/glance/images/2',
         'is_public': True,
-- 
cgit 


From 51e8841b7cd818e5a3e0fa6bf023561b0160717d Mon Sep 17 00:00:00 2001
From: Dan Prince <dan.prince@rackspace.com>
Date: Fri, 25 Mar 2011 10:07:42 -0400
Subject: Use metadata = image.get('properties', {}).

---
 nova/api/openstack/image_metadata.py | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

(limited to 'nova')

diff --git a/nova/api/openstack/image_metadata.py b/nova/api/openstack/image_metadata.py
index e09952967..c9d6ac532 100644
--- a/nova/api/openstack/image_metadata.py
+++ b/nova/api/openstack/image_metadata.py
@@ -36,9 +36,7 @@ class Controller(wsgi.Controller):
     def _get_metadata(self, context, image_id, image=None):
         if not image:
             image = self.image_service.show(context, image_id)
-        metadata = {}
-        if 'properties' in image:
-            metadata = image['properties']
+        metadata = image.get('properties', {})
         return metadata
 
     def index(self, req, image_id):
-- 
cgit