Rename nova.compute.instance_types to flavors

First step in removing references to instance_types. Rename instnace_types.py
and update references to it. We currently use instance_type and flavor as
synonyms, to reduce confusion we are picking one. We are going with our own
terminology, flavors.

renamed:    nova/compute/instance_types.py -> nova/compute/flavors.py

Partially implements bp flavor-instance-type-dedup

Change-Id: I9dc04cf311aa8813be4f5329f23729d2c43cae6d

61 files changed, 390 insertions, 389 deletions

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index da319bc8b..e2abde48c 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -36,7 +36,7 @@ from nova import block_device
 from nova.cloudpipe import pipelib
 from nova import compute
 from nova.compute import api as compute_api
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova.compute import vm_states
 from nova import db
 from nova import exception
@@ -1091,7 +1091,7 @@ class CloudController(object):
 
     @staticmethod
     def _format_instance_type(instance, result):
-        instance_type = instance_types.extract_instance_type(instance)
+        instance_type = flavors.extract_instance_type(instance)
         result['instanceType'] = instance_type['name']
 
     @staticmethod
@@ -1323,7 +1323,7 @@ class CloudController(object):
             raise exception.EC2APIError(_('Image must be available'))
 
         (instances, resv_id) = self.compute_api.create(context,
-            instance_type=instance_types.get_instance_type_by_name(
+            instance_type=flavors.get_instance_type_by_name(
                 kwargs.get('instance_type', None)),
             image_href=image_uuid,
             max_count=int(kwargs.get('max_count', min_count)),
diff --git a/nova/api/metadata/base.py b/nova/api/metadata/base.py
index f50ddeb25..d53241308 100644
--- a/nova/api/metadata/base.py
+++ b/nova/api/metadata/base.py
@@ -28,7 +28,7 @@ from oslo.config import cfg
 from nova.api.ec2 import ec2utils
 from nova.api.metadata import password
 from nova import block_device
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova import conductor
 from nova import context
 from nova import network
@@ -209,7 +209,7 @@ class InstanceMetadata():
             meta_data['product-codes'] = []
 
         if self._check_version('2007-08-29', version):
-            instance_type = instance_types.extract_instance_type(self.instance)
+            instance_type = flavors.extract_instance_type(self.instance)
             meta_data['instance-type'] = instance_type['name']
 
         if False and self._check_version('2007-10-10', version):
diff --git a/nova/api/openstack/compute/contrib/flavor_access.py b/nova/api/openstack/compute/contrib/flavor_access.py
index 39220ee4a..566eb6472 100644
--- a/nova/api/openstack/compute/contrib/flavor_access.py
+++ b/nova/api/openstack/compute/contrib/flavor_access.py
@@ -22,7 +22,7 @@ import webob
 from nova.api.openstack import extensions
 from nova.api.openstack import wsgi
 from nova.api.openstack import xmlutil
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova import exception
 
 
@@ -70,7 +70,7 @@ class FlavorAccessTemplate(xmlutil.TemplateBuilder):
 def _marshall_flavor_access(flavor_id):
     rval = []
     try:
-        access_list = instance_types.\
+        access_list = flavors.\
                       get_instance_type_access_by_flavor_id(flavor_id)
     except exception.FlavorNotFound:
         explanation = _("Flavor not found.")
@@ -95,7 +95,7 @@ class FlavorAccessController(object):
         authorize(context)
 
         try:
-            flavor = instance_types.get_instance_type_by_flavor_id(flavor_id)
+            flavor = flavors.get_instance_type_by_flavor_id(flavor_id)
         except exception.FlavorNotFound:
             explanation = _("Flavor not found.")
             raise webob.exc.HTTPNotFound(explanation=explanation)
@@ -119,7 +119,7 @@ class FlavorActionController(wsgi.Controller):
     def _get_flavor_refs(self, context):
         """Return a dictionary mapping flavorid to flavor_ref."""
 
-        flavor_refs = instance_types.get_all_types(context)
+        flavor_refs = flavors.get_all_types(context)
         rval = {}
         for name, obj in flavor_refs.iteritems():
             rval[obj['flavorid']] = obj
@@ -173,7 +173,7 @@ class FlavorActionController(wsgi.Controller):
         tenant = vals['tenant']
 
         try:
-            instance_types.add_instance_type_access(id, tenant, context)
+            flavors.add_instance_type_access(id, tenant, context)
         except exception.FlavorAccessExists as err:
             raise webob.exc.HTTPConflict(explanation=err.format_message())
 
@@ -190,7 +190,7 @@ class FlavorActionController(wsgi.Controller):
         tenant = vals['tenant']
 
         try:
-            instance_types.remove_instance_type_access(id, tenant, context)
+            flavors.remove_instance_type_access(id, tenant, context)
         except exception.FlavorAccessNotFound, e:
             raise webob.exc.HTTPNotFound(explanation=e.format_message())
 
diff --git a/nova/api/openstack/compute/contrib/flavormanage.py b/nova/api/openstack/compute/contrib/flavormanage.py
index ddf8aa5af..c36b40125 100644
--- a/nova/api/openstack/compute/contrib/flavormanage.py
+++ b/nova/api/openstack/compute/contrib/flavormanage.py
@@ -18,7 +18,7 @@ from nova.api.openstack.compute import flavors as flavors_api
 from nova.api.openstack.compute.views import flavors as flavors_view
 from nova.api.openstack import extensions
 from nova.api.openstack import wsgi
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova import exception
 
 
@@ -40,12 +40,12 @@ class FlavorManageController(wsgi.Controller):
         authorize(context)
 
         try:
-            flavor = instance_types.get_instance_type_by_flavor_id(
+            flavor = flavors.get_instance_type_by_flavor_id(
                     id, read_deleted="no")
         except exception.NotFound, e:
             raise webob.exc.HTTPNotFound(explanation=e.format_message())
 
-        instance_types.destroy(flavor['name'])
+        flavors.destroy(flavor['name'])
 
         return webob.Response(status_int=202)
 
@@ -67,7 +67,7 @@ class FlavorManageController(wsgi.Controller):
         is_public = vals.get('os-flavor-access:is_public', True)
 
         try:
-            flavor = instance_types.create(name, memory_mb, vcpus,
+            flavor = flavors.create(name, memory_mb, vcpus,
                                            root_gb, ephemeral_gb, flavorid,
                                            swap, rxtx_factor, is_public)
             req.cache_db_flavor(flavor)
diff --git a/nova/api/openstack/compute/contrib/simple_tenant_usage.py b/nova/api/openstack/compute/contrib/simple_tenant_usage.py
index b653564c0..e5f9b44b7 100644
--- a/nova/api/openstack/compute/contrib/simple_tenant_usage.py
+++ b/nova/api/openstack/compute/contrib/simple_tenant_usage.py
@@ -24,7 +24,7 @@ from nova.api.openstack import extensions
 from nova.api.openstack import wsgi
 from nova.api.openstack import xmlutil
 from nova.compute import api
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova import exception
 from nova.openstack.common import timeutils
 
@@ -108,7 +108,7 @@ class SimpleTenantUsageController(object):
         """Get flavor information from the instance's system_metadata,
         allowing a fallback to lookup by-id for deleted instances only."""
         try:
-            return instance_types.extract_instance_type(instance)
+            return flavors.extract_instance_type(instance)
         except KeyError:
             if not instance['deleted']:
                 # Only support the fallback mechanism for deleted instances
diff --git a/nova/api/openstack/compute/flavors.py b/nova/api/openstack/compute/flavors.py
index a0d33abd4..42b627cf4 100644
--- a/nova/api/openstack/compute/flavors.py
+++ b/nova/api/openstack/compute/flavors.py
@@ -21,7 +21,7 @@ from nova.api.openstack import common
 from nova.api.openstack.compute.views import flavors as flavors_view
 from nova.api.openstack import wsgi
 from nova.api.openstack import xmlutil
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova import exception
 
 
@@ -70,21 +70,21 @@ class Controller(wsgi.Controller):
     @wsgi.serializers(xml=MinimalFlavorsTemplate)
     def index(self, req):
         """Return all flavors in brief."""
-        flavors = self._get_flavors(req)
-        return self._view_builder.index(req, flavors)
+        limited_flavors = self._get_flavors(req)
+        return self._view_builder.index(req, limited_flavors)
 
     @wsgi.serializers(xml=FlavorsTemplate)
     def detail(self, req):
         """Return all flavors in detail."""
-        flavors = self._get_flavors(req)
-        req.cache_db_flavors(flavors)
-        return self._view_builder.detail(req, flavors)
+        limited_flavors = self._get_flavors(req)
+        req.cache_db_flavors(limited_flavors)
+        return self._view_builder.detail(req, limited_flavors)
 
     @wsgi.serializers(xml=FlavorTemplate)
     def show(self, req, id):
         """Return data about the given flavor id."""
         try:
-            flavor = instance_types.get_instance_type_by_flavor_id(id)
+            flavor = flavors.get_instance_type_by_flavor_id(id)
             req.cache_db_flavor(flavor)
         except exception.NotFound:
             raise webob.exc.HTTPNotFound()
@@ -137,8 +137,8 @@ class Controller(wsgi.Controller):
                 msg = _('Invalid minDisk filter [%s]') % req.params['minDisk']
                 raise webob.exc.HTTPBadRequest(explanation=msg)
 
-        flavors = instance_types.get_all_types(context, filters=filters)
-        flavors_list = flavors.values()
+        limited_flavors = flavors.get_all_types(context, filters=filters)
+        flavors_list = limited_flavors.values()
         sorted_flavors = sorted(flavors_list,
                                 key=lambda item: item['flavorid'])
         limited_flavors = common.limited_by_marker(sorted_flavors, req)
diff --git a/nova/api/openstack/compute/servers.py b/nova/api/openstack/compute/servers.py
index 94912da97..30f8e6fe8 100644
--- a/nova/api/openstack/compute/servers.py
+++ b/nova/api/openstack/compute/servers.py
@@ -28,7 +28,7 @@ from nova.api.openstack.compute.views import servers as views_servers
 from nova.api.openstack import wsgi
 from nova.api.openstack import xmlutil
 from nova import compute
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova import exception
 from nova.openstack.common import importutils
 from nova.openstack.common import log as logging
@@ -872,7 +872,7 @@ class Controller(wsgi.Controller):
             scheduler_hints = server_dict.get('scheduler_hints', {})
 
         try:
-            _get_inst_type = instance_types.get_instance_type_by_flavor_id
+            _get_inst_type = flavors.get_instance_type_by_flavor_id
             inst_type = _get_inst_type(flavor_id, read_deleted="no")
 
             (instances, resv_id) = self.compute_api.create(context,
diff --git a/nova/api/openstack/compute/views/servers.py b/nova/api/openstack/compute/views/servers.py
index f00ab9921..0cd6afaa1 100644
--- a/nova/api/openstack/compute/views/servers.py
+++ b/nova/api/openstack/compute/views/servers.py
@@ -22,7 +22,7 @@ from nova.api.openstack import common
 from nova.api.openstack.compute.views import addresses as views_addresses
 from nova.api.openstack.compute.views import flavors as views_flavors
 from nova.api.openstack.compute.views import images as views_images
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova.openstack.common import log as logging
 from nova.openstack.common import timeutils
 
@@ -181,7 +181,7 @@ class ViewBuilder(common.ViewBuilder):
             return ""
 
     def _get_flavor(self, request, instance):
-        instance_type = instance_types.extract_instance_type(instance)
+        instance_type = flavors.extract_instance_type(instance)
         if not instance_type:
             LOG.warn(_("Instance has had its instance_type removed "
                     "from the DB"), instance=instance)
diff --git a/nova/cloudpipe/pipelib.py b/nova/cloudpipe/pipelib.py
index c395a754c..0727528c2 100644
--- a/nova/cloudpipe/pipelib.py
+++ b/nova/cloudpipe/pipelib.py
@@ -29,7 +29,7 @@ import zipfile
 from oslo.config import cfg
 
 from nova import compute
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova import crypto
 from nova import db
 from nova import exception
@@ -126,7 +126,7 @@ class CloudPipe(object):
         LOG.debug(_("Launching VPN for %s") % (context.project_id))
         key_name = self.setup_key_pair(context)
         group_name = self.setup_security_group(context)
-        instance_type = instance_types.get_instance_type_by_name(
+        instance_type = flavors.get_instance_type_by_name(
                 CONF.vpn_instance_type)
         instance_name = '%s%s' % (context.project_id, CONF.vpn_key_suffix)
         user_data = self.get_encoded_zip(context.project_id)
diff --git a/nova/cmd/manage.py b/nova/cmd/manage.py
index 41b97f26d..9bec62f09 100644
--- a/nova/cmd/manage.py
+++ b/nova/cmd/manage.py
@@ -65,7 +65,7 @@ gettext.install('nova', unicode=1)
 
 from nova.api.ec2 import ec2utils
 from nova import availability_zones
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova import config
 from nova import context
 from nova import db
@@ -621,7 +621,7 @@ class VmCommands(object):
                            context.get_admin_context(), host)
 
         for instance in instances:
-            instance_type = instance_types.extract_instance_type(instance)
+            instance_type = flavors.extract_instance_type(instance)
             print ("%-10s %-15s %-10s %-10s %-26s %-9s %-9s %-9s"
                    " %-10s %-10s %-10s %-5d" % (instance['display_name'],
                                                 instance['host'],
@@ -889,7 +889,7 @@ class InstanceTypeCommands(object):
                flavorid=None, swap=0, rxtx_factor=1.0, is_public=True):
         """Creates instance types / flavors."""
         try:
-            instance_types.create(name, memory, vcpus, root_gb,
+            flavors.create(name, memory, vcpus, root_gb,
                                   ephemeral_gb, flavorid, swap, rxtx_factor,
                                   is_public)
         except exception.InvalidInput as e:
@@ -914,7 +914,7 @@ class InstanceTypeCommands(object):
     def delete(self, name):
         """Marks instance types / flavors as deleted."""
         try:
-            instance_types.destroy(name)
+            flavors.destroy(name)
         except exception.InstanceTypeNotFound:
             print _("Valid instance type name is required")
             return(1)
@@ -931,9 +931,9 @@ class InstanceTypeCommands(object):
         """Lists all active or specific instance types / flavors."""
         try:
             if name is None:
-                inst_types = instance_types.get_all_types()
+                inst_types = flavors.get_all_types()
             else:
-                inst_types = instance_types.get_instance_type_by_name(name)
+                inst_types = flavors.get_instance_type_by_name(name)
         except db_exc.DBError as e:
             _db_error(e)
         if isinstance(inst_types.values()[0], dict):
@@ -949,7 +949,7 @@ class InstanceTypeCommands(object):
         """Add key/value pair to specified instance type's extra_specs."""
         try:
             try:
-                inst_type = instance_types.get_instance_type_by_name(name)
+                inst_type = flavors.get_instance_type_by_name(name)
             except exception.InstanceTypeNotFoundByName as e:
                 print e
                 return(2)
@@ -971,7 +971,7 @@ class InstanceTypeCommands(object):
         """Delete the specified extra spec for instance type."""
         try:
             try:
-                inst_type = instance_types.get_instance_type_by_name(name)
+                inst_type = flavors.get_instance_type_by_name(name)
             except exception.InstanceTypeNotFoundByName as e:
                 print e
                 return(2)
diff --git a/nova/compute/api.py b/nova/compute/api.py
index 512b991d7..c56270cc3 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -32,8 +32,8 @@ from oslo.config import cfg
 
 from nova import availability_zones
 from nova import block_device
+from nova.compute import flavors
 from nova.compute import instance_actions
-from nova.compute import instance_types
 from nova.compute import power_state
 from nova.compute import rpcapi as compute_rpcapi
 from nova.compute import task_states
@@ -496,7 +496,7 @@ class API(base.Base):
             security_groups = ['default']
 
         if not instance_type:
-            instance_type = instance_types.get_default_instance_type()
+            instance_type = flavors.get_default_instance_type()
         if not min_count:
             min_count = 1
         if not max_count:
@@ -579,7 +579,7 @@ class API(base.Base):
             availability_zone, forced_host, forced_node = \
                     self._handle_availability_zone(availability_zone)
 
-            system_metadata = instance_types.save_instance_type_info(
+            system_metadata = flavors.save_instance_type_info(
                 dict(), instance_type)
 
             base_options = {
@@ -1165,7 +1165,7 @@ class API(base.Base):
                     new_instance['instance_type_id'] ==
                         migration_ref['new_instance_type_id']):
                 old_inst_type_id = migration_ref['old_instance_type_id']
-                get_inst_type_by_id = instance_types.get_instance_type
+                get_inst_type_by_id = flavors.get_instance_type
                 try:
                     old_inst_type = get_inst_type_by_id(old_inst_type_id)
                 except exception.InstanceTypeNotFound:
@@ -1262,7 +1262,7 @@ class API(base.Base):
     def restore(self, context, instance):
         """Restore a previously deleted (but not reclaimed) instance."""
         # Reserve quotas
-        instance_type = instance_types.extract_instance_type(instance)
+        instance_type = flavors.extract_instance_type(instance)
         num_instances, quota_reservations = self._check_num_instances_quota(
                 context, instance_type, 1, 1)
 
@@ -1342,7 +1342,7 @@ class API(base.Base):
     #NOTE(bcwaldon): this doesn't really belong in this class
     def get_instance_type(self, context, instance_type_id):
         """Get an instance type by instance type id."""
-        return instance_types.get_instance_type(instance_type_id)
+        return flavors.get_instance_type(instance_type_id)
 
     def get(self, context, instance_id):
         """Get a single instance with the given instance_id."""
@@ -1399,7 +1399,7 @@ class API(base.Base):
         filters = {}
 
         def _remap_flavor_filter(flavor_id):
-            instance_type = instance_types.get_instance_type_by_flavor_id(
+            instance_type = flavors.get_instance_type_by_flavor_id(
                     flavor_id)
 
             filters['instance_type_id'] = instance_type['id']
@@ -1678,7 +1678,7 @@ class API(base.Base):
 
         #disk format of vhd is non-shrinkable
         if orig_image.get('disk_format') == 'vhd':
-            instance_type = instance_types.extract_instance_type(instance)
+            instance_type = flavors.extract_instance_type(instance)
             min_disk = instance_type['root_gb']
         else:
             #set new image values to the original image values
@@ -1770,7 +1770,7 @@ class API(base.Base):
         metadata = kwargs.get('metadata', {})
         self._check_metadata_properties_quota(context, metadata)
 
-        instance_type = instance_types.extract_instance_type(instance)
+        instance_type = flavors.extract_instance_type(instance)
         if instance_type['memory_mb'] < int(image.get('min_ram') or 0):
             raise exception.InstanceTypeMemoryTooSmall()
         if instance_type['root_gb'] < int(image.get('min_disk') or 0):
@@ -1942,9 +1942,9 @@ class API(base.Base):
         Calculate deltas required to reverse a prior upsizing
         quota adjustment.
         """
-        old_instance_type = instance_types.get_instance_type(
+        old_instance_type = flavors.get_instance_type(
             migration_ref['old_instance_type_id'])
-        new_instance_type = instance_types.get_instance_type(
+        new_instance_type = flavors.get_instance_type(
             migration_ref['new_instance_type_id'])
 
         return API._resize_quota_delta(context, new_instance_type,
@@ -1955,9 +1955,9 @@ class API(base.Base):
         """
         Calculate deltas required to adjust quota for an instance downsize.
         """
-        old_instance_type = instance_types.extract_instance_type(instance,
+        old_instance_type = flavors.extract_instance_type(instance,
                                                                  'old_')
-        new_instance_type = instance_types.extract_instance_type(instance,
+        new_instance_type = flavors.extract_instance_type(instance,
                                                                  'new_')
         return API._resize_quota_delta(context, new_instance_type,
                                        old_instance_type, 1, -1)
@@ -1977,7 +1977,7 @@ class API(base.Base):
         the original flavor_id. If flavor_id is not None, the instance should
         be migrated to a new host and resized to the new flavor_id.
         """
-        current_instance_type = instance_types.extract_instance_type(instance)
+        current_instance_type = flavors.extract_instance_type(instance)
 
         # If flavor_id is not provided, only migrate the instance.
         if not flavor_id:
@@ -1985,7 +1985,7 @@ class API(base.Base):
                       instance=instance)
             new_instance_type = current_instance_type
         else:
-            new_instance_type = instance_types.get_instance_type_by_flavor_id(
+            new_instance_type = flavors.get_instance_type_by_flavor_id(
                     flavor_id, read_deleted="no")
 
         current_instance_type_name = current_instance_type['name']
diff --git a/nova/compute/cells_api.py b/nova/compute/cells_api.py
index 9c0f72c97..7168313ec 100644
--- a/nova/compute/cells_api.py
+++ b/nova/compute/cells_api.py
@@ -20,7 +20,7 @@ from nova import block_device
 from nova.cells import rpcapi as cells_rpcapi
 from nova.cells import utils as cells_utils
 from nova.compute import api as compute_api
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova.compute import rpcapi as compute_rpcapi
 from nova.compute import vm_states
 from nova import exception
@@ -338,19 +338,19 @@ class ComputeCellsAPI(compute_api.API):
         # specified flavor_id is valid and exists. We'll need to load
         # it again, but that should be safe.
 
-        old_instance_type = instance_types.extract_instance_type(instance)
+        old_instance_type = flavors.extract_instance_type(instance)
 
         if not flavor_id:
             new_instance_type = old_instance_type
         else:
-            new_instance_type = instance_types.get_instance_type_by_flavor_id(
+            new_instance_type = flavors.get_instance_type_by_flavor_id(
                     flavor_id, read_deleted="no")
 
         # NOTE(johannes): Later, when the resize is confirmed or reverted,
         # the superclass implementations of those methods will need access
         # to a local migration record for quota reasons. We don't need
         # source and/or destination information, just the old and new
-        # instance_types. Status is set to 'finished' since nothing else
+        # flavors. Status is set to 'finished' since nothing else
         # will update the status along the way.
         self.db.migration_create(context.elevated(),
                     {'instance_uuid': instance['uuid'],
diff --git a/nova/compute/instance_types.py b/nova/compute/flavors.py
index 871761986..c4ce550eb 100644
--- a/nova/compute/instance_types.py
+++ b/nova/compute/flavors.py
@@ -150,7 +150,7 @@ def destroy(name):
 
 
 def get_all_types(ctxt=None, inactive=False, filters=None):
-    """Get all non-deleted instance_types.
+    """Get all non-deleted flavors.
 
     Pass true as argument if you want deleted instance types returned also.
     """
diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 588837266..1fcceec99 100755
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -43,7 +43,7 @@ from nova import block_device
 from nova.cells import rpcapi as cells_rpcapi
 from nova.cloudpipe import pipelib
 from nova import compute
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova.compute import power_state
 from nova.compute import resource_tracker
 from nova.compute import rpcapi as compute_rpcapi
@@ -1114,7 +1114,7 @@ class ComputeManager(manager.SchedulerDependentManager):
             # TODO(jk0): Should size be required in the image service?
             return image_meta
 
-        instance_type = instance_types.extract_instance_type(instance)
+        instance_type = flavors.extract_instance_type(instance)
         allowed_size_gb = instance_type['root_gb']
 
         # NOTE(johannes): root_gb is allowed to be 0 for legacy reasons
@@ -2129,15 +2129,15 @@ class ComputeManager(manager.SchedulerDependentManager):
         """
         sys_meta = utils.metadata_to_dict(instance['system_metadata'])
         if restore_old:
-            instance_type = instance_types.extract_instance_type(instance,
+            instance_type = flavors.extract_instance_type(instance,
                                                                  'old_')
-            sys_meta = instance_types.save_instance_type_info(sys_meta,
+            sys_meta = flavors.save_instance_type_info(sys_meta,
                                                               instance_type)
         else:
-            instance_type = instance_types.extract_instance_type(instance)
+            instance_type = flavors.extract_instance_type(instance)
 
-        instance_types.delete_instance_type_info(sys_meta, 'old_')
-        instance_types.delete_instance_type_info(sys_meta, 'new_')
+        flavors.delete_instance_type_info(sys_meta, 'old_')
+        flavors.delete_instance_type_info(sys_meta, 'new_')
 
         return sys_meta, instance_type
 
@@ -2352,7 +2352,7 @@ class ComputeManager(manager.SchedulerDependentManager):
         # NOTE(danms): Stash the new instance_type to avoid having to
         # look it up in the database later
         sys_meta = utils.metadata_to_dict(instance['system_metadata'])
-        instance_types.save_instance_type_info(sys_meta, instance_type,
+        flavors.save_instance_type_info(sys_meta, instance_type,
                                                 prefix='new_')
         instance = self._instance_update(context, instance['uuid'],
                                          system_metadata=sys_meta)
@@ -2519,15 +2519,15 @@ class ComputeManager(manager.SchedulerDependentManager):
         resize_instance = False
         old_instance_type_id = migration['old_instance_type_id']
         new_instance_type_id = migration['new_instance_type_id']
-        old_instance_type = instance_types.extract_instance_type(instance)
+        old_instance_type = flavors.extract_instance_type(instance)
         sys_meta = utils.metadata_to_dict(instance['system_metadata'])
-        instance_types.save_instance_type_info(sys_meta,
+        flavors.save_instance_type_info(sys_meta,
                                                old_instance_type,
                                                prefix='old_')
         if old_instance_type_id != new_instance_type_id:
-            instance_type = instance_types.extract_instance_type(instance,
+            instance_type = flavors.extract_instance_type(instance,
                                                                  prefix='new_')
-            instance_types.save_instance_type_info(sys_meta, instance_type)
+            flavors.save_instance_type_info(sys_meta, instance_type)
 
             instance = self._instance_update(
                     context,
diff --git a/nova/compute/resource_tracker.py b/nova/compute/resource_tracker.py
index 0ee707922..e5edfa564 100644
--- a/nova/compute/resource_tracker.py
+++ b/nova/compute/resource_tracker.py
@@ -22,7 +22,7 @@ model.
 from oslo.config import cfg
 
 from nova.compute import claims
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova.compute import task_states
 from nova.compute import vm_states
 from nova import conductor
@@ -160,7 +160,7 @@ class ResourceTracker(object):
         be done while the COMPUTE_RESOURCES_SEMAPHORE is held so the resource
         claim will not be lost if the audit process starts.
         """
-        old_instance_type = instance_types.extract_instance_type(instance)
+        old_instance_type = flavors.extract_instance_type(instance)
 
         return self.conductor_api.migration_create(context, instance,
                 {'dest_compute': self.host,
@@ -580,7 +580,7 @@ class ResourceTracker(object):
             instance_type_id = instance['instance_type_id']
 
         try:
-            return instance_types.extract_instance_type(instance, prefix)
+            return flavors.extract_instance_type(instance, prefix)
         except KeyError:
             return self.conductor_api.instance_type_get(context,
                     instance_type_id)
diff --git a/nova/compute/utils.py b/nova/compute/utils.py
index e13914264..1ce115b20 100644
--- a/nova/compute/utils.py
+++ b/nova/compute/utils.py
@@ -23,7 +23,7 @@ import traceback
 from oslo.config import cfg
 
 from nova import block_device
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova import exception
 from nova.network import model as network_model
 from nova import notifications
@@ -151,7 +151,7 @@ def get_device_name_for_instance(context, instance, bdms, device):
     # NOTE(vish): remove this when xenapi is properly setting
     #             default_ephemeral_device and default_swap_device
     if driver.compute_driver_matches('xenapi.XenAPIDriver'):
-        instance_type = instance_types.extract_instance_type(instance)
+        instance_type = flavors.extract_instance_type(instance)
         if instance_type['ephemeral_gb']:
             used_letters.add('b')
 
diff --git a/nova/network/api.py b/nova/network/api.py
index b8baf9810..cb3a0f5db 100644
--- a/nova/network/api.py
+++ b/nova/network/api.py
@@ -21,7 +21,7 @@
 import functools
 import inspect
 
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova.db import base
 from nova import exception
 from nova.network import floating_ips
@@ -266,7 +266,7 @@ class API(base.Base):
         #             this is called from compute.manager which shouldn't
         #             have db access so we do it on the other side of the
         #             rpc.
-        instance_type = instance_types.extract_instance_type(instance)
+        instance_type = flavors.extract_instance_type(instance)
         args = {}
         args['vpn'] = vpn
         args['requested_networks'] = requested_networks
@@ -316,7 +316,7 @@ class API(base.Base):
     def add_fixed_ip_to_instance(self, context, instance, network_id,
                                  conductor_api=None):
         """Adds a fixed ip to instance from specified network."""
-        instance_type = instance_types.extract_instance_type(instance)
+        instance_type = flavors.extract_instance_type(instance)
         args = {'instance_id': instance['uuid'],
                 'rxtx_factor': instance_type['rxtx_factor'],
                 'host': instance['host'],
@@ -329,7 +329,7 @@ class API(base.Base):
                                       conductor_api=None):
         """Removes a fixed ip from instance from specified network."""
 
-        instance_type = instance_types.extract_instance_type(instance)
+        instance_type = flavors.extract_instance_type(instance)
         args = {'instance_id': instance['uuid'],
                 'rxtx_factor': instance_type['rxtx_factor'],
                 'host': instance['host'],
@@ -374,7 +374,7 @@ class API(base.Base):
 
     def _get_instance_nw_info(self, context, instance):
         """Returns all network info related to an instance."""
-        instance_type = instance_types.extract_instance_type(instance)
+        instance_type = flavors.extract_instance_type(instance)
         args = {'instance_id': instance['uuid'],
                 'rxtx_factor': instance_type['rxtx_factor'],
                 'host': instance['host'],
@@ -491,7 +491,7 @@ class API(base.Base):
     @wrap_check_policy
     def migrate_instance_start(self, context, instance, migration):
         """Start to migrate the network of an instance."""
-        instance_type = instance_types.extract_instance_type(instance)
+        instance_type = flavors.extract_instance_type(instance)
         args = dict(
             instance_uuid=instance['uuid'],
             rxtx_factor=instance_type['rxtx_factor'],
@@ -511,7 +511,7 @@ class API(base.Base):
     @wrap_check_policy
     def migrate_instance_finish(self, context, instance, migration):
         """Finish migrating the network of an instance."""
-        instance_type = instance_types.extract_instance_type(instance)
+        instance_type = flavors.extract_instance_type(instance)
         args = dict(
             instance_uuid=instance['uuid'],
             rxtx_factor=instance_type['rxtx_factor'],
diff --git a/nova/network/quantumv2/api.py b/nova/network/quantumv2/api.py
index 688918739..8da43a3d8 100644
--- a/nova/network/quantumv2/api.py
+++ b/nova/network/quantumv2/api.py
@@ -20,7 +20,7 @@ import time
 
 from oslo.config import cfg
 
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova import conductor
 from nova import context
 from nova.db import base
@@ -309,7 +309,7 @@ class API(base.Base):
         """
         self._refresh_quantum_extensions_cache()
         if 'nvp-qos' in self.extensions:
-            instance_type = instance_types.extract_instance_type(instance)
+            instance_type = flavors.extract_instance_type(instance)
             rxtx_factor = instance_type.get('rxtx_factor')
             port_req_body['port']['rxtx_factor'] = rxtx_factor
 
diff --git a/nova/notifications.py b/nova/notifications.py
index ecd708d60..4442d9904 100644
--- a/nova/notifications.py
+++ b/nova/notifications.py
@@ -21,7 +21,7 @@ the system.
 
 from oslo.config import cfg
 
-from nova.compute import instance_types
+from nova.compute import flavors
 import nova.context
 from nova import db
 from nova.image import glance
@@ -284,7 +284,7 @@ def info_from_instance(context, instance_ref, network_info,
 
     image_ref_url = glance.generate_image_url(instance_ref['image_ref'])
 
-    instance_type = instance_types.extract_instance_type(instance_ref)
+    instance_type = flavors.extract_instance_type(instance_ref)
     instance_type_name = instance_type.get('name', '')
 
     if system_metadata is None:
diff --git a/nova/scheduler/driver.py b/nova/scheduler/driver.py
index 92c7779e8..506c77cff 100644
--- a/nova/scheduler/driver.py
+++ b/nova/scheduler/driver.py
@@ -25,7 +25,7 @@ import sys
 
 from oslo.config import cfg
 
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova.compute import power_state
 from nova.compute import rpcapi as compute_rpcapi
 from nova.compute import utils as compute_utils
@@ -257,7 +257,7 @@ class Scheduler(object):
 
         # If dest is not specified, have scheduler pick one.
         if dest is None:
-            instance_type = instance_types.extract_instance_type(instance_ref)
+            instance_type = flavors.extract_instance_type(instance_ref)
             image = self.image_service.show(context, instance_ref['image_ref'])
             request_spec = {'instance_properties': instance_ref,
                             'instance_type': instance_type,
diff --git a/nova/scheduler/filter_scheduler.py b/nova/scheduler/filter_scheduler.py
index 8f99db0ae..440492f40 100644
--- a/nova/scheduler/filter_scheduler.py
+++ b/nova/scheduler/filter_scheduler.py
@@ -23,7 +23,7 @@ import random
 
 from oslo.config import cfg
 
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova import exception
 from nova.openstack.common import log as logging
 from nova.openstack.common.notifier import api as notifier
@@ -380,7 +380,7 @@ class FilterScheduler(driver.Scheduler):
         host_state = self.host_manager.host_state_cls(dest, node)
         host_state.update_from_compute_node(compute)
 
-        instance_type = instance_types.extract_instance_type(instance_ref)
+        instance_type = flavors.extract_instance_type(instance_ref)
         filter_properties = {'instance_type': instance_type}
 
         hosts = self.host_manager.get_filtered_hosts([host_state],
diff --git a/nova/tests/api/ec2/test_cinder_cloud.py b/nova/tests/api/ec2/test_cinder_cloud.py
index 4a21f7fad..60797c8f7 100644
--- a/nova/tests/api/ec2/test_cinder_cloud.py
+++ b/nova/tests/api/ec2/test_cinder_cloud.py
@@ -26,7 +26,7 @@ from oslo.config import cfg
 from nova.api.ec2 import cloud
 from nova.api.ec2 import ec2utils
 from nova.compute import api as compute_api
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova.compute import utils as compute_utils
 from nova import context
 from nova import db
@@ -40,7 +40,7 @@ from nova import volume
 
 CONF = cfg.CONF
 CONF.import_opt('compute_driver', 'nova.virt.driver')
-CONF.import_opt('default_instance_type', 'nova.compute.instance_types')
+CONF.import_opt('default_instance_type', 'nova.compute.flavors')
 CONF.import_opt('use_ipv6', 'nova.netconf')
 
 
@@ -413,8 +413,8 @@ class CinderCloudTestCase(test.TestCase):
 
     def _setUpBlockDeviceMapping(self):
         image_uuid = 'cedef40a-ed67-4d10-800e-17455edce175'
-        sys_meta = instance_types.save_instance_type_info(
-            {}, instance_types.get_instance_type(1))
+        sys_meta = flavors.save_instance_type_info(
+            {}, flavors.get_instance_type(1))
         inst1 = db.instance_create(self.context,
                                   {'image_ref': image_uuid,
                                    'instance_type_id': 1,
diff --git a/nova/tests/api/ec2/test_cloud.py b/nova/tests/api/ec2/test_cloud.py
index c6ec305c6..e58d260fb 100644
--- a/nova/tests/api/ec2/test_cloud.py
+++ b/nova/tests/api/ec2/test_cloud.py
@@ -33,7 +33,7 @@ from nova.api.ec2 import ec2utils
 from nova.api.ec2 import inst_state
 from nova.api.metadata import password
 from nova.compute import api as compute_api
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova.compute import power_state
 from nova.compute import rpcapi as compute_rpcapi
 from nova.compute import utils as compute_utils
@@ -58,7 +58,7 @@ from nova import volume
 
 CONF = cfg.CONF
 CONF.import_opt('compute_driver', 'nova.virt.driver')
-CONF.import_opt('default_instance_type', 'nova.compute.instance_types')
+CONF.import_opt('default_instance_type', 'nova.compute.flavors')
 CONF.import_opt('use_ipv6', 'nova.netconf')
 LOG = logging.getLogger(__name__)
 
@@ -762,8 +762,8 @@ class CloudTestCase(test.TestCase):
         self._stub_instance_get_with_fixed_ips('get')
 
         image_uuid = 'cedef40a-ed67-4d10-800e-17455edce175'
-        sys_meta = instance_types.save_instance_type_info(
-            {}, instance_types.get_instance_type(1))
+        sys_meta = flavors.save_instance_type_info(
+            {}, flavors.get_instance_type(1))
         inst1 = db.instance_create(self.context, {'reservation_id': 'a',
                                                   'image_ref': image_uuid,
                                                   'instance_type_id': 1,
@@ -868,8 +868,8 @@ class CloudTestCase(test.TestCase):
                        fake_change_instance_metadata)
 
         # Create some test images
-        sys_meta = instance_types.save_instance_type_info(
-            {}, instance_types.get_instance_type(1))
+        sys_meta = flavors.save_instance_type_info(
+            {}, flavors.get_instance_type(1))
         image_uuid = 'cedef40a-ed67-4d10-800e-17455edce175'
         inst1_kwargs = {
                 'reservation_id': 'a',
@@ -1040,8 +1040,8 @@ class CloudTestCase(test.TestCase):
         self._stub_instance_get_with_fixed_ips('get')
 
         image_uuid = 'cedef40a-ed67-4d10-800e-17455edce175'
-        sys_meta = instance_types.save_instance_type_info(
-            {}, instance_types.get_instance_type(1))
+        sys_meta = flavors.save_instance_type_info(
+            {}, flavors.get_instance_type(1))
         inst_base = {
                 'reservation_id': 'a',
                 'image_ref': image_uuid,
@@ -1095,8 +1095,8 @@ class CloudTestCase(test.TestCase):
         def test_instance_state(expected_code, expected_name,
                                 power_state_, vm_state_, values=None):
             image_uuid = 'cedef40a-ed67-4d10-800e-17455edce175'
-            sys_meta = instance_types.save_instance_type_info(
-                {}, instance_types.get_instance_type(1))
+            sys_meta = flavors.save_instance_type_info(
+                {}, flavors.get_instance_type(1))
             values = values or {}
             values.update({'image_ref': image_uuid, 'instance_type_id': 1,
                            'power_state': power_state_, 'vm_state': vm_state_,
@@ -1130,8 +1130,8 @@ class CloudTestCase(test.TestCase):
         self._stub_instance_get_with_fixed_ips('get')
 
         image_uuid = 'cedef40a-ed67-4d10-800e-17455edce175'
-        sys_meta = instance_types.save_instance_type_info(
-            {}, instance_types.get_instance_type(1))
+        sys_meta = flavors.save_instance_type_info(
+            {}, flavors.get_instance_type(1))
         inst1 = db.instance_create(self.context, {'reservation_id': 'a',
                                                   'image_ref': image_uuid,
                                                   'instance_type_id': 1,
@@ -1157,8 +1157,8 @@ class CloudTestCase(test.TestCase):
 
     def test_describe_instances_deleted(self):
         image_uuid = 'cedef40a-ed67-4d10-800e-17455edce175'
-        sys_meta = instance_types.save_instance_type_info(
-            {}, instance_types.get_instance_type(1))
+        sys_meta = flavors.save_instance_type_info(
+            {}, flavors.get_instance_type(1))
         args1 = {'reservation_id': 'a',
                  'image_ref': image_uuid,
                  'instance_type_id': 1,
@@ -1182,8 +1182,8 @@ class CloudTestCase(test.TestCase):
 
     def test_describe_instances_with_image_deleted(self):
         image_uuid = 'aebef54a-ed67-4d10-912f-14455edce176'
-        sys_meta = instance_types.save_instance_type_info(
-            {}, instance_types.get_instance_type(1))
+        sys_meta = flavors.save_instance_type_info(
+            {}, flavors.get_instance_type(1))
         args1 = {'reservation_id': 'a',
                  'image_ref': image_uuid,
                  'instance_type_id': 1,
@@ -2256,9 +2256,9 @@ class CloudTestCase(test.TestCase):
                        self._fake_bdm_get)
 
         def fake_get(ctxt, instance_id):
-            inst_type = instance_types.get_default_instance_type()
+            inst_type = flavors.get_default_instance_type()
             inst_type['name'] = 'fake_type'
-            sys_meta = instance_types.save_instance_type_info({}, inst_type)
+            sys_meta = flavors.save_instance_type_info({}, inst_type)
             sys_meta = utils.dict_to_metadata(sys_meta)
             return {
                 'id': 0,
diff --git a/nova/tests/api/openstack/compute/contrib/test_flavor_access.py b/nova/tests/api/openstack/compute/contrib/test_flavor_access.py
index b3564dede..6bae7882f 100644
--- a/nova/tests/api/openstack/compute/contrib/test_flavor_access.py
+++ b/nova/tests/api/openstack/compute/contrib/test_flavor_access.py
@@ -19,8 +19,8 @@ from lxml import etree
 from webob import exc
 
 from nova.api.openstack.compute.contrib import flavor_access
-from nova.api.openstack.compute import flavors
-from nova.compute import instance_types
+from nova.api.openstack.compute import flavors as flavors_api
+from nova.compute import flavors
 from nova import context
 from nova import exception
 from nova import test
@@ -116,15 +116,15 @@ class FakeResponse(object):
 class FlavorAccessTest(test.TestCase):
     def setUp(self):
         super(FlavorAccessTest, self).setUp()
-        self.flavor_controller = flavors.Controller()
+        self.flavor_controller = flavors_api.Controller()
         self.flavor_access_controller = flavor_access.FlavorAccessController()
         self.flavor_action_controller = flavor_access.FlavorActionController()
         self.req = FakeRequest()
         self.context = self.req.environ['nova.context']
-        self.stubs.Set(instance_types, 'get_instance_type_by_flavor_id',
+        self.stubs.Set(flavors, 'get_instance_type_by_flavor_id',
                        fake_get_instance_type_by_flavor_id)
-        self.stubs.Set(instance_types, 'get_all_types', fake_get_all_types)
-        self.stubs.Set(instance_types, 'get_instance_type_access_by_flavor_id',
+        self.stubs.Set(flavors, 'get_all_types', fake_get_all_types)
+        self.stubs.Set(flavors, 'get_instance_type_access_by_flavor_id',
                        fake_get_instance_type_access_by_flavor_id)
 
     def _verify_flavor_list(self, result, expected):
@@ -249,7 +249,7 @@ class FlavorAccessTest(test.TestCase):
         def stub_add_instance_type_access(flavorid, projectid, ctxt=None):
             self.assertEqual('3', flavorid, "flavorid")
             self.assertEqual("proj2", projectid, "projectid")
-        self.stubs.Set(instance_types, 'add_instance_type_access',
+        self.stubs.Set(flavors, 'add_instance_type_access',
                        stub_add_instance_type_access)
         expected = {'flavor_access':
             [{'flavor_id': '3', 'tenant_id': 'proj3'}]}
@@ -264,7 +264,7 @@ class FlavorAccessTest(test.TestCase):
         def stub_add_instance_type_access(flavorid, projectid, ctxt=None):
             raise exception.FlavorAccessExists(flavor_id=flavorid,
                                                project_id=projectid)
-        self.stubs.Set(instance_types, 'add_instance_type_access',
+        self.stubs.Set(flavors, 'add_instance_type_access',
                        stub_add_instance_type_access)
         body = {'addTenantAccess': {'tenant': 'proj2'}}
         req = fakes.HTTPRequest.blank('/v2/fake/flavors/2/action',
@@ -277,7 +277,7 @@ class FlavorAccessTest(test.TestCase):
         def stub_remove_instance_type_access(flavorid, projectid, ctxt=None):
             raise exception.FlavorAccessNotFound(flavor_id=flavorid,
                                                  project_id=projectid)
-        self.stubs.Set(instance_types, 'remove_instance_type_access',
+        self.stubs.Set(flavors, 'remove_instance_type_access',
                        stub_remove_instance_type_access)
         body = {'removeTenantAccess': {'tenant': 'proj2'}}
         req = fakes.HTTPRequest.blank('/v2/fake/flavors/2/action',
diff --git a/nova/tests/api/openstack/compute/contrib/test_flavor_disabled.py b/nova/tests/api/openstack/compute/contrib/test_flavor_disabled.py
index 5d15264ab..8a8660a67 100644
--- a/nova/tests/api/openstack/compute/contrib/test_flavor_disabled.py
+++ b/nova/tests/api/openstack/compute/contrib/test_flavor_disabled.py
@@ -16,7 +16,7 @@ from lxml import etree
 import webob
 
 from nova.api.openstack.compute.contrib import flavor_disabled
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova.openstack.common import jsonutils
 from nova import test
 from nova.tests.api.openstack import fakes
@@ -57,9 +57,9 @@ class FlavorDisabledTest(test.TestCase):
               '.flavor_disabled.Flavor_disabled')
         self.flags(osapi_compute_extension=[ext])
         fakes.stub_out_nw_api(self.stubs)
-        self.stubs.Set(instance_types, "get_all_types",
+        self.stubs.Set(flavors, "get_all_types",
                        fake_instance_type_get_all)
-        self.stubs.Set(instance_types,
+        self.stubs.Set(flavors,
                        "get_instance_type_by_flavor_id",
                        fake_instance_type_get_by_flavor_id)
 
diff --git a/nova/tests/api/openstack/compute/contrib/test_flavor_manage.py b/nova/tests/api/openstack/compute/contrib/test_flavor_manage.py
index 9b58e7b74..2ca02cafa 100644
--- a/nova/tests/api/openstack/compute/contrib/test_flavor_manage.py
+++ b/nova/tests/api/openstack/compute/contrib/test_flavor_manage.py
@@ -18,7 +18,7 @@ import datetime
 import webob
 
 from nova.api.openstack.compute.contrib import flavormanage
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova import exception
 from nova.openstack.common import jsonutils
 from nova import test
@@ -80,11 +80,11 @@ def fake_create(name, memory_mb, vcpus, root_gb, ephemeral_gb,
 class FlavorManageTest(test.TestCase):
     def setUp(self):
         super(FlavorManageTest, self).setUp()
-        self.stubs.Set(instance_types,
+        self.stubs.Set(flavors,
                        "get_instance_type_by_flavor_id",
                        fake_get_instance_type_by_flavor_id)
-        self.stubs.Set(instance_types, "destroy", fake_destroy)
-        self.stubs.Set(instance_types, "create", fake_create)
+        self.stubs.Set(flavors, "destroy", fake_destroy)
+        self.stubs.Set(flavors, "create", fake_create)
         self.flags(
             osapi_compute_extension=[
                 'nova.api.openstack.compute.contrib.select_extensions'],
@@ -156,7 +156,7 @@ class FlavorManageTest(test.TestCase):
             }
         }
 
-        self.stubs.Set(instance_types, "create", fake_create)
+        self.stubs.Set(flavors, "create", fake_create)
         url = '/v2/fake/flavors'
         req = webob.Request.blank(url)
         req.headers['Content-Type'] = 'application/json'
@@ -210,7 +210,7 @@ class FlavorManageTest(test.TestCase):
                         flavorid, swap, rxtx_factor, is_public):
             raise exception.InstanceTypeExists(name=name)
 
-        self.stubs.Set(instance_types, "create", fake_create)
+        self.stubs.Set(flavors, "create", fake_create)
         url = '/v2/fake/flavors'
         req = webob.Request.blank(url)
         req.headers['Content-Type'] = 'application/json'
diff --git a/nova/tests/api/openstack/compute/contrib/test_flavor_rxtx.py b/nova/tests/api/openstack/compute/contrib/test_flavor_rxtx.py
index d86f750cf..965d0e1bb 100644
--- a/nova/tests/api/openstack/compute/contrib/test_flavor_rxtx.py
+++ b/nova/tests/api/openstack/compute/contrib/test_flavor_rxtx.py
@@ -15,7 +15,7 @@
 from lxml import etree
 import webob
 
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova.openstack.common import jsonutils
 from nova import test
 from nova.tests.api.openstack import fakes
@@ -56,9 +56,9 @@ class FlavorRxtxTest(test.TestCase):
               '.flavor_rxtx.Flavor_rxtx')
         self.flags(osapi_compute_extension=[ext])
         fakes.stub_out_nw_api(self.stubs)
-        self.stubs.Set(instance_types, "get_all_types",
+        self.stubs.Set(flavors, "get_all_types",
                        fake_instance_type_get_all)
-        self.stubs.Set(instance_types,
+        self.stubs.Set(flavors,
                        "get_instance_type_by_flavor_id",
                        fake_instance_type_get_by_flavor_id)
 
diff --git a/nova/tests/api/openstack/compute/contrib/test_flavor_swap.py b/nova/tests/api/openstack/compute/contrib/test_flavor_swap.py
index eeb0fe632..ea3ab6e34 100644
--- a/nova/tests/api/openstack/compute/contrib/test_flavor_swap.py
+++ b/nova/tests/api/openstack/compute/contrib/test_flavor_swap.py
@@ -15,7 +15,7 @@
 from lxml import etree
 import webob
 
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova.openstack.common import jsonutils
 from nova import test
 from nova.tests.api.openstack import fakes
@@ -56,9 +56,9 @@ class FlavorSwapTest(test.TestCase):
               '.flavor_swap.Flavor_swap')
         self.flags(osapi_compute_extension=[ext])
         fakes.stub_out_nw_api(self.stubs)
-        self.stubs.Set(instance_types, "get_all_types",
+        self.stubs.Set(flavors, "get_all_types",
                        fake_instance_type_get_all)
-        self.stubs.Set(instance_types,
+        self.stubs.Set(flavors,
                        "get_instance_type_by_flavor_id",
                        fake_instance_type_get_by_flavor_id)
 
diff --git a/nova/tests/api/openstack/compute/contrib/test_flavorextradata.py b/nova/tests/api/openstack/compute/contrib/test_flavorextradata.py
index 1c5703381..f45f98bbc 100644
--- a/nova/tests/api/openstack/compute/contrib/test_flavorextradata.py
+++ b/nova/tests/api/openstack/compute/contrib/test_flavorextradata.py
@@ -17,7 +17,7 @@ import datetime
 
 import webob
 
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova.openstack.common import jsonutils
 from nova import test
 from nova.tests.api.openstack import fakes
@@ -54,9 +54,9 @@ class FlavorextradataTest(test.TestCase):
         ext = ('nova.api.openstack.compute.contrib'
               '.flavorextradata.Flavorextradata')
         self.flags(osapi_compute_extension=[ext])
-        self.stubs.Set(instance_types, 'get_instance_type_by_flavor_id',
+        self.stubs.Set(flavors, 'get_instance_type_by_flavor_id',
                                         fake_get_instance_type_by_flavor_id)
-        self.stubs.Set(instance_types, 'get_all_types', fake_get_all_types)
+        self.stubs.Set(flavors, 'get_all_types', fake_get_all_types)
 
     def _verify_flavor_response(self, flavor, expected):
         for key in expected:
diff --git a/nova/tests/api/openstack/compute/contrib/test_simple_tenant_usage.py b/nova/tests/api/openstack/compute/contrib/test_simple_tenant_usage.py
index ea692c8e6..004a6716e 100644
--- a/nova/tests/api/openstack/compute/contrib/test_simple_tenant_usage.py
+++ b/nova/tests/api/openstack/compute/contrib/test_simple_tenant_usage.py
@@ -22,7 +22,7 @@ import webob
 
 from nova.api.openstack.compute.contrib import simple_tenant_usage
 from nova.compute import api
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova import context
 from nova import exception
 from nova.openstack.common import jsonutils
@@ -59,7 +59,7 @@ FAKE_INST_TYPE = {'id': 1,
 
 def get_fake_db_instance(start, end, instance_id, tenant_id):
     sys_meta = utils.dict_to_metadata(
-        instance_types.save_instance_type_info({}, FAKE_INST_TYPE))
+        flavors.save_instance_type_info({}, FAKE_INST_TYPE))
     return {'id': instance_id,
             'uuid': '00000000-0000-0000-0000-00000000000000%02d' % instance_id,
             'image_ref': '1',
@@ -415,7 +415,7 @@ class SimpleTenantUsageControllerTest(test.TestCase):
         class FakeComputeAPI:
             def get_instance_type(self, context, flavor_type):
                 if flavor_type == 1:
-                    return instance_types.get_default_instance_type()
+                    return flavors.get_default_instance_type()
                 else:
                     raise exception.InstanceTypeNotFound(flavor_type)
 
@@ -429,11 +429,11 @@ class SimpleTenantUsageControllerTest(test.TestCase):
                              instance_type_id=1,
                              vm_state='deleted',
                              deleted=0)
-        basetype = instance_types.get_default_instance_type()
+        basetype = flavors.get_default_instance_type()
         sys_meta = utils.dict_to_metadata(
-            instance_types.save_instance_type_info({}, basetype))
+            flavors.save_instance_type_info({}, basetype))
         self.baseinst['system_metadata'] = sys_meta
-        self.basetype = instance_types.extract_instance_type(self.baseinst)
+        self.basetype = flavors.extract_instance_type(self.baseinst)
 
     def test_get_flavor_from_sys_meta(self):
         # Non-deleted instances get their type information from their
@@ -458,7 +458,7 @@ class SimpleTenantUsageControllerTest(test.TestCase):
                                      deleted=1)
         flavor = self.controller._get_flavor(self.context, self.compute_api,
                                              inst_without_sys_meta, {})
-        self.assertEqual(flavor, instance_types.get_default_instance_type())
+        self.assertEqual(flavor, flavors.get_default_instance_type())
 
     def test_get_flavor_from_deleted_with_id_of_deleted(self):
         # Verify the legacy behavior of instance_type_id pointing to a
diff --git a/nova/tests/api/openstack/compute/contrib/test_volumes.py b/nova/tests/api/openstack/compute/contrib/test_volumes.py
index 83372b251..cc0c1c1cc 100644
--- a/nova/tests/api/openstack/compute/contrib/test_volumes.py
+++ b/nova/tests/api/openstack/compute/contrib/test_volumes.py
@@ -22,7 +22,7 @@ from webob import exc
 
 from nova.api.openstack.compute.contrib import volumes
 from nova.compute import api as compute_api
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova import context
 from nova.openstack.common import jsonutils
 from nova.openstack.common import timeutils
@@ -46,7 +46,7 @@ def fake_compute_api_create(cls, context, instance_type, image_href, **kwargs):
     global _block_device_mapping_seen
     _block_device_mapping_seen = kwargs.get('block_device_mapping')
 
-    inst_type = instance_types.get_instance_type_by_flavor_id(2)
+    inst_type = flavors.get_instance_type_by_flavor_id(2)
     resv_id = None
     return ([{'id': 1,
              'display_name': 'test_server',
diff --git a/nova/tests/api/openstack/compute/test_flavors.py b/nova/tests/api/openstack/compute/test_flavors.py
index 3a11c92fe..45eeeb34b 100644
--- a/nova/tests/api/openstack/compute/test_flavors.py
+++ b/nova/tests/api/openstack/compute/test_flavors.py
@@ -22,7 +22,7 @@ import urlparse
 
 from nova.api.openstack.compute import flavors
 from nova.api.openstack import xmlutil
-import nova.compute.instance_types
+import nova.compute.flavors
 from nova import context
 from nova import db
 from nova import exception
@@ -86,16 +86,16 @@ class FlavorsTest(test.TestCase):
         self.flags(osapi_compute_extension=[])
         fakes.stub_out_networking(self.stubs)
         fakes.stub_out_rate_limiting(self.stubs)
-        self.stubs.Set(nova.compute.instance_types, "get_all_types",
+        self.stubs.Set(nova.compute.flavors, "get_all_types",
                        fake_instance_type_get_all)
-        self.stubs.Set(nova.compute.instance_types,
+        self.stubs.Set(nova.compute.flavors,
                        "get_instance_type_by_flavor_id",
                        fake_instance_type_get_by_flavor_id)
 
         self.controller = flavors.Controller()
 
     def test_get_flavor_by_invalid_id(self):
-        self.stubs.Set(nova.compute.instance_types,
+        self.stubs.Set(nova.compute.flavors,
                        "get_instance_type_by_flavor_id",
                        return_instance_type_not_found)
         req = fakes.HTTPRequest.blank('/v2/fake/flavors/asdf')
@@ -341,7 +341,7 @@ class FlavorsTest(test.TestCase):
         self.assertEqual(flavor, expected)
 
     def test_get_empty_flavor_list(self):
-        self.stubs.Set(nova.compute.instance_types, "get_all_types",
+        self.stubs.Set(nova.compute.flavors, "get_all_types",
                        empty_instance_type_get_all)
 
         req = fakes.HTTPRequest.blank('/v2/fake/flavors')
@@ -683,7 +683,7 @@ class DisabledFlavorsWithRealDBTest(test.TestCase):
         super(DisabledFlavorsWithRealDBTest, self).setUp()
         self.controller = flavors.Controller()
 
-        # Add a new disabled type to the list of instance_types/flavors
+        # Add a new disabled type to the list of flavors
         self.req = fakes.HTTPRequest.blank('/v2/fake/flavors')
         self.context = self.req.environ['nova.context']
         self.admin_context = context.get_admin_context()
diff --git a/nova/tests/api/openstack/compute/test_servers.py b/nova/tests/api/openstack/compute/test_servers.py
index 4fe8a41db..43d5d3306 100644
--- a/nova/tests/api/openstack/compute/test_servers.py
+++ b/nova/tests/api/openstack/compute/test_servers.py
@@ -34,7 +34,7 @@ from nova.api.openstack.compute import views
 from nova.api.openstack import extensions
 from nova.api.openstack import xmlutil
 from nova.compute import api as compute_api
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova.compute import task_states
 from nova.compute import vm_states
 from nova import context
@@ -1728,7 +1728,7 @@ class ServersControllerCreateTest(test.TestCase):
         self.controller = servers.Controller(self.ext_mgr)
 
         def instance_create(context, inst):
-            inst_type = instance_types.get_instance_type_by_flavor_id(3)
+            inst_type = flavors.get_instance_type_by_flavor_id(3)
             image_uuid = '76fa36fc-c930-4bf3-8c8a-ea2a2420deb6'
             def_image_ref = 'http://localhost/images/%s' % image_uuid
             self.instance_cache_num += 1
diff --git a/nova/tests/api/openstack/fakes.py b/nova/tests/api/openstack/fakes.py
index 386d27618..0a78020bd 100644
--- a/nova/tests/api/openstack/fakes.py
+++ b/nova/tests/api/openstack/fakes.py
@@ -33,7 +33,7 @@ from nova.api.openstack.compute import versions
 from nova.api.openstack import urlmap
 from nova.api.openstack import wsgi as os_wsgi
 from nova.compute import api as compute_api
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova.compute import vm_states
 from nova import context
 from nova.db.sqlalchemy import models
@@ -437,8 +437,8 @@ def stub_instance(id, user_id=None, project_id=None, host=None,
     else:
         metadata = []
 
-    inst_type = instance_types.get_instance_type_by_flavor_id(int(flavor_id))
-    sys_meta = instance_types.save_instance_type_info({}, inst_type)
+    inst_type = flavors.get_instance_type_by_flavor_id(int(flavor_id))
+    sys_meta = flavors.save_instance_type_info({}, inst_type)
 
     if host is not None:
         host = str(host)
diff --git a/nova/tests/compute/test_compute.py b/nova/tests/compute/test_compute.py
index 3be5819ab..5e43c63da 100644
--- a/nova/tests/compute/test_compute.py
+++ b/nova/tests/compute/test_compute.py
@@ -33,7 +33,7 @@ from oslo.config import cfg
 import nova
 from nova import compute
 from nova.compute import api as compute_api
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova.compute import manager as compute_manager
 from nova.compute import power_state
 from nova.compute import rpcapi as compute_rpcapi
@@ -220,8 +220,8 @@ class BaseTestCase(test.TestCase):
 
         def make_fake_sys_meta():
             sys_meta = {}
-            inst_type = instance_types.get_instance_type_by_name(type_name)
-            for key in instance_types.system_metadata_instance_type_props:
+            inst_type = flavors.get_instance_type_by_name(type_name)
+            for key in flavors.system_metadata_instance_type_props:
                 sys_meta['instance_type_%s' % key] = inst_type[key]
             return sys_meta
 
@@ -234,7 +234,7 @@ class BaseTestCase(test.TestCase):
         inst['project_id'] = self.project_id
         inst['host'] = 'fake_host'
         inst['node'] = NODENAME
-        type_id = instance_types.get_instance_type_by_name(type_name)['id']
+        type_id = flavors.get_instance_type_by_name(type_name)['id']
         inst['instance_type_id'] = type_id
         inst['ami_launch_index'] = 0
         inst['memory_mb'] = 0
@@ -2160,7 +2160,7 @@ class ComputeTestCase(BaseTestCase):
         self.assertEquals(payload['user_id'], self.user_id)
         self.assertEquals(payload['instance_id'], inst_ref['uuid'])
         self.assertEquals(payload['instance_type'], 'm1.tiny')
-        type_id = instance_types.get_instance_type_by_name('m1.tiny')['id']
+        type_id = flavors.get_instance_type_by_name('m1.tiny')['id']
         self.assertEquals(str(payload['instance_type_id']), str(type_id))
         self.assertEquals(payload['state'], 'active')
         self.assertTrue('display_name' in payload)
@@ -2273,7 +2273,7 @@ class ComputeTestCase(BaseTestCase):
         self.assertEquals(payload['user_id'], self.user_id)
         self.assertEquals(payload['instance_id'], instance['uuid'])
         self.assertEquals(payload['instance_type'], 'm1.tiny')
-        type_id = instance_types.get_instance_type_by_name('m1.tiny')['id']
+        type_id = flavors.get_instance_type_by_name('m1.tiny')['id']
         self.assertEquals(str(payload['instance_type_id']), str(type_id))
         self.assertTrue('display_name' in payload)
         self.assertTrue('created_at' in payload)
@@ -2647,7 +2647,7 @@ class ComputeTestCase(BaseTestCase):
         reservations = self._ensure_quota_reservations_committed()
 
         instance = jsonutils.to_primitive(self._create_fake_instance())
-        instance_type = instance_types.get_default_instance_type()
+        instance_type = flavors.get_default_instance_type()
         db.instance_update(self.context, instance["uuid"],
                           {"task_state": task_states.RESIZE_PREP})
         self.compute.prep_resize(self.context, instance=instance,
@@ -2727,7 +2727,7 @@ class ComputeTestCase(BaseTestCase):
                               jsonutils.dumps(connection_info))
 
         # begin resize
-        instance_type = instance_types.get_default_instance_type()
+        instance_type = flavors.get_default_instance_type()
         db.instance_update(self.context, instance["uuid"],
                           {"task_state": task_states.RESIZE_PREP})
         self.compute.prep_resize(self.context, instance=instance,
@@ -2821,7 +2821,7 @@ class ComputeTestCase(BaseTestCase):
         reservations = self._ensure_quota_reservations_rolledback()
 
         instance = jsonutils.to_primitive(self._create_fake_instance())
-        instance_type = instance_types.get_default_instance_type()
+        instance_type = flavors.get_default_instance_type()
         self.compute.prep_resize(self.context, instance=instance,
                                  instance_type=instance_type,
                                  image={}, reservations=reservations)
@@ -2899,7 +2899,7 @@ class ComputeTestCase(BaseTestCase):
         self.assertEquals(payload['user_id'], self.user_id)
         self.assertEquals(payload['instance_id'], inst_ref['uuid'])
         self.assertEquals(payload['instance_type'], 'm1.tiny')
-        type_id = instance_types.get_instance_type_by_name('m1.tiny')['id']
+        type_id = flavors.get_instance_type_by_name('m1.tiny')['id']
         self.assertEquals(str(payload['instance_type_id']), str(type_id))
         self.assertTrue('display_name' in payload)
         self.assertTrue('created_at' in payload)
@@ -2915,7 +2915,7 @@ class ComputeTestCase(BaseTestCase):
         cur_time = datetime.datetime(2012, 12, 21, 12, 21)
         timeutils.set_time_override(old_time)
         instance = jsonutils.to_primitive(self._create_fake_instance())
-        new_type = instance_types.get_instance_type_by_name('m1.small')
+        new_type = flavors.get_instance_type_by_name('m1.small')
         new_type = jsonutils.to_primitive(new_type)
         new_type_id = new_type['id']
         self.compute.run_instance(self.context, instance=instance)
@@ -2977,7 +2977,7 @@ class ComputeTestCase(BaseTestCase):
         new_instance = db.instance_update(self.context, instance['uuid'],
                                       {'host': 'foo'})
         new_instance = jsonutils.to_primitive(new_instance)
-        instance_type = instance_types.get_default_instance_type()
+        instance_type = flavors.get_default_instance_type()
         self.compute.prep_resize(self.context, instance=new_instance,
                 instance_type=instance_type, image={})
         db.migration_get_by_instance_and_status(self.context.elevated(),
@@ -3000,7 +3000,7 @@ class ComputeTestCase(BaseTestCase):
         self.assertEquals(payload['user_id'], self.user_id)
         self.assertEquals(payload['instance_id'], new_instance['uuid'])
         self.assertEquals(payload['instance_type'], 'm1.tiny')
-        type_id = instance_types.get_instance_type_by_name('m1.tiny')['id']
+        type_id = flavors.get_instance_type_by_name('m1.tiny')['id']
         self.assertEquals(str(payload['instance_type_id']), str(type_id))
         self.assertTrue('display_name' in payload)
         self.assertTrue('created_at' in payload)
@@ -3023,7 +3023,7 @@ class ComputeTestCase(BaseTestCase):
         new_instance = db.instance_update(self.context, instance['uuid'],
                                           {'host': self.compute.host})
         new_instance = jsonutils.to_primitive(new_instance)
-        instance_type = instance_types.get_default_instance_type()
+        instance_type = flavors.get_default_instance_type()
 
         self.assertRaises(exception.MigrationError, self.compute.prep_resize,
                           self.context, instance=new_instance,
@@ -3043,7 +3043,7 @@ class ComputeTestCase(BaseTestCase):
         new_instance = db.instance_update(self.context, instance['uuid'],
                                           {'host': None})
         new_instance = jsonutils.to_primitive(new_instance)
-        instance_type = instance_types.get_default_instance_type()
+        instance_type = flavors.get_default_instance_type()
 
         self.assertRaises(exception.MigrationError, self.compute.prep_resize,
                           self.context, instance=new_instance,
@@ -3061,7 +3061,7 @@ class ComputeTestCase(BaseTestCase):
                        throw_up)
 
         instance = jsonutils.to_primitive(self._create_fake_instance())
-        instance_type = instance_types.get_default_instance_type()
+        instance_type = flavors.get_default_instance_type()
 
         reservations = self._ensure_quota_reservations_rolledback()
 
@@ -3092,7 +3092,7 @@ class ComputeTestCase(BaseTestCase):
     def test_resize_instance(self):
         # Ensure instance can be migrated/resized.
         instance = jsonutils.to_primitive(self._create_fake_instance())
-        instance_type = instance_types.get_default_instance_type()
+        instance_type = flavors.get_default_instance_type()
 
         self.compute.run_instance(self.context, instance=instance)
         new_instance = db.instance_update(self.context, instance['uuid'],
@@ -3216,20 +3216,20 @@ class ComputeTestCase(BaseTestCase):
         instance['system_metadata'].append(dict(key='instance_type_id',
                                                 value=old))
         sys_meta = dict(instance_type_id=old)
-        self.mox.StubOutWithMock(instance_types, 'extract_instance_type')
-        self.mox.StubOutWithMock(instance_types, 'delete_instance_type_info')
-        self.mox.StubOutWithMock(instance_types, 'save_instance_type_info')
+        self.mox.StubOutWithMock(flavors, 'extract_instance_type')
+        self.mox.StubOutWithMock(flavors, 'delete_instance_type_info')
+        self.mox.StubOutWithMock(flavors, 'save_instance_type_info')
         if revert:
-            instance_types.extract_instance_type(instance, 'old_').AndReturn(
+            flavors.extract_instance_type(instance, 'old_').AndReturn(
                 {'instance_type_id': old})
-            instance_types.save_instance_type_info(
+            flavors.save_instance_type_info(
                 sys_meta, {'instance_type_id': old}).AndReturn(sys_meta)
         else:
-            instance_types.extract_instance_type(instance).AndReturn(
+            flavors.extract_instance_type(instance).AndReturn(
                 {'instance_type_id': new})
-        instance_types.delete_instance_type_info(
+        flavors.delete_instance_type_info(
             sys_meta, 'old_').AndReturn(sys_meta)
-        instance_types.delete_instance_type_info(
+        flavors.delete_instance_type_info(
             sys_meta, 'new_').AndReturn(sys_meta)
 
         self.mox.ReplayAll()
@@ -3252,7 +3252,7 @@ class ComputeTestCase(BaseTestCase):
         self._test_cleanup_stored_instance_types('1', '1', True)
 
     def test_get_by_flavor_id(self):
-        type = instance_types.get_instance_type_by_flavor_id(1)
+        type = flavors.get_instance_type_by_flavor_id(1)
         self.assertEqual(type['name'], 'm1.tiny')
 
     def test_resize_same_source_fails(self):
@@ -3262,7 +3262,7 @@ class ComputeTestCase(BaseTestCase):
         instance = jsonutils.to_primitive(self._create_fake_instance())
         self.compute.run_instance(self.context, instance=instance)
         instance = db.instance_get_by_uuid(self.context, instance['uuid'])
-        instance_type = instance_types.get_default_instance_type()
+        instance_type = flavors.get_default_instance_type()
         self.assertRaises(exception.MigrationError, self.compute.prep_resize,
                 self.context, instance=instance,
                 instance_type=instance_type, image={},
@@ -3281,7 +3281,7 @@ class ComputeTestCase(BaseTestCase):
         reservations = self._ensure_quota_reservations_rolledback()
 
         inst_ref = jsonutils.to_primitive(self._create_fake_instance())
-        instance_type = instance_types.get_default_instance_type()
+        instance_type = flavors.get_default_instance_type()
 
         self.compute.run_instance(self.context, instance=inst_ref)
         inst_ref = db.instance_update(self.context, inst_ref['uuid'],
@@ -4775,7 +4775,7 @@ class ComputeAPITestCase(BaseTestCase):
     def test_create_with_too_little_ram(self):
         # Test an instance type with too little memory.
 
-        inst_type = instance_types.get_default_instance_type()
+        inst_type = flavors.get_default_instance_type()
         inst_type['memory_mb'] = 1
 
         self.fake_image['min_ram'] = 2
@@ -4794,7 +4794,7 @@ class ComputeAPITestCase(BaseTestCase):
     def test_create_with_too_little_disk(self):
         # Test an instance type with too little disk space.
 
-        inst_type = instance_types.get_default_instance_type()
+        inst_type = flavors.get_default_instance_type()
         inst_type['root_gb'] = 1
 
         self.fake_image['min_disk'] = 2
@@ -4813,7 +4813,7 @@ class ComputeAPITestCase(BaseTestCase):
     def test_create_just_enough_ram_and_disk(self):
         # Test an instance type with just enough ram and disk space.
 
-        inst_type = instance_types.get_default_instance_type()
+        inst_type = flavors.get_default_instance_type()
         inst_type['root_gb'] = 2
         inst_type['memory_mb'] = 2
 
@@ -4829,7 +4829,7 @@ class ComputeAPITestCase(BaseTestCase):
     def test_create_with_no_ram_and_disk_reqs(self):
         # Test an instance type with no min_ram or min_disk.
 
-        inst_type = instance_types.get_default_instance_type()
+        inst_type = flavors.get_default_instance_type()
         inst_type['root_gb'] = 1
         inst_type['memory_mb'] = 1
 
@@ -4842,7 +4842,7 @@ class ComputeAPITestCase(BaseTestCase):
     def test_create_with_deleted_image(self):
         # If we're given a deleted image by glance, we should not be able to
         # build from it
-        inst_type = instance_types.get_default_instance_type()
+        inst_type = flavors.get_default_instance_type()
 
         self.fake_image['name'] = 'fake_name'
         self.fake_image['status'] = 'DELETED'
@@ -4861,7 +4861,7 @@ class ComputeAPITestCase(BaseTestCase):
         cases = [dict(), dict(display_name=None)]
         for instance in cases:
             (ref, resv_id) = self.compute_api.create(self.context,
-                instance_types.get_default_instance_type(),
+                flavors.get_default_instance_type(),
                 'fake-image-uuid', **instance)
             try:
                 self.assertNotEqual(ref[0]['display_name'], None)
@@ -4872,7 +4872,7 @@ class ComputeAPITestCase(BaseTestCase):
         # Make sure image properties are copied into system metadata.
         (ref, resv_id) = self.compute_api.create(
                 self.context,
-                instance_type=instance_types.get_default_instance_type(),
+                instance_type=flavors.get_default_instance_type(),
                 image_href='fake-image-uuid')
         try:
             sys_metadata = db.instance_system_metadata_get(self.context,
@@ -4889,7 +4889,7 @@ class ComputeAPITestCase(BaseTestCase):
             db.instance_destroy(self.context, ref[0]['uuid'])
 
     def test_create_saves_type_in_system_metadata(self):
-        instance_type = instance_types.get_default_instance_type()
+        instance_type = flavors.get_default_instance_type()
         (ref, resv_id) = self.compute_api.create(
                 self.context,
                 instance_type=instance_type,
@@ -4915,7 +4915,7 @@ class ComputeAPITestCase(BaseTestCase):
         group = self._create_group()
         (ref, resv_id) = self.compute_api.create(
                 self.context,
-                instance_type=instance_types.get_default_instance_type(),
+                instance_type=flavors.get_default_instance_type(),
                 image_href=None,
                 security_group=['testgroup'])
         try:
@@ -4928,7 +4928,7 @@ class ComputeAPITestCase(BaseTestCase):
             db.instance_destroy(self.context, ref[0]['uuid'])
 
     def test_create_instance_with_invalid_security_group_raises(self):
-        instance_type = instance_types.get_default_instance_type()
+        instance_type = flavors.get_default_instance_type()
 
         pre_build_len = len(db.instance_get_all(self.context))
         self.assertRaises(exception.SecurityGroupNotFoundForProject,
@@ -4943,7 +4943,7 @@ class ComputeAPITestCase(BaseTestCase):
     def test_create_with_large_user_data(self):
         # Test an instance type with too much user data.
 
-        inst_type = instance_types.get_default_instance_type()
+        inst_type = flavors.get_default_instance_type()
 
         self.fake_image['min_ram'] = 2
         self.stubs.Set(fake_image._FakeImageService, 'show', self.fake_show)
@@ -4955,7 +4955,7 @@ class ComputeAPITestCase(BaseTestCase):
     def test_create_with_malformed_user_data(self):
         # Test an instance type with malformed user data.
 
-        inst_type = instance_types.get_default_instance_type()
+        inst_type = flavors.get_default_instance_type()
 
         self.fake_image['min_ram'] = 2
         self.stubs.Set(fake_image._FakeImageService, 'show', self.fake_show)
@@ -4967,7 +4967,7 @@ class ComputeAPITestCase(BaseTestCase):
     def test_create_with_base64_user_data(self):
         # Test an instance type with ok much user data.
 
-        inst_type = instance_types.get_default_instance_type()
+        inst_type = flavors.get_default_instance_type()
 
         self.fake_image['min_ram'] = 2
         self.stubs.Set(fake_image._FakeImageService, 'show', self.fake_show)
@@ -4998,7 +4998,7 @@ class ComputeAPITestCase(BaseTestCase):
                  ('hello_server', 'hello-server')]
         for display_name, hostname in cases:
             (ref, resv_id) = self.compute_api.create(self.context,
-                instance_types.get_default_instance_type(), None,
+                flavors.get_default_instance_type(), None,
                 display_name=display_name)
             try:
                 self.assertEqual(ref[0]['hostname'], hostname)
@@ -5011,7 +5011,7 @@ class ComputeAPITestCase(BaseTestCase):
 
         (ref, resv_id) = self.compute_api.create(
                 self.context,
-                instance_type=instance_types.get_default_instance_type(),
+                instance_type=flavors.get_default_instance_type(),
                 image_href=None,
                 security_group=['testgroup'])
         try:
@@ -5027,7 +5027,7 @@ class ComputeAPITestCase(BaseTestCase):
 
         (ref, resv_id) = self.compute_api.create(
                 self.context,
-                instance_type=instance_types.get_default_instance_type(),
+                instance_type=flavors.get_default_instance_type(),
                 image_href=None,
                 security_group=['testgroup'])
 
@@ -5138,7 +5138,7 @@ class ComputeAPITestCase(BaseTestCase):
     def test_delete_in_resizing(self):
         def fake_quotas_reserve(context, expire=None, project_id=None,
                                                              **deltas):
-            old_type = instance_types.get_instance_type_by_name('m1.tiny')
+            old_type = flavors.get_instance_type_by_name('m1.tiny')
             # ensure using old instance type to create reservations
             self.assertEqual(deltas['cores'], -old_type['vcpus'])
             self.assertEqual(deltas['ram'], -old_type['memory_mb'])
@@ -5149,7 +5149,7 @@ class ComputeAPITestCase(BaseTestCase):
                 'host': CONF.host})
 
         # create a fake migration record (manager does this)
-        new_inst_type = instance_types.get_instance_type_by_name('m1.small')
+        new_inst_type = flavors.get_instance_type_by_name('m1.small')
         db.migration_create(self.context.elevated(),
                  {'instance_uuid': instance['uuid'],
                   'old_instance_type_id': instance['instance_type_id'],
@@ -5592,7 +5592,7 @@ class ComputeAPITestCase(BaseTestCase):
 
     def test_hostname_create(self):
         # Ensure instance hostname is set during creation.
-        inst_type = instance_types.get_instance_type_by_name('m1.tiny')
+        inst_type = flavors.get_instance_type_by_name('m1.tiny')
         (instances, _) = self.compute_api.create(self.context,
                                                  inst_type,
                                                  None,
@@ -5753,7 +5753,7 @@ class ComputeAPITestCase(BaseTestCase):
                                           {'extra_param': 'value1'})
 
         self.assertEqual(image['name'], 'snap1')
-        instance_type = instance_types.extract_instance_type(instance)
+        instance_type = flavors.extract_instance_type(instance)
         self.assertEqual(image['min_ram'], self.fake_image['min_ram'])
         self.assertEqual(image['min_disk'], instance_type['root_gb'])
         properties = image['properties']
@@ -5981,14 +5981,14 @@ class ComputeAPITestCase(BaseTestCase):
         self.compute_api.resize(self.context, instance, '4')
 
         # Do the prep/finish_resize steps (manager does this)
-        old_type = instance_types.extract_instance_type(instance)
-        new_type = instance_types.get_instance_type_by_flavor_id('4')
+        old_type = flavors.extract_instance_type(instance)
+        new_type = flavors.get_instance_type_by_flavor_id('4')
         sys_meta = utils.metadata_to_dict(instance['system_metadata'])
-        sys_meta = instance_types.save_instance_type_info(sys_meta,
+        sys_meta = flavors.save_instance_type_info(sys_meta,
                                                           old_type, 'old_')
-        sys_meta = instance_types.save_instance_type_info(sys_meta,
+        sys_meta = flavors.save_instance_type_info(sys_meta,
                                                           new_type, 'new_')
-        sys_meta = instance_types.save_instance_type_info(sys_meta,
+        sys_meta = flavors.save_instance_type_info(sys_meta,
                                                           new_type)
 
         # create a fake migration record (manager does this)
@@ -6053,9 +6053,9 @@ class ComputeAPITestCase(BaseTestCase):
         memory_mb = 128
         root_gb = 0
         vcpus = 1
-        instance_types.create(name, memory_mb, vcpus, root_gb, 0,
+        flavors.create(name, memory_mb, vcpus, root_gb, 0,
                               flavorid, 0, 1.0, True)
-        instance_types.destroy(name)
+        flavors.destroy(name)
         self.assertRaises(exception.FlavorNotFound, self.compute_api.resize,
                 self.context, instance, flavorid)
 
@@ -6085,12 +6085,12 @@ class ComputeAPITestCase(BaseTestCase):
         memory_mb = 102400
         root_gb = 0
         vcpus = 1
-        instance_types.create(name, memory_mb, vcpus, root_gb, 0,
+        flavors.create(name, memory_mb, vcpus, root_gb, 0,
                               flavorid, 0, 1.0, True)
         self.assertRaises(exception.TooManyInstances, self.compute_api.resize,
                 self.context, instance, flavorid)
 
-        instance_types.destroy(name)
+        flavors.destroy(name)
         self.compute.terminate_instance(self.context, instance=instance)
 
     def test_resize_revert_deleted_flavor_fails(self):
@@ -6099,7 +6099,7 @@ class ComputeAPITestCase(BaseTestCase):
         memory_mb = 128
         root_gb = 0
         vcpus = 1
-        instance_types.create(orig_name, memory_mb, vcpus, root_gb, 0,
+        flavors.create(orig_name, memory_mb, vcpus, root_gb, 0,
                               orig_flavorid, 0, 1.0, True)
 
         instance = self._create_fake_instance(type_name=orig_name)
@@ -6108,7 +6108,7 @@ class ComputeAPITestCase(BaseTestCase):
         self.compute.run_instance(self.context, instance=instance)
 
         old_instance_type_id = instance['instance_type_id']
-        new_flavor = instance_types.get_instance_type_by_name('m1.tiny')
+        new_flavor = flavors.get_instance_type_by_name('m1.tiny')
         new_flavorid = new_flavor['flavorid']
         new_instance_type_id = new_flavor['id']
         self.compute_api.resize(self.context, instance, new_flavorid)
@@ -6121,7 +6121,7 @@ class ComputeAPITestCase(BaseTestCase):
         instance = db.instance_update(self.context, instance['uuid'],
                                       {'task_state': None,
                                        'vm_state': vm_states.RESIZED})
-        instance_types.destroy(orig_name)
+        flavors.destroy(orig_name)
         self.assertRaises(exception.InstanceTypeNotFound,
                           self.compute_api.revert_resize,
                           self.context, instance)
@@ -6169,7 +6169,7 @@ class ComputeAPITestCase(BaseTestCase):
         instance = self._create_fake_instance(dict(host='host2'))
         instance = db.instance_get_by_uuid(self.context, instance['uuid'])
         instance = jsonutils.to_primitive(instance)
-        orig_instance_type = instance_types.extract_instance_type(instance)
+        orig_instance_type = flavors.extract_instance_type(instance)
         self.compute.run_instance(self.context, instance=instance)
         # We need to set the host to something 'known'.  Unfortunately,
         # the compute manager is using a cached copy of CONF.host,
@@ -6730,7 +6730,7 @@ class ComputeAPITestCase(BaseTestCase):
         self.assertThat(bdms, matchers.DictListMatches(expected_result))
 
         self.compute_api._update_block_device_mapping(
-            self.context, instance_types.get_default_instance_type(),
+            self.context, flavors.get_default_instance_type(),
             instance['uuid'], block_device_mapping)
         bdms = [self._parse_db_block_device_mapping(bdm_ref)
                 for bdm_ref in db.block_device_mapping_get_all_by_instance(
@@ -6789,7 +6789,7 @@ class ComputeAPITestCase(BaseTestCase):
         """Verify building an instance has a reservation_id that
         matches return value from create"""
         (refs, resv_id) = self.compute_api.create(self.context,
-                instance_types.get_default_instance_type(), None)
+                flavors.get_default_instance_type(), None)
         try:
             self.assertEqual(len(refs), 1)
             self.assertEqual(refs[0]['reservation_id'], resv_id)
@@ -6802,7 +6802,7 @@ class ComputeAPITestCase(BaseTestCase):
         in both instances
         """
         (refs, resv_id) = self.compute_api.create(self.context,
-                instance_types.get_default_instance_type(), None,
+                flavors.get_default_instance_type(), None,
                 min_count=2, max_count=2)
         try:
             self.assertEqual(len(refs), 2)
@@ -6816,7 +6816,7 @@ class ComputeAPITestCase(BaseTestCase):
     def test_multi_instance_display_name_template(self):
         self.flags(multi_instance_display_name_template='%(name)s')
         (refs, resv_id) = self.compute_api.create(self.context,
-                instance_types.get_default_instance_type(), None,
+                flavors.get_default_instance_type(), None,
                 min_count=2, max_count=2, display_name='x')
         self.assertEqual(refs[0]['display_name'], 'x')
         self.assertEqual(refs[0]['hostname'], 'x')
@@ -6825,7 +6825,7 @@ class ComputeAPITestCase(BaseTestCase):
 
         self.flags(multi_instance_display_name_template='%(name)s-%(count)s')
         (refs, resv_id) = self.compute_api.create(self.context,
-                instance_types.get_default_instance_type(), None,
+                flavors.get_default_instance_type(), None,
                 min_count=2, max_count=2, display_name='x')
         self.assertEqual(refs[0]['display_name'], 'x-1')
         self.assertEqual(refs[0]['hostname'], 'x-1')
@@ -6834,7 +6834,7 @@ class ComputeAPITestCase(BaseTestCase):
 
         self.flags(multi_instance_display_name_template='%(name)s-%(uuid)s')
         (refs, resv_id) = self.compute_api.create(self.context,
-                instance_types.get_default_instance_type(), None,
+                flavors.get_default_instance_type(), None,
                 min_count=2, max_count=2, display_name='x')
         self.assertEqual(refs[0]['display_name'], 'x-%s' % refs[0]['uuid'])
         self.assertEqual(refs[0]['hostname'], 'x-%s' % refs[0]['uuid'])
@@ -7537,7 +7537,7 @@ class ComputeAPITestCase(BaseTestCase):
         inst['project_id'] = self.project_id
         inst['host'] = 'fake_host'
         inst['node'] = NODENAME
-        type_id = instance_types.get_instance_type_by_name('m1.tiny')['id']
+        type_id = flavors.get_instance_type_by_name('m1.tiny')['id']
         inst['instance_type_id'] = type_id
         inst['ami_launch_index'] = 0
         inst['memory_mb'] = 0
@@ -8046,7 +8046,7 @@ class DisabledInstanceTypesTestCase(BaseTestCase):
     def setUp(self):
         super(DisabledInstanceTypesTestCase, self).setUp()
         self.compute_api = compute.API()
-        self.inst_type = instance_types.get_default_instance_type()
+        self.inst_type = flavors.get_default_instance_type()
 
     def test_can_build_instance_from_visible_instance_type(self):
         self.inst_type['disabled'] = False
@@ -8061,7 +8061,7 @@ class DisabledInstanceTypesTestCase(BaseTestCase):
     def test_can_resize_to_visible_instance_type(self):
         instance = self._create_fake_instance()
         orig_get_instance_type_by_flavor_id =\
-                instance_types.get_instance_type_by_flavor_id
+                flavors.get_instance_type_by_flavor_id
 
         def fake_get_instance_type_by_flavor_id(flavor_id, ctxt=None,
                                                 read_deleted="yes"):
@@ -8071,7 +8071,7 @@ class DisabledInstanceTypesTestCase(BaseTestCase):
             instance_type['disabled'] = False
             return instance_type
 
-        self.stubs.Set(instance_types, 'get_instance_type_by_flavor_id',
+        self.stubs.Set(flavors, 'get_instance_type_by_flavor_id',
                        fake_get_instance_type_by_flavor_id)
 
         # FIXME(sirp): for legacy this raises FlavorNotFound instead of
@@ -8082,7 +8082,7 @@ class DisabledInstanceTypesTestCase(BaseTestCase):
     def test_cannot_resize_to_disabled_instance_type(self):
         instance = self._create_fake_instance()
         orig_get_instance_type_by_flavor_id = \
-                instance_types.get_instance_type_by_flavor_id
+                flavors.get_instance_type_by_flavor_id
 
         def fake_get_instance_type_by_flavor_id(flavor_id, ctxt=None,
                                                 read_deleted="yes"):
@@ -8092,7 +8092,7 @@ class DisabledInstanceTypesTestCase(BaseTestCase):
             instance_type['disabled'] = True
             return instance_type
 
-        self.stubs.Set(instance_types, 'get_instance_type_by_flavor_id',
+        self.stubs.Set(flavors, 'get_instance_type_by_flavor_id',
                        fake_get_instance_type_by_flavor_id)
 
         # FIXME(sirp): for legacy this raises FlavorNotFound instead of
@@ -8386,7 +8386,7 @@ class ComputeRescheduleResizeOrReraiseTestCase(BaseTestCase):
         super(ComputeRescheduleResizeOrReraiseTestCase, self).setUp()
         self.instance = self._create_fake_instance()
         self.instance_uuid = self.instance['uuid']
-        self.instance_type = instance_types.get_instance_type_by_name(
+        self.instance_type = flavors.get_instance_type_by_name(
                 "m1.tiny")
 
     def test_reschedule_resize_or_reraise_called(self):
@@ -8493,7 +8493,7 @@ class ComputeInactiveImageTestCase(BaseTestCase):
 
     def test_create_instance_with_deleted_image(self):
         # Make sure we can't start an instance with a deleted image.
-        inst_type = instance_types.get_instance_type_by_name('m1.tiny')
+        inst_type = flavors.get_instance_type_by_name('m1.tiny')
         self.assertRaises(exception.ImageNotActive,
                           self.compute_api.create,
                           self.context, inst_type, 'fake-image-uuid')
diff --git a/nova/tests/compute/test_compute_utils.py b/nova/tests/compute/test_compute_utils.py
index 05d91075c..d2bc41003 100644
--- a/nova/tests/compute/test_compute_utils.py
+++ b/nova/tests/compute/test_compute_utils.py
@@ -21,7 +21,7 @@ import string
 
 from oslo.config import cfg
 
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova.compute import utils as compute_utils
 from nova import context
 from nova import db
@@ -185,7 +185,7 @@ class ComputeValidateDeviceTestCase(test.TestCase):
                 'ephemeral_gb': 10,
                 'swap': 0,
                 })
-        self.stubs.Set(instance_types, 'get_instance_type',
+        self.stubs.Set(flavors, 'get_instance_type',
                        lambda instance_type_id, ctxt=None: self.instance_type)
         device = self._validate_device()
         self.assertEqual(device, '/dev/xvdc')
@@ -195,7 +195,7 @@ class ComputeValidateDeviceTestCase(test.TestCase):
                 'ephemeral_gb': 0,
                 'swap': 10,
                 })
-        self.stubs.Set(instance_types, 'get_instance_type',
+        self.stubs.Set(flavors, 'get_instance_type',
                        lambda instance_type_id, ctxt=None: self.instance_type)
         device = self._validate_device()
         self.assertEqual(device, '/dev/xvdb')
@@ -205,7 +205,7 @@ class ComputeValidateDeviceTestCase(test.TestCase):
                 'ephemeral_gb': 10,
                 'swap': 10,
                 })
-        self.stubs.Set(instance_types, 'get_instance_type',
+        self.stubs.Set(flavors, 'get_instance_type',
                        lambda instance_type_id, ctxt=None: self.instance_type)
         device = self._validate_device()
         self.assertEqual(device, '/dev/xvdd')
@@ -215,7 +215,7 @@ class ComputeValidateDeviceTestCase(test.TestCase):
                 'ephemeral_gb': 0,
                 'swap': 10,
                 })
-        self.stubs.Set(instance_types, 'get_instance_type',
+        self.stubs.Set(flavors, 'get_instance_type',
                        lambda instance_type_id, ctxt=None: self.instance_type)
         device = self._validate_device()
         self.assertEqual(device, '/dev/xvdb')
@@ -258,8 +258,8 @@ class UsageInfoTestCase(test.TestCase):
 
     def _create_instance(self, params={}):
         """Create a test instance."""
-        instance_type = instance_types.get_instance_type_by_name('m1.tiny')
-        sys_meta = instance_types.save_instance_type_info({}, instance_type)
+        instance_type = flavors.get_instance_type_by_name('m1.tiny')
+        sys_meta = flavors.save_instance_type_info({}, instance_type)
         inst = {}
         inst['image_ref'] = 1
         inst['reservation_id'] = 'r-fakeres'
@@ -295,7 +295,7 @@ class UsageInfoTestCase(test.TestCase):
         self.assertEquals(payload['user_id'], self.user_id)
         self.assertEquals(payload['instance_id'], instance['uuid'])
         self.assertEquals(payload['instance_type'], 'm1.tiny')
-        type_id = instance_types.get_instance_type_by_name('m1.tiny')['id']
+        type_id = flavors.get_instance_type_by_name('m1.tiny')['id']
         self.assertEquals(str(payload['instance_type_id']), str(type_id))
         for attr in ('display_name', 'created_at', 'launched_at',
                      'state', 'state_description',
@@ -340,7 +340,7 @@ class UsageInfoTestCase(test.TestCase):
         self.assertEquals(payload['user_id'], self.user_id)
         self.assertEquals(payload['instance_id'], instance['uuid'])
         self.assertEquals(payload['instance_type'], 'm1.tiny')
-        type_id = instance_types.get_instance_type_by_name('m1.tiny')['id']
+        type_id = flavors.get_instance_type_by_name('m1.tiny')['id']
         self.assertEquals(str(payload['instance_type_id']), str(type_id))
         for attr in ('display_name', 'created_at', 'launched_at',
                      'state', 'state_description',
@@ -376,7 +376,7 @@ class UsageInfoTestCase(test.TestCase):
         self.assertEquals(payload['user_id'], self.user_id)
         self.assertEquals(payload['instance_id'], instance['uuid'])
         self.assertEquals(payload['instance_type'], 'm1.tiny')
-        type_id = instance_types.get_instance_type_by_name('m1.tiny')['id']
+        type_id = flavors.get_instance_type_by_name('m1.tiny')['id']
         self.assertEquals(str(payload['instance_type_id']), str(type_id))
         for attr in ('display_name', 'created_at', 'launched_at',
                      'state', 'state_description', 'image_meta'):
diff --git a/nova/tests/compute/test_resource_tracker.py b/nova/tests/compute/test_resource_tracker.py
index 6d26174c7..43bed38ba 100644
--- a/nova/tests/compute/test_resource_tracker.py
+++ b/nova/tests/compute/test_resource_tracker.py
@@ -21,7 +21,7 @@ import uuid
 
 from oslo.config import cfg
 
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova.compute import resource_tracker
 from nova.compute import task_states
 from nova.compute import vm_states
@@ -153,7 +153,7 @@ class BaseTestCase(test.TestCase):
 
     def _fake_instance_system_metadata(self, instance_type, prefix=''):
         sys_meta = []
-        for key in instance_types.system_metadata_instance_type_props.keys():
+        for key in flavors.system_metadata_instance_type_props.keys():
             sys_meta.append({'key': '%sinstance_type_%s' % (prefix, key),
                              'value': instance_type[key]})
         return sys_meta
diff --git a/nova/tests/conductor/test_conductor.py b/nova/tests/conductor/test_conductor.py
index b3088855a..3780fc7cf 100644
--- a/nova/tests/conductor/test_conductor.py
+++ b/nova/tests/conductor/test_conductor.py
@@ -17,7 +17,7 @@
 import mox
 
 from nova.api.ec2 import ec2utils
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova.compute import utils as compute_utils
 from nova.compute import vm_states
 from nova import conductor
@@ -73,7 +73,7 @@ class _BaseTestCase(object):
         inst['user_id'] = self.user_id
         inst['project_id'] = self.project_id
         inst['host'] = 'fake_host'
-        type_id = instance_types.get_instance_type_by_name(type_name)['id']
+        type_id = flavors.get_instance_type_by_name(type_name)['id']
         inst['instance_type_id'] = type_id
         inst['ami_launch_index'] = 0
         inst['memory_mb'] = 0
diff --git a/nova/tests/network/test_api.py b/nova/tests/network/test_api.py
index 304229b20..1e92fa286 100644
--- a/nova/tests/network/test_api.py
+++ b/nova/tests/network/test_api.py
@@ -22,7 +22,7 @@ import random
 
 import mox
 
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova import context
 from nova import exception
 from nova import network
@@ -81,9 +81,9 @@ class ApiTestCase(test.TestCase):
         self.network_api.network_rpcapi.allocate_for_instance(
             mox.IgnoreArg(), **kwargs).AndReturn([])
         self.mox.ReplayAll()
-        inst_type = instance_types.get_default_instance_type()
+        inst_type = flavors.get_default_instance_type()
         inst_type['rxtx_factor'] = 0
-        sys_meta = instance_types.save_instance_type_info({}, inst_type)
+        sys_meta = flavors.save_instance_type_info({}, inst_type)
         instance = dict(id='id', uuid='uuid', project_id='project_id',
             host='host', system_metadata=utils.dict_to_metadata(sys_meta))
         self.network_api.allocate_for_instance(
@@ -140,10 +140,10 @@ class ApiTestCase(test.TestCase):
         self._do_test_associate_floating_ip(None)
 
     def _stub_migrate_instance_calls(self, method, multi_host, info):
-        fake_instance_type = instance_types.get_default_instance_type()
+        fake_instance_type = flavors.get_default_instance_type()
         fake_instance_type['rxtx_factor'] = 1.21
         sys_meta = utils.dict_to_metadata(
-            instance_types.save_instance_type_info({}, fake_instance_type))
+            flavors.save_instance_type_info({}, fake_instance_type))
         fake_instance = {'uuid': 'fake_uuid',
                          'instance_type_id': fake_instance_type['id'],
                          'project_id': 'fake_project_id',
diff --git a/nova/tests/network/test_quantumv2.py b/nova/tests/network/test_quantumv2.py
index 5922d7e1e..ec1e88d86 100644
--- a/nova/tests/network/test_quantumv2.py
+++ b/nova/tests/network/test_quantumv2.py
@@ -21,7 +21,7 @@ import mox
 from oslo.config import cfg
 from quantumclient.v2_0 import client
 
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova import context
 from nova import exception
 from nova.network import model
@@ -389,10 +389,10 @@ class TestQuantumv2(test.TestCase):
         self.moxed_client.list_extensions().AndReturn(
             {'extensions': [{'name': 'nvp-qos'}]})
         self.mox.ReplayAll()
-        instance_type = instance_types.get_default_instance_type()
+        instance_type = flavors.get_default_instance_type()
         instance_type['rxtx_factor'] = 1
         sys_meta = utils.dict_to_metadata(
-            instance_types.save_instance_type_info({}, instance_type))
+            flavors.save_instance_type_info({}, instance_type))
         instance = {'system_metadata': sys_meta}
         port_req_body = {'port': {}}
         api._populate_quantum_extension_values(instance, port_req_body)
diff --git a/nova/tests/scheduler/fakes.py b/nova/tests/scheduler/fakes.py
index 4e4ab7c37..024d37969 100644
--- a/nova/tests/scheduler/fakes.py
+++ b/nova/tests/scheduler/fakes.py
@@ -18,7 +18,7 @@ Fakes For Scheduler tests.
 
 import mox
 
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova.compute import vm_states
 from nova import db
 from nova.scheduler import filter_scheduler
@@ -126,7 +126,7 @@ class FakeInstance(object):
         inst['launch_time'] = '10'
         inst['user_id'] = 'fake'
         inst['project_id'] = 'fake'
-        type_id = instance_types.get_instance_type_by_name(type_name)['id']
+        type_id = flavors.get_instance_type_by_name(type_name)['id']
         inst['instance_type_id'] = type_id
         inst['ami_launch_index'] = 0
         inst.update(params)
diff --git a/nova/tests/scheduler/test_filter_scheduler.py b/nova/tests/scheduler/test_filter_scheduler.py
index 74952aa0e..c8c04dc77 100644
--- a/nova/tests/scheduler/test_filter_scheduler.py
+++ b/nova/tests/scheduler/test_filter_scheduler.py
@@ -18,7 +18,7 @@ Tests For Filter Scheduler.
 
 import mox
 
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova.compute import rpcapi as compute_rpcapi
 from nova.compute import utils as compute_utils
 from nova.compute import vm_states
@@ -329,7 +329,7 @@ class FilterSchedulerTestCase(test_scheduler.SchedulerTestCase):
         instance = db.instance_create(self.context, {})
 
         instance_properties = {'project_id': 'fake', 'os_type': 'Linux'}
-        instance_type = instance_types.get_instance_type_by_name("m1.tiny")
+        instance_type = flavors.get_instance_type_by_name("m1.tiny")
         request_spec = {'instance_properties': instance_properties,
                         'instance_type': instance_type}
         retry = {'hosts': [], 'num_attempts': 1}
diff --git a/nova/tests/scheduler/test_scheduler.py b/nova/tests/scheduler/test_scheduler.py
index 461b81b4b..60d45fed4 100644
--- a/nova/tests/scheduler/test_scheduler.py
+++ b/nova/tests/scheduler/test_scheduler.py
@@ -22,7 +22,7 @@ Tests For Scheduler
 import mox
 
 from nova.compute import api as compute_api
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova.compute import power_state
 from nova.compute import rpcapi as compute_rpcapi
 from nova.compute import task_states
@@ -435,11 +435,11 @@ class SchedulerTestCase(test.TestCase):
         self.assertEqual(result, ['host2'])
 
     def _live_migration_instance(self):
-        inst_type = instance_types.get_instance_type(1)
+        inst_type = flavors.get_instance_type(1)
         # NOTE(danms): we have _got_ to stop doing this!
         inst_type['memory_mb'] = 1024
         sys_meta = utils.dict_to_metadata(
-            instance_types.save_instance_type_info({}, inst_type))
+            flavors.save_instance_type_info({}, inst_type))
         return {'id': 31337,
                 'uuid': 'fake_uuid',
                 'name': 'fake-instance',
@@ -788,7 +788,7 @@ class SchedulerTestCase(test.TestCase):
 
         # Confirm dest is picked by scheduler if not set.
         self.mox.StubOutWithMock(self.driver, 'select_hosts')
-        self.mox.StubOutWithMock(instance_types, 'extract_instance_type')
+        self.mox.StubOutWithMock(flavors, 'extract_instance_type')
 
         request_spec = {'instance_properties': instance,
                         'instance_type': {},
@@ -799,7 +799,7 @@ class SchedulerTestCase(test.TestCase):
         ignore_hosts = [instance['host']]
         filter_properties = {'ignore_hosts': ignore_hosts}
 
-        instance_types.extract_instance_type(instance).AndReturn({})
+        flavors.extract_instance_type(instance).AndReturn({})
         self.driver.select_hosts(self.context, request_spec,
                                  filter_properties).AndReturn(['fake_host2'])
 
@@ -812,7 +812,7 @@ class SchedulerTestCase(test.TestCase):
         instance = self._live_migration_instance()
 
         # Confirm scheduler picks target host if none given.
-        self.mox.StubOutWithMock(instance_types, 'extract_instance_type')
+        self.mox.StubOutWithMock(flavors, 'extract_instance_type')
         self.mox.StubOutWithMock(self.driver, '_live_migration_src_check')
         self.mox.StubOutWithMock(self.driver, 'select_hosts')
         self.mox.StubOutWithMock(self.driver, '_live_migration_common_check')
@@ -831,7 +831,7 @@ class SchedulerTestCase(test.TestCase):
 
         self.driver._live_migration_src_check(self.context, instance)
 
-        instance_types.extract_instance_type(
+        flavors.extract_instance_type(
                 instance).MultipleTimes().AndReturn({})
 
         # First selected host raises exception.InvalidHypervisorType
diff --git a/nova/tests/test_instance_types.py b/nova/tests/test_instance_types.py
index 5c8b4be14..5afa4005f 100644
--- a/nova/tests/test_instance_types.py
+++ b/nova/tests/test_instance_types.py
@@ -17,7 +17,7 @@ Unit Tests for instance types code
 """
 import time
 
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova import context
 from nova import db
 from nova.db.sqlalchemy import models
@@ -31,7 +31,7 @@ class InstanceTypeTestCase(test.TestCase):
     def _generate_name(self):
         """return a name not in the DB."""
         nonexistent_flavor = str(int(time.time()))
-        flavors = instance_types.get_all_types()
+        flavors = flavors.get_all_types()
         while nonexistent_flavor in flavors:
             nonexistent_flavor += "z"
         else:
@@ -41,7 +41,7 @@ class InstanceTypeTestCase(test.TestCase):
         """return a flavorid not in the DB."""
         nonexistent_flavor = 2700
         flavor_ids = [value["id"] for key, value in
-                      instance_types.get_all_types().iteritems()]
+                      flavors.get_all_types().iteritems()]
         while nonexistent_flavor in flavor_ids:
             nonexistent_flavor += 1
         else:
@@ -49,17 +49,17 @@ class InstanceTypeTestCase(test.TestCase):
 
     def _existing_flavor(self):
         """return first instance type name."""
-        return instance_types.get_all_types().keys()[0]
+        return flavors.get_all_types().keys()[0]
 
     def test_instance_type_create(self):
         # Ensure instance types can be created.
         name = 'Instance create test'
         flavor_id = '512'
 
-        original_list = instance_types.get_all_types()
+        original_list = flavors.get_all_types()
 
         # create new type and make sure values stick
-        inst_type = instance_types.create(name, 256, 1, 120,
+        inst_type = flavors.create(name, 256, 1, 120,
                                           flavorid=flavor_id)
         self.assertEqual(inst_type['flavorid'], flavor_id)
         self.assertEqual(inst_type['name'], name)
@@ -71,7 +71,7 @@ class InstanceTypeTestCase(test.TestCase):
         self.assertEqual(inst_type['rxtx_factor'], 1.0)
 
         # make sure new type shows up in list
-        new_list = instance_types.get_all_types()
+        new_list = flavors.get_all_types()
         self.assertNotEqual(len(original_list), len(new_list),
                             'instance type was not created')
 
@@ -80,10 +80,10 @@ class InstanceTypeTestCase(test.TestCase):
         name = 'Small Flavor'
         flavorid = 'flavor1'
 
-        original_list = instance_types.get_all_types()
+        original_list = flavors.get_all_types()
 
         # create new type and make sure values stick
-        inst_type = instance_types.create(name, 256, 1, 120, 100, flavorid)
+        inst_type = flavors.create(name, 256, 1, 120, 100, flavorid)
         inst_type_id = inst_type['id']
         self.assertEqual(inst_type['flavorid'], flavorid)
         self.assertEqual(inst_type['name'], name)
@@ -95,21 +95,21 @@ class InstanceTypeTestCase(test.TestCase):
         self.assertEqual(inst_type['rxtx_factor'], 1.0)
 
         # make sure new type shows up in list
-        new_list = instance_types.get_all_types()
+        new_list = flavors.get_all_types()
         self.assertNotEqual(len(original_list), len(new_list),
                             'instance type was not created')
 
-        instance_types.destroy(name)
+        flavors.destroy(name)
         self.assertRaises(exception.InstanceTypeNotFound,
-                          instance_types.get_instance_type, inst_type_id)
+                          flavors.get_instance_type, inst_type_id)
 
         # deleted instance should not be in list anymoer
-        new_list = instance_types.get_all_types()
+        new_list = flavors.get_all_types()
         self.assertEqual(original_list, new_list)
 
     def test_instance_type_create_without_flavorid(self):
         name = 'Small Flavor'
-        inst_type = instance_types.create(name, 256, 1, 120, 100)
+        inst_type = flavors.create(name, 256, 1, 120, 100)
         self.assertNotEqual(inst_type['flavorid'], None)
         self.assertEqual(inst_type['name'], name)
         self.assertEqual(inst_type['memory_mb'], 256)
@@ -123,7 +123,7 @@ class InstanceTypeTestCase(test.TestCase):
         # Ensure that auto-generated uuid is assigned.
         name = 'Empty String ID Flavor'
         flavorid = ''
-        inst_type = instance_types.create(name, 256, 1, 120, 100, flavorid)
+        inst_type = flavors.create(name, 256, 1, 120, 100, flavorid)
         self.assertEqual(len(inst_type['flavorid']), 36)
         self.assertEqual(inst_type['name'], name)
         self.assertEqual(inst_type['memory_mb'], 256)
@@ -135,7 +135,7 @@ class InstanceTypeTestCase(test.TestCase):
 
     def test_instance_type_create_with_custom_rxtx_factor(self):
         name = 'Custom RXTX Factor'
-        inst_type = instance_types.create(name, 256, 1, 120, 100,
+        inst_type = flavors.create(name, 256, 1, 120, 100,
                                           rxtx_factor=9.9)
         self.assertNotEqual(inst_type['flavorid'], None)
         self.assertEqual(inst_type['name'], name)
@@ -150,18 +150,18 @@ class InstanceTypeTestCase(test.TestCase):
         # Ensure instance types raises InvalidInput for invalid characters.
         name = "foo.bar!@#$%^-test_name"
         flavorid = "flavor1"
-        self.assertRaises(exception.InvalidInput, instance_types.create,
+        self.assertRaises(exception.InvalidInput, flavors.create,
                 name, 256, 1, 120, 100, flavorid)
 
     def test_instance_type_create_with_long_flavor_name(self):
         # Flavor name with 255 characters or less is valid.
         name = 'a' * 255
-        inst_type = instance_types.create(name, 64, 1, 120, flavorid=11)
+        inst_type = flavors.create(name, 64, 1, 120, flavorid=11)
         self.assertEqual(inst_type['name'], name)
 
         # Flavor name which is more than 255 characters will cause error.
         name = 'a' * 256
-        self.assertRaises(exception.InvalidInput, instance_types.create,
+        self.assertRaises(exception.InvalidInput, flavors.create,
                           name, 64, 1, 120, flavorid=11)
 
     def test_add_instance_type_access(self):
@@ -169,9 +169,9 @@ class InstanceTypeTestCase(test.TestCase):
         project_id = 'fake'
         ctxt = context.RequestContext(user_id, project_id, is_admin=True)
         flavor_id = 'flavor1'
-        type_ref = instance_types.create('some flavor', 256, 1, 120, 100,
+        type_ref = flavors.create('some flavor', 256, 1, 120, 100,
                                           flavorid=flavor_id)
-        access_ref = instance_types.add_instance_type_access(flavor_id,
+        access_ref = flavors.add_instance_type_access(flavor_id,
                                                              project_id,
                                                              ctxt=ctxt)
         self.assertEqual(access_ref["project_id"], project_id)
@@ -182,13 +182,13 @@ class InstanceTypeTestCase(test.TestCase):
         project_id = 'fake'
         ctxt = context.RequestContext(user_id, project_id, is_admin=True)
         flavor_id = 'flavor1'
-        type_ref = instance_types.create('some flavor', 256, 1, 120, 100,
+        type_ref = flavors.create('some flavor', 256, 1, 120, 100,
                                           flavorid=flavor_id)
-        access_ref = instance_types.add_instance_type_access(flavor_id,
+        access_ref = flavors.add_instance_type_access(flavor_id,
                                                              project_id,
                                                              ctxt=ctxt)
         self.assertRaises(exception.FlavorAccessExists,
-                          instance_types.add_instance_type_access,
+                          flavors.add_instance_type_access,
                           flavor_id, project_id, ctxt)
 
     def test_add_instance_type_access_invalid_flavor(self):
@@ -197,7 +197,7 @@ class InstanceTypeTestCase(test.TestCase):
         ctxt = context.RequestContext(user_id, project_id, is_admin=True)
         flavor_id = 'no_such_flavor'
         self.assertRaises(exception.FlavorNotFound,
-                          instance_types.add_instance_type_access,
+                          flavors.add_instance_type_access,
                           flavor_id, project_id, ctxt)
 
     def test_remove_instance_type_access(self):
@@ -205,13 +205,14 @@ class InstanceTypeTestCase(test.TestCase):
         project_id = 'fake'
         ctxt = context.RequestContext(user_id, project_id, is_admin=True)
         flavor_id = 'flavor1'
-        it = instance_types
-        type_ref = it.create('some flavor', 256, 1, 120, 100,
+        type_ref = flavors.create('some flavor', 256, 1, 120, 100,
                                           flavorid=flavor_id)
-        access_ref = it.add_instance_type_access(flavor_id, project_id, ctxt)
-        it.remove_instance_type_access(flavor_id, project_id, ctxt)
+        access_ref = flavors.add_instance_type_access(flavor_id, project_id,
+                                                      ctxt)
+        flavors.remove_instance_type_access(flavor_id, project_id, ctxt)
 
-        projects = it.get_instance_type_access_by_flavor_id(flavor_id, ctxt)
+        projects = flavors.get_instance_type_access_by_flavor_id(flavor_id,
+                                                                 ctxt)
         self.assertEqual([], projects)
 
     def test_remove_instance_type_access_doesnt_exists(self):
@@ -219,17 +220,17 @@ class InstanceTypeTestCase(test.TestCase):
         project_id = 'fake'
         ctxt = context.RequestContext(user_id, project_id, is_admin=True)
         flavor_id = 'flavor1'
-        type_ref = instance_types.create('some flavor', 256, 1, 120, 100,
+        type_ref = flavors.create('some flavor', 256, 1, 120, 100,
                                           flavorid=flavor_id)
         self.assertRaises(exception.FlavorAccessNotFound,
-                          instance_types.remove_instance_type_access,
+                          flavors.remove_instance_type_access,
                           flavor_id, project_id, ctxt=ctxt)
 
     def test_get_all_instance_types(self):
         # Ensures that all instance types can be retrieved.
         session = sql_session.get_session()
         total_instance_types = session.query(models.InstanceTypes).count()
-        inst_types = instance_types.get_all_types()
+        inst_types = flavors.get_all_types()
         self.assertEqual(total_instance_types, len(inst_types))
 
     def test_invalid_create_args_should_fail(self):
@@ -257,78 +258,78 @@ class InstanceTypeTestCase(test.TestCase):
 
         for (args, kwargs) in invalid_sigs:
             self.assertRaises(exception.InvalidInput,
-                              instance_types.create, *args, **kwargs)
+                              flavors.create, *args, **kwargs)
 
     def test_non_existent_inst_type_shouldnt_delete(self):
         # Ensures that instance type creation fails with invalid args.
         self.assertRaises(exception.InstanceTypeNotFoundByName,
-                          instance_types.destroy,
+                          flavors.destroy,
                           'unknown_flavor')
 
     def test_duplicate_names_fail(self):
         # Ensures that name duplicates raise InstanceTypeCreateFailed.
         name = 'some_name'
-        instance_types.create(name, 256, 1, 120, 200, 'flavor1')
+        flavors.create(name, 256, 1, 120, 200, 'flavor1')
         self.assertRaises(exception.InstanceTypeExists,
-                          instance_types.create,
+                          flavors.create,
                           name, 256, 1, 120, 200, 'flavor2')
 
     def test_duplicate_flavorids_fail(self):
         # Ensures that flavorid duplicates raise InstanceTypeCreateFailed.
         flavorid = 'flavor1'
-        instance_types.create('name one', 256, 1, 120, 200, flavorid)
+        flavors.create('name one', 256, 1, 120, 200, flavorid)
         self.assertRaises(exception.InstanceTypeIdExists,
-                          instance_types.create,
+                          flavors.create,
                           'name two', 256, 1, 120, 200, flavorid)
 
     def test_will_not_destroy_with_no_name(self):
         # Ensure destroy said path of no name raises error.
         self.assertRaises(exception.InstanceTypeNotFoundByName,
-                          instance_types.destroy, None)
+                          flavors.destroy, None)
 
     def test_will_not_get_bad_default_instance_type(self):
         # ensures error raised on bad default instance type.
         self.flags(default_instance_type='unknown_flavor')
         self.assertRaises(exception.InstanceTypeNotFound,
-                          instance_types.get_default_instance_type)
+                          flavors.get_default_instance_type)
 
     def test_will_get_instance_type_by_id(self):
-        default_instance_type = instance_types.get_default_instance_type()
+        default_instance_type = flavors.get_default_instance_type()
         instance_type_id = default_instance_type['id']
-        fetched = instance_types.get_instance_type(instance_type_id)
+        fetched = flavors.get_instance_type(instance_type_id)
         self.assertEqual(default_instance_type, fetched)
 
     def test_will_not_get_instance_type_by_unknown_id(self):
         # Ensure get by name returns default flavor with no name.
         self.assertRaises(exception.InstanceTypeNotFound,
-                         instance_types.get_instance_type, 10000)
+                         flavors.get_instance_type, 10000)
 
     def test_will_not_get_instance_type_with_bad_id(self):
         # Ensure get by name returns default flavor with bad name.
         self.assertRaises(exception.InstanceTypeNotFound,
-                          instance_types.get_instance_type, 'asdf')
+                          flavors.get_instance_type, 'asdf')
 
     def test_instance_type_get_by_None_name_returns_default(self):
         # Ensure get by name returns default flavor with no name.
-        default = instance_types.get_default_instance_type()
-        actual = instance_types.get_instance_type_by_name(None)
+        default = flavors.get_default_instance_type()
+        actual = flavors.get_instance_type_by_name(None)
         self.assertEqual(default, actual)
 
     def test_will_not_get_instance_type_with_bad_name(self):
         # Ensure get by name returns default flavor with bad name.
         self.assertRaises(exception.InstanceTypeNotFound,
-                          instance_types.get_instance_type_by_name, 10000)
+                          flavors.get_instance_type_by_name, 10000)
 
     def test_will_not_get_instance_by_unknown_flavor_id(self):
         # Ensure get by flavor raises error with wrong flavorid.
         self.assertRaises(exception.FlavorNotFound,
-                          instance_types.get_instance_type_by_flavor_id,
+                          flavors.get_instance_type_by_flavor_id,
                           'unknown_flavor')
 
     def test_will_get_instance_by_flavor_id(self):
-        default_instance_type = instance_types.get_default_instance_type()
+        default_instance_type = flavors.get_default_instance_type()
         flavorid = default_instance_type['flavorid']
-        fetched = instance_types.get_instance_type_by_flavor_id(flavorid)
+        fetched = flavors.get_instance_type_by_flavor_id(flavorid)
         self.assertEqual(default_instance_type, fetched)
 
     def test_can_read_deleted_types_using_flavor_id(self):
@@ -336,15 +337,15 @@ class InstanceTypeTestCase(test.TestCase):
         inst_type_name = "test"
         inst_type_flavor_id = "test1"
 
-        inst_type = instance_types.create(inst_type_name, 256, 1, 120, 100,
+        inst_type = flavors.create(inst_type_name, 256, 1, 120, 100,
                 inst_type_flavor_id)
         self.assertEqual(inst_type_name, inst_type["name"])
 
         # NOTE(jk0): The deleted flavor will show up here because the context
         # in get_instance_type_by_flavor_id() is set to use read_deleted by
         # default.
-        instance_types.destroy(inst_type["name"])
-        deleted_inst_type = instance_types.get_instance_type_by_flavor_id(
+        flavors.destroy(inst_type["name"])
+        deleted_inst_type = flavors.get_instance_type_by_flavor_id(
                 inst_type_flavor_id)
         self.assertEqual(inst_type_name, deleted_inst_type["name"])
 
@@ -354,11 +355,11 @@ class InstanceTypeTestCase(test.TestCase):
         example when creating a server and attempting to translate from
         flavorid to instance_type_id.
         """
-        instance_types.create("instance_type1", 256, 1, 120, 100, "test1")
-        instance_types.destroy("instance_type1")
-        instance_types.create("instance_type1_redo", 256, 1, 120, 100, "test1")
+        flavors.create("instance_type1", 256, 1, 120, 100, "test1")
+        flavors.destroy("instance_type1")
+        flavors.create("instance_type1_redo", 256, 1, 120, 100, "test1")
 
-        instance_type = instance_types.get_instance_type_by_flavor_id(
+        instance_type = flavors.get_instance_type_by_flavor_id(
                 "test1", read_deleted="no")
         self.assertEqual("instance_type1_redo", instance_type["name"])
 
@@ -368,15 +369,15 @@ class InstanceTypeToolsTest(test.TestCase):
         return [{'key': key, 'value': value} for key, value in data.items()]
 
     def _test_extract_instance_type(self, prefix):
-        instance_type = instance_types.get_default_instance_type()
+        instance_type = flavors.get_default_instance_type()
 
         metadata = {}
-        instance_types.save_instance_type_info(metadata, instance_type,
+        flavors.save_instance_type_info(metadata, instance_type,
                                                prefix)
         instance = {'system_metadata': self._dict_to_metadata(metadata)}
-        _instance_type = instance_types.extract_instance_type(instance, prefix)
+        _instance_type = flavors.extract_instance_type(instance, prefix)
 
-        props = instance_types.system_metadata_instance_type_props.keys()
+        props = flavors.system_metadata_instance_type_props.keys()
         for key in instance_type.keys():
             if key not in props:
                 del instance_type[key]
@@ -390,29 +391,29 @@ class InstanceTypeToolsTest(test.TestCase):
         self._test_extract_instance_type('foo_')
 
     def test_save_instance_type_info(self):
-        instance_type = instance_types.get_default_instance_type()
+        instance_type = flavors.get_default_instance_type()
 
         example = {}
         example_prefix = {}
 
-        for key in instance_types.system_metadata_instance_type_props.keys():
+        for key in flavors.system_metadata_instance_type_props.keys():
             example['instance_type_%s' % key] = instance_type[key]
             example_prefix['fooinstance_type_%s' % key] = instance_type[key]
 
         metadata = {}
-        instance_types.save_instance_type_info(metadata, instance_type)
+        flavors.save_instance_type_info(metadata, instance_type)
         self.assertEqual(example, metadata)
 
         metadata = {}
-        instance_types.save_instance_type_info(metadata, instance_type, 'foo')
+        flavors.save_instance_type_info(metadata, instance_type, 'foo')
         self.assertEqual(example_prefix, metadata)
 
     def test_delete_instance_type_info(self):
-        instance_type = instance_types.get_default_instance_type()
+        instance_type = flavors.get_default_instance_type()
         metadata = {}
-        instance_types.save_instance_type_info(metadata, instance_type)
-        instance_types.save_instance_type_info(metadata, instance_type, '_')
-        instance_types.delete_instance_type_info(metadata, '', '_')
+        flavors.save_instance_type_info(metadata, instance_type)
+        flavors.save_instance_type_info(metadata, instance_type, '_')
+        flavors.delete_instance_type_info(metadata, '', '_')
         self.assertEqual(metadata, {})
 
 
diff --git a/nova/tests/test_libvirt.py b/nova/tests/test_libvirt.py
index a955d2f38..35b65d764 100644
--- a/nova/tests/test_libvirt.py
+++ b/nova/tests/test_libvirt.py
@@ -31,7 +31,7 @@ from oslo.config import cfg
 from xml.dom import minidom
 
 from nova.api.ec2 import cloud
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova.compute import power_state
 from nova.compute import task_states
 from nova.compute import vm_mode
@@ -320,7 +320,7 @@ class LibvirtConnTestCase(test.TestCase):
                        lambda *a, **k: self.conn)
 
         instance_type = db.instance_type_get(self.context, 5)
-        sys_meta = instance_types.save_instance_type_info({}, instance_type)
+        sys_meta = flavors.save_instance_type_info({}, instance_type)
 
         nova.tests.image.fake.stub_out_image_service(self.stubs)
         self.test_instance = {
@@ -2557,7 +2557,7 @@ class LibvirtConnTestCase(test.TestCase):
         instance_ref['image_ref'] = 123456  # we send an int to test sha1 call
         instance_type = db.instance_type_get(self.context,
                                              instance_ref['instance_type_id'])
-        sys_meta = instance_types.save_instance_type_info({}, instance_type)
+        sys_meta = flavors.save_instance_type_info({}, instance_type)
         instance_ref['system_metadata'] = sys_meta
         instance = db.instance_create(self.context, instance_ref)
 
@@ -4724,8 +4724,8 @@ class LibvirtDriverTestCase(test.TestCase):
         if not params:
             params = {}
 
-        sys_meta = instance_types.save_instance_type_info(
-            {}, instance_types.get_instance_type_by_name('m1.tiny'))
+        sys_meta = flavors.save_instance_type_info(
+            {}, flavors.get_instance_type_by_name('m1.tiny'))
 
         inst = {}
         inst['image_ref'] = '1'
@@ -4733,7 +4733,7 @@ class LibvirtDriverTestCase(test.TestCase):
         inst['launch_time'] = '10'
         inst['user_id'] = 'fake'
         inst['project_id'] = 'fake'
-        type_id = instance_types.get_instance_type_by_name('m1.tiny')['id']
+        type_id = flavors.get_instance_type_by_name('m1.tiny')['id']
         inst['instance_type_id'] = type_id
         inst['ami_launch_index'] = 0
         inst['host'] = 'host1'
diff --git a/nova/tests/test_libvirt_blockinfo.py b/nova/tests/test_libvirt_blockinfo.py
index eef2deb50..aae5bec58 100644
--- a/nova/tests/test_libvirt_blockinfo.py
+++ b/nova/tests/test_libvirt_blockinfo.py
@@ -16,7 +16,7 @@
 #    under the License.
 
 from nova import block_device
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova import context
 from nova import db
 from nova import exception
@@ -34,7 +34,7 @@ class LibvirtBlockInfoTest(test.TestCase):
         self.project_id = 'fake'
         self.context = context.get_admin_context()
         instance_type = db.instance_type_get(self.context, 2)
-        sys_meta = instance_types.save_instance_type_info({}, instance_type)
+        sys_meta = flavors.save_instance_type_info({}, instance_type)
         nova.tests.image.fake.stub_out_image_service(self.stubs)
         self.test_instance = {
                 'uuid': '32dfcb37-5af1-552b-357c-be8c3aa38310',
diff --git a/nova/tests/test_metadata.py b/nova/tests/test_metadata.py
index 01f274f7c..86d618930 100644
--- a/nova/tests/test_metadata.py
+++ b/nova/tests/test_metadata.py
@@ -37,7 +37,7 @@ from nova.api.metadata import base
 from nova.api.metadata import handler
 from nova.api.metadata import password
 from nova import block_device
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova.conductor import api as conductor_api
 from nova import db
 from nova.db.sqlalchemy import api
@@ -77,8 +77,8 @@ INSTANCES = (
 
 def get_default_sys_meta():
     return utils.dict_to_metadata(
-        instance_types.save_instance_type_info(
-            {}, instance_types.get_default_instance_type()))
+        flavors.save_instance_type_info(
+            {}, flavors.get_default_instance_type()))
 
 
 def return_non_existing_address(*args, **kwarg):
diff --git a/nova/tests/test_notifications.py b/nova/tests/test_notifications.py
index 68ef540b1..0d2108557 100644
--- a/nova/tests/test_notifications.py
+++ b/nova/tests/test_notifications.py
@@ -21,7 +21,7 @@ import copy
 
 from oslo.config import cfg
 
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova.compute import task_states
 from nova.compute import vm_states
 from nova import context
@@ -69,8 +69,8 @@ class NotificationsTestCase(test.TestCase):
         self.instance = self._wrapped_create()
 
     def _wrapped_create(self, params=None):
-        instance_type = instance_types.get_instance_type_by_name('m1.tiny')
-        sys_meta = instance_types.save_instance_type_info({}, instance_type)
+        instance_type = flavors.get_instance_type_by_name('m1.tiny')
+        sys_meta = flavors.save_instance_type_info({}, instance_type)
         inst = {}
         inst['image_ref'] = 1
         inst['user_id'] = self.user_id
diff --git a/nova/tests/test_powervm.py b/nova/tests/test_powervm.py
index 73299f23a..2a2a072b7 100644
--- a/nova/tests/test_powervm.py
+++ b/nova/tests/test_powervm.py
@@ -24,7 +24,7 @@ from nova import context
 from nova import db
 from nova import test
 
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova.compute import power_state
 from nova.compute import task_states
 from nova.network import model as network_model
@@ -180,7 +180,7 @@ class PowerVMDriverTestCase(test.TestCase):
         fake.stub_out_image_service(self.stubs)
         ctxt = context.get_admin_context()
         instance_type = db.instance_type_get(ctxt, 1)
-        sys_meta = instance_types.save_instance_type_info({}, instance_type)
+        sys_meta = flavors.save_instance_type_info({}, instance_type)
         return db.instance_create(ctxt,
                         {'user_id': 'fake',
                         'project_id': 'fake',
diff --git a/nova/tests/test_quota.py b/nova/tests/test_quota.py
index 1f422748b..b585aede5 100644
--- a/nova/tests/test_quota.py
+++ b/nova/tests/test_quota.py
@@ -21,7 +21,7 @@ import datetime
 from oslo.config import cfg
 
 from nova import compute
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova import context
 from nova import db
 from nova.db.sqlalchemy import api as sqa_api
@@ -95,7 +95,7 @@ class QuotaIntegrationTestCase(test.TestCase):
         for i in range(CONF.quota_instances):
             instance = self._create_instance()
             instance_uuids.append(instance['uuid'])
-        inst_type = instance_types.get_instance_type_by_name('m1.small')
+        inst_type = flavors.get_instance_type_by_name('m1.small')
         image_uuid = 'cedef40a-ed67-4d10-800e-17455edce175'
         self.assertRaises(exception.QuotaError, compute.API().create,
                                             self.context,
@@ -108,7 +108,7 @@ class QuotaIntegrationTestCase(test.TestCase):
 
     def test_too_many_cores(self):
         instance = self._create_instance(cores=4)
-        inst_type = instance_types.get_instance_type_by_name('m1.small')
+        inst_type = flavors.get_instance_type_by_name('m1.small')
         image_uuid = 'cedef40a-ed67-4d10-800e-17455edce175'
         self.assertRaises(exception.QuotaError, compute.API().create,
                                             self.context,
@@ -146,7 +146,7 @@ class QuotaIntegrationTestCase(test.TestCase):
         metadata = {}
         for i in range(CONF.quota_metadata_items + 1):
             metadata['key%s' % i] = 'value%s' % i
-        inst_type = instance_types.get_instance_type_by_name('m1.small')
+        inst_type = flavors.get_instance_type_by_name('m1.small')
         image_uuid = 'cedef40a-ed67-4d10-800e-17455edce175'
         self.assertRaises(exception.QuotaError, compute.API().create,
                                             self.context,
@@ -158,7 +158,7 @@ class QuotaIntegrationTestCase(test.TestCase):
 
     def _create_with_injected_files(self, files):
         api = compute.API()
-        inst_type = instance_types.get_instance_type_by_name('m1.small')
+        inst_type = flavors.get_instance_type_by_name('m1.small')
         image_uuid = 'cedef40a-ed67-4d10-800e-17455edce175'
         api.create(self.context, min_count=1, max_count=1,
                 instance_type=inst_type, image_href=image_uuid,
@@ -166,7 +166,7 @@ class QuotaIntegrationTestCase(test.TestCase):
 
     def test_no_injected_files(self):
         api = compute.API()
-        inst_type = instance_types.get_instance_type_by_name('m1.small')
+        inst_type = flavors.get_instance_type_by_name('m1.small')
         image_uuid = 'cedef40a-ed67-4d10-800e-17455edce175'
         api.create(self.context,
                    instance_type=inst_type,
diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index 3490a5dbf..091bf4722 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -26,7 +26,7 @@ import re
 from oslo.config import cfg
 
 from nova.compute import api as compute_api
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova.compute import power_state
 from nova.compute import task_states
 from nova.compute import vm_states
@@ -179,7 +179,7 @@ def stub_vm_utils_with_vdi_attached_here(function, should_return=True):
 def create_instance_with_system_metadata(context, instance_values):
     instance_type = db.instance_type_get(context,
                                          instance_values['instance_type_id'])
-    sys_meta = instance_types.save_instance_type_info({},
+    sys_meta = flavors.save_instance_type_info({},
                                                       instance_type)
     instance_values['system_metadata'] = sys_meta
     return db.instance_create(context, instance_values)
@@ -1188,7 +1188,7 @@ class XenAPIVMTestCase(stubs.XenAPITestBase):
 
     def test_per_instance_usage_running(self):
         instance = self._create_instance(spawn=True)
-        instance_type = instance_types.get_instance_type(3)
+        instance_type = flavors.get_instance_type(3)
 
         expected = {instance['uuid']: {'memory_mb': instance_type['memory_mb'],
                                        'uuid': instance['uuid']}}
@@ -1461,7 +1461,7 @@ class XenAPIMigrateInstance(stubs.XenAPITestBase):
         self.assertEqual(self.fake_vm_start_called, True)
 
     def test_finish_migrate_no_local_storage(self):
-        tiny_type = instance_types.get_instance_type_by_name('m1.tiny')
+        tiny_type = flavors.get_instance_type_by_name('m1.tiny')
         tiny_type_id = tiny_type['id']
         self.instance_values.update({'instance_type_id': tiny_type_id,
                                      'root_gb': 0})
diff --git a/nova/tests/utils.py b/nova/tests/utils.py
index e9248c7b7..3d429aada 100644
--- a/nova/tests/utils.py
+++ b/nova/tests/utils.py
@@ -18,7 +18,7 @@ import platform
 
 from oslo.config import cfg
 
-from nova.compute import instance_types
+from nova.compute import flavors
 import nova.context
 import nova.db
 from nova import exception
@@ -72,7 +72,7 @@ def get_test_instance(context=None, instance_type=None):
         instance_type = get_test_instance_type(context)
 
     metadata = {}
-    instance_types.save_instance_type_info(metadata, instance_type, '')
+    flavors.save_instance_type_info(metadata, instance_type, '')
 
     test_instance = {'memory_kb': '2048000',
                      'basepath': '/some/path',
diff --git a/nova/virt/baremetal/pxe.py b/nova/virt/baremetal/pxe.py
index 795099ebc..4c63f2b07 100644
--- a/nova/virt/baremetal/pxe.py
+++ b/nova/virt/baremetal/pxe.py
@@ -25,7 +25,7 @@ import os
 
 from oslo.config import cfg
 
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova import exception
 from nova.openstack.common.db import exception as db_exc
 from nova.openstack.common import fileutils
@@ -174,7 +174,7 @@ def get_pxe_config_file_path(instance):
 
 
 def get_partition_sizes(instance):
-    instance_type = instance_types.extract_instance_type(instance)
+    instance_type = flavors.extract_instance_type(instance)
     root_mb = instance_type['root_gb'] * 1024
     swap_mb = instance_type['swap']
 
diff --git a/nova/virt/baremetal/tilera.py b/nova/virt/baremetal/tilera.py
index c926817cd..d9a065bf1 100755
--- a/nova/virt/baremetal/tilera.py
+++ b/nova/virt/baremetal/tilera.py
@@ -24,7 +24,7 @@ import os
 
 from oslo.config import cfg
 
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova import exception
 from nova.openstack.common.db import exception as db_exc
 from nova.openstack.common import fileutils
@@ -117,7 +117,7 @@ def get_tilera_nfs_path(node_id):
 
 
 def get_partition_sizes(instance):
-    instance_type = instance_types.extract_instance_type(instance)
+    instance_type = flavors.extract_instance_type(instance)
     root_mb = instance_type['root_gb'] * 1024
     swap_mb = instance_type['swap']
 
diff --git a/nova/virt/hyperv/imagecache.py b/nova/virt/hyperv/imagecache.py
index 5d68bab61..2e28dc9db 100644
--- a/nova/virt/hyperv/imagecache.py
+++ b/nova/virt/hyperv/imagecache.py
@@ -19,7 +19,7 @@ Image caching and management.
 """
 import os
 
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova.openstack.common import excutils
 from nova.openstack.common import lockutils
 from nova.openstack.common import log as logging
@@ -51,7 +51,7 @@ class ImageCache(object):
     def _get_root_vhd_size_gb(self, instance):
         try:
             # In case of resizes we need the old root disk size
-            old_instance_type = instance_types.extract_instance_type(
+            old_instance_type = flavors.extract_instance_type(
                 instance, prefix='old_')
             return old_instance_type['root_gb']
         except KeyError:
diff --git a/nova/virt/libvirt/blockinfo.py b/nova/virt/libvirt/blockinfo.py
index 8f1e72ab0..39b6292b1 100644
--- a/nova/virt/libvirt/blockinfo.py
+++ b/nova/virt/libvirt/blockinfo.py
@@ -68,7 +68,7 @@ variables / types used
 from oslo.config import cfg
 
 from nova import block_device
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova import exception
 from nova.virt import configdrive
 from nova.virt import driver
@@ -300,7 +300,7 @@ def get_disk_mapping(virt_type, instance,
 
        Returns the guest disk mapping for the devices."""
 
-    inst_type = instance_types.extract_instance_type(instance)
+    inst_type = flavors.extract_instance_type(instance)
 
     mapping = {}
 
diff --git a/nova/virt/libvirt/driver.py b/nova/virt/libvirt/driver.py
index a0d2d0a7b..5571e8810 100755
--- a/nova/virt/libvirt/driver.py
+++ b/nova/virt/libvirt/driver.py
@@ -63,7 +63,7 @@ from xml.dom import minidom
 
 from nova.api.metadata import base as instance_metadata
 from nova import block_device
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova.compute import power_state
 from nova.compute import task_states
 from nova.compute import vm_mode
@@ -1788,7 +1788,7 @@ class LibvirtDriver(driver.ComputeDriver):
                                      user_id=instance['user_id'],
                                      project_id=instance['project_id'])
 
-        inst_type = instance_types.extract_instance_type(instance)
+        inst_type = flavors.extract_instance_type(instance)
 
         # NOTE(ndipanov): Even if disk_mapping was passed in, which
         # currently happens only on rescue - we still don't want to
diff --git a/nova/virt/powervm/blockdev.py b/nova/virt/powervm/blockdev.py
index 657e96f06..7c67c03c1 100644
--- a/nova/virt/powervm/blockdev.py
+++ b/nova/virt/powervm/blockdev.py
@@ -20,7 +20,7 @@ import re
 
 from oslo.config import cfg
 
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova.compute import task_states
 from nova.image import glance
 from nova.openstack.common import excutils
@@ -175,7 +175,7 @@ class PowerVMLocalVolumeAdapter(PowerVMDiskAdapter):
 
         # calculate root device size in bytes
         # we respect the minimum root device size in constants
-        instance_type = instance_types.extract_instance_type(instance)
+        instance_type = flavors.extract_instance_type(instance)
         size_gb = max(instance_type['root_gb'], constants.POWERVM_MIN_ROOT_GB)
         size = size_gb * 1024 * 1024 * 1024
 
diff --git a/nova/virt/powervm/driver.py b/nova/virt/powervm/driver.py
index 603ee0b61..199b10704 100755
--- a/nova/virt/powervm/driver.py
+++ b/nova/virt/powervm/driver.py
@@ -19,7 +19,7 @@ import time
 
 from oslo.config import cfg
 
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova.image import glance
 from nova.openstack.common import log as logging
 from nova.virt import driver
@@ -290,7 +290,7 @@ class PowerVMDriver(driver.ComputeDriver):
         """
         lpar_obj = self._powervm._create_lpar_instance(instance, network_info)
 
-        instance_type = instance_types.extract_instance_type(instance)
+        instance_type = flavors.extract_instance_type(instance)
         new_lv_size = instance_type['root_gb']
         old_lv_size = disk_info['old_lv_size']
         if 'root_disk_file' in disk_info:
diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py
index 904f12e30..fb25ccbf4 100644
--- a/nova/virt/xenapi/vm_utils.py
+++ b/nova/virt/xenapi/vm_utils.py
@@ -37,7 +37,7 @@ from oslo.config import cfg
 
 from nova.api.metadata import base as instance_metadata
 from nova import block_device
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova.compute import power_state
 from nova.compute import task_states
 from nova import exception
@@ -210,7 +210,7 @@ def create_vm(session, instance, name_label, kernel, ramdisk,
 
         3. Using hardware virtualization
     """
-    instance_type = instance_types.extract_instance_type(instance)
+    instance_type = flavors.extract_instance_type(instance)
     mem = str(long(instance_type['memory_mb']) * 1024 * 1024)
     vcpus = str(instance_type['vcpus'])
 
@@ -323,7 +323,7 @@ def _is_vm_shutdown(session, vm_ref):
 
 
 def ensure_free_mem(session, instance):
-    instance_type = instance_types.extract_instance_type(instance)
+    instance_type = flavors.extract_instance_type(instance)
     mem = long(instance_type['memory_mb']) * 1024 * 1024
     host = session.get_xenapi_host()
     host_free_mem = long(session.call_xenapi("host.compute_free_memory",
@@ -777,7 +777,7 @@ def resize_disk(session, instance, vdi_ref, instance_type):
 
 def auto_configure_disk(session, vdi_ref, new_gb):
     """Partition and resize FS to match the size specified by
-    instance_types.root_gb.
+    flavors.root_gb.
 
     This is a fail-safe to prevent accidentally destroying data on a disk
     erroneously marked as auto_disk_config=True.
@@ -1177,7 +1177,7 @@ def _check_vdi_size(context, session, instance, vdi_uuid):
 
     # FIXME(jk0): this was copied directly from compute.manager.py, let's
     # refactor this to a common area
-    instance_type = instance_types.extract_instance_type(instance)
+    instance_type = flavors.extract_instance_type(instance)
     allowed_size_gb = instance_type['root_gb']
     allowed_size_bytes = allowed_size_gb * 1024 * 1024 * 1024
 
diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py
index e7dd3cff0..72a156cb6 100644
--- a/nova/virt/xenapi/vmops.py
+++ b/nova/virt/xenapi/vmops.py
@@ -29,7 +29,7 @@ from oslo.config import cfg
 
 from nova import block_device
 from nova.compute import api as compute
-from nova.compute import instance_types
+from nova.compute import flavors
 from nova.compute import power_state
 from nova.compute import task_states
 from nova.compute import vm_mode
@@ -564,7 +564,7 @@ class VMOps(object):
     def _attach_disks(self, instance, vm_ref, name_label, vdis,
                       disk_image_type, admin_password=None, files=None):
         ctx = nova_context.get_admin_context()
-        instance_type = instance_types.extract_instance_type(instance)
+        instance_type = flavors.extract_instance_type(instance)
 
         # Attach (required) root disk
         if disk_image_type == vm_utils.ImageType.DISK_ISO:
@@ -689,7 +689,7 @@ class VMOps(object):
             agent.resetnetwork()
 
         # Set VCPU weight
-        instance_type = instance_types.extract_instance_type(instance)
+        instance_type = flavors.extract_instance_type(instance)
         vcpu_weight = instance_type['vcpu_weight']
         if vcpu_weight is not None:
             LOG.debug(_("Setting VCPU weight"), instance=instance)