Rename: intance_type_metadata -> instance_type_extra_specs

6 files changed, 88 insertions, 87 deletions

diff --git a/nova/db/api.py b/nova/db/api.py
index 5ade51f02..a1a434d3d 100644
--- a/nova/db/api.py
+++ b/nova/db/api.py
@@ -1251,19 +1251,19 @@ def instance_metadata_update_or_create(context, instance_id, metadata):
 ####################
 
 
-def instance_type_metadata_get(context, instance_type_id):
-    """Get all metadata for an instance type."""
-    return IMPL.instance_type_metadata_get(context, instance_type_id)
+def instance_type_extra_specs_get(context, instance_type_id):
+    """Get all extra specs for an instance type."""
+    return IMPL.instance_type_extra_specs_get(context, instance_type_id)
 
 
-def instance_type_metadata_delete(context, instance_type_id, key):
-    """Delete the given metadata item."""
-    IMPL.instance_type_metadata_delete(context, instance_type_id, key)
+def instance_type_extra_specs_delete(context, instance_type_id, key):
+    """Delete the given extra specs item."""
+    IMPL.instance_type_extra_specs_delete(context, instance_type_id, key)
 
 
-def instance_type_metadata_update_or_create(context, instance_type_id,
-                                            metadata):
-    """Create or update instance type metadata. This adds or modifies the
-    key/value pairs specified in the metadata dict argument"""
-    IMPL.instance_type_metadata_update_or_create(context, instance_type_id,
-                                                 metadata)
+def instance_type_extra_specs_update_or_create(context, instance_type_id,
+                                               extra_specs):
+    """Create or update instance type extra specs. This adds or modifies the
+    key/value pairs specified in the extra specs dict argument"""
+    IMPL.instance_type_extra_specs_update_or_create(context, instance_type_id,
+                                                    extra_specs)
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 0c7f31366..e586bbc64 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -2456,22 +2456,22 @@ def console_get(context, console_id, instance_id=None):
 
 @require_admin_context
 def instance_type_create(_context, values):
-    """Create a new instance type. In order to pass in metadata,
-    the values dict should contain a 'meta' key/value pair:
+    """Create a new instance type. In order to pass in extra specs,
+    the values dict should contain a 'extra_specs' key/value pair:
 
