This branch modifies the fixes all of the deprecation warnings about empty context. It does this by adding the following fixes/features

  * promotes api/context.py to context.py because it is used by the whole system
  * adds more information to the context object
  * passes the context through rpc
  * adds a helper method for promoting to admin context (elevate())
  * modifies most checks to use context.project_id instead of context.project.id to avoid
    trips to the database

This included a lot of merge fixing and backporting from the anso deploy branch so some stuff may be broken.  Right now it throws an Exception('die') in addition to the deprecation warning so we get a stack trace and can find any other deprecated calls.  This needs some testing, especially of the openstack api.

12 files changed, 173 insertions, 169 deletions

diff --git a/nova/tests/access_unittest.py b/nova/tests/access_unittest.py
index 4b40ffd0a..8167259c4 100644
--- a/nova/tests/access_unittest.py
+++ b/nova/tests/access_unittest.py
@@ -20,6 +20,7 @@ import unittest
 import logging
 import webob
 
+from nova import context
 from nova import exception
 from nova import flags
 from nova import test
@@ -35,44 +36,25 @@ class AccessTestCase(test.TrialTestCase):
     def setUp(self):
         super(AccessTestCase, self).setUp()
         um = manager.AuthManager()
+        self.context = context.get_admin_context()
         # Make test users
-        try:
-            self.testadmin = um.create_user('testadmin')
-        except Exception, err:
-            logging.error(str(err))
-        try:
-            self.testpmsys = um.create_user('testpmsys')
-        except: pass
-        try:
-            self.testnet = um.create_user('testnet')
-        except: pass
-        try:
-            self.testsys = um.create_user('testsys')
-        except: pass
+        self.testadmin = um.create_user('testadmin')
+        self.testpmsys = um.create_user('testpmsys')
+        self.testnet = um.create_user('testnet')
+        self.testsys = um.create_user('testsys')
         # Assign some rules
-        try:
-            um.add_role('testadmin', 'cloudadmin')
-        except: pass
-        try:
-            um.add_role('testpmsys', 'sysadmin')
-        except: pass
-        try:
-            um.add_role('testnet', 'netadmin')
-        except: pass
-        try:
-            um.add_role('testsys', 'sysadmin')
-        except: pass
+        um.add_role('testadmin', 'cloudadmin')
+        um.add_role('testpmsys', 'sysadmin')
+        um.add_role('testnet', 'netadmin')
+        um.add_role('testsys', 'sysadmin')
 
         # Make a test project
-        try:
-            self.project = um.create_project('testproj', 'testpmsys', 'a test project', ['testpmsys', 'testnet', 'testsys'])
-        except: pass
-        try:
-            self.project.add_role(self.testnet, 'netadmin')
-        except: pass
-        try:
-            self.project.add_role(self.testsys, 'sysadmin')
-        except: pass
+        self.project = um.create_project('testproj',
+                                         'testpmsys',
+                                         'a test project',
+                                         ['testpmsys', 'testnet', 'testsys'])
+        self.project.add_role(self.testnet, 'netadmin')
+        self.project.add_role(self.testsys, 'sysadmin')
         #user is set in each test
         def noopWSGIApp(environ, start_response):
             start_response('200 OK', [])
@@ -97,10 +79,8 @@ class AccessTestCase(test.TrialTestCase):
         super(AccessTestCase, self).tearDown()
 
     def response_status(self, user, methodName):
