merge trunk

36 files changed, 4815 insertions, 1441 deletions

diff --git a/nova/api/openstack/common.py b/nova/api/openstack/common.py
index bff050347..8cad1273a 100644
--- a/nova/api/openstack/common.py
+++ b/nova/api/openstack/common.py
@@ -20,9 +20,12 @@ 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,6 +59,36 @@ def limited(items, request, max_limit=1000):
     return items[offset:range_end]
 
 
+def limited_by_marker(items, request, max_limit=FLAGS.osapi_max_limit):
+    """Return a slice of items according to the requested marker and limit."""
+
+    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))
+    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)
+    start_index = 0
+    if marker:
+        start_index = -1
+        for i, item in enumerate(items):
+            if item['id'] == marker:
+                start_index = i + 1
+                break
+        if start_index < 0:
+            raise webob.exc.HTTPBadRequest(_('marker [%s] not found' % marker))
+    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 0dad46268..144d14536 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -82,7 +82,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]
@@ -551,6 +551,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):
@@ -574,6 +577,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/console/vmrc.py b/nova/console/vmrc.py
new file mode 100644
index 000000000..521da289f
--- /dev/null
+++ b/nova/console/vmrc.py
@@ -0,0 +1,144 @@
+# 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.
+"""
+
+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
+
+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(sateesh): Encrypt pool password
+        return password
+
+    def generate_password(self, vim_session, pool, instance_name):
+        """
+        Returns VMRC Connection credentials.
+
+        Return string is of the form '<VM PATH>:<ESX Username>@<ESX Password>'.
+        """
+        username, password = pool['username'], pool['password']
+        vms = vim_session._call_method(vim_util, "get_objects",
+                    "VirtualMachine", ["name", "config.files.vmPathName"])
+        vm_ds_path_name = None
+        vm_ref = None
+        for vm in vms:
+            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.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 or not."""
+        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, vim_session, pool, instance_name):
+        """
+        Returns a VMRC Session.
+
+        Return string is of the form '<VM MOID>:<VMRC Ticket>'.
+        """
+        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.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)
+        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 or not."""
+        return True
diff --git a/nova/console/vmrc_manager.py b/nova/console/vmrc_manager.py
new file mode 100644
index 000000000..09beac7a0
--- /dev/null
+++ b/nova/console/vmrc_manager.py
@@ -0,0 +1,158 @@
+# 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
+from nova.virt.vmwareapi_conn import VMWareAPISession
+
+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.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(
+                        self._get_vim_session(pool),
+                        pool,
+                        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):
+        """
+        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']
+        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):
+        """Removes a console entry."""
+        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):
+        """Gets console pool info for the instance."""
+        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
diff --git a/nova/flags.py b/nova/flags.py
index 00868d9b9..f011ab383 100644
--- a/nova/flags.py
+++ b/nova/flags.py
@@ -304,6 +304,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/network/vmwareapi_net.py b/nova/network/vmwareapi_net.py
new file mode 100644
index 000000000..93e6584f0
--- /dev/null
+++ b/nova/network/vmwareapi_net.py
@@ -0,0 +1,91 @@
+# 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 import network_utils
+
+LOG = logging.getLogger("nova.network.vmwareapi_net")
+
+FLAGS = flags.FLAGS
+flags.DEFINE_string('vlan_interface', 'vmnic0',
+                    'Physical network adapter name in VMware ESX host for '
+                    'vlan networking')
+
+
+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 if the vlan_interface physical network adapter exists on the host
+    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 = network_utils.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"
+    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
+        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 = \
+            network_utils.get_vlanid_and_vswitch_for_portgroup(session, bridge)
+
+        # 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") % locals())
+
+        # 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") % locals())
diff --git a/nova/objectstore/bucket.py b/nova/objectstore/bucket.py
deleted file mode 100644
index b213e18e8..000000000
--- a/nova/objectstore/bucket.py
+++ /dev/null
@@ -1,181 +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.DEFINE_string('buckets_path', '$state_path/buckets',
-                    'path to s3 buckets')
-
-
-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/s3server.py b/nova/objectstore/s3server.py
new file mode 100644
index 000000000..dd6327c8f
--- /dev/null
+++ b/nova/objectstore/s3server.py
@@ -0,0 +1,335 @@
+# 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
+# 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
+
+import routes
+import webob
+
+from nova import flags
+from nova import log as logging
+from nova import utils
+from nova import wsgi
+
+
+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, mapper=None):
+        if mapper is None:
+            mapper = routes.Mapper()
+
+        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))
+        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):
+    """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
+
+    @webob.dec.wsgify
+    def __call__(self, request):
+        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)
+
+    def invalid(self, **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('<' + utils.utf8(name) +
+                     ' xmlns="http://doc.s3.amazonaws.com/2006-03-01">')
+        self._render_parts(value.values()[0], parts)
+        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(utils.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('<' + utils.utf8(name) + '>')
+                    self._render_parts(subsubvalue, parts)
+                    parts.append('</' + utils.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):
+            self.set_status(404)
+            return
+        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):
+            self.set_status(403)
+            return
+        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):
+            self.set_status(404)
+            return
+        if len(os.listdir(path)) > 0:
+            self.set_status(403)
+            return
+        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):
+            self.set_status(404)
+            return
+        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):
+            self.set_status(404)
+            return
+        path = self._object_path(bucket, object_name)
+        if not path.startswith(bucket_dir) or os.path.isdir(path):
+            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):
+        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):
+            self.set_status(404)
+            return
+        os.unlink(path)
+        self.set_status(204)
+        self.finish()
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/test.py b/nova/test.py
index e0fef6101..3b608520a 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,7 @@ import unittest
 import mox
 import shutil
 import stubout
+from eventlet import greenthread
 
 from nova import context
 from nova import db
@@ -39,6 +41,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 +82,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 +103,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 +146,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.
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 9462bd40b..c48cc5179 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -239,6 +239,36 @@ 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())
+        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 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):
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):
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_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
new file mode 100644
index 000000000..c78772f27
--- /dev/null
+++ b/nova/tests/test_objectstore.py
@@ -0,0 +1,148 @@
+# 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 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 wsgi
+from nova import test
+from nova.auth import manager
+from nova.objectstore import s3server
+
+
+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 S3APITestCase(test.TestCase):
+    """Test objectstore through S3 API."""
+
+    def setUp(self):
+        """Setup users, projects, and start a test server."""
+        super(S3APITestCase, self).setUp()
+        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)
+        self.admin_project = self.auth_manager.create_project('admin',
+                                                              self.admin_user)
+
+        shutil.rmtree(FLAGS.buckets_path)
+        os.mkdir(FLAGS.buckets_path)
+
+        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')
+        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."""
+            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."""
+        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'
+
+        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."""
+        bucket_name = 'testbucket'
+        key_name = 'somekey'
+        key_contents = 'somekey'
+
+        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)
+
+        # make sure the contents are correct
+        key = bucket.get_key(key_name)
+        self.assertEquals(key.get_contents_as_string(), key_contents,
+                          "Bad contents")
+
+        # delete the key
+        key.delete()
+
+        self._ensure_no_buckets(bucket.get_all_keys())
+
+    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')
+        super(S3APITestCase, self).tearDown()
diff --git a/nova/tests/test_vmwareapi.py b/nova/tests/test_vmwareapi.py
new file mode 100644
index 000000000..22b66010a
--- /dev/null
+++ b/nova/tests/test_vmwareapi.py
@@ -0,0 +1,252 @@
+# 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 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.flags(vmwareapi_host_ip='test_url',