-    {'meta' : {'k1': 'v1', 'k2': 'v2', ...}}
+    {'extra_specs' : {'k1': 'v1', 'k2': 'v2', ...}}
 
     """
     try:
-        metadata = values.get('meta')
-        metadata_refs = []
-        if metadata:
-            for k, v in metadata.iteritems():
-                metadata_ref = models.InstanceTypeMetadata()
-                metadata_ref['key'] = k
-                metadata_ref['value'] = v
-                metadata_refs.append(metadata_ref)
-        values['meta'] = metadata_refs
+        specs = values.get('extra_specs')
+        specs_refs = []
+        if specs:
+            for k, v in specs.iteritems():
+                specs_ref = models.InstanceTypeExtraSpecs()
+                specs_ref['key'] = k
+                specs_ref['value'] = v
+                specs_refs.append(specs_ref)
+        values['extra_specs'] = specs_refs
         instance_type_ref = models.InstanceTypes()
         instance_type_ref.update(values)
         instance_type_ref.save()
@@ -2697,24 +2697,24 @@ def instance_metadata_update_or_create(context, instance_id, metadata):
 
 
 @require_context
-def instance_type_metadata_get(context, instance_type_id):
+def instance_type_extra_specs_get(context, instance_type_id):
     session = get_session()
 
-    meta_results = session.query(models.InstanceTypeMetadata).\
+    spec_results = session.query(models.InstanceTypeExtraSpecs).\
                     filter_by(instance_type_id=instance_type_id).\
                     filter_by(deleted=False).\
                     all()
 
-    meta_dict = {}
-    for i in meta_results:
-        meta_dict[i['key']] = i['value']
-    return meta_dict
+    spec_dict = {}
+    for i in spec_results:
+        spec_dict[i['key']] = i['value']
+    return spec_dict
 
 
 @require_context
-def instance_type_metadata_delete(context, instance_type_id, key):
+def instance_type_extra_specs_delete(context, instance_type_id, key):
     session = get_session()
-    session.query(models.InstanceTypeMetadata).\
+    session.query(models.InstanceTypeExtraSpecs).\
         filter_by(instance_type_id=instance_type_id).\
         filter_by(key=key).\
         filter_by(deleted=False).\
@@ -2724,36 +2724,37 @@ def instance_type_metadata_delete(context, instance_type_id, key):
 
 
 @require_context
-def instance_type_metadata_get_item(context, instance_type_id, key):
+def instance_type_extra_specs_get_item(context, instance_type_id, key):
     session = get_session()
 
-    meta_result = session.query(models.InstanceMetadata).\
+    sppec_result = session.query(models.InstanceTypeExtraSpecs).\
                     filter_by(instance_type_id=instance_type_id).\
                     filter_by(key=key).\
                     filter_by(deleted=False).\
                     first()
 
-    if not meta_result:
+    if not spec_result:
         raise exception.\
-           InstanceTypeMetadataNotFound(metadata_key=key,
+           InstanceTypeExtraSpecsNotFound(extra_specs_key=key,
                                         instance_type_id=instance_type_id)
-    return meta_result
+    return spec_result
 
 
 @require_context
-def instance_type_metadata_update_or_create(context, instance_type_id,
-                                            metadata):
+def instance_type_extra_specs_update_or_create(context, instance_type_id,
+                                               specs):
     session = get_session()
-    meta_ref = None
-    for key, value in metadata.iteritems():
+    spec_ref = None
+    for key, value in specs.iteritems():
         try:
-            meta_ref = instance_type_metadata_get_item(context,
-                                                       instance_type_id, key,
-                                                       session)
+            spec_ref = instance_type_extra_specs_get_item(context,
+                                                          instance_type_id,
+                                                          key,
+                                                          session)
         except:
-            meta_ref = models.InstanceTypeMetadata()
-        meta_ref.update({"key": key, "value": value,
-                            "instance_type_id": instance_type_id,
-                            "deleted": 0})
-        meta_ref.save(session=session)
-    return metadata
+            spec_ref = models.InstanceTypeExtraSpecs()
+        spec_ref.update({"key": key, "value": value,
+                         "instance_type_id": instance_type_id,
+                         "deleted": 0})
+        spec_ref.save(session=session)
+    return specs
diff --git a/nova/db/sqlalchemy/migrate_repo/versions/021_add_instance_type_metadata.py b/nova/db/sqlalchemy/migrate_repo/versions/021_add_instance_type_extra_specs.py
index 22b741614..f26ad6d2c 100644
--- a/nova/db/sqlalchemy/migrate_repo/versions/021_add_instance_type_metadata.py
+++ b/nova/db/sqlalchemy/migrate_repo/versions/021_add_instance_type_extra_specs.py
@@ -30,7 +30,7 @@ instance_types = Table('instance_types', meta,
 # New Tables
 #
 
-instance_type_metadata_table = Table('instance_type_metadata', meta,
+instance_type_extra_specs_table = Table('instance_type_extra_specs', meta,
         Column('created_at', DateTime(timezone=False)),
         Column('updated_at', DateTime(timezone=False)),
         Column('deleted_at', DateTime(timezone=False)),
@@ -52,7 +52,7 @@ def upgrade(migrate_engine):
     # Upgrade operations go here. Don't create your own engine;
     # bind migrate_engine to your metadata
     meta.bind = migrate_engine
-    for table in (instance_type_metadata_table, ):
+    for table in (instance_type_extra_specs_table, ):
         try:
             table.create()
         except Exception:
@@ -63,5 +63,5 @@ def upgrade(migrate_engine):
 
 def downgrade(migrate_engine):
     # Operations to reverse the above upgrade go here.
-    for table in (instance_type_metadata_table, ):
+    for table in (instance_type_extra_specs_table, ):
         table.drop()
diff --git a/nova/db/sqlalchemy/models.py b/nova/db/sqlalchemy/models.py
index dbe448ef8..d4c217450 100644
--- a/nova/db/sqlalchemy/models.py
+++ b/nova/db/sqlalchemy/models.py
@@ -663,19 +663,19 @@ class InstanceMetadata(BASE, NovaBase):
                                 'InstanceMetadata.deleted == False)')
 
 
-class InstanceTypeMetadata(BASE, NovaBase):
-    """Represents a metadata key/value pair for an instance_type"""
-    __tablename__ = 'instance_type_metadata'
+class InstanceTypeExtraSpecs(BASE, NovaBase):
+    """Represents additional specs as key/value pairs for an instance_type"""
+    __tablename__ = 'instance_type_extra_specs'
     id = Column(Integer, primary_key=True)
     key = Column(String(255))
     value = Column(String(255))
     instance_type_id = Column(Integer, ForeignKey('instance_types.id'),
                               nullable=False)
-    instance_type = relationship(InstanceTypes, backref="meta",
+    instance_type = relationship(InstanceTypes, backref="extra_specs",
                  foreign_keys=instance_type_id,
                  primaryjoin='and_('
-                 'InstanceTypeMetadata.instance_type_id == InstanceTypes.id,'
-                 'InstanceTypeMetadata.deleted == False)')
+                 'InstanceTypeExtraSpecs.instance_type_id == InstanceTypes.id,'
+                 'InstanceTypeExtraSpecs.deleted == False)')
 
 
 class Zone(BASE, NovaBase):
diff --git a/nova/exception.py b/nova/exception.py
index ce287b7d6..394004fe6 100644
--- a/nova/exception.py
+++ b/nova/exception.py
@@ -482,9 +482,9 @@ class InstanceMetadataNotFound(NotFound):
                 "key %(metadata_key)s.")
 
 
-class InstanceTypeMetadataNotFound(NotFound):
-    message = _("Instance Type %(instance_type_id)s has no metadata with "
-                "key %(metadata_key)s.")
+class InstanceTypeExtraSpecsNotFound(NotFound):
+    message = _("Instance Type %(instance_type_id)s has no extra specs with "
+                "key %(extra_specs_key)s.")
 
 
 class LDAPObjectNotFound(NotFound):
diff --git a/nova/tests/test_instance_types_metadata.py b/nova/tests/test_instance_types_extra_specs.py
index 1c4185888..e739225fc 100644
--- a/nova/tests/test_instance_types_metadata.py
+++ b/nova/tests/test_instance_types_extra_specs.py
@@ -13,7 +13,7 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 """
-Unit Tests for instance types metadata code
+Unit Tests for instance types extra specs code
 """
 
 from nova import context
@@ -23,22 +23,22 @@ from nova.db.sqlalchemy.session import get_session
 from nova.db.sqlalchemy import models
 
 
-class InstanceTypeMetadataTestCase(test.TestCase):
+class InstanceTypeExtraSpecsTestCase(test.TestCase):
 
     def setUp(self):
-        super(InstanceTypeMetadataTestCase, self).setUp()
+        super(InstanceTypeExtraSpecsTestCase, self).setUp()
         self.context = context.get_admin_context()
         values = dict(name="cg1.4xlarge",
                       memory_mb=22000,
                       vcpus=8,
                       local_gb=1690,
                       flavorid=105)
-        metadata = dict(cpu_arch="x86_64",
+        specs = dict(cpu_arch="x86_64",
                         cpu_model="Nehalem",
                         xpu_arch="fermi",
                         xpus=2,
                         xpu_model="Tesla 2050")
-        values['meta'] = metadata
+        values['extra_specs'] = specs
         ref = db.api.instance_type_create(self.context,
                                           values)
         self.instance_type_id = ref.id
@@ -46,61 +46,61 @@ class InstanceTypeMetadataTestCase(test.TestCase):
     def tearDown(self):
         # Remove the instance type from the database
         db.api.instance_type_purge(context.get_admin_context(), "cg1.4xlarge")
-        super(InstanceTypeMetadataTestCase, self).tearDown()
+        super(InstanceTypeExtraSpecsTestCase, self).tearDown()
 
-    def test_instance_type_metadata_get(self):
-        expected_metadata = dict(cpu_arch="x86_64",
+    def test_instance_type_specs_get(self):
+        expected_specs = dict(cpu_arch="x86_64",
                                  cpu_model="Nehalem",
                                  xpu_arch="fermi",
                                  xpus="2",
                                  xpu_model="Tesla 2050")
-        actual_metadata = db.api.instance_type_metadata_get(
+        actual_specs = db.api.instance_type_extra_specs_get(
                               context.get_admin_context(),
                               self.instance_type_id)
-        self.assertEquals(expected_metadata, actual_metadata)
+        self.assertEquals(expected_specs, actual_specs)
 
-    def test_instance_type_metadata_delete(self):
-        expected_metadata = dict(cpu_arch="x86_64",
+    def test_instance_type_extra_specs_delete(self):
+        expected_specs = dict(cpu_arch="x86_64",
                                  cpu_model="Nehalem",
                                  xpu_arch="fermi",
                                  xpus="2")
-        db.api.instance_type_metadata_delete(context.get_admin_context(),
+        db.api.instance_type_extra_specs_delete(context.get_admin_context(),
                                       self.instance_type_id,
                                       "xpu_model")
-        actual_metadata = db.api.instance_type_metadata_get(
+        actual_specs = db.api.instance_type_extra_specs_get(
                               context.get_admin_context(),
                               self.instance_type_id)
-        self.assertEquals(expected_metadata, actual_metadata)
+        self.assertEquals(expected_specs, actual_specs)
 
-    def test_instance_type_metadata_update(self):
-        expected_metadata = dict(cpu_arch="x86_64",
+    def test_instance_type_extra_specs_update(self):
+        expected_specs = dict(cpu_arch="x86_64",
                                  cpu_model="Sandy Bridge",
                                  xpu_arch="fermi",
                                  xpus="2",
                                  xpu_model="Tesla 2050")
-        db.api.instance_type_metadata_update_or_create(
+        db.api.instance_type_extra_specs_update_or_create(
                               context.get_admin_context(),
                               self.instance_type_id,
                               dict(cpu_model="Sandy Bridge"))
-        actual_metadata = db.api.instance_type_metadata_get(
+        actual_specs = db.api.instance_type_extra_specs_get(
                               context.get_admin_context(),
                               self.instance_type_id)
-        self.assertEquals(expected_metadata, actual_metadata)
+        self.assertEquals(expected_specs, actual_specs)
 
-    def test_instance_type_metadata_create(self):
-        expected_metadata = dict(cpu_arch="x86_64",
+    def test_instance_type_extra_specs_create(self):
+        expected_specs = dict(cpu_arch="x86_64",
                                  cpu_model="Nehalem",
                                  xpu_arch="fermi",
                                  xpus="2",
                                  xpu_model="Tesla 2050",
                                  net_arch="ethernet",
                                  net_mbps="10000")
-        db.api.instance_type_metadata_update_or_create(
+        db.api.instance_type_extra_specs_update_or_create(
                               context.get_admin_context(),
                               self.instance_type_id,
                               dict(net_arch="ethernet",
                                    net_mbps=10000))
-        actual_metadata = db.api.instance_type_metadata_get(
+        actual_specs = db.api.instance_type_extra_specs_get(
                               context.get_admin_context(),
                               self.instance_type_id)
-        self.assertEquals(expected_metadata, actual_metadata)
+        self.assertEquals(expected_specs, actual_specs)