removed a few more references to twisted

5 files changed, 36 insertions, 44 deletions

diff --git a/nova/rpc.py b/nova/rpc.py
index 6a634a4ec..b5df4904b 100644
--- a/nova/rpc.py
+++ b/nova/rpc.py
@@ -237,7 +237,9 @@ class DirectPublisher(Publisher):
 def msg_reply(msg_id, reply=None, failure=None):
     """Sends a reply or an error on the channel signified by msg_id
 
-    failure should be a twisted failure object"""
+    failure should be a sys.exc_info() tuple.
+
+    """
     if failure:
         message = str(failure[1])
         tb = traceback.format_exception(*failure)
@@ -332,7 +334,7 @@ def call(context, topic, msg):
         pass
     consumer.close()
     # NOTE(termie): this is a little bit of a change from the original
-    #               twisted-based code where returning a Failure
+    #               non-eventlet code where returning a Failure
     #               instance from a deferred call is very similar to
     #               raising an exception
     if isinstance(wait_msg.result, Exception):
diff --git a/nova/service.py b/nova/service.py
index 576cf8b85..5c171b2ae 100644
--- a/nova/service.py
+++ b/nova/service.py
@@ -258,8 +258,6 @@ def serve(*services):
     #    FLAGS.logfile = '%s.log' % name
     #if not FLAGS.prefix:
     #    FLAGS.prefix = name
-    #elif FLAGS.prefix.endswith('twisted'):
-    #    FLAGS.prefix = FLAGS.prefix.replace('twisted', name)
 
     action = 'start'
     if len(argv) > 1:
diff --git a/nova/virt/images.py b/nova/virt/images.py
index 4d7c65f12..1c9b2e093 100644
--- a/nova/virt/images.py
+++ b/nova/virt/images.py
@@ -50,7 +50,7 @@ def _fetch_s3_image(image, path, user, project):
 
     # This should probably move somewhere else, like e.g. a download_as
     # method on User objects and at the same time get rewritten to use
-    # twisted web client.
+    # a web client.
     headers = {}
     headers['Date'] = time.strftime("%a, %d %b %Y %H:%M:%S GMT", time.gmtime())
 
diff --git a/nova/virt/xenapi/network_utils.py b/nova/virt/xenapi/network_utils.py
index 8cb4cce3a..d8632f393 100644
--- a/nova/virt/xenapi/network_utils.py
+++ b/nova/virt/xenapi/network_utils.py
@@ -20,8 +20,6 @@ records and their attributes like bridges, PIFs, QoS, as well as
 their lookup functions.
 """
 