+                   vmwareapi_host_username='test_username',

+                   vmwareapi_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()

+        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_instance_in_the_db(self):

+        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)

+

+    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()

+

+    def _check_vm_record(self):

+        """

+        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 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 vSphere API.

+        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_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)

+        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_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)

+        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_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)

+        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_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)

+        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.assertEquals(len(instances), 1)

+        self.conn.destroy(self.instance)

+        instances = self.conn.list_instances()

+        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

+

+    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..478ee742b
--- /dev/null
+++ b/nova/tests/vmwareapi/__init__.py
@@ -0,0 +1,21 @@
+# 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.

+

+"""

+:mod:`vmwareapi` -- Stubs for VMware API

+=======================================

+"""

diff --git a/nova/tests/vmwareapi/db_fakes.py b/nova/tests/vmwareapi/db_fakes.py
new file mode 100644
index 000000000..0addd5573
--- /dev/null
+++ b/nova/tests/vmwareapi/db_fakes.py
@@ -0,0 +1,109 @@
+# 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

+

+

+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):

+            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[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'

+

+    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]

+

+    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)

+    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/vmwareapi/stubs.py b/nova/tests/vmwareapi/stubs.py
new file mode 100644
index 000000000..a648efb16
--- /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)

diff --git a/nova/virt/connection.py b/nova/virt/connection.py
index af7001715..99a8849f1 100644
--- a/nova/virt/connection.py
+++ b/nova/virt/connection.py
@@ -26,9 +26,10 @@ from nova import log as logging
 from nova import utils
 from nova.virt import driver
 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")
@@ -68,6 +69,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/__init__.py b/nova/virt/vmwareapi/__init__.py
new file mode 100644
index 000000000..d9b27de08
--- /dev/null
+++ b/nova/virt/vmwareapi/__init__.py
@@ -0,0 +1,19 @@
+# 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.
+"""
+: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
new file mode 100644
index 000000000..53fa8f24d
--- /dev/null
+++ b/nova/virt/vmwareapi/error_util.py
@@ -0,0 +1,96 @@
+# 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(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.

