merged trunk, just in case

3 files changed, 44 insertions, 49 deletions

diff --git a/nova/api/__init__.py b/nova/api/__init__.py
index 8a1d9fe32..707c1623e 100644
--- a/nova/api/__init__.py
+++ b/nova/api/__init__.py
@@ -35,37 +35,31 @@ flags.DEFINE_string('osapi_subdomain', 'api',
                     'subdomain running the OpenStack API')
 flags.DEFINE_string('ec2api_subdomain', 'ec2',
                     'subdomain running the EC2 API')
-flags.DEFINE_string('FAKE_subdomain', None,
-                    'set to api or ec2 to fake the subdomain of the host '
-                    'for testing')
 FLAGS = flags.FLAGS
 
 
 class API(wsgi.Router):
     """Routes top-level requests to the appropriate controller."""
 
-    def __init__(self):
-        osapidomain = {'sub_domain': [FLAGS.osapi_subdomain]}
-        ec2domain = {'sub_domain': [FLAGS.ec2api_subdomain]}
-        # If someone wants to pretend they're hitting the OSAPI subdomain
-        # on their local box, they can set FAKE_subdomain to 'api', which
-        # removes subdomain restrictions from the OpenStack API routes below.
-        if FLAGS.FAKE_subdomain == 'api':
-            osapidomain = {}
-        elif FLAGS.FAKE_subdomain == 'ec2':
-            ec2domain = {}
+    def __init__(self, default_api):
+        osapi_subdomain = {'sub_domain': [FLAGS.osapi_subdomain]}
+        ec2api_subdomain = {'sub_domain': [FLAGS.ec2api_subdomain]}
+        if default_api == 'os':
+            osapi_subdomain = {}
+        elif default_api == 'ec2':
+            ec2api_subdomain = {}
         mapper = routes.Mapper()
         mapper.sub_domains = True
+
         mapper.connect("/", controller=self.osapi_versions,
-                            conditions=osapidomain)
+                       conditions=osapi_subdomain)
         mapper.connect("/v1.0/{path_info:.*}", controller=openstack.API(),
-                            conditions=osapidomain)
+                       conditions=osapi_subdomain)
 
         mapper.connect("/", controller=self.ec2api_versions,
-                            conditions=ec2domain)
+                       conditions=ec2api_subdomain)
         mapper.connect("/services/{path_info:.*}", controller=ec2.API(),
-                            conditions=ec2domain)
-        mapper.connect("/cloudpipe/{path_info:.*}", controller=cloudpipe.API())
+                       conditions=ec2api_subdomain)
         mrh = metadatarequesthandler.MetadataRequestHandler()
         for s in ['/latest',
                   '/2009-04-04',
@@ -78,7 +72,9 @@ class API(wsgi.Router):
                   '/2007-01-19',
                   '/1.0']:
             mapper.connect('%s/{path_info:.*}' % s, controller=mrh,
-                           conditions=ec2domain)
+                           conditions=ec2api_subdomain)
+
+        mapper.connect("/cloudpipe/{path_info:.*}", controller=cloudpipe.API())
         super(API, self).__init__(mapper)
 
     @webob.dec.wsgify
diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 8aed0763c..fbe4caa48 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -99,6 +99,7 @@ class CloudController(object):
 """
     def __init__(self):
         self.network_manager = utils.import_object(FLAGS.network_manager)
+        self.compute_manager = utils.import_object(FLAGS.compute_manager)
         self.setup()
 
     def __str__(self):
@@ -845,21 +846,21 @@ class CloudController(object):
         elevated = context.elevated()
 
         for num in range(num_instances):
-            instance_ref = db.instance_create(context, base_options)
-            inst_id = instance_ref['id']
 
-            for security_group_id in security_groups:
-                db.instance_add_security_group(elevated,
-                                               inst_id,
-                                               security_group_id)
+            instance_ref = self.compute_manager.create_instance(context,
+                                           security_groups,
+                                           mac_address=utils.generate_mac(),
+                                           launch_index=num,
+                                           **base_options)
+            inst_id = instance_ref['id']
 
-            inst = {}
-            inst['mac_address'] = utils.generate_mac()
-            inst['launch_index'] = num
             internal_id = instance_ref['internal_id']
             ec2_id = internal_id_to_ec2_id(internal_id)
-            inst['hostname'] = ec2_id
-            db.instance_update(context, inst_id, inst)
+
+            self.compute_manager.update_instance(context,
+                                                 inst_id,
+                                                 hostname=ec2_id)
+
             # TODO(vish): This probably should be done in the scheduler
             #             or in compute as a call.  The network should be
             #             allocated after the host is assigned and setup
@@ -905,11 +906,12 @@ class CloudController(object):
                               id_str)
                 continue
             now = datetime.datetime.utcnow()
-            db.instance_update(context,
-                               instance_ref['id'],
-                               {'state_description': 'terminating',
-                                'state': 0,
-                                'terminated_at': now})
+            self.compute_manager.update_instance(context,
+                                         instance_ref['id'],
+                                         state_description='terminating',
+                                         state=0,
+                                         terminated_at=now)
+
             # FIXME(ja): where should network deallocate occur?
             address = db.instance_get_floating_address(context,
                                                        instance_ref['id'])
diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index ef773c3be..1d8aa2fa4 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -95,6 +95,7 @@ class Controller(wsgi.Controller):
             db_driver = FLAGS.db_driver
         self.db_driver = utils.import_object(db_driver)
         self.network_manager = utils.import_object(FLAGS.network_manager)
+        self.compute_manager = utils.import_object(FLAGS.compute_manager)
         super(Controller, self).__init__()
 
     def index(self, req):
@@ -242,34 +243,30 @@ class Controller(wsgi.Controller):
         inst['memory_mb'] = flavor['memory_mb']
         inst['vcpus'] = flavor['vcpus']
         inst['local_gb'] = flavor['local_gb']
-
-        ref = self.db_driver.instance_create(ctxt, inst)
-        inst['id'] = ref.internal_id
-
         inst['mac_address'] = utils.generate_mac()
-
-        #TODO(dietz) is this necessary?
         inst['launch_index'] = 0
 
-        inst['hostname'] = str(ref.internal_id)
-        self.db_driver.instance_update(ctxt, inst['id'], inst)
+        ref = self.compute_manager.create_instance(ctxt, **inst)
+        inst['id'] = ref['internal_id']
+
+        inst['hostname'] = str(ref['internal_id'])
+        self.compute_manager.update_instance(ctxt, inst['id'], **inst)
 
-        network_manager = utils.import_object(FLAGS.network_manager)
-        address = network_manager.allocate_fixed_ip(ctxt,
-            inst['id'])
+        address = self.network_manager.allocate_fixed_ip(ctxt,
+                                                         inst['id'])
 
         # TODO(vish): This probably should be done in the scheduler
         #             network is setup when host is assigned
-        network_topic = self._get_network_topic(ctxt, network_manager)
+        network_topic = self._get_network_topic(ctxt)
         rpc.call(ctxt,
                  network_topic,
                  {"method": "setup_fixed_ip",
                   "args": {"address": address}})
         return inst
 
-    def _get_network_topic(self, context, network_manager):
+    def _get_network_topic(self, context):
         """Retrieves the network host for a project"""
-        network_ref = network_manager.get_network(context)
+        network_ref = self.network_manager.get_network(context)
         host = network_ref['host']
         if not host:
             host = rpc.call(context,