-from twisted.internet import defer
-
 
 class NetworkHelper():
     """
@@ -31,14 +29,13 @@ class NetworkHelper():
         return
 
     @classmethod
-    @defer.inlineCallbacks
     def find_network_with_bridge(cls, session, bridge):
         """ Return the network on which the bridge is attached, if found """
         expr = 'field "bridge" = "%s"' % bridge
-        networks = yield session.call_xenapi('network.get_all_records_where',
-                                           expr)
+        networks = session.call_xenapi('network.get_all_records_where',
+                                       expr)
         if len(networks) == 1:
-            defer.returnValue(networks.keys()[0])
+            return networks.keys()[0]
         elif len(networks) > 1:
             raise Exception('Found non-unique network for bridge %s' % bridge)
         else:
diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py
index d36cdaea5..0223e512a 100644
--- a/nova/virt/xenapi/vmops.py
+++ b/nova/virt/xenapi/vmops.py
@@ -20,8 +20,6 @@ Management class for VM-related functions (spawn, reboot, etc).
 
 import logging
 
-from twisted.internet import defer
-
 from nova import db
 from nova import context
 from nova.auth.manager import AuthManager
@@ -46,10 +44,9 @@ class VMOps(object):
         return [self._session.get_xenapi().VM.get_name_label(vm) \
                 for vm in self._session.get_xenapi().VM.get_all()]
 
-    @defer.inlineCallbacks
     def spawn(self, instance):
         """ Create VM instance """
-        vm = yield VMHelper.lookup(self._session, instance.name)
+        vm = VMHelper.lookup(self._session, instance.name)
         if vm is not None:
             raise Exception('Attempted to create non-unique name %s' %
                             instance.name)
@@ -57,66 +54,64 @@ class VMOps(object):
         bridge = db.project_get_network(context.get_admin_context(),
                                       instance.project_id).bridge
         network_ref = \
-            yield NetworkHelper.find_network_with_bridge(self._session, bridge)
+            NetworkHelper.find_network_with_bridge(self._session, bridge)
 
         user = AuthManager().get_user(instance.user_id)
         project = AuthManager().get_project(instance.project_id)
-        vdi_uuid = yield VMHelper.fetch_image(self._session,
-            instance.image_id, user, project, True)
-        kernel = yield VMHelper.fetch_image(self._session,
-            instance.kernel_id, user, project, False)
-        ramdisk = yield VMHelper.fetch_image(self._session,
-            instance.ramdisk_id, user, project, False)
-        vdi_ref = yield self._session.call_xenapi('VDI.get_by_uuid', vdi_uuid)
-        vm_ref = yield VMHelper.create_vm(self._session,
-                                          instance, kernel, ramdisk)
-        yield VMHelper.create_vbd(self._session, vm_ref, vdi_ref, 0, True)
+        vdi_uuid = VMHelper.fetch_image(
+                self._session, instance.image_id, user, project, True)
+        kernel = VMHelper.fetch_image(
+                self._session, instance.kernel_id, user, project, False)
+        ramdisk = VMHelper.fetch_image(
+                self._session, instance.ramdisk_id, user, project, False)
+        vdi_ref = self._session.call_xenapi('VDI.get_by_uuid', vdi_uuid)
+        vm_ref = VMHelper.create_vm(
+                self._session, instance, kernel, ramdisk)
+        VMHelper.create_vbd(self._session, vm_ref, vdi_ref, 0, True)
         if network_ref:
-            yield VMHelper.create_vif(self._session, vm_ref,
-                                      network_ref, instance.mac_address)
+            VMHelper.create_vif(self._session, vm_ref,
+                                network_ref, instance.mac_address)
         logging.debug('Starting VM %s...', vm_ref)
-        yield self._session.call_xenapi('VM.start', vm_ref, False, False)
+        self._session.call_xenapi('VM.start', vm_ref, False, False)
         logging.info('Spawning VM %s created %s.', instance.name,
                      vm_ref)
 
-    @defer.inlineCallbacks
     def reboot(self, instance):
         """ Reboot VM instance """
         instance_name = instance.name
-        vm = yield VMHelper.lookup(self._session, instance_name)
+        vm = VMHelper.lookup(self._session, instance_name)
         if vm is None:
             raise Exception('instance not present %s' % instance_name)
-        task = yield self._session.call_xenapi('Async.VM.clean_reboot', vm)
-        yield self._session.wait_for_task(task)
+        task = self._session.call_xenapi('Async.VM.clean_reboot', vm)
+        self._session.wait_for_task(task)
 
-    @defer.inlineCallbacks
     def destroy(self, instance):
         """ Destroy VM instance """
-        vm = yield VMHelper.lookup(self._session, instance.name)
+        vm = VMHelper.lookup(self._session, instance.name)
         if vm is None:
             # Don't complain, just return.  This lets us clean up instances
             # that have already disappeared from the underlying platform.
-            defer.returnValue(None)
+            return
         # Get the VDIs related to the VM
-        vdis = yield VMHelper.lookup_vm_vdis(self._session, vm)
+        vdis = VMHelper.lookup_vm_vdis(self._session, vm)
         try:
-            task = yield self._session.call_xenapi('Async.VM.hard_shutdown',
+            task = self._session.call_xenapi('Async.VM.hard_shutdown',
                                                    vm)
-            yield self._session.wait_for_task(task)
+            self._session.wait_for_task(task)
         except XenAPI.Failure, exc:
             logging.warn(exc)
         # Disk clean-up
         if vdis:
             for vdi in vdis:
                 try:
-                    task = yield self._session.call_xenapi('Async.VDI.destroy',
-                                                           vdi)
-                    yield self._session.wait_for_task(task)
+                    task = self._session.call_xenapi('Async.VDI.destroy',
+                                                     vdi)
+                    self._session.wait_for_task(task)
                 except XenAPI.Failure, exc:
                     logging.warn(exc)
         try:
-            task = yield self._session.call_xenapi('Async.VM.destroy', vm)
-            yield self._session.wait_for_task(task)
+            task = self._session.call_xenapi('Async.VM.destroy', vm)
+            self._session.wait_for_task(task)
         except XenAPI.Failure, exc:
             logging.warn(exc)