+    """

+

+    @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.

+        For example NotAuthenticated fault.

+        """

+        fault_list = []

+        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 "

+                    "occurred in the call to RetrieveProperties") %

+                    exc_msg_list))

diff --git a/nova/virt/vmwareapi/fake.py b/nova/virt/vmwareapi/fake.py
new file mode 100644
index 000000000..4bb467fa9
--- /dev/null
+++ b/nova/virt/vmwareapi/fake.py
@@ -0,0 +1,711 @@
+# 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 import error_util

+

+_CLASSES = ['Datacenter', 'Datastore', 'ResourcePool', 'VirtualMachine',

+            'Network', 'HostSystem', 'HostNetworkSystem', '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_network_system()

+    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, table_obj):

+    """Create an object in the db."""

+    _db_content[table][table_obj.obj] = table_obj

+

+

+def _get_objects(obj_type):

+    """Get objects of the type."""

+    lst_objs = []

+    for key in _db_content[obj_type]:

+        lst_objs.append(_db_content[obj_type][key])

+    return lst_objs

+

+

+class Prop(object):

+    """Property Object base class."""

+

+    def __init__(self):

+        self.name = None

+        self.val = None

+

+

+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."""

+        super(ManagedObject, self).__setattr__('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.name = attr

+        elem.val = val

+        self.propSet.append(elem)

+

+    def __getattr__(self, attr):

+        for elem in self.propSet:

+            if elem.name == attr:

+                return elem.val

+        raise exception.Error(_("Property %(attr)s not set for the managed "

+                        "object %(objName)s") %

+                        {'attr': attr,

+                         'objName': self.objName})

+

+

+class DataObject(object):

+    """Data object base class."""

+    pass

+

+

+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.

+    """

+    pass

+

+

+class VirtualDiskFlatVer2BackingInfo(DataObject):

+    """VirtualDiskFlatVer2BackingInfo class."""

+    pass

+

+

+class VirtualLsiLogicController(DataObject):

+    """VirtualLsiLogicController class."""

+    pass

+

+

+class VirtualMachine(ManagedObject):

+    """Virtual Machine class."""