-        context = Context()
-        context.project = self.project
-        context.user = user
-        environ = {'ec2.context' : context,
+        ctxt = context.RequestContext(user, self.project)
+        environ = {'ec2.context' : ctxt,
                    'ec2.controller': 'some string',
                    'ec2.action': methodName}
         req = webob.Request.blank('/', environ)
diff --git a/nova/tests/api_unittest.py b/nova/tests/api_unittest.py
index 7ab27e000..414db1e11 100644
--- a/nova/tests/api_unittest.py
+++ b/nova/tests/api_unittest.py
@@ -25,6 +25,7 @@ import random
 import StringIO
 import webob
 
+from nova import context
 from nova import flags
 from nova import test
 from nova import api
@@ -131,7 +132,7 @@ class ApiEc2TestCase(test.BaseTestCase):
         user = self.manager.create_user('fake', 'fake', 'fake')
         project = self.manager.create_project('fake', 'fake', 'fake')
         # NOTE(vish): create depends on pool, so call helper directly
-        cloud._gen_key(None, user.id, keyname)
+        cloud._gen_key(context.get_admin_context(), user.id, keyname)
 
         rv = self.ec2.get_all_key_pairs()
         results = [k for k in rv if k.name == keyname]
diff --git a/nova/tests/cloud_unittest.py b/nova/tests/cloud_unittest.py
index ff466135d..20099069c 100644
--- a/nova/tests/cloud_unittest.py
+++ b/nova/tests/cloud_unittest.py
@@ -30,6 +30,7 @@ from twisted.internet import defer
 import unittest
 from xml.etree import ElementTree
 
+from nova import context
 from nova import crypto
 from nova import db
 from nova import flags
@@ -38,7 +39,6 @@ from nova import test
 from nova import utils
 from nova.auth import manager
 from nova.compute import power_state
-from nova.api.ec2 import context
 from nova.api.ec2 import cloud
 from nova.objectstore import image
 
@@ -78,7 +78,7 @@ class CloudTestCase(test.TrialTestCase):
         self.manager = manager.AuthManager()
         self.user = self.manager.create_user('admin', 'admin', 'admin', True)
         self.project = self.manager.create_project('proj', 'admin', 'proj')
-        self.context = context.APIRequestContext(user=self.user,
+        self.context = context.RequestContext(user=self.user,
                                                  project=self.project)
 
     def tearDown(self):
@@ -243,34 +243,34 @@ class CloudTestCase(test.TrialTestCase):
         self.assertEqual('', img.metadata['description'])
 
     def test_update_of_instance_display_fields(self):
-        inst = db.instance_create({}, {})
+        inst = db.instance_create(self.context, {})
         ec2_id = cloud.internal_id_to_ec2_id(inst['internal_id'])
         self.cloud.update_instance(self.context, ec2_id,
                                    display_name='c00l 1m4g3')
-        inst = db.instance_get({}, inst['id'])
+        inst = db.instance_get(self.context, inst['id'])
         self.assertEqual('c00l 1m4g3', inst['display_name'])
-        db.instance_destroy({}, inst['id'])
+        db.instance_destroy(self.context, inst['id'])
 
     def test_update_of_instance_wont_update_private_fields(self):
-        inst = db.instance_create({}, {})
+        inst = db.instance_create(self.context, {})
         self.cloud.update_instance(self.context, inst['id'],
                                    mac_address='DE:AD:BE:EF')
-        inst = db.instance_get({}, inst['id'])
+        inst = db.instance_get(self.context, inst['id'])
         self.assertEqual(None, inst['mac_address'])
-        db.instance_destroy({}, inst['id'])
+        db.instance_destroy(self.context, inst['id'])
 
     def test_update_of_volume_display_fields(self):
-        vol = db.volume_create({}, {})
+        vol = db.volume_create(self.context, {})
         self.cloud.update_volume(self.context, vol['id'],
                                  display_name='c00l v0lum3')
-        vol = db.volume_get({}, vol['id'])
+        vol = db.volume_get(self.context, vol['id'])
         self.assertEqual('c00l v0lum3', vol['display_name'])
-        db.volume_destroy({}, vol['id'])
+        db.volume_destroy(self.context, vol['id'])
 
     def test_update_of_volume_wont_update_private_fields(self):
-        vol = db.volume_create({}, {})
+        vol = db.volume_create(self.context, {})
         self.cloud.update_volume(self.context, vol['id'],
                                    mountpoint='/not/here')
-        vol = db.volume_get({}, vol['id'])
+        vol = db.volume_get(self.context, vol['id'])
         self.assertEqual(None, vol['mountpoint'])
-        db.volume_destroy({}, vol['id'])
+        db.volume_destroy(self.context, vol['id'])
diff --git a/nova/tests/compute_unittest.py b/nova/tests/compute_unittest.py
index 5a7f170f3..01e1bcd30 100644
--- a/nova/tests/compute_unittest.py
+++ b/nova/tests/compute_unittest.py
@@ -24,13 +24,13 @@ import logging
 
 from twisted.internet import defer
 
+from nova import context
 from nova import db
 from nova import exception
 from nova import flags
 from nova import test
 from nova import utils
 from nova.auth import manager
-from nova.api import context
 
 FLAGS = flags.FLAGS
 
@@ -46,7 +46,7 @@ class ComputeTestCase(test.TrialTestCase):
         self.manager = manager.AuthManager()
         self.user = self.manager.create_user('fake', 'fake', 'fake')
         self.project = self.manager.create_project('fake', 'fake', 'fake')
-        self.context = None
+        self.context = context.get_admin_context()
 
     def tearDown(self):  # pylint: disable-msg=C0103
         self.manager.delete_user(self.user)
@@ -73,13 +73,13 @@ class ComputeTestCase(test.TrialTestCase):
 
         yield self.compute.run_instance(self.context, instance_id)
 
-        instances = db.instance_get_all(None)
+        instances = db.instance_get_all(context.get_admin_context())
         logging.info("Running instances: %s", instances)
         self.assertEqual(len(instances), 1)
 
         yield self.compute.terminate_instance(self.context, instance_id)
 
-        instances = db.instance_get_all(None)
+        instances = db.instance_get_all(context.get_admin_context())
         logging.info("After terminating instances: %s", instances)
         self.assertEqual(len(instances), 0)
 
@@ -97,8 +97,7 @@ class ComputeTestCase(test.TrialTestCase):
         self.assertEqual(instance_ref['deleted_at'], None)
         terminate = datetime.datetime.utcnow()
         yield self.compute.terminate_instance(self.context, instance_id)
-        self.context = context.get_admin_context(user=self.user,
-                                                 read_deleted=True)
+        self.context = self.context.elevated(True)
         instance_ref = db.instance_get(self.context, instance_id)
         self.assert_(instance_ref['launched_at'] < terminate)
         self.assert_(instance_ref['deleted_at'] > terminate)
diff --git a/nova/tests/network_unittest.py b/nova/tests/network_unittest.py
index 3afb4d19e..e8dd2624f 100644
--- a/nova/tests/network_unittest.py
+++ b/nova/tests/network_unittest.py
@@ -22,13 +22,13 @@ import IPy
 import os
 import logging
 
+from nova import context
 from nova import db
 from nova import exception
 from nova import flags
 from nova import test
 from nova import utils
 from nova.auth import manager
-from nova.api.ec2 import context
 
 FLAGS = flags.FLAGS
 
@@ -49,13 +49,13 @@ class NetworkTestCase(test.TrialTestCase):
         self.user = self.manager.create_user('netuser', 'netuser', 'netuser')
         self.projects = []
         self.network = utils.import_object(FLAGS.network_manager)
-        self.context = context.APIRequestContext(project=None, user=self.user)
+        self.context = context.RequestContext(project=None, user=self.user)
         for i in range(5):
             name = 'project%s' % i
             project = self.manager.create_project(name, 'netuser', name)
             self.projects.append(project)
             # create the necessary network data for the project
-            user_context = context.APIRequestContext(project=self.projects[i],
+            user_context = context.RequestContext(project=self.projects[i],
                                                      user=self.user)
             network_ref = self.network.get_network(user_context)
             self.network.set_network_host(context.get_admin_context(),
@@ -69,8 +69,8 @@ class NetworkTestCase(test.TrialTestCase):
         super(NetworkTestCase, self).tearDown()
         # TODO(termie): this should really be instantiating clean datastores
         #               in between runs, one failure kills all the tests
-        db.instance_destroy(None, self.instance_id)
-        db.instance_destroy(None, self.instance2_id)
+        db.instance_destroy(context.get_admin_context(), self.instance_id)
+        db.instance_destroy(context.get_admin_context(), self.instance2_id)
         for project in self.projects:
             self.manager.delete_project(project)
         self.manager.delete_user(self.user)
@@ -79,7 +79,8 @@ class NetworkTestCase(test.TrialTestCase):
         if not mac:
             mac = utils.generate_mac()
         project = self.projects[project_num]
-        self.context.project = project
+        self.context._project = project
+        self.context.project_id = project.id
         return db.instance_create(self.context,
                                   {'project_id': project.id,
                                    'mac_address': mac})
@@ -88,35 +89,39 @@ class NetworkTestCase(test.TrialTestCase):
         """Create an address in given project num"""
         if instance_id is None:
             instance_id = self.instance_id
-        self.context.project = self.projects[project_num]
+        self.context._project = self.projects[project_num]
+        self.context.project_id = self.projects[project_num].id
         return self.network.allocate_fixed_ip(self.context, instance_id)
 
     def _deallocate_address(self, project_num, address):
-        self.context.project = self.projects[project_num]
+        self.context._project = self.projects[project_num]
+        self.context.project_id = self.projects[project_num].id
         self.network.deallocate_fixed_ip(self.context, address)
 
 
     def test_public_network_association(self):
         """Makes sure that we can allocaate a public ip"""
         # TODO(vish): better way of adding floating ips
-        self.context.project = self.projects[0]
+        self.context._project = self.projects[0]
+        self.context.project_id = self.projects[0].id
         pubnet = IPy.IP(flags.FLAGS.floating_range)
         address = str(pubnet[0])
         try:
-            db.floating_ip_get_by_address(None, address)
+            db.floating_ip_get_by_address(context.get_admin_context(), address)
         except exception.NotFound:
-            db.floating_ip_create(None, {'address': address,
-                                         'host': FLAGS.host})
+            db.floating_ip_create(context.get_admin_context(),
+                                  {'address': address,
+                                   'host': FLAGS.host})
         float_addr = self.network.allocate_floating_ip(self.context,
                                                        self.projects[0].id)
         fix_addr = self._create_address(0)
         lease_ip(fix_addr)
         self.assertEqual(float_addr, str(pubnet[0]))
         self.network.associate_floating_ip(self.context, float_addr, fix_addr)
-        address = db.instance_get_floating_address(None, self.instance_id)
+        address = db.instance_get_floating_address(context.get_admin_context(), self.instance_id)
         self.assertEqual(address, float_addr)
         self.network.disassociate_floating_ip(self.context, float_addr)
-        address = db.instance_get_floating_address(None, self.instance_id)
+        address = db.instance_get_floating_address(context.get_admin_context(), self.instance_id)
         self.assertEqual(address, None)
         self.network.deallocate_floating_ip(self.context, float_addr)
         self.network.deallocate_fixed_ip(self.context, fix_addr)
@@ -178,7 +183,8 @@ class NetworkTestCase(test.TrialTestCase):
             lease_ip(address)
             lease_ip(address2)
             lease_ip(address3)
-            self.context.project = self.projects[i]
+            self.context._project = self.projects[i]
+            self.context.project_id = self.projects[i].id
             self.assertFalse(is_allocated_in_project(address,
                                                      self.projects[0].id))
             self.assertFalse(is_allocated_in_project(address2,
@@ -192,8 +198,9 @@ class NetworkTestCase(test.TrialTestCase):
             release_ip(address2)
             release_ip(address3)
         for instance_id in instance_ids:
-            db.instance_destroy(None, instance_id)
-        self.context.project = self.projects[0]
+            db.instance_destroy(context.get_admin_context(), instance_id)
+        self.context._project = self.projects[0]
+        self.context.project_id = self.projects[0].id
         self.network.deallocate_fixed_ip(self.context, first)
         self._deallocate_address(0, first)
         release_ip(first)
@@ -208,16 +215,17 @@ class NetworkTestCase(test.TrialTestCase):
     def test_too_many_networks(self):
         """Ensure error is raised if we run out of networks"""
         projects = []
-        networks_left = FLAGS.num_networks - db.network_count(None)
+        networks_left = (FLAGS.num_networks -
+                         db.network_count(context.get_admin_context()))
         for i in range(networks_left):
             project = self.manager.create_project('many%s' % i, self.user)
             projects.append(project)
-            db.project_get_network(None, project.id)
+            db.project_get_network(context.get_admin_context(), project.id)
         project = self.manager.create_project('last', self.user)
         projects.append(project)
         self.assertRaises(db.NoMoreNetworks,
                           db.project_get_network,
-                          None,
+                          context.get_admin_context(),
                           project.id)
         for project in projects:
             self.manager.delete_project(project)
@@ -246,18 +254,18 @@ class NetworkTestCase(test.TrialTestCase):
         There are ips reserved at the bottom and top of the range.
         services (network, gateway, CloudPipe, broadcast)
         """
-        network = db.project_get_network(None, self.projects[0].id)
+        network = db.project_get_network(context.get_admin_context(), self.projects[0].id)
         net_size = flags.FLAGS.network_size
-        total_ips = (db.network_count_available_ips(None, network['id']) +
-                     db.network_count_reserved_ips(None, network['id']) +
-                     db.network_count_allocated_ips(None, network['id']))
+        total_ips = (db.network_count_available_ips(context.get_admin_context(), network['id']) +
+                     db.network_count_reserved_ips(context.get_admin_context(), network['id']) +
+                     db.network_count_allocated_ips(context.get_admin_context(), network['id']))
         self.assertEqual(total_ips, net_size)
 
     def test_too_many_addresses(self):
         """Test for a NoMoreAddresses exception when all fixed ips are used.
         """
-        network = db.project_get_network(None, self.projects[0].id)
-        num_available_ips = db.network_count_available_ips(None,
+        network = db.project_get_network(context.get_admin_context(), self.projects[0].id)
+        num_available_ips = db.network_count_available_ips(context.get_admin_context(),
                                                            network['id'])
         addresses = []
         instance_ids = []
@@ -268,7 +276,7 @@ class NetworkTestCase(test.TrialTestCase):
             addresses.append(address)
             lease_ip(address)
 
-        self.assertEqual(db.network_count_available_ips(None,
+        self.assertEqual(db.network_count_available_ips(context.get_admin_context(),
                                                         network['id']), 0)
         self.assertRaises(db.NoMoreAddresses,
                           self.network.allocate_fixed_ip,
@@ -278,17 +286,17 @@ class NetworkTestCase(test.TrialTestCase):
         for i in range(num_available_ips):
             self.network.deallocate_fixed_ip(self.context, addresses[i])
             release_ip(addresses[i])
-            db.instance_destroy(None, instance_ids[i])
-        self.assertEqual(db.network_count_available_ips(None,
+            db.instance_destroy(context.get_admin_context(), instance_ids[i])
+        self.assertEqual(db.network_count_available_ips(context.get_admin_context(),
                                                         network['id']),
                          num_available_ips)
 
 
 def is_allocated_in_project(address, project_id):
     """Returns true if address is in specified project"""
-    project_net = db.project_get_network(None, project_id)
-    network = db.fixed_ip_get_network(None, address)
-    instance = db.fixed_ip_get_instance(None, address)
+    project_net = db.project_get_network(context.get_admin_context(), project_id)
+    network = db.fixed_ip_get_network(context.get_admin_context(), address)
+    instance = db.fixed_ip_get_instance(context.get_admin_context(), address)
     # instance exists until release
     return instance is not None and network['id'] == project_net['id']
 
@@ -300,8 +308,8 @@ def binpath(script):
 
 def lease_ip(private_ip):
     """Run add command on dhcpbridge"""
-    network_ref = db.fixed_ip_get_network(None, private_ip)
-    instance_ref = db.fixed_ip_get_instance(None, private_ip)
+    network_ref = db.fixed_ip_get_network(context.get_admin_context(), private_ip)
+    instance_ref = db.fixed_ip_get_instance(context.get_admin_context(), private_ip)
     cmd = "%s add %s %s fake" % (binpath('nova-dhcpbridge'),
                                  instance_ref['mac_address'],
                                  private_ip)
@@ -314,8 +322,8 @@ def lease_ip(private_ip):
 
 def release_ip(private_ip):
     """Run del command on dhcpbridge"""
-    network_ref = db.fixed_ip_get_network(None, private_ip)
-    instance_ref = db.fixed_ip_get_instance(None, private_ip)
+    network_ref = db.fixed_ip_get_network(context.get_admin_context(), private_ip)
+    instance_ref = db.fixed_ip_get_instance(context.get_admin_context(), private_ip)
     cmd = "%s del %s %s fake" % (binpath('nova-dhcpbridge'),
                                  instance_ref['mac_address'],
                                  private_ip)
diff --git a/nova/tests/objectstore_unittest.py b/nova/tests/objectstore_unittest.py
index 872f1ab23..f096ac6fe 100644
--- a/nova/tests/objectstore_unittest.py
+++ b/nova/tests/objectstore_unittest.py
@@ -32,6 +32,7 @@ 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
@@ -70,13 +71,7 @@ class ObjectStoreTestCase(test.TrialTestCase):
         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'])
-
-        class Context(object):
-            """Dummy context for running tests."""
-            user = None
-            project = None
-
-        self.context = Context()
+        self.context = context.RequestContext('user1', 'proj1')
 
     def tearDown(self): # pylint: disable-msg=C0103
         """Tear down users and projects."""
@@ -89,8 +84,6 @@ class ObjectStoreTestCase(test.TrialTestCase):
 
     def test_buckets(self):
         """Test the bucket API."""
-        self.context.user = self.auth_manager.get_user('user1')
-        self.context.project = self.auth_manager.get_project('proj1')
         objectstore.bucket.Bucket.create('new_bucket', self.context)
         bucket = objectstore.bucket.Bucket('new_bucket')
 
@@ -98,14 +91,12 @@ class ObjectStoreTestCase(test.TrialTestCase):
         self.assert_(bucket.is_authorized(self.context))
 
         # another user is not authorized
-        self.context.user = self.auth_manager.get_user('user2')
-        self.context.project = self.auth_manager.get_project('proj2')
-        self.assertFalse(bucket.is_authorized(self.context))
+        context2 = context.RequestContext('user2', 'proj2')
+        self.assertFalse(bucket.is_authorized(context2))
 
         # admin is authorized to use bucket
-        self.context.user = self.auth_manager.get_user('admin_user')
-        self.context.project = None
-        self.assertTrue(bucket.is_authorized(self.context))
+        admin_context = context.RequestContext('admin_user', None)
+        self.assertTrue(bucket.is_authorized(admin_context))
 
         # new buckets are empty
         self.assertTrue(bucket.list_keys()['Contents'] == [])
@@ -143,8 +134,6 @@ class ObjectStoreTestCase(test.TrialTestCase):
     def do_test_images(self, manifest_file, expect_kernel_and_ramdisk,
                              image_bucket, image_name):
         "Test the image API."
-        self.context.user = self.auth_manager.get_user('user1')
-        self.context.project = self.auth_manager.get_project('proj1')
 
         # create a bucket for our bundle
         objectstore.bucket.Bucket.create(image_bucket, self.context)
@@ -179,9 +168,8 @@ class ObjectStoreTestCase(test.TrialTestCase):
             self.assertFalse('ramdiskId' in my_img.metadata)
 
         # verify image permissions
-        self.context.user = self.auth_manager.get_user('user2')
-        self.context.project = self.auth_manager.get_project('proj2')
-        self.assertFalse(my_img.is_authorized(self.context))
+        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'})
diff --git a/nova/tests/quota_unittest.py b/nova/tests/quota_unittest.py
index 370ccd506..72e44bf52 100644
--- a/nova/tests/quota_unittest.py
+++ b/nova/tests/quota_unittest.py
@@ -18,6 +18,7 @@
 
 import logging
 
+from nova import context
 from nova import db
 from nova import exception
 from nova import flags
@@ -26,7 +27,6 @@ from nova import test
 from nova import utils
 from nova.auth import manager
 from nova.api.ec2 import cloud
-from nova.api.ec2 import context
 
 
 FLAGS = flags.FLAGS
@@ -48,8 +48,8 @@ class QuotaTestCase(test.TrialTestCase):
         self.user = self.manager.create_user('admin', 'admin', 'admin', True)
         self.project = self.manager.create_project('admin', 'admin', 'admin')
         self.network = utils.import_object(FLAGS.network_manager)
-        self.context = context.APIRequestContext(project=self.project,
-                                                 user=self.user)
+        self.context = context.RequestContext(project=self.project,
+                                              user=self.user)
 
     def tearDown(self):  # pylint: disable-msg=C0103
         manager.AuthManager().delete_project(self.project)
@@ -94,7 +94,7 @@ class QuotaTestCase(test.TrialTestCase):
         for i in range(FLAGS.quota_instances):
             instance_id = self._create_instance()
             instance_ids.append(instance_id)
-        self.assertRaises(cloud.QuotaError, self.cloud.run_instances, 
+        self.assertRaises(cloud.QuotaError, self.cloud.run_instances,
                                             self.context,
                                             min_count=1,
                                             max_count=1,
@@ -106,7 +106,7 @@ class QuotaTestCase(test.TrialTestCase):
         instance_ids = []
         instance_id = self._create_instance(cores=4)
         instance_ids.append(instance_id)
-        self.assertRaises(cloud.QuotaError, self.cloud.run_instances, 
+        self.assertRaises(cloud.QuotaError, self.cloud.run_instances,
                                             self.context,
                                             min_count=1,
                                             max_count=1,
@@ -139,9 +139,9 @@ class QuotaTestCase(test.TrialTestCase):
     def test_too_many_addresses(self):
         address = '192.168.0.100'
         try:
-            db.floating_ip_get_by_address(None, address)
+            db.floating_ip_get_by_address(context.get_admin_context(), address)
         except exception.NotFound:
-            db.floating_ip_create(None, {'address': address,
+            db.floating_ip_create(context.get_admin_context(), {'address': address,
                                          'host': FLAGS.host})
         float_addr = self.network.allocate_floating_ip(self.context,
                                                        self.project.id)
diff --git a/nova/tests/rpc_unittest.py b/nova/tests/rpc_unittest.py
index 9652841f2..5d2bb1046 100644
--- a/nova/tests/rpc_unittest.py
+++ b/nova/tests/rpc_unittest.py
@@ -22,6 +22,7 @@ import logging
 
 from twisted.internet import defer
 
+from nova import context
 from nova import flags
 from nova import rpc
 from nova import test
@@ -40,14 +41,24 @@ class RpcTestCase(test.TrialTestCase):
                                             topic='test',
                                             proxy=self.receiver)
         self.consumer.attach_to_twisted()
+        self.context= context.get_admin_context()
 
     def test_call_succeed(self):
         """Get a value through rpc call"""
         value = 42
-        result = yield rpc.call_twisted('test', {"method": "echo",
+        result = yield rpc.call_twisted(self.context,
+                                        'test', {"method": "echo",
                                                  "args": {"value": value}})
         self.assertEqual(value, result)
 
+    def test_context_passed(self):
+        """Makes sure a context is passed through rpc call"""
+        value = 42
+        result = yield rpc.call_twisted(self.context,
+                                        'test', {"method": "context",
+                                                 "args": {"value": value}})
+        self.assertEqual(self.context.to_dict(), result)
+
     def test_call_exception(self):
         """Test that exception gets passed back properly
 
@@ -56,11 +67,13 @@ class RpcTestCase(test.TrialTestCase):
         to an int in the test.
         """
         value = 42
-        self.assertFailure(rpc.call_twisted('test', {"method": "fail",
+        self.assertFailure(rpc.call_twisted(self.context,
+                                            'test', {"method": "fail",
                                                      "args": {"value": value}}),
                            rpc.RemoteError)
         try:
-            yield rpc.call_twisted('test', {"method": "fail",
+            yield rpc.call_twisted(self.context,
+                                   'test', {"method": "fail",
                                             "args": {"value": value}})
             self.fail("should have thrown rpc.RemoteError")
         except rpc.RemoteError as exc:
@@ -73,12 +86,19 @@ class TestReceiver(object):
     Uses static methods because we aren't actually storing any state"""
 
     @staticmethod
-    def echo(value):
+    def echo(context, value):
         """Simply returns whatever value is sent in"""
         logging.debug("Received %s", value)
         return defer.succeed(value)
 
     @staticmethod
-    def fail(value):
+    def context(context, value):
+        """Returns dictionary version of context"""
+        logging.debug("Received %s", context)
+        return defer.succeed(context.to_dict())
+
+    @staticmethod
+    def fail(context, value):
         """Raises an exception with the value sent in"""
         raise Exception(value)
+
diff --git a/nova/tests/scheduler_unittest.py b/nova/tests/scheduler_unittest.py
index 80100fc2f..379f8cdc8 100644
--- a/nova/tests/scheduler_unittest.py
+++ b/nova/tests/scheduler_unittest.py
@@ -19,6 +19,7 @@
 Tests For Scheduler
 """
 
+from nova import context
 from nova import db
 from nova import flags
 from nova import service
@@ -50,22 +51,24 @@ class SchedulerTestCase(test.TrialTestCase):
     def test_fallback(self):
         scheduler = manager.SchedulerManager()
         self.mox.StubOutWithMock(rpc, 'cast', use_mock_anything=True)
-        rpc.cast('topic.fallback_host',
+        ctxt = context.get_admin_context()
+        rpc.cast(ctxt,
+                 'topic.fallback_host',
                  {'method': 'noexist',
-                  'args': {'context': None,
-                           'num': 7}})
+                  'args': {'num': 7}})
         self.mox.ReplayAll()
-        scheduler.noexist(None, 'topic', num=7)
+        scheduler.noexist(ctxt, 'topic', num=7)
 
     def test_named_method(self):
         scheduler = manager.SchedulerManager()
         self.mox.StubOutWithMock(rpc, 'cast', use_mock_anything=True)
-        rpc.cast('topic.named_host',
+        ctxt = context.get_admin_context()
+        rpc.cast(ctxt,
+                 'topic.named_host',
                  {'method': 'named_method',
-                  'args': {'context': None,
-                           'num': 7}})
+                  'args': {'num': 7}})
         self.mox.ReplayAll()
-        scheduler.named_method(None, 'topic', num=7)
+        scheduler.named_method(ctxt, 'topic', num=7)
 
 
 class SimpleDriverTestCase(test.TrialTestCase):
@@ -79,11 +82,10 @@ class SimpleDriverTestCase(test.TrialTestCase):
                    volume_driver='nova.volume.driver.FakeAOEDriver',
                    scheduler_driver='nova.scheduler.simple.SimpleScheduler')
         self.scheduler = manager.SchedulerManager()
-        self.context = None
         self.manager = auth_manager.AuthManager()
         self.user = self.manager.create_user('fake', 'fake', 'fake')
         self.project = self.manager.create_project('fake', 'fake', 'fake')
-        self.context = None
+        self.context = context.get_admin_context()
 
     def tearDown(self):  # pylint: disable-msg=C0103
         self.manager.delete_user(self.user)
diff --git a/nova/tests/service_unittest.py b/nova/tests/service_unittest.py
index 6afeec377..61db52742 100644
--- a/nova/tests/service_unittest.py
+++ b/nova/tests/service_unittest.py
@@ -24,6 +24,7 @@ import mox
 
 from twisted.application.app import startApplication
 
+from nova import context
 from nova import exception
 from nova import flags
 from nova import rpc
@@ -47,6 +48,7 @@ class ServiceTestCase(test.BaseTestCase):
     def setUp(self):  # pylint: disable=C0103
         super(ServiceTestCase, self).setUp()
         self.mox.StubOutWithMock(service, 'db')
+        self.context = context.get_admin_context()
 
     def test_create(self):
         host = 'foo'
@@ -90,10 +92,10 @@ class ServiceTestCase(test.BaseTestCase):
                        'report_count': 0,
                        'id': 1}
 
-        service.db.service_get_by_args(None,
+        service.db.service_get_by_args(mox.IgnoreArg(),
                                        host,
                                        binary).AndRaise(exception.NotFound())
-        service.db.service_create(None,
+        service.db.service_create(mox.IgnoreArg(),
                                   service_create).AndReturn(service_ref)
         self.mox.ReplayAll()
 
@@ -113,10 +115,10 @@ class ServiceTestCase(test.BaseTestCase):
                        'report_count': 0,
                        'id': 1}
         service.db.__getattr__('report_state')
-        service.db.service_get_by_args(None,
+        service.db.service_get_by_args(self.context,
                                        host,
                                        binary).AndReturn(service_ref)
-        service.db.service_update(None, service_ref['id'],
+        service.db.service_update(self.context, service_ref['id'],
                                   mox.ContainsKeyValue('report_count', 1))
 
         self.mox.ReplayAll()
@@ -135,13 +137,13 @@ class ServiceTestCase(test.BaseTestCase):
                        'id': 1}
 
         service.db.__getattr__('report_state')
-        service.db.service_get_by_args(None,
+        service.db.service_get_by_args(self.context,
                                       host,
                                       binary).AndRaise(exception.NotFound())
-        service.db.service_create(None,
+        service.db.service_create(self.context,
                                   service_create).AndReturn(service_ref)
-        service.db.service_get(None, service_ref['id']).AndReturn(service_ref)
-        service.db.service_update(None, service_ref['id'],
+        service.db.service_get(self.context, service_ref['id']).AndReturn(service_ref)
+        service.db.service_update(self.context, service_ref['id'],
                                   mox.ContainsKeyValue('report_count', 1))
 
         self.mox.ReplayAll()
@@ -157,7 +159,7 @@ class ServiceTestCase(test.BaseTestCase):
                        'id': 1}
 
         service.db.__getattr__('report_state')
-        service.db.service_get_by_args(None,
+        service.db.service_get_by_args(self.context,
                                        host,
                                        binary).AndRaise(Exception())
 
@@ -176,10 +178,10 @@ class ServiceTestCase(test.BaseTestCase):
                        'id': 1}
 
         service.db.__getattr__('report_state')
-        service.db.service_get_by_args(None,
+        service.db.service_get_by_args(self.context,
                                        host,
                                        binary).AndReturn(service_ref)
-        service.db.service_update(None, service_ref['id'],
+        service.db.service_update(self.context, service_ref['id'],
                                   mox.ContainsKeyValue('report_count', 1))
 
         self.mox.ReplayAll()
diff --git a/nova/tests/virt_unittest.py b/nova/tests/virt_unittest.py
index edcdba425..76af5cabd 100644
--- a/nova/tests/virt_unittest.py
+++ b/nova/tests/virt_unittest.py
@@ -17,11 +17,11 @@
 from xml.etree.ElementTree import fromstring as xml_to_tree
 from xml.dom.minidom import parseString as xml_to_dom
 
+from nova import context
 from nova import db
 from nova import flags
 from nova import test
 from nova import utils
-from nova.api import context
 from nova.api.ec2 import cloud
 from nova.auth import manager
 from nova.virt import libvirt_conn
@@ -51,9 +51,9 @@ class LibvirtConnTestCase(test.TrialTestCase):
                      'bridge'         : 'br101',
                      'instance_type'  : 'm1.small'}
 
-        instance_ref = db.instance_create(None, instance)
-        user_context = context.APIRequestContext(project=self.project,
-                                                 user=self.user)
+        user_context = context.RequestContext(project=self.project,
+                                              user=self.user)
+        instance_ref = db.instance_create(user_context, instance)
         network_ref = self.network.get_network(user_context)
         self.network.set_network_host(context.get_admin_context(),
                                       network_ref['id'])
@@ -61,9 +61,10 @@ class LibvirtConnTestCase(test.TrialTestCase):
         fixed_ip = { 'address'    : ip,
                      'network_id' : network_ref['id'] }
 
-        fixed_ip_ref = db.fixed_ip_create(None, fixed_ip)
-        db.fixed_ip_update(None, ip, { 'allocated'   : True,
-                                          'instance_id' : instance_ref['id'] })
+        ctxt = context.get_admin_context()
+        fixed_ip_ref = db.fixed_ip_create(ctxt, fixed_ip)
+        db.fixed_ip_update(ctxt, ip, {'allocated': True,
+                                      'instance_id': instance_ref['id'] })
 
         type_uri_map = { 'qemu' : ('qemu:///system',
                               [(lambda t: t.find('.').get('type'), 'qemu'),
@@ -132,7 +133,7 @@ class NWFilterTestCase(test.TrialTestCase):
         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.context = context.APIRequestContext(self.user, self.project)
+        self.context = context.RequestContext(self.user, self.project)
 
         self.fake_libvirt_connection = Mock()
 
diff --git a/nova/tests/volume_unittest.py b/nova/tests/volume_unittest.py
index 1d665b502..8e2fa11c1 100644
--- a/nova/tests/volume_unittest.py
+++ b/nova/tests/volume_unittest.py
@@ -22,6 +22,7 @@ import logging
 
 from twisted.internet import defer
 
+from nova import context
 from nova import exception
 from nova import db
 from nova import flags
@@ -39,7 +40,7 @@ class VolumeTestCase(test.TrialTestCase):
         self.compute = utils.import_object(FLAGS.compute_manager)
         self.flags(connection_type='fake')
         self.volume = utils.import_object(FLAGS.volume_manager)
-        self.context = None
+        self.context = context.get_admin_context()
 
     @staticmethod
     def _create_volume(size='0'):
@@ -51,19 +52,19 @@ class VolumeTestCase(test.TrialTestCase):
         vol['availability_zone'] = FLAGS.storage_availability_zone
         vol['status'] = "creating"
         vol['attach_status'] = "detached"
-        return db.volume_create(None, vol)['id']
+        return db.volume_create(context.get_admin_context(), vol)['id']
 
     @defer.inlineCallbacks
     def test_create_delete_volume(self):
         """Test volume can be created and deleted"""
         volume_id = self._create_volume()
         yield self.volume.create_volume(self.context, volume_id)
-        self.assertEqual(volume_id, db.volume_get(None, volume_id).id)
+        self.assertEqual(volume_id, db.volume_get(context.get_admin_context(), volume_id).id)
 
         yield self.volume.delete_volume(self.context, volume_id)
         self.assertRaises(exception.NotFound,
                           db.volume_get,
-                          None,
+                          self.context,
                           volume_id)
 
     @defer.inlineCallbacks
@@ -92,7 +93,7 @@ class VolumeTestCase(test.TrialTestCase):
         self.assertFailure(self.volume.create_volume(self.context,
                                                      volume_id),
                            db.NoMoreBlades)
-        db.volume_destroy(None, volume_id)
+        db.volume_destroy(context.get_admin_context(), volume_id)
         for volume_id in vols:
             yield self.volume.delete_volume(self.context, volume_id)
 
@@ -113,12 +114,13 @@ class VolumeTestCase(test.TrialTestCase):
         volume_id = self._create_volume()
         yield self.volume.create_volume(self.context, volume_id)
         if FLAGS.fake_tests:
-            db.volume_attached(None, volume_id, instance_id, mountpoint)
+            db.volume_attached(self.context, volume_id, instance_id, mountpoint)
         else:
-            yield self.compute.attach_volume(instance_id,
+            yield self.compute.attach_volume(self.context,
+                                             instance_id,
                                              volume_id,
                                              mountpoint)
-        vol = db.volume_get(None, volume_id)
+        vol = db.volume_get(context.get_admin_context(), volume_id)
         self.assertEqual(vol['status'], "in-use")
         self.assertEqual(vol['attach_status'], "attached")
         self.assertEqual(vol['mountpoint'], mountpoint)
@@ -128,17 +130,18 @@ class VolumeTestCase(test.TrialTestCase):
         self.assertFailure(self.volume.delete_volume(self.context, volume_id),
                            exception.Error)
         if FLAGS.fake_tests:
-            db.volume_detached(None, volume_id)
+            db.volume_detached(self.context, volume_id)
         else:
-            yield self.compute.detach_volume(instance_id,
+            yield self.compute.detach_volume(self.context,
+                                             instance_id,
                                              volume_id)
-        vol = db.volume_get(None, volume_id)
+        vol = db.volume_get(self.context, volume_id)
         self.assertEqual(vol['status'], "available")
 
         yield self.volume.delete_volume(self.context, volume_id)
         self.assertRaises(exception.Error,
                           db.volume_get,
-                          None,
+                          self.context,
                           volume_id)
         db.instance_destroy(self.context, instance_id)
 
@@ -151,7 +154,7 @@ class VolumeTestCase(test.TrialTestCase):
         def _check(volume_id):
             """Make sure blades aren't duplicated"""
             volume_ids.append(volume_id)
-            (shelf_id, blade_id) = db.volume_get_shelf_and_blade(None,
+            (shelf_id, blade_id) = db.volume_get_shelf_and_blade(context.get_admin_context(),
                                                                  volume_id)
             shelf_blade = '%s.%s' % (shelf_id, blade_id)
             self.assert_(shelf_blade not in shelf_blades)