This branch removes most of the dependencies on twisted and moves towards the plan described by https://blueprints.launchpad.net/nova/+spec/unified-service-architecture

Tests are currently passing besides objectstore which is being skipped because it is heavily reliant on our twisted pieces, and I can run everything using the nova.sh

Additionally this adds nova-combined that covers everythign except for nova-objectstore, to test it what I've usually done is run nova.sh as usual

$ sudo ./eventlet_merge/contrib/nova.sh run ignored eventlet_merge

and then quit all the services except for nova-objectstore and then in one of the screens do

$ ./eventlet_merge/bin/nova-combined

And then run whatever manual testing you normally run.

Once objectstore has been deprecated and removed nova-combined can be expected to run the whole nova stack in a single process for testing and dev.

1 files changed, 85 insertions, 15 deletions

diff --git a/nova/test.py b/nova/test.py
index 5c2a72819..7076f1bf4 100644
--- a/nova/test.py
+++ b/nova/test.py
@@ -25,11 +25,12 @@ and some black magic for inline callbacks.
 import datetime
 import sys
 import time
+import unittest
 
 import mox
 import stubout
 from twisted.internet import defer
-from twisted.trial import unittest
+from twisted.trial import unittest as trial_unittest
 
 from nova import context
 from nova import db
@@ -55,11 +56,11 @@ def skip_if_fake(func):
     return _skipper
 
 
-class TrialTestCase(unittest.TestCase):
+class TestCase(unittest.TestCase):
     """Test case base class for all unit tests"""
     def setUp(self):
         """Run before each test method to initialize test environment"""
-        super(TrialTestCase, self).setUp()
+        super(TestCase, self).setUp()
         # NOTE(vish): We need a better method for creating fixtures for tests
         #             now that we have some required db setup for the system
         #             to work properly.
@@ -94,7 +95,87 @@ class TrialTestCase(unittest.TestCase):
             db.fixed_ip_disassociate_all_by_timeout(ctxt, FLAGS.host,
                                                     self.start)
             db.network_disassociate_all(ctxt)
-            rpc.Consumer.attach_to_twisted = self.originalAttach
+            rpc.Consumer.attach_to_eventlet = self.originalAttach
+            for x in self.injected:
+                try:
+                    x.stop()
+                except AssertionError:
+                    pass
+
+            if FLAGS.fake_rabbit:
+                fakerabbit.reset_all()
+
+            db.security_group_destroy_all(ctxt)
+            super(TestCase, self).tearDown()
+        finally:
+            self.reset_flags()
+
+    def flags(self, **kw):
+        """Override flag variables for a test"""
+        for k, v in kw.iteritems():
+            if k in self.flag_overrides:
+                self.reset_flags()
+                raise Exception(
+                        'trying to override already overriden flag: %s' % k)
+            self.flag_overrides[k] = getattr(FLAGS, k)
+            setattr(FLAGS, k, v)
+
+    def reset_flags(self):
+        """Resets all flag variables for the test.  Runs after each test"""
+        FLAGS.Reset()
+        for k, v in self._original_flags.iteritems():
+            setattr(FLAGS, k, v)
+
+    def _monkey_patch_attach(self):
+        self.originalAttach = rpc.Consumer.attach_to_eventlet
+
+        def _wrapped(innerSelf):
+            rv = self.originalAttach(innerSelf)
+            self.injected.append(rv)
+            return rv
+
+        _wrapped.func_name = self.originalAttach.func_name
+        rpc.Consumer.attach_to_eventlet = _wrapped
+
+
+class TrialTestCase(trial_unittest.TestCase):
+    """Test case base class for all unit tests"""
+    def setUp(self):
+        """Run before each test method to initialize test environment"""
+        super(TrialTestCase, self).setUp()
+        # NOTE(vish): We need a better method for creating fixtures for tests
+        #             now that we have some required db setup for the system
+        #             to work properly.
+        self.start = datetime.datetime.utcnow()
+        ctxt = context.get_admin_context()
+        if db.network_count(ctxt) != 5:
+            network_manager.VlanManager().create_networks(ctxt,
+                                                          FLAGS.fixed_range,
+                                                          5, 16,
+                                                          FLAGS.vlan_start,
+                                                          FLAGS.vpn_start)
+
+        # emulate some of the mox stuff, we can't use the metaclass
+        # because it screws with our generators
+        self.mox = mox.Mox()
+        self.stubs = stubout.StubOutForTesting()
+        self.flag_overrides = {}
+        self.injected = []
+        self._original_flags = FLAGS.FlagValuesDict()
+
+    def tearDown(self):
+        """Runs after each test method to finalize/tear down test
+        environment."""
+        try:
+            self.mox.UnsetStubs()
+            self.stubs.UnsetAll()
+            self.stubs.SmartUnsetAll()
+            self.mox.VerifyAll()
+            # NOTE(vish): Clean up any ips associated during the test.
+            ctxt = context.get_admin_context()
+            db.fixed_ip_disassociate_all_by_timeout(ctxt, FLAGS.host,
+                                                    self.start)
+            db.network_disassociate_all(ctxt)
             for x in self.injected:
                 try:
                     x.stop()
@@ -147,14 +228,3 @@ class TrialTestCase(unittest.TestCase):
             return d
         _wrapped.func_name = func.func_name
         return _wrapped
-
-    def _monkey_patch_attach(self):
-        self.originalAttach = rpc.Consumer.attach_to_twisted
-
-        def _wrapped(innerSelf):
-            rv = self.originalAttach(innerSelf)
-            self.injected.append(rv)
-            return rv
-
-        _wrapped.func_name = self.originalAttach.func_name
-        rpc.Consumer.attach_to_twisted = _wrapped