+

+    def __init__(self, **kwargs):

+        super(VirtualMachine, self).__init__("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("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))

+        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 AttributeError:

+            # Case of Reconfig of VM to set extra params

+            self.set("config.extraConfig", val.extraConfig)

+

+

+class Network(ManagedObject):

+    """Network class."""

+

+    def __init__(self):

+        super(Network, self).__init__("Network")

+        self.set("summary.name", "vmnet0")

+

+

+class ResourcePool(ManagedObject):

+    """Resource Pool class."""

+

+    def __init__(self):

+        super(ResourcePool, self).__init__("ResourcePool")

+        self.set("name", "ResPool")

+

+

+class Datastore(ManagedObject):

+    """Datastore class."""

+

+    def __init__(self):

+        super(Datastore, self).__init__("Datastore")

+        self.set("summary.type", "VMFS")

+        self.set("summary.name", "fake-ds")

+

+

+class HostNetworkSystem(ManagedObject):

+    """HostNetworkSystem class."""

+

+    def __init__(self):

+        super(HostNetworkSystem, self).__init__("HostNetworkSystem")

+        self.set("name", "networkSystem")

+

+        pnic_do = DataObject()

+        pnic_do.device = "vmnic0"

+

+        net_info_pnic = DataObject()

+        net_info_pnic.PhysicalNic = [pnic_do]

+

+        self.set("networkInfo.pnic", net_info_pnic)

+

+

+class HostSystem(ManagedObject):

+    """Host System class."""

+

+    def __init__(self):

+        super(HostSystem, self).__init__("HostSystem")

+        self.set("name", "ha-host")

+        if _db_content.get("HostNetworkSystem", None) is None:

+            create_host_network_system()

+        host_net_key = _db_content["HostNetworkSystem"].keys()[0]

+        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"

+        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):

+        super(Datacenter, self).__init__("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"):

+        super(Task, self).__init__("Task")

+        info = DataObject

+        info.name = task_name

+        info.state = state

+        self.set("info", info)

+

+

+def create_host_network_system():

+    host_net_system = HostNetworkSystem()

+    _create_object("HostNetworkSystem", host_net_system)

+

+

+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") 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:

+        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

+        for file in _db_content.get("files"):

+            if file.find(file_path) != -1:

+                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):

+    """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.NotFound(_("There is no VM registered"))

+    if vm_ref not in _db_content.get("VirtualMachine"):

+        raise exception.NotFound(_("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 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_session(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 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."""

+        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.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")

+                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.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.NotFound(_(" No Virtual Machine has been "

+                                       "registered yet"))

+        if vm_ref not in _db_content.get("VirtualMachine"):

+            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")

+        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

+                # 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

+                        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, exc:

+                LOG.exception(exc)

+                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 == "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)

+        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
new file mode 100644
index 000000000..2ec773b7b
--- /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/network_utils.py b/nova/virt/vmwareapi/network_utils.py
new file mode 100644
index 000000000..e77842535
--- /dev/null
+++ b/nova/virt/vmwareapi/network_utils.py
@@ -0,0 +1,149 @@
+# 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 exception

+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

+

+LOG = logging.getLogger("nova.virt.vmwareapi.network_utils")

+

+

+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

+

+

+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

+

+

+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
new file mode 100644
index 000000000..84f4942eb
--- /dev/null
+++ b/nova/virt/vmwareapi/read_write_util.py
@@ -0,0 +1,182 @@
+# 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.

+

+"""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.

+

+"""

+

+import httplib

+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

+

+LOG = logging.getLogger("nova.virt.vmwareapi.read_write_util")

+

+FLAGS = flags.FLAGS

+

+USER_AGENT = "OpenStack-ESX-Adapter"

+

+try:

+    READ_CHUNKSIZE = client.BaseClient.CHUNKSIZE

+except AttributeError:

+    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):

+    """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."""

+        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 Exception, exc:

+            LOG.exception(exc)

+

+    def __del__(self):

+        """Close the file handle on garbage collection."""

+        self.close()

+

+    def _build_vim_cookie_headers(self, vim_cookies):

+        """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."""

+        raise NotImplementedError

+

+    def read(self, chunk_size):

+        """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"):

+        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 HTTP connection close 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"):

+        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 a chunk of data."""

+        # 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."""

+        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..ba14f1512
--- /dev/null
+++ b/nova/virt/vmwareapi/vim.py
@@ -0,0 +1,176 @@
+# 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.

+

+"""

+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'

+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'

+                   '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

+        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"):

+        """

+        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]

+        """

+        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"))

+        # 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)

+        self.client = Client(wsdl_url, location=url,

+                            plugins=[VIMMessagePlugin()])

+        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):

+                """

+                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

+                    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 error_util.VimAttributeError(_("No such SOAP method "

+                         "'%s' provided by VI SDK") % (attr_name), excep)

+                except (httplib.CannotSendRequest,

+                        httplib.ResponseNotReady,

+                        httplib.CannotSendHeader), 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 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 error_util.SessionOverLoadException(_("Type "

+                                    "error in  %s: ") % (attr_name), excep)

+                    else:

+                        raise error_util.VimException(

+                           _("Exception in %s ") % (attr_name), excep)

+            return vim_request_handler

+

+    def _request_managed_object_builder(self, managed_object):

+        """Builds the request managed object."""

+        # Request Managed Object Builder

+        if type(managed_object) == type(""):

+            mo = Property(managed_object)

+            mo._type = managed_object

+        else:

+            mo = managed_object

+        return mo

+

+    def __repr__(self):

+        return "VIM Object"

+

+    def __str__(self):

+        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..11214231c
--- /dev/null
+++ b/nova/virt/vmwareapi/vim_util.py
@@ -0,0 +1,217 @@
+# 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.

+"""

+

+

+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, 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 = spec_type

+    traversal_spec.path = path

+    traversal_spec.skip = skip

+    traversal_spec.selectSet = select_set

+    return traversal_spec

+

+

+def build_recursive_traversal_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 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

+    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

+    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

+    cr_to_h = build_traversal_spec(client_factory, "cr_to_h",

+                                   "ComputeResource", "host", False, [])

+

+    # 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

+    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

+    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

+    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

+    traversal_spec = build_traversal_spec(client_factory, "visitFolders",

+                                  "Folder", "childEntity", False,

+                                  [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])

+    return traversal_spec

+

+

+def build_property_spec(client_factory, type="VirtualMachine",

+                        properties_to_collect=["name"],

+                        all_properties=False):

+    """Builds the Property Spec."""

+    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(client_factory, root_folder, traversal_specs):

+    """Builds the object Spec."""

+    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(client_factory, property_specs, object_specs):

+    """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

+    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 = client_factory.create('ns0:PropertyFilterSpec')

+    property_spec = client_factory.create('ns0:PropertySpec')

+    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')

+    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])

+

+

+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."""

+    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(client_factory,

+                                [property_spec],

+                                [object_spec])

+    return vim.RetrieveProperties(vim.get_service_content().propertyCollector,

+                                specSet=[property_filter_spec])

+

+

+def get_prop_spec(client_factory, spec_type, properties):

+    """Builds the Property Spec Object."""

+    prop_spec = client_factory.create('ns0:PropertySpec')

+    prop_spec.type = spec_type

+    prop_spec.pathSet = properties

+    return prop_spec

+

+

+def get_obj_spec(client_factory, obj, select_set=None):

+    """Builds the Object Spec object."""

+    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

+    return obj_spec

+

+

+def get_prop_filter_spec(client_factory, obj_spec, prop_spec):

+    """Builds the Property Filter Spec Object."""

+    prop_filter_spec = \

+        client_factory.create('ns0:PropertyFilterSpec')

+    prop_filter_spec.propSet = prop_spec

+    prop_filter_spec.objectSet = obj_spec

+    return prop_filter_spec

+

+

+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.

+    """

+    client_factory = vim.client.factory

+    if len(obj_list) == 0:

+        return []

+    prop_spec = get_prop_spec(client_factory, type, properties)

+    lst_obj_specs = []

+    for obj in obj_list:

+        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
new file mode 100644
index 000000000..a2fa7600c
--- /dev/null
+++ b/nova/virt/vmwareapi/vm_util.py
@@ -0,0 +1,306 @@
+# 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 VM utility module to build SOAP object specs.

+"""

+

+

+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(client_factory, instance, data_store_name,

+                       network_name="vmnet0",

+                       os_type="otherGuest"):

+    """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 = client_factory.create('ns0:VirtualMachineFileInfo')

+    vm_file_info.vmPathName = "[" + data_store_name + "]"

+    config_spec.files = vm_file_info

+

+    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)

+

+    nic_spec = create_network_spec(client_factory,

+                                    network_name, instance.mac_address)

+

+    device_config_spec = [nic_spec]

+

+    config_spec.deviceChange = device_config_spec

+    return config_spec

+

+

+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 = \

+        client_factory.create('ns0:VirtualDeviceConfigSpec')

+    virtual_device_config.operation = "add"

+    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(client_factory, network_name, mac_address):

+    """

+    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

+    net_device = client_factory.create('ns0:VirtualPCNet32')

+

+    backing = \

+        client_factory.create('ns0:VirtualEthernetCardNetworkBackingInfo')

+    backing.deviceName = network_name

+

+    connectable_spec = \

+        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

+

+    # 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_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

+    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(client_factory,

+                                            controller_key)

+        device_config_spec.append(controller_spec)

+    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

+    return config_spec

+

+

+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 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(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(client_factory, size_in_kb, adapter_type="lsiLogic"):

+    """Builds the virtual disk create spec."""

+    create_vmdk_spec = \

+        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(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.

+    """

+    virtual_device_config = \

+        client_factory.create('ns0:VirtualDeviceConfigSpec')

+    virtual_device_config.operation = "add"

+    if file_path is None:

+        virtual_device_config.fileOperation = "create"

+

+    virtual_disk = client_factory.create('ns0:VirtualDisk')

+

+    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

+    else:

+        disk_file_backing.fileName = ""

+

+    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

+

+    # 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

+    virtual_disk.capacityInKB = disksize

+

+    virtual_device_config.device = virtual_disk

+

+    return virtual_device_config

+

+

+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"

+

+    vm_file_info = client_factory.create('ns0:VirtualMachineFileInfo')

+    vm_file_info.vmPathName = "[" + data_store_name + "]"

+    config_spec.files = vm_file_info

+

+    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

+

+    controller_key = -101

+    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

+    return 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 = \

+        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
new file mode 100644
index 000000000..cf6c88bbd
--- /dev/null
+++ b/nova/virt/vmwareapi/vmops.py
@@ -0,0 +1,789 @@
+# 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.

+

+"""

+Class for VM tasks like spawn, snapshot, suspend, resume etc.

+"""

+

+import base64

+import os

+import time

+import urllib

+import urllib2

+import uuid

+

+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 import network_utils

+

+FLAGS = flags.FLAGS

+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.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()

+

+        network = db.network_get_by_instance(context.get_admin_context(),

+                                            instance['id'])

+

+        net_name = network['bridge']

+

+        def _check_if_network_bridge_exists():

+            network_ref = \

+                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"

+                        " exist on the ESX host") % net_name)

+

+        _check_if_network_bridge_exists()

+

+        def _get_datastore_ref():

+            """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:

+                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

+                    return data_store_name

+

+            if data_store_name is None:

+                msg = _("Couldn't get a local Datastore reference")

+                LOG.exception(msg)

+                raise exception.Error(msg)

+

+        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.

+            """

+            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")

+            return vmdk_file_size_in_kb, os_type, adapter_type

+

+        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."""

+            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_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.

+            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

+        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

+            vm_create_task = self._session._call_method(

+                                    self._session._get_vim(),

+                                    "CreateVM_Task", vm_folder_mor,

+                                    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)

+

+        _execute_create_vm()

+

+        # 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

+        # 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)

+

+        def _create_virtual_disk():

+            """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"

+                      " %(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(client_factory,

+                                    vmdk_file_size_in_kb, adapter_type)

+            vmdk_create_task = self._session._call_method(

+                self._session._get_vim(),

+                "CreateVirtualDisk_Task",

+                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})

+

+        _create_virtual_disk()

+

+        def _delete_disk_file():

+            LOG.debug(_("Deleting 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})

+            # Delete the -flat.vmdk file created. .vmdk file is retained.

+            vmdk_delete_task = self._session._call_method(

+                        self._session._get_vim(),

+                        "DeleteDatastoreFile_Task",

+                        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})

+

+        _delete_disk_file()

+

+        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

+            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=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}))

+        _fetch_image_on_esx_datastore()

+

+        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.

+            """

+            vmdk_attach_config_spec = vm_util.get_vmdk_attach_config_spec(

+                                client_factory,

+                                vmdk_file_size_in_kb, uploaded_vmdk_path,

+                                adapter_type)

+            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)

+

+        _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_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)

+        _power_on_vm()

+

+    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.NotFound(_("instance - %s not present") %

+                                     instance.name)

+

+        client_factory = self._session._get_vim().client.factory

+        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

+            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(client_factory,

+                                                            hardware_devices)

+            datastore_name = vm_util.split_datastore_path(

+                                      vmdk_file_path_before_snapshot)[0]

+            os_type = self._session._call_method(vim_util,

+                        "get_dynamic_property", vm_ref,

+                        "VirtualMachine", "summary.config.guestId")

+            return (vmdk_file_path_before_snapshot, adapter_type,

+                    datastore_name, os_type)

+

+        vmdk_file_path_before_snapshot, adapter_type, datastore_name,\

+            os_type = _get_vm_and_vmdk_attribs()

+

+        def _create_vm_snapshot():

+            # 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)

+

+        _create_vm_snapshot()

+

+        def _check_if_tmp_folder_exists():

+            # 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,

+                                    "VirtualMachine",

+                                    "datastore")

+            if not ds_ref_ret:

+                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(),

+                                       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"))

+

+        _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.

+        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_spec = vm_util.get_copy_virtual_disk_spec(client_factory,

+                                                            adapter_type)

+            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",

+                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)

+

+        _copy_vmdk_content()

+

+        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.

+            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=cookies,

+                file_path="vmware-tmp/%s-flat.vmdk" % random_name)

+            LOG.debug(_("Uploaded image %s") % snapshot_name)

+

+        _upload_vmdk_to_image_repository()

+

+        def _clean_temp_data():

+            """

+            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(

+                self._session._get_vim(),

+                "DeleteVirtualDisk_Task",

+                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)

+

+        _clean_temp_data()

+

+    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.NotFound(_("instance - %s not present") %

+                                     instance.name)

+        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:

+            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 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)

+            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: %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 %(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,

+                    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") %

+                           ({'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: %s")

+                             % str(excep))

+        except Exception, exc:

+            LOG.exception(exc)

+

+    def pause(self, instance, callback):

+        """Pause a VM instance."""

+        raise exception.APIError("pause not supported for vmwareapi")

+

+    def unpause(self, instance, callback):

+        """Un-Pause a VM instance."""

+        raise exception.APIError("unpause not supported for vmwareapi")

+

+    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.NotFound(_("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.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)

+

+    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.NotFound(_("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.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.NotFound(_("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."""

+        raise exception.APIError("get_diagnostics not implemented for "

+                                 "vmwareapi")

+

+    def get_console_output(self, instance):

+        """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") %

+                                     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 '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.

+        """

+        vm_ref = self._get_vm_ref_from_the_name(instance.name)

+        if vm_ref is None:

+            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

+        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(client_factory, mac_addr,

+                                        ip_addr, net_mask, gateway)

+        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 %(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."""

+        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 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,

+                    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..50c6baedf
--- /dev/null
+++ b/nova/virt/vmwareapi/vmware_images.py
@@ -0,0 +1,201 @@
+# 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 Image transfer.

+"""

+

+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

+

+LOG = logging.getLogger("nova.virt.vmwareapi.vmware_images")

+

+FLAGS = flags.FLAGS

+

+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):

+    """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

+    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

+    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)

+    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"),

+                                kwargs.get("data_center_name"),

+                                kwargs.get("datastore_name"),

+                                kwargs.get("cookies"),

+                                kwargs.get("file_path"),

+                                file_size)

+    start_transfer(read_file_handle, file_size,

+                   write_file_handle=write_file_handle)

+    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 _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()

+    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",

+                      "type": "vmdk",

+                      "properties": {"vmware_adaptertype":

+                                            kwargs.get("adapter_type"),

+                                     "vmware_ostype": kwargs.get("os_type"),

+                                     "vmware_image_version":

+                                            kwargs.get("image_version")}}

+    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)

+

+

+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 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":

+        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"]

+    elif FLAGS.image_service == "nova.image.s3.S3ImageService":

+        raise NotImplementedError

+    elif FLAGS.image_service == "nova.image.local.LocalImageService":

+        raise NotImplementedError

+    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
new file mode 100644
index 000000000..87c3fa299
--- /dev/null
+++ b/nova/virt/vmwareapi_conn.py
@@ -0,0 +1,375 @@
+# 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 connection to the VMware ESX platform.

+

+**Related Flags**

+

+: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 time

+

+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

+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

+

+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',

+                   5.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')

+flags.DEFINE_string('vmwareapi_vlan_interface',

+                   'vmnic0',

+                   'Physical ethernet adapter name for vlan networking')

+

+TIME_BETWEEN_API_CALL_RETRIES = 2.0

+

+

+class Failure(Exception):

+    """Base Exception class for handling task failures."""

+

+    def __init__(self, details):

+        self.details = details

+

+    def __str__(self):

+        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"):

+        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."""

+        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.

+    """

+

+    def __init__(self, host_ip, host_username, host_password,

+                 api_retry_count, scheme="https"):

+        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 _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 = self._get_vim_object()

+                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:

+                        # 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:

+                LOG.critical(_("In vmwareapi:_create_session, "

+                              "got this exception: %s") % excep)

+                raise exception.Error(excep)

+

+    def __del__(self):

+        """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 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."""

+        return isinstance(module, vim.Vim)

+

+    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

+        last_fault_list = []

+        while True:

+            try:

+                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:]

+                    args = [self.vim] + args

+                retry_count += 1

+                temp_module = module

+

+                for method_elem in method.split("."):

+                    temp_module = getattr(temp_module, method_elem)

+

+                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

+                # 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

+                    # 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

+            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: %s") % exc)

+        raise

+

+    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()

+        loop = utils.LoopingCall(self._poll_task, instance_id, task_ref,

+                                      done)

+        loop.start(FLAGS.vmwareapi_task_poll_interval, now=True)

+        ret_val = done.wait()

+        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.debug(_("Task [%(task_name)s] %(task_ref)s "

+                            "status: success") % locals())

+                done.send("success")

+            else:

+                error_info = str(task_info.error.localizedMessage)

+                action["error"] = error_info

+                LOG.warn(_("Task [%(task_name)s] %(task_ref)s "

+                          "status: error %(error_info)s") % locals())

+                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)

+            done.send_exception(excep)

diff --git a/nova/volume/driver.py b/nova/volume/driver.py
index 779b46755..28d08201b 100644
--- a/nova/volume/driver.py
+++ b/nova/volume/driver.py
@@ -422,18 +422,17 @@ 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 +440,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 +492,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."""