Merge lp:~vladimir.p/nova/volume_type_extradata into lp:~hudson-openstack/nova/trunk

[Vladimir Popovski]

Added volume metadata / volume types / volume types extra_specs

[lp:~vladimir.p/nova/volume_type_extradata]

1466. By Vladimir Popovski on 2011-08-24

added Openstack APIs for volume types & extradata

1467. By Vladimir Popovski on 2011-08-24

forgot to add new extension to test_extensions

[Vish Ishaya (vishvananda)]

very nice. Tests look good. Unfortunately this needs to merge with milestone-proposed, so it could use a backport. That could be a little challenging because you merged with trunk along the way. Generally what i do is

bzr merge ../trunk
bzr commit
bzr diff old=../

bzr branch trunk -r 1479 new-branch # this is where we branched milestone

cd new-branch
bzr diff old=../trunk ../volume_type_extradata | patch -p0
bzr commit
bzr push --overwrite lp:~vladimir.p/nova/volume_type_extradata

That should have all your changes in one commit based of of 1479. That way we can apply it to both trunk and milestone cleanly.

Aside from that looks great.

review: Needs Fixing

[Vish Ishaya (vishvananda)]

Just realized that this has an FFE, so it doesn't need to be rebased to get into D4, it can go in after. You can ignore my instructions above.

review: Approve

[lp:~vladimir.p/nova/volume_type_extradata]

1468. By Vladimir Popovski on 2011-08-24

added new tables to list of DBs in migration.py

1469. By Vladimir Popovski on 2011-08-24

merged with nova 1490

[Dan Prince (dan-prince)]

Looks good.

review: Approve

[Ben McGraw (mcgrue)]

lgtm

review: Approve

=== modified file 'nova/api/openstack/contrib/volumes.py'
--- nova/api/openstack/contrib/volumes.py	2011-07-26 17:10:31 +0000
+++ nova/api/openstack/contrib/volumes.py	2011-08-24 23:44:25 +0000
@@ -24,6 +24,7 @@
 from nova import log as logging
 from nova import quota
 from nova import volume
+from nova.volume import volume_types
 from nova.api.openstack import common
 from nova.api.openstack import extensions
 from nova.api.openstack import faults
@@ -63,6 +64,22 @@
 
     d['displayName'] = vol['display_name']
     d['displayDescription'] = vol['display_description']
+
+    if vol['volume_type_id'] and vol.get('volume_type'):
+        d['volumeType'] = vol['volume_type']['name']
+    else:
+        d['volumeType'] = vol['volume_type_id']
+
+    LOG.audit(_("vol=%s"), vol, context=context)
+
+    if vol.get('volume_metadata'):
+        meta_dict = {}
+        for i in vol['volume_metadata']:
+            meta_dict[i['key']] = i['value']
+        d['metadata'] = meta_dict
+    else:
+        d['metadata'] = {}
+
     return d
 
 
@@ -80,6 +97,8 @@
                     "createdAt",
                     "displayName",
                     "displayDescription",
+                    "volumeType",
+                    "metadata",
                     ]}}}
 
     def __init__(self):
@@ -136,12 +155,25 @@
         vol = body['volume']
         size = vol['size']
         LOG.audit(_("Create volume of %s GB"), size, context=context)
+
+        vol_type = vol.get('volume_type', None)
+        if vol_type:
+            try:
+                vol_type = volume_types.get_volume_type_by_name(context,
+                                                                vol_type)
+            except exception.NotFound:
+                return faults.Fault(exc.HTTPNotFound())
+
+        metadata = vol.get('metadata', None)
+
         new_volume = self.volume_api.create(context, size, None,
                                             vol.get('display_name'),
-                                            vol.get('display_description'))
+                                            vol.get('display_description'),
+                                            volume_type=vol_type,
+                                            metadata=metadata)
 
         # Work around problem that instance is lazy-loaded...
-        new_volume['instance'] = None
+        new_volume = self.volume_api.get(context, new_volume['id'])
 
         retval = _translate_volume_detail_view(context, new_volume)
 

=== added file 'nova/api/openstack/contrib/volumetypes.py'
--- nova/api/openstack/contrib/volumetypes.py	1970-01-01 00:00:00 +0000
+++ nova/api/openstack/contrib/volumetypes.py	2011-08-24 23:44:25 +0000
@@ -0,0 +1,197 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright (c) 2011 Zadara Storage Inc.
+# Copyright (c) 2011 OpenStack LLC.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+""" The volume type & volume types extra specs extension"""
+
+from webob import exc
+
+from nova import db
+from nova import exception
+from nova import quota
+from nova.volume import volume_types
+from nova.api.openstack import extensions
+from nova.api.openstack import faults
+from nova.api.openstack import wsgi
+
+
+class VolumeTypesController(object):
+    """ The volume types API controller for the Openstack API """
+
+    def index(self, req):
+        """ Returns the list of volume types """
+        context = req.environ['nova.context']
+        return volume_types.get_all_types(context)
+
+    def create(self, req, body):
+        """Creates a new volume type."""
+        context = req.environ['nova.context']
+
+        if not body or body == "":
+            return faults.Fault(exc.HTTPUnprocessableEntity())
+
+        vol_type = body.get('volume_type', None)
+        if vol_type is None or vol_type == "":
+            return faults.Fault(exc.HTTPUnprocessableEntity())
+
+        name = vol_type.get('name', None)
+        specs = vol_type.get('extra_specs', {})
+
+        if name is None or name == "":
+            return faults.Fault(exc.HTTPUnprocessableEntity())
+
+        try:
+            volume_types.create(context, name, specs)
+            vol_type = volume_types.get_volume_type_by_name(context, name)
+        except quota.QuotaError as error:
+            self._handle_quota_error(error)
+        except exception.NotFound:
+            return faults.Fault(exc.HTTPNotFound())
+
+        return {'volume_type': vol_type}
+
+    def show(self, req, id):
+        """ Return a single volume type item """
+        context = req.environ['nova.context']
+
+        try:
+            vol_type = volume_types.get_volume_type(context, id)
+        except exception.NotFound or exception.ApiError:
+            return faults.Fault(exc.HTTPNotFound())
+
+        return {'volume_type': vol_type}
+
+    def delete(self, req, id):
+        """ Deletes an existing volume type """
+        context = req.environ['nova.context']
+
+        try:
+            vol_type = volume_types.get_volume_type(context, id)
+            volume_types.destroy(context, vol_type['name'])
+        except exception.NotFound:
+            return faults.Fault(exc.HTTPNotFound())
+
+    def _handle_quota_error(self, error):
+        """Reraise quota errors as api-specific http exceptions."""
+        if error.code == "MetadataLimitExceeded":
+            raise exc.HTTPBadRequest(explanation=error.message)
+        raise error
+
+
+class VolumeTypeExtraSpecsController(object):
+    """ The volume type extra specs API controller for the Openstack API """
+
+    def _get_extra_specs(self, context, vol_type_id):
+        extra_specs = db.api.volume_type_extra_specs_get(context, vol_type_id)
+        specs_dict = {}
+        for key, value in extra_specs.iteritems():
+            specs_dict[key] = value
+        return dict(extra_specs=specs_dict)
+
+    def _check_body(self, body):
+        if body == None or body == "":
+            expl = _('No Request Body')
+            raise exc.HTTPBadRequest(explanation=expl)
+
+    def index(self, req, vol_type_id):
+        """ Returns the list of extra specs for a given volume type """
+        context = req.environ['nova.context']
+        return self._get_extra_specs(context, vol_type_id)
+
+    def create(self, req, vol_type_id, body):
+        self._check_body(body)
+        context = req.environ['nova.context']
+        specs = body.get('extra_specs')
+        try:
+            db.api.volume_type_extra_specs_update_or_create(context,
+                                                            vol_type_id,
+                                                            specs)
+        except quota.QuotaError as error:
+            self._handle_quota_error(error)
+        return body
+
+    def update(self, req, vol_type_id, id, body):
+        self._check_body(body)
+        context = req.environ['nova.context']
+        if not id in body:
+            expl = _('Request body and URI mismatch')
+            raise exc.HTTPBadRequest(explanation=expl)
+        if len(body) > 1:
+            expl = _('Request body contains too many items')
+            raise exc.HTTPBadRequest(explanation=expl)
+        try:
+            db.api.volume_type_extra_specs_update_or_create(context,
+                                                            vol_type_id,
+                                                            body)
+        except quota.QuotaError as error:
+            self._handle_quota_error(error)
+
+        return body
+
+    def show(self, req, vol_type_id, id):
+        """ Return a single extra spec item """
+        context = req.environ['nova.context']
+        specs = self._get_extra_specs(context, vol_type_id)
+        if id in specs['extra_specs']:
+            return {id: specs['extra_specs'][id]}
+        else:
+            return faults.Fault(exc.HTTPNotFound())
+
+    def delete(self, req, vol_type_id, id):
+        """ Deletes an existing extra spec """
+        context = req.environ['nova.context']
+        db.api.volume_type_extra_specs_delete(context, vol_type_id, id)
+
+    def _handle_quota_error(self, error):
+        """Reraise quota errors as api-specific http exceptions."""
+        if error.code == "MetadataLimitExceeded":
+            raise exc.HTTPBadRequest(explanation=error.message)
+        raise error
+
+
+class Volumetypes(extensions.ExtensionDescriptor):
+
+    def get_name(self):
+        return "VolumeTypes"
+
+    def get_alias(self):
+        return "os-volume-types"
+
+    def get_description(self):
+        return "Volume types support"
+
+    def get_namespace(self):
+        return \
+         "http://docs.openstack.org/ext/volume_types/api/v1.1"
+
+    def get_updated(self):
+        return "2011-08-24T00:00:00+00:00"
+
+    def get_resources(self):
+        resources = []
+        res = extensions.ResourceExtension(
+                    'os-volume-types',
+                    VolumeTypesController())
+        resources.append(res)
+
+        res = extensions.ResourceExtension('extra_specs',
+                            VolumeTypeExtraSpecsController(),
+                            parent=dict(
+                                member_name='vol_type',
+                                collection_name='os-volume-types'))
+        resources.append(res)
+
+        return resources

=== modified file 'nova/db/api.py'
--- nova/db/api.py	2011-08-22 23:35:09 +0000
+++ nova/db/api.py	2011-08-24 23:44:25 +0000
@@ -1436,3 +1436,79 @@
     key/value pairs specified in the extra specs dict argument"""
     IMPL.instance_type_extra_specs_update_or_create(context, instance_type_id,
                                                     extra_specs)
+
+
+##################
+
+
+def volume_metadata_get(context, volume_id):
+    """Get all metadata for a volume."""
+    return IMPL.volume_metadata_get(context, volume_id)
+
+
+def volume_metadata_delete(context, volume_id, key):
+    """Delete the given metadata item."""
+    IMPL.volume_metadata_delete(context, volume_id, key)
+
+
+def volume_metadata_update(context, volume_id, metadata, delete):
+    """Update metadata if it exists, otherwise create it."""
+    IMPL.volume_metadata_update(context, volume_id, metadata, delete)
+
+
+##################
+
+
+def volume_type_create(context, values):
+    """Create a new volume type."""
+    return IMPL.volume_type_create(context, values)
+
+
+def volume_type_get_all(context, inactive=False):
+    """Get all volume types."""
+    return IMPL.volume_type_get_all(context, inactive)
+
+
+def volume_type_get(context, id):
+    """Get volume type by id."""
+    return IMPL.volume_type_get(context, id)
+
+
+def volume_type_get_by_name(context, name):
+    """Get volume type by name."""
+    return IMPL.volume_type_get_by_name(context, name)
+
+
+def volume_type_destroy(context, name):
+    """Delete a volume type."""
+    return IMPL.volume_type_destroy(context, name)
+
+
+def volume_type_purge(context, name):
+    """Purges (removes) a volume type from DB.
+
+    Use volume_type_destroy for most cases
+
+    """
+    return IMPL.volume_type_purge(context, name)
+
+
+####################
+
+
+def volume_type_extra_specs_get(context, volume_type_id):
+    """Get all extra specs for a volume type."""
+    return IMPL.volume_type_extra_specs_get(context, volume_type_id)
+
+
+def volume_type_extra_specs_delete(context, volume_type_id, key):
+    """Delete the given extra specs item."""
+    IMPL.volume_type_extra_specs_delete(context, volume_type_id, key)
+
+
+def volume_type_extra_specs_update_or_create(context, volume_type_id,
+                                               extra_specs):
+    """Create or update volume type extra specs. This adds or modifies the
+    key/value pairs specified in the extra specs dict argument"""
+    IMPL.volume_type_extra_specs_update_or_create(context, volume_type_id,
+                                                    extra_specs)

=== modified file 'nova/db/sqlalchemy/api.py'
--- nova/db/sqlalchemy/api.py	2011-08-22 23:35:09 +0000
+++ nova/db/sqlalchemy/api.py	2011-08-24 23:44:25 +0000
@@ -132,6 +132,20 @@
     return wrapper
 
 
+def require_volume_exists(f):
+    """Decorator to require the specified volume to exist.
+
+    Requres the wrapped function to use context and volume_id as
+    their first two arguments.
+    """
+
+    def wrapper(context, volume_id, *args, **kwargs):
+        db.api.volume_get(context, volume_id)
+        return f(context, volume_id, *args, **kwargs)
+    wrapper.__name__ = f.__name__
+    return wrapper
+
+
 ###################
 
 
@@ -1019,11 +1033,11 @@
 ###################
 
 
-def _metadata_refs(metadata_dict):
+def _metadata_refs(metadata_dict, meta_class):
     metadata_refs = []
     if metadata_dict:
         for k, v in metadata_dict.iteritems():
-            metadata_ref = models.InstanceMetadata()
+            metadata_ref = meta_class()
             metadata_ref['key'] = k
             metadata_ref['value'] = v
             metadata_refs.append(metadata_ref)
@@ -1037,8 +1051,8 @@
     context - request context object
     values - dict containing column values.
     """
-    values['metadata'] = _metadata_refs(values.get('metadata'))
-
+    values['metadata'] = _metadata_refs(values.get('metadata'),
+                                        models.InstanceMetadata)
     instance_ref = models.Instance()
     instance_ref['uuid'] = str(utils.gen_uuid())
 
@@ -2144,6 +2158,8 @@
 
 @require_context
 def volume_create(context, values):
+    values['volume_metadata'] = _metadata_refs(values.get('metadata'),
+                                               models.VolumeMetadata)
     volume_ref = models.Volume()
     volume_ref.update(values)
 
@@ -2180,6 +2196,11 @@
         session.query(models.IscsiTarget).\
                 filter_by(volume_id=volume_id).\
                 update({'volume_id': None})
+        session.query(models.VolumeMetadata).\
+                filter_by(volume_id=volume_id).\
+                update({'deleted': True,
+                        'deleted_at': utils.utcnow(),
+                        'updated_at': literal_column('updated_at')})
 
 
 @require_admin_context
@@ -2203,12 +2224,16 @@
     if is_admin_context(context):
         result = session.query(models.Volume).\
                          options(joinedload('instance')).\
+                         options(joinedload('volume_metadata')).\
+                         options(joinedload('volume_type')).\
                          filter_by(id=volume_id).\
                          filter_by(deleted=can_read_deleted(context)).\
                          first()
     elif is_user_context(context):
         result = session.query(models.Volume).\
                          options(joinedload('instance')).\
+                         options(joinedload('volume_metadata')).\
+                         options(joinedload('volume_type')).\
                          filter_by(project_id=context.project_id).\
                          filter_by(id=volume_id).\
                          filter_by(deleted=False).\
@@ -2224,6 +2249,8 @@
     session = get_session()
     return session.query(models.Volume).\
                    options(joinedload('instance')).\
+                   options(joinedload('volume_metadata')).\
+                   options(joinedload('volume_type')).\
                    filter_by(deleted=can_read_deleted(context)).\
                    all()
 
@@ -2233,6 +2260,8 @@
     session = get_session()
     return session.query(models.Volume).\
                    options(joinedload('instance')).\
+                   options(joinedload('volume_metadata')).\
+                   options(joinedload('volume_type')).\
                    filter_by(host=host).\
                    filter_by(deleted=can_read_deleted(context)).\
                    all()
@@ -2242,6 +2271,8 @@
 def volume_get_all_by_instance(context, instance_id):
     session = get_session()
     result = session.query(models.Volume).\
+                     options(joinedload('volume_metadata')).\
+                     options(joinedload('volume_type')).\
                      filter_by(instance_id=instance_id).\
                      filter_by(deleted=False).\
                      all()
@@ -2257,6 +2288,8 @@
     session = get_session()
     return session.query(models.Volume).\
                    options(joinedload('instance')).\
+                   options(joinedload('volume_metadata')).\
+                   options(joinedload('volume_type')).\
                    filter_by(project_id=project_id).\
                    filter_by(deleted=can_read_deleted(context)).\
                    all()
@@ -2269,6 +2302,8 @@
                      filter_by(id=volume_id).\
                      filter_by(deleted=can_read_deleted(context)).\
                      options(joinedload('instance')).\
+                     options(joinedload('volume_metadata')).\
+                     options(joinedload('volume_type')).\
                      first()
     if not result:
         raise exception.VolumeNotFound(volume_id=volume_id)
@@ -2303,12 +2338,116 @@
 @require_context
 def volume_update(context, volume_id, values):
     session = get_session()
+    metadata = values.get('metadata')
+    if metadata is not None:
+        volume_metadata_update(context,
+                                volume_id,
+                                values.pop('metadata'),
+                                delete=True)
     with session.begin():
         volume_ref = volume_get(context, volume_id, session=session)
         volume_ref.update(values)
         volume_ref.save(session=session)
 
 
+####################
+
+
+@require_context
+@require_volume_exists
+def volume_metadata_get(context, volume_id):
+    session = get_session()
+
+    meta_results = session.query(models.VolumeMetadata).\
+                    filter_by(volume_id=volume_id).\
+                    filter_by(deleted=False).\
+                    all()
+
+    meta_dict = {}
+    for i in meta_results:
+        meta_dict[i['key']] = i['value']
+    return meta_dict
+
+
+@require_context
+@require_volume_exists
+def volume_metadata_delete(context, volume_id, key):
+    session = get_session()
+    session.query(models.VolumeMetadata).\
+        filter_by(volume_id=volume_id).\
+        filter_by(key=key).\
+        filter_by(deleted=False).\
+        update({'deleted': True,
+                'deleted_at': utils.utcnow(),
+                'updated_at': literal_column('updated_at')})
+
+
+@require_context
+@require_volume_exists
+def volume_metadata_delete_all(context, volume_id):
+    session = get_session()
+    session.query(models.VolumeMetadata).\
+        filter_by(volume_id=volume_id).\
+        filter_by(deleted=False).\
+        update({'deleted': True,
+                'deleted_at': utils.utcnow(),
+                'updated_at': literal_column('updated_at')})
+
+
+@require_context
+@require_volume_exists
+def volume_metadata_get_item(context, volume_id, key, session=None):
+    if not session:
+        session = get_session()
+
+    meta_result = session.query(models.VolumeMetadata).\
+                    filter_by(volume_id=volume_id).\
+                    filter_by(key=key).\
+                    filter_by(deleted=False).\
+                    first()
+
+    if not meta_result:
+        raise exception.VolumeMetadataNotFound(metadata_key=key,
+                                               volume_id=volume_id)
+    return meta_result
+
+
+@require_context
+@require_volume_exists
+def volume_metadata_update(context, volume_id, metadata, delete):
+    session = get_session()
+
+    # Set existing metadata to deleted if delete argument is True
+    if delete:
+        original_metadata = volume_metadata_get(context, volume_id)
+        for meta_key, meta_value in original_metadata.iteritems():
+            if meta_key not in metadata:
+                meta_ref = volume_metadata_get_item(context, volume_id,
+                                                    meta_key, session)
+                meta_ref.update({'deleted': True})
+                meta_ref.save(session=session)
+
+    meta_ref = None
+
+    # Now update all existing items with new values, or create new meta objects
+    for meta_key, meta_value in metadata.iteritems():
+
+        # update the value whether it exists or not
+        item = {"value": meta_value}
+
+        try:
+            meta_ref = volume_metadata_get_item(context, volume_id,
+                                                  meta_key, session)
+        except exception.VolumeMetadataNotFound, e:
+            meta_ref = models.VolumeMetadata()
+            item.update({"key": meta_key, "volume_id": volume_id})
+
+        meta_ref.update(item)
+        meta_ref.save(session=session)
+
+    return metadata
+
+
 ###################
 
 
@@ -3143,7 +3282,7 @@
 
 
 def _dict_with_extra_specs(inst_type_query):
-    """Takes an instance type query returned by sqlalchemy
+    """Takes an instance OR volume type query returned by sqlalchemy
     and returns it as a dictionary, converting the extra_specs
     entry from a list of dicts:
 
@@ -3525,3 +3664,176 @@
                          "deleted": 0})
         spec_ref.save(session=session)
     return specs
+
+
+##################
+
+
+@require_admin_context
+def volume_type_create(_context, values):
+    """Create a new instance type. In order to pass in extra specs,
+    the values dict should contain a 'extra_specs' key/value pair:
+
+    {'extra_specs' : {'k1': 'v1', 'k2': 'v2', ...}}
+
+    """
+    try:
+        specs = values.get('extra_specs')
+
+        values['extra_specs'] = _metadata_refs(values.get('extra_specs'),
+                                                models.VolumeTypeExtraSpecs)
+        volume_type_ref = models.VolumeTypes()
+        volume_type_ref.update(values)
+        volume_type_ref.save()
+    except Exception, e:
+        raise exception.DBError(e)
+    return volume_type_ref
+
+
+@require_context
+def volume_type_get_all(context, inactive=False, filters={}):
+    """
+    Returns a dict describing all volume_types with name as key.
+    """
+    session = get_session()
+    if inactive:
+        vol_types = session.query(models.VolumeTypes).\
+                        options(joinedload('extra_specs')).\
+                        order_by("name").\
+                        all()
+    else:
+        vol_types = session.query(models.VolumeTypes).\
+                        options(joinedload('extra_specs')).\
+                        filter_by(deleted=False).\
+                        order_by("name").\
+                        all()
+    vol_dict = {}
+    if vol_types:
+        for i in vol_types:
+            vol_dict[i['name']] = _dict_with_extra_specs(i)
+    return vol_dict
+
+
+@require_context
+def volume_type_get(context, id):
+    """Returns a dict describing specific volume_type"""
+    session = get_session()
+    vol_type = session.query(models.VolumeTypes).\
+                    options(joinedload('extra_specs')).\
+                    filter_by(id=id).\
+                    first()
+
+    if not vol_type:
+        raise exception.VolumeTypeNotFound(volume_type=id)
+    else:
+        return _dict_with_extra_specs(vol_type)
+
+
+@require_context
+def volume_type_get_by_name(context, name):
+    """Returns a dict describing specific volume_type"""
+    session = get_session()
+    vol_type = session.query(models.VolumeTypes).\
+                    options(joinedload('extra_specs')).\
+                    filter_by(name=name).\
+                    first()
+    if not vol_type:
+        raise exception.VolumeTypeNotFoundByName(volume_type_name=name)
+    else:
+        return _dict_with_extra_specs(vol_type)
+
+
+@require_admin_context
+def volume_type_destroy(context, name):
+    """ Marks specific volume_type as deleted"""
+    session = get_session()
+    volume_type_ref = session.query(models.VolumeTypes).\
+                                      filter_by(name=name)
+    records = volume_type_ref.update(dict(deleted=True))
+    if records == 0:
+        raise exception.VolumeTypeNotFoundByName(volume_type_name=name)
+    else:
+        return volume_type_ref
+
+
+@require_admin_context
+def volume_type_purge(context, name):
+    """ Removes specific volume_type from DB
+        Usually volume_type_destroy should be used
+    """
+    session = get_session()
+    volume_type_ref = session.query(models.VolumeTypes).\
+                                      filter_by(name=name)
+    records = volume_type_ref.delete()
+    if records == 0:
+        raise exception.VolumeTypeNotFoundByName(volume_type_name=name)
+    else:
+        return volume_type_ref
+
+
+####################
+
+
+@require_context
+def volume_type_extra_specs_get(context, volume_type_id):
+    session = get_session()
+
+    spec_results = session.query(models.VolumeTypeExtraSpecs).\
+                    filter_by(volume_type_id=volume_type_id).\
+                    filter_by(deleted=False).\
+                    all()
+
+    spec_dict = {}
+    for i in spec_results:
+        spec_dict[i['key']] = i['value']
+    return spec_dict
+
+
+@require_context
+def volume_type_extra_specs_delete(context, volume_type_id, key):
+    session = get_session()
+    session.query(models.VolumeTypeExtraSpecs).\
+        filter_by(volume_type_id=volume_type_id).\
+        filter_by(key=key).\
+        filter_by(deleted=False).\
+        update({'deleted': True,
+                'deleted_at': utils.utcnow(),
+                'updated_at': literal_column('updated_at')})
+
+
+@require_context
+def volume_type_extra_specs_get_item(context, volume_type_id, key,
+                                       session=None):
+
+    if not session:
+        session = get_session()
+
+    spec_result = session.query(models.VolumeTypeExtraSpecs).\
+                    filter_by(volume_type_id=volume_type_id).\
+                    filter_by(key=key).\
+                    filter_by(deleted=False).\
+                    first()
+
+    if not spec_result:
+        raise exception.\
+           VolumeTypeExtraSpecsNotFound(extra_specs_key=key,
+                                        volume_type_id=volume_type_id)
+    return spec_result
+
+
+@require_context
+def volume_type_extra_specs_update_or_create(context, volume_type_id,
+                                             specs):
+    session = get_session()
+    spec_ref = None
+    for key, value in specs.iteritems():
+        try:
+            spec_ref = volume_type_extra_specs_get_item(
+                context, volume_type_id, key, session)
+        except exception.VolumeTypeExtraSpecsNotFound, e:
+            spec_ref = models.VolumeTypeExtraSpecs()
+        spec_ref.update({"key": key, "value": value,
+                         "volume_type_id": volume_type_id,
+                         "deleted": 0})
+        spec_ref.save(session=session)
+    return specs

=== added file 'nova/db/sqlalchemy/migrate_repo/versions/042_add_volume_types_and_extradata.py'
--- nova/db/sqlalchemy/migrate_repo/versions/042_add_volume_types_and_extradata.py	1970-01-01 00:00:00 +0000
+++ nova/db/sqlalchemy/migrate_repo/versions/042_add_volume_types_and_extradata.py	2011-08-24 23:44:25 +0000
@@ -0,0 +1,115 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright (c) 2011 Zadara Storage Inc.
+# Copyright (c) 2011 OpenStack LLC.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from sqlalchemy import Column, DateTime, Integer, MetaData, String, Table
+from sqlalchemy import Text, Boolean, ForeignKey
+
+from nova import log as logging
+
+meta = MetaData()
+
+# Just for the ForeignKey and column creation to succeed, these are not the
+# actual definitions of tables .
+#
+
+volumes = Table('volumes', meta,
+       Column('id', Integer(),  primary_key=True, nullable=False),
+       )
+
+volume_type_id = Column('volume_type_id', Integer(), nullable=True)
+
+
+# New Tables
+#
+
+volume_types = Table('volume_types', meta,
+       Column('created_at', DateTime(timezone=False)),
+       Column('updated_at', DateTime(timezone=False)),
+       Column('deleted_at', DateTime(timezone=False)),
+       Column('deleted', Boolean(create_constraint=True, name=None)),
+       Column('id', Integer(), primary_key=True, nullable=False),
+       Column('name',
+              String(length=255, convert_unicode=False, assert_unicode=None,
+                     unicode_error=None, _warn_on_bytestring=False),
+              unique=True))
+
+volume_type_extra_specs_table = Table('volume_type_extra_specs', meta,
+        Column('created_at', DateTime(timezone=False)),
+        Column('updated_at', DateTime(timezone=False)),
+        Column('deleted_at', DateTime(timezone=False)),
+        Column('deleted', Boolean(create_constraint=True, name=None)),
+        Column('id', Integer(), primary_key=True, nullable=False),
+        Column('volume_type_id',
+               Integer(),
+               ForeignKey('volume_types.id'),
+               nullable=False),
+        Column('key',
+               String(length=255, convert_unicode=False, assert_unicode=None,
+                      unicode_error=None, _warn_on_bytestring=False)),
+        Column('value',
+               String(length=255, convert_unicode=False, assert_unicode=None,
+                      unicode_error=None, _warn_on_bytestring=False)))
+
+
+volume_metadata_table = Table('volume_metadata', meta,
+        Column('created_at', DateTime(timezone=False)),
+        Column('updated_at', DateTime(timezone=False)),
+        Column('deleted_at', DateTime(timezone=False)),
+        Column('deleted', Boolean(create_constraint=True, name=None)),
+        Column('id', Integer(), primary_key=True, nullable=False),
+        Column('volume_id',
+               Integer(),
+               ForeignKey('volumes.id'),
+               nullable=False),
+        Column('key',
+               String(length=255, convert_unicode=False, assert_unicode=None,
+                      unicode_error=None, _warn_on_bytestring=False)),
+        Column('value',
+               String(length=255, convert_unicode=False, assert_unicode=None,
+                      unicode_error=None, _warn_on_bytestring=False)))
+
+
+new_tables = (volume_types,
+              volume_type_extra_specs_table,
+              volume_metadata_table)
+
+#
+# Tables to alter
+#
+
+
+def upgrade(migrate_engine):
+    meta.bind = migrate_engine
+
+    for table in new_tables:
+        try:
+            table.create()
+        except Exception:
+            logging.info(repr(table))
+            logging.exception('Exception while creating table')
+            raise
+
+    volumes.create_column(volume_type_id)
+
+
+def downgrade(migrate_engine):
+    meta.bind = migrate_engine
+
+    volumes.drop_column(volume_type_id)
+
+    for table in new_tables:
+        table.drop()

=== modified file 'nova/db/sqlalchemy/migration.py'
--- nova/db/sqlalchemy/migration.py	2011-06-24 12:01:51 +0000
+++ nova/db/sqlalchemy/migration.py	2011-08-24 23:44:25 +0000
@@ -64,7 +64,8 @@
                           'users', 'user_project_association',
                           'user_project_role_association',
                           'user_role_association',
-                          'volumes'):
+                          'volumes', 'volume_metadata',
+                          'volume_types', 'volume_type_extra_specs'):
                 assert table in meta.tables
             return db_version_control(1)
         except AssertionError:

=== modified file 'nova/db/sqlalchemy/models.py'
--- nova/db/sqlalchemy/models.py	2011-08-23 04:17:57 +0000
+++ nova/db/sqlalchemy/models.py	2011-08-24 23:44:25 +0000
@@ -318,6 +318,50 @@
     provider_location = Column(String(255))
     provider_auth = Column(String(255))
 
+    volume_type_id = Column(Integer)
+
+
+class VolumeMetadata(BASE, NovaBase):
+    """Represents a metadata key/value pair for a volume"""
+    __tablename__ = 'volume_metadata'
+    id = Column(Integer, primary_key=True)
+    key = Column(String(255))
+    value = Column(String(255))
+    volume_id = Column(Integer, ForeignKey('volumes.id'), nullable=False)
+    volume = relationship(Volume, backref="volume_metadata",
+                            foreign_keys=volume_id,
+                            primaryjoin='and_('
+                                'VolumeMetadata.volume_id == Volume.id,'
+                                'VolumeMetadata.deleted == False)')
+
+
+class VolumeTypes(BASE, NovaBase):
+    """Represent possible volume_types of volumes offered"""
+    __tablename__ = "volume_types"
+    id = Column(Integer, primary_key=True)
+    name = Column(String(255), unique=True)
+
+    volumes = relationship(Volume,
+                           backref=backref('volume_type', uselist=False),
+                           foreign_keys=id,
+                           primaryjoin='and_(Volume.volume_type_id == '
+                                       'VolumeTypes.id)')
+
+
+class VolumeTypeExtraSpecs(BASE, NovaBase):
+    """Represents additional specs as key/value pairs for a volume_type"""
+    __tablename__ = 'volume_type_extra_specs'
+    id = Column(Integer, primary_key=True)
+    key = Column(String(255))
+    value = Column(String(255))
+    volume_type_id = Column(Integer, ForeignKey('volume_types.id'),
+                              nullable=False)
+    volume_type = relationship(VolumeTypes, backref="extra_specs",
+                 foreign_keys=volume_type_id,
+                 primaryjoin='and_('
+                 'VolumeTypeExtraSpecs.volume_type_id == VolumeTypes.id,'
+                 'VolumeTypeExtraSpecs.deleted == False)')
+
 
 class Quota(BASE, NovaBase):
     """Represents a single quota override for a project.
@@ -803,6 +847,7 @@
               Network, SecurityGroup, SecurityGroupIngressRule,
               SecurityGroupInstanceAssociation, AuthToken, User,
               Project, Certificate, ConsolePool, Console, Zone,
+              VolumeMetadata, VolumeTypes, VolumeTypeExtraSpecs,
               AgentBuild, InstanceMetadata, InstanceTypeExtraSpecs, Migration)
     engine = create_engine(FLAGS.sql_connection, echo=False)
     for model in models:

=== modified file 'nova/exception.py'
--- nova/exception.py	2011-08-22 23:35:09 +0000
+++ nova/exception.py	2011-08-24 23:44:25 +0000
@@ -197,6 +197,10 @@
     message = _("Invalid instance type %(instance_type)s.")
 
 
+class InvalidVolumeType(Invalid):
+    message = _("Invalid volume type %(volume_type)s.")
+
+
 class InvalidPortRange(Invalid):
     message = _("Invalid port range %(from_port)s:%(to_port)s.")
 
@@ -338,6 +342,29 @@
     message = _("Volume not found for instance %(instance_id)s.")
 
 
+class VolumeMetadataNotFound(NotFound):
+    message = _("Volume %(volume_id)s has no metadata with "
+                "key %(metadata_key)s.")
+
+
+class NoVolumeTypesFound(NotFound):
+    message = _("Zero volume types found.")
+
+
+class VolumeTypeNotFound(NotFound):
+    message = _("Volume type %(volume_type_id)s could not be found.")
+
+
+class VolumeTypeNotFoundByName(VolumeTypeNotFound):
+    message = _("Volume type with name %(volume_type_name)s "
+                "could not be found.")
+
+
+class VolumeTypeExtraSpecsNotFound(NotFound):
+    message = _("Volume Type %(volume_type_id)s has no extra specs with "
+                "key %(extra_specs_key)s.")
+
+
 class SnapshotNotFound(NotFound):
     message = _("Snapshot %(snapshot_id)s could not be found.")
 

=== modified file 'nova/tests/api/openstack/test_extensions.py'
--- nova/tests/api/openstack/test_extensions.py	2011-08-22 23:35:09 +0000
+++ nova/tests/api/openstack/test_extensions.py	2011-08-24 23:44:25 +0000
@@ -97,6 +97,7 @@
             "SecurityGroups",
             "VirtualInterfaces",
             "Volumes",
+            "VolumeTypes",
             ]
         self.ext_list.sort()
 

=== added file 'nova/tests/api/openstack/test_volume_types.py'
--- nova/tests/api/openstack/test_volume_types.py	1970-01-01 00:00:00 +0000
+++ nova/tests/api/openstack/test_volume_types.py	2011-08-24 23:44:25 +0000
@@ -0,0 +1,171 @@
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import json
+import stubout
+import webob
+
+from nova import exception
+from nova import context
+from nova import test
+from nova import log as logging
+from nova.volume import volume_types
+from nova.tests.api.openstack import fakes
+
+LOG = logging.getLogger('nova.tests.api.openstack.test_volume_types')
+
+last_param = {}
+
+
+def stub_volume_type(id):
+    specs = {
+            "key1": "value1",
+            "key2": "value2",
+            "key3": "value3",
+            "key4": "value4",
+            "key5": "value5"}
+    return dict(id=id, name='vol_type_%s' % str(id), extra_specs=specs)
+
+
+def return_volume_types_get_all_types(context):
+    return dict(vol_type_1=stub_volume_type(1),
+                vol_type_2=stub_volume_type(2),
+                vol_type_3=stub_volume_type(3))
+
+
+def return_empty_volume_types_get_all_types(context):
+    return {}
+
+
+def return_volume_types_get_volume_type(context, id):
+    if id == "777":
+        raise exception.VolumeTypeNotFound(volume_type_id=id)
+    return stub_volume_type(int(id))
+
+
+def return_volume_types_destroy(context, name):
+    if name == "777":
+        raise exception.VolumeTypeNotFoundByName(volume_type_name=name)
+    pass
+
+
+def return_volume_types_create(context, name, specs):
+    pass
+
+
+def return_volume_types_get_by_name(context, name):
+    if name == "777":
+        raise exception.VolumeTypeNotFoundByName(volume_type_name=name)
+    return stub_volume_type(int(name.split("_")[2]))
+
+
+class VolumeTypesApiTest(test.TestCase):
+    def setUp(self):
+        super(VolumeTypesApiTest, self).setUp()
+        fakes.stub_out_key_pair_funcs(self.stubs)
+
+    def tearDown(self):
+        self.stubs.UnsetAll()
+        super(VolumeTypesApiTest, self).tearDown()
+
+    def test_volume_types_index(self):
+        self.stubs.Set(volume_types, 'get_all_types',
+                       return_volume_types_get_all_types)
+        req = webob.Request.blank('/v1.1/123/os-volume-types')
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(200, res.status_int)
+        res_dict = json.loads(res.body)
+        self.assertEqual('application/json', res.headers['Content-Type'])
+
+        self.assertEqual(3, len(res_dict))
+        for name in ['vol_type_1', 'vol_type_2', 'vol_type_3']:
+            self.assertEqual(name, res_dict[name]['name'])
+            self.assertEqual('value1', res_dict[name]['extra_specs']['key1'])
+
+    def test_volume_types_index_no_data(self):
+        self.stubs.Set(volume_types, 'get_all_types',
+                       return_empty_volume_types_get_all_types)
+        req = webob.Request.blank('/v1.1/123/os-volume-types')
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+        self.assertEqual(200, res.status_int)
+        self.assertEqual('application/json', res.headers['Content-Type'])
+        self.assertEqual(0, len(res_dict))
+
+    def test_volume_types_show(self):
+        self.stubs.Set(volume_types, 'get_volume_type',
+                       return_volume_types_get_volume_type)
+        req = webob.Request.blank('/v1.1/123/os-volume-types/1')
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(200, res.status_int)
+        res_dict = json.loads(res.body)
+        self.assertEqual('application/json', res.headers['Content-Type'])
+        self.assertEqual(1, len(res_dict))
+        self.assertEqual('vol_type_1', res_dict['volume_type']['name'])
+
+    def test_volume_types_show_not_found(self):
+        self.stubs.Set(volume_types, 'get_volume_type',
+                       return_volume_types_get_volume_type)
+        req = webob.Request.blank('/v1.1/123/os-volume-types/777')
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(404, res.status_int)
+
+    def test_volume_types_delete(self):
+        self.stubs.Set(volume_types, 'get_volume_type',
+                       return_volume_types_get_volume_type)
+        self.stubs.Set(volume_types, 'destroy',
+                       return_volume_types_destroy)
+        req = webob.Request.blank('/v1.1/123/os-volume-types/1')
+        req.method = 'DELETE'
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(200, res.status_int)
+
+    def test_volume_types_delete_not_found(self):
+        self.stubs.Set(volume_types, 'get_volume_type',
+                       return_volume_types_get_volume_type)
+        self.stubs.Set(volume_types, 'destroy',
+                       return_volume_types_destroy)
+        req = webob.Request.blank('/v1.1/123/os-volume-types/777')
+        req.method = 'DELETE'
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(404, res.status_int)
+
+    def test_create(self):
+        self.stubs.Set(volume_types, 'create',
+                       return_volume_types_create)
+        self.stubs.Set(volume_types, 'get_volume_type_by_name',
+                       return_volume_types_get_by_name)
+        req = webob.Request.blank('/v1.1/123/os-volume-types')
+        req.method = 'POST'
+        req.body = '{"volume_type": {"name": "vol_type_1", '\
+                                    '"extra_specs": {"key1": "value1"}}}'
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(200, res.status_int)
+        res_dict = json.loads(res.body)
+        self.assertEqual('application/json', res.headers['Content-Type'])
+        self.assertEqual(1, len(res_dict))
+        self.assertEqual('vol_type_1', res_dict['volume_type']['name'])
+
+    def test_create_empty_body(self):
+        self.stubs.Set(volume_types, 'create',
+                       return_volume_types_create)
+        self.stubs.Set(volume_types, 'get_volume_type_by_name',
+                       return_volume_types_get_by_name)
+        req = webob.Request.blank('/v1.1/123/os-volume-types')
+        req.method = 'POST'
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(400, res.status_int)

=== added file 'nova/tests/api/openstack/test_volume_types_extra_specs.py'
--- nova/tests/api/openstack/test_volume_types_extra_specs.py	1970-01-01 00:00:00 +0000
+++ nova/tests/api/openstack/test_volume_types_extra_specs.py	2011-08-24 23:44:25 +0000
@@ -0,0 +1,181 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright (c) 2011 Zadara Storage Inc.
+# Copyright (c) 2011 OpenStack LLC.
+# Copyright 2011 University of Southern California
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import json
+import stubout
+import webob
+import os.path
+
+
+from nova import test
+from nova.api import openstack
+from nova.api.openstack import extensions
+from nova.tests.api.openstack import fakes
+import nova.wsgi
+
+
+def return_create_volume_type_extra_specs(context, volume_type_id,
+                                          extra_specs):
+    return stub_volume_type_extra_specs()
+
+
+def return_volume_type_extra_specs(context, volume_type_id):
+    return stub_volume_type_extra_specs()
+
+
+def return_empty_volume_type_extra_specs(context, volume_type_id):
+    return {}
+
+
+def delete_volume_type_extra_specs(context, volume_type_id, key):
+    pass
+
+
+def stub_volume_type_extra_specs():
+    specs = {
+            "key1": "value1",
+            "key2": "value2",
+            "key3": "value3",
+            "key4": "value4",
+            "key5": "value5"}
+    return specs
+
+
+class VolumeTypesExtraSpecsTest(test.TestCase):
+
+    def setUp(self):
+        super(VolumeTypesExtraSpecsTest, self).setUp()
+        fakes.stub_out_key_pair_funcs(self.stubs)
+        self.api_path = '/v1.1/123/os-volume-types/1/extra_specs'
+
+    def test_index(self):
+        self.stubs.Set(nova.db.api, 'volume_type_extra_specs_get',
+                       return_volume_type_extra_specs)
+        request = webob.Request.blank(self.api_path)
+        res = request.get_response(fakes.wsgi_app())
+        self.assertEqual(200, res.status_int)
+        res_dict = json.loads(res.body)
+        self.assertEqual('application/json', res.headers['Content-Type'])
+        self.assertEqual('value1', res_dict['extra_specs']['key1'])
+
+    def test_index_no_data(self):
+        self.stubs.Set(nova.db.api, 'volume_type_extra_specs_get',
+                       return_empty_volume_type_extra_specs)
+        req = webob.Request.blank(self.api_path)
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+        self.assertEqual(200, res.status_int)
+        self.assertEqual('application/json', res.headers['Content-Type'])
+        self.assertEqual(0, len(res_dict['extra_specs']))
+
+    def test_show(self):
+        self.stubs.Set(nova.db.api, 'volume_type_extra_specs_get',
+                       return_volume_type_extra_specs)
+        req = webob.Request.blank(self.api_path + '/key5')
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(200, res.status_int)
+        res_dict = json.loads(res.body)
+        self.assertEqual('application/json', res.headers['Content-Type'])
+        self.assertEqual('value5', res_dict['key5'])
+
+    def test_show_spec_not_found(self):
+        self.stubs.Set(nova.db.api, 'volume_type_extra_specs_get',
+                       return_empty_volume_type_extra_specs)
+        req = webob.Request.blank(self.api_path + '/key6')
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+        self.assertEqual(404, res.status_int)
+
+    def test_delete(self):
+        self.stubs.Set(nova.db.api, 'volume_type_extra_specs_delete',
+                       delete_volume_type_extra_specs)
+        req = webob.Request.blank(self.api_path + '/key5')
+        req.method = 'DELETE'
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(200, res.status_int)
+
+    def test_create(self):
+        self.stubs.Set(nova.db.api,
+                       'volume_type_extra_specs_update_or_create',
+                       return_create_volume_type_extra_specs)
+        req = webob.Request.blank(self.api_path)
+        req.method = 'POST'
+        req.body = '{"extra_specs": {"key1": "value1"}}'
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+        self.assertEqual(200, res.status_int)
+        self.assertEqual('application/json', res.headers['Content-Type'])
+        self.assertEqual('value1', res_dict['extra_specs']['key1'])
+
+    def test_create_empty_body(self):
+        self.stubs.Set(nova.db.api,
+                       'volume_type_extra_specs_update_or_create',
+                       return_create_volume_type_extra_specs)
+        req = webob.Request.blank(self.api_path)
+        req.method = 'POST'
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(400, res.status_int)
+
+    def test_update_item(self):
+        self.stubs.Set(nova.db.api,
+                       'volume_type_extra_specs_update_or_create',
+                       return_create_volume_type_extra_specs)
+        req = webob.Request.blank(self.api_path + '/key1')
+        req.method = 'PUT'
+        req.body = '{"key1": "value1"}'
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(200, res.status_int)
+        self.assertEqual('application/json', res.headers['Content-Type'])
+        res_dict = json.loads(res.body)
+        self.assertEqual('value1', res_dict['key1'])
+
+    def test_update_item_empty_body(self):
+        self.stubs.Set(nova.db.api,
+                       'volume_type_extra_specs_update_or_create',
+                       return_create_volume_type_extra_specs)
+        req = webob.Request.blank(self.api_path + '/key1')
+        req.method = 'PUT'
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(400, res.status_int)
+
+    def test_update_item_too_many_keys(self):
+        self.stubs.Set(nova.db.api,
+                       'volume_type_extra_specs_update_or_create',
+                       return_create_volume_type_extra_specs)
+        req = webob.Request.blank(self.api_path + '/key1')
+        req.method = 'PUT'
+        req.body = '{"key1": "value1", "key2": "value2"}'
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(400, res.status_int)
+
+    def test_update_item_body_uri_mismatch(self):
+        self.stubs.Set(nova.db.api,
+                       'volume_type_extra_specs_update_or_create',
+                       return_create_volume_type_extra_specs)
+        req = webob.Request.blank(self.api_path + '/bad')
+        req.method = 'PUT'
+        req.body = '{"key1": "value1"}'
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(400, res.status_int)

=== modified file 'nova/tests/integrated/test_volumes.py'
--- nova/tests/integrated/test_volumes.py	2011-08-03 21:06:56 +0000
+++ nova/tests/integrated/test_volumes.py	2011-08-24 23:44:25 +0000
@@ -285,6 +285,23 @@
         self.assertEquals(undisco_move['mountpoint'], device)
         self.assertEquals(undisco_move['instance_id'], server_id)
 
+    def test_create_volume_with_metadata(self):
+        """Creates and deletes a volume."""
+
+        # Create volume
+        metadata = {'key1': 'value1',
+                    'key2': 'value2'}
+        created_volume = self.api.post_volume(
+            {'volume': {'size': 1,
+                        'metadata': metadata}})
+        LOG.debug("created_volume: %s" % created_volume)
+        self.assertTrue(created_volume['id'])
+        created_volume_id = created_volume['id']
+
+        # Check it's there and metadata present
+        found_volume = self.api.get_volume(created_volume_id)
+        self.assertEqual(created_volume_id, found_volume['id'])
+        self.assertEqual(metadata, found_volume['metadata'])
 
 if __name__ == "__main__":
     unittest.main()

=== added file 'nova/tests/test_volume_types.py'
--- nova/tests/test_volume_types.py	1970-01-01 00:00:00 +0000
+++ nova/tests/test_volume_types.py	2011-08-24 23:44:25 +0000
@@ -0,0 +1,207 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright (c) 2011 Zadara Storage Inc.
+# Copyright (c) 2011 OpenStack LLC.
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+"""
+Unit Tests for volume types code
+"""
+import time
+
+from nova import context
+from nova import db
+from nova import exception
+from nova import flags
+from nova import log as logging
+from nova import test
+from nova import utils
+from nova.volume import volume_types
+from nova.db.sqlalchemy.session import get_session
+from nova.db.sqlalchemy import models
+
+FLAGS = flags.FLAGS
+LOG = logging.getLogger('nova.tests.test_volume_types')
+
+
+class VolumeTypeTestCase(test.TestCase):
+    """Test cases for volume type code"""
+    def setUp(self):
+        super(VolumeTypeTestCase, self).setUp()
+
+        self.ctxt = context.get_admin_context()
+        self.vol_type1_name = str(int(time.time()))
+        self.vol_type1_specs = dict(
+                    type="physical drive",
+                    drive_type="SAS",
+                    size="300",
+                    rpm="7200",
+                    visible="True")
+        self.vol_type1 = dict(name=self.vol_type1_name,
+                              extra_specs=self.vol_type1_specs)
+
+    def test_volume_type_create_then_destroy(self):
+        """Ensure volume types can be created and deleted"""
+        prev_all_vtypes = volume_types.get_all_types(self.ctxt)
+
+        volume_types.create(self.ctxt,
+                            self.vol_type1_name,
+                            self.vol_type1_specs)
+        new = volume_types.get_volume_type_by_name(self.ctxt,
+                                                   self.vol_type1_name)
+
+        LOG.info(_("Given data: %s"), self.vol_type1_specs)
+        LOG.info(_("Result data: %s"), new)
+
+        for k, v in self.vol_type1_specs.iteritems():
+            self.assertEqual(v, new['extra_specs'][k],
+                             'one of fields doesnt match')
+
+        new_all_vtypes = volume_types.get_all_types(self.ctxt)
+        self.assertEqual(len(prev_all_vtypes) + 1,
+                         len(new_all_vtypes),
+                         'drive type was not created')
+
+        volume_types.destroy(self.ctxt, self.vol_type1_name)
+        new_all_vtypes = volume_types.get_all_types(self.ctxt)
+        self.assertEqual(prev_all_vtypes,
+                         new_all_vtypes,
+                         'drive type was not deleted')
+
+    def test_volume_type_create_then_purge(self):
+        """Ensure volume types can be created and deleted"""
+        prev_all_vtypes = volume_types.get_all_types(self.ctxt, inactive=1)
+
+        volume_types.create(self.ctxt,
+                            self.vol_type1_name,
+                            self.vol_type1_specs)
+        new = volume_types.get_volume_type_by_name(self.ctxt,
+                                                   self.vol_type1_name)
+
+        for k, v in self.vol_type1_specs.iteritems():
+            self.assertEqual(v, new['extra_specs'][k],
+                             'one of fields doesnt match')
+
+        new_all_vtypes = volume_types.get_all_types(self.ctxt, inactive=1)
+        self.assertEqual(len(prev_all_vtypes) + 1,
+                         len(new_all_vtypes),
+                         'drive type was not created')
+
+        volume_types.destroy(self.ctxt, self.vol_type1_name)
+        new_all_vtypes2 = volume_types.get_all_types(self.ctxt, inactive=1)
+        self.assertEqual(len(new_all_vtypes),
+                         len(new_all_vtypes2),
+                         'drive type was incorrectly deleted')
+
+        volume_types.purge(self.ctxt, self.vol_type1_name)
+        new_all_vtypes2 = volume_types.get_all_types(self.ctxt, inactive=1)
+        self.assertEqual(len(new_all_vtypes) - 1,
+                         len(new_all_vtypes2),
+                         'drive type was not purged')
+
+    def test_get_all_volume_types(self):
+        """Ensures that all volume types can be retrieved"""
+        session = get_session()
+        total_volume_types = session.query(models.VolumeTypes).\
+                                           count()
+        vol_types = volume_types.get_all_types(self.ctxt)
+        self.assertEqual(total_volume_types, len(vol_types))
+
+    def test_non_existant_inst_type_shouldnt_delete(self):
+        """Ensures that volume type creation fails with invalid args"""
+        self.assertRaises(exception.ApiError,
+                          volume_types.destroy, self.ctxt, "sfsfsdfdfs")
+
+    def test_repeated_vol_types_should_raise_api_error(self):
+        """Ensures that volume duplicates raises ApiError"""
+        new_name = self.vol_type1_name + "dup"
+        volume_types.create(self.ctxt, new_name)
+        volume_types.destroy(self.ctxt, new_name)
+        self.assertRaises(
+                exception.ApiError,
+                volume_types.create, self.ctxt, new_name)
+
+    def test_invalid_volume_types_params(self):
+        """Ensures that volume type creation fails with invalid args"""
+        self.assertRaises(exception.InvalidVolumeType,
+                          volume_types.destroy, self.ctxt, None)
+        self.assertRaises(exception.InvalidVolumeType,
+                          volume_types.purge, self.ctxt, None)
+        self.assertRaises(exception.InvalidVolumeType,
+                          volume_types.get_volume_type, self.ctxt, None)
+        self.assertRaises(exception.InvalidVolumeType,
+                          volume_types.get_volume_type_by_name,
+                          self.ctxt, None)
+
+    def test_volume_type_get_by_id_and_name(self):
+        """Ensure volume types get returns same entry"""
+        volume_types.create(self.ctxt,
+                            self.vol_type1_name,
+                            self.vol_type1_specs)
+        new = volume_types.get_volume_type_by_name(self.ctxt,
+                                                   self.vol_type1_name)
+
+        new2 = volume_types.get_volume_type(self.ctxt, new['id'])
+        self.assertEqual(new, new2)
+
+    def test_volume_type_search_by_extra_spec(self):
+        """Ensure volume types get by extra spec returns correct type"""
+        volume_types.create(self.ctxt, "type1", {"key1": "val1",
+                                                 "key2": "val2"})
+        volume_types.create(self.ctxt, "type2", {"key2": "val2",
+                                                 "key3": "val3"})
+        volume_types.create(self.ctxt, "type3", {"key3": "another_value",
+                                                 "key4": "val4"})
+
+        vol_types = volume_types.get_all_types(self.ctxt,
+                        search_opts={'extra_specs': {"key1": "val1"}})
+        LOG.info("vol_types: %s" % vol_types)
+        self.assertEqual(len(vol_types), 1)
+        self.assertTrue("type1" in vol_types.keys())
+        self.assertEqual(vol_types['type1']['extra_specs'],
+                         {"key1": "val1", "key2": "val2"})
+
+        vol_types = volume_types.get_all_types(self.ctxt,
+                        search_opts={'extra_specs': {"key2": "val2"}})
+        LOG.info("vol_types: %s" % vol_types)
+        self.assertEqual(len(vol_types), 2)
+        self.assertTrue("type1" in vol_types.keys())
+        self.assertTrue("type2" in vol_types.keys())
+
+        vol_types = volume_types.get_all_types(self.ctxt,
+                        search_opts={'extra_specs': {"key3": "val3"}})
+        LOG.info("vol_types: %s" % vol_types)
+        self.assertEqual(len(vol_types), 1)
+        self.assertTrue("type2" in vol_types.keys())
+
+    def test_volume_type_search_by_extra_spec_multiple(self):
+        """Ensure volume types get by extra spec returns correct type"""
+        volume_types.create(self.ctxt, "type1", {"key1": "val1",
+                                                 "key2": "val2",
+                                                 "key3": "val3"})
+        volume_types.create(self.ctxt, "type2", {"key2": "val2",
+                                                 "key3": "val3"})
+        volume_types.create(self.ctxt, "type3", {"key1": "val1",
+                                                 "key3": "val3",
+                                                 "key4": "val4"})
+
+        vol_types = volume_types.get_all_types(self.ctxt,
+                        search_opts={'extra_specs': {"key1": "val1",
+                                                     "key3": "val3"}})
+        LOG.info("vol_types: %s" % vol_types)
+        self.assertEqual(len(vol_types), 2)
+        self.assertTrue("type1" in vol_types.keys())
+        self.assertTrue("type3" in vol_types.keys())
+        self.assertEqual(vol_types['type1']['extra_specs'],
+                         {"key1": "val1", "key2": "val2", "key3": "val3"})
+        self.assertEqual(vol_types['type3']['extra_specs'],
+                         {"key1": "val1", "key3": "val3", "key4": "val4"})

=== added file 'nova/tests/test_volume_types_extra_specs.py'
--- nova/tests/test_volume_types_extra_specs.py	1970-01-01 00:00:00 +0000
+++ nova/tests/test_volume_types_extra_specs.py	2011-08-24 23:44:25 +0000
@@ -0,0 +1,132 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright (c) 2011 Zadara Storage Inc.
+# Copyright (c) 2011 OpenStack LLC.
+# Copyright 2011 University of Southern California
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+"""
+Unit Tests for volume types extra specs code
+"""
+
+from nova import context
+from nova import db
+from nova import test
+from nova.db.sqlalchemy.session import get_session
+from nova.db.sqlalchemy import models
+
+
+class VolumeTypeExtraSpecsTestCase(test.TestCase):
+
+    def setUp(self):
+        super(VolumeTypeExtraSpecsTestCase, self).setUp()
+        self.context = context.get_admin_context()
+        self.vol_type1 = dict(name="TEST: Regular volume test")
+        self.vol_type1_specs = dict(vol_extra1="value1",
+                                  vol_extra2="value2",
+                                  vol_extra3=3)
+        self.vol_type1['extra_specs'] = self.vol_type1_specs
+        ref = db.api.volume_type_create(self.context, self.vol_type1)
+        self.volume_type1_id = ref.id
+        for k, v in self.vol_type1_specs.iteritems():
+            self.vol_type1_specs[k] = str(v)
+
+        self.vol_type2_noextra = dict(name="TEST: Volume type without extra")
+        ref = db.api.volume_type_create(self.context, self.vol_type2_noextra)
+        self.vol_type2_id = ref.id
+
+    def tearDown(self):
+        # Remove the instance type from the database
+        db.api.volume_type_purge(context.get_admin_context(),
+                                 self.vol_type1['name'])
+        db.api.volume_type_purge(context.get_admin_context(),
+                                 self.vol_type2_noextra['name'])
+        super(VolumeTypeExtraSpecsTestCase, self).tearDown()
+
+    def test_volume_type_specs_get(self):
+        expected_specs = self.vol_type1_specs.copy()
+        actual_specs = db.api.volume_type_extra_specs_get(
+                              context.get_admin_context(),
+                              self.volume_type1_id)
+        self.assertEquals(expected_specs, actual_specs)
+
+    def test_volume_type_extra_specs_delete(self):
+        expected_specs = self.vol_type1_specs.copy()
+        del expected_specs['vol_extra2']
+        db.api.volume_type_extra_specs_delete(context.get_admin_context(),
+                                      self.volume_type1_id,
+                                      'vol_extra2')
+        actual_specs = db.api.volume_type_extra_specs_get(
+                              context.get_admin_context(),
+                              self.volume_type1_id)
+        self.assertEquals(expected_specs, actual_specs)
+
+    def test_volume_type_extra_specs_update(self):
+        expected_specs = self.vol_type1_specs.copy()
+        expected_specs['vol_extra3'] = "4"
+        db.api.volume_type_extra_specs_update_or_create(
+                              context.get_admin_context(),
+                              self.volume_type1_id,
+                              dict(vol_extra3=4))
+        actual_specs = db.api.volume_type_extra_specs_get(
+                              context.get_admin_context(),
+                              self.volume_type1_id)
+        self.assertEquals(expected_specs, actual_specs)
+
+    def test_volume_type_extra_specs_create(self):
+        expected_specs = self.vol_type1_specs.copy()
+        expected_specs['vol_extra4'] = 'value4'
+        expected_specs['vol_extra5'] = 'value5'
+        db.api.volume_type_extra_specs_update_or_create(
+                              context.get_admin_context(),
+                              self.volume_type1_id,
+                              dict(vol_extra4="value4",
+                                   vol_extra5="value5"))
+        actual_specs = db.api.volume_type_extra_specs_get(
+                              context.get_admin_context(),
+                              self.volume_type1_id)
+        self.assertEquals(expected_specs, actual_specs)
+
+    def test_volume_type_get_with_extra_specs(self):
+        volume_type = db.api.volume_type_get(
+                            context.get_admin_context(),
+                            self.volume_type1_id)
+        self.assertEquals(volume_type['extra_specs'],
+                          self.vol_type1_specs)
+
+        volume_type = db.api.volume_type_get(
+                            context.get_admin_context(),
+                            self.vol_type2_id)
+        self.assertEquals(volume_type['extra_specs'], {})
+
+    def test_volume_type_get_by_name_with_extra_specs(self):
+        volume_type = db.api.volume_type_get_by_name(
+                            context.get_admin_context(),
+                            self.vol_type1['name'])
+        self.assertEquals(volume_type['extra_specs'],
+                          self.vol_type1_specs)
+
+        volume_type = db.api.volume_type_get_by_name(
+                            context.get_admin_context(),
+                            self.vol_type2_noextra['name'])
+        self.assertEquals(volume_type['extra_specs'], {})
+
+    def test_volume_type_get_all(self):
+        expected_specs = self.vol_type1_specs.copy()
+
+        types = db.api.volume_type_get_all(context.get_admin_context())
+
+        self.assertEquals(
+            types[self.vol_type1['name']]['extra_specs'], expected_specs)
+
+        self.assertEquals(
+            types[self.vol_type2_noextra['name']]['extra_specs'], {})

=== modified file 'nova/volume/api.py'
--- nova/volume/api.py	2011-07-25 14:07:32 +0000
+++ nova/volume/api.py	2011-08-24 23:44:25 +0000
@@ -41,7 +41,8 @@
 class API(base.Base):
     """API for interacting with the volume manager."""
 
-    def create(self, context, size, snapshot_id, name, description):
+    def create(self, context, size, snapshot_id, name, description,
+                     volume_type=None, metadata=None, availability_zone=None):
         if snapshot_id != None:
             snapshot = self.get_snapshot(context, snapshot_id)
             if snapshot['status'] != "available":
@@ -57,16 +58,27 @@
             raise quota.QuotaError(_("Volume quota exceeded. You cannot "
                                      "create a volume of size %sG") % size)
 
+        if availability_zone is None:
+            availability_zone = FLAGS.storage_availability_zone
+
+        if volume_type is None:
+            volume_type_id = None
+        else:
+            volume_type_id = volume_type.get('id', None)
+
         options = {
             'size': size,
             'user_id': context.user_id,
             'project_id': context.project_id,
             'snapshot_id': snapshot_id,
-            'availability_zone': FLAGS.storage_availability_zone,
+            'availability_zone': availability_zone,
             'status': "creating",
             'attach_status': "detached",
             'display_name': name,
-            'display_description': description}
+            'display_description': description,
+            'volume_type_id': volume_type_id,
+            'metadata': metadata,
+            }
 
         volume = self.db.volume_create(context, options)
         rpc.cast(context,
@@ -105,10 +117,44 @@
         rv = self.db.volume_get(context, volume_id)
         return dict(rv.iteritems())
 
-    def get_all(self, context):
+    def get_all(self, context, search_opts={}):
         if context.is_admin:
-            return self.db.volume_get_all(context)
-        return self.db.volume_get_all_by_project(context, context.project_id)
+            volumes = self.db.volume_get_all(context)
+        else:
+            volumes = self.db.volume_get_all_by_project(context,
+                                    context.project_id)
+
+        if search_opts:
+            LOG.debug(_("Searching by: %s") % str(search_opts))
+
+            def _check_metadata_match(volume, searchdict):
+                volume_metadata = {}
+                for i in volume.get('volume_metadata'):
+                    volume_metadata[i['key']] = i['value']
+
+                for k, v in searchdict:
+                    if k not in volume_metadata.keys()\
+                       or volume_metadata[k] != v:
+                        return False
+                return True
+
+            # search_option to filter_name mapping.
+            filter_mapping = {'metadata': _check_metadata_match}
+
+            for volume in volumes:
+                # go over all filters in the list
+                for opt, values in search_opts.iteritems():
+                    try:
+                        filter_func = filter_mapping[opt]
+                    except KeyError:
+                        # no such filter - ignore it, go to next filter
+                        continue
+                    else:
+                        if filter_func(volume, values) == False:
+                            # if one of conditions didn't match - remove
+                            volumes.remove(volume)
+                            break
+        return volumes
 
     def get_snapshot(self, context, snapshot_id):
         rv = self.db.snapshot_get(context, snapshot_id)
@@ -183,3 +229,29 @@
                  {"method": "delete_snapshot",
                   "args": {"topic": FLAGS.volume_topic,
                            "snapshot_id": snapshot_id}})
+
+    def get_volume_metadata(self, context, volume_id):
+        """Get all metadata associated with a volume."""
+        rv = self.db.volume_metadata_get(context, volume_id)
+        return dict(rv.iteritems())
+
+    def delete_volume_metadata(self, context, volume_id, key):
+        """Delete the given metadata item from an volume."""
+        self.db.volume_metadata_delete(context, volume_id, key)
+
+    def update_volume_metadata(self, context, volume_id,
+                                 metadata, delete=False):
+        """Updates or creates volume metadata.
+
+        If delete is True, metadata items that are not specified in the
+        `metadata` argument will be deleted.
+
+        """
+        if delete:
+            _metadata = metadata
+        else:
+            _metadata = self.get_volume_metadata(context, volume_id)
+            _metadata.update(metadata)
+
+        self.db.volume_metadata_update(context, volume_id, _metadata, True)
+        return _metadata

=== added file 'nova/volume/volume_types.py'
--- nova/volume/volume_types.py	1970-01-01 00:00:00 +0000
+++ nova/volume/volume_types.py	2011-08-24 23:44:25 +0000
@@ -0,0 +1,129 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright (c) 2011 Zadara Storage Inc.
+# Copyright (c) 2011 OpenStack LLC.
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# Copyright (c) 2010 Citrix Systems, Inc.
+# Copyright 2011 Ken Pepple
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""Built-in volume type properties."""
+
+from nova import context
+from nova import db
+from nova import exception
+from nova import flags
+from nova import log as logging
+
+FLAGS = flags.FLAGS
+LOG = logging.getLogger('nova.volume.volume_types')
+
+
+def create(context, name, extra_specs={}):
+    """Creates volume types."""
+    try:
+        db.volume_type_create(context,
+                              dict(name=name,
+                                   extra_specs=extra_specs))
+    except exception.DBError, e:
+        LOG.exception(_('DB error: %s') % e)
+        raise exception.ApiError(_("Cannot create volume_type with "
+                                    "name %(name)s and specs %(extra_specs)s")
+                                    % locals())
+
+
+def destroy(context, name):
+    """Marks volume types as deleted."""
+    if name is None:
+        raise exception.InvalidVolumeType(volume_type=name)
+    else:
+        try:
+            db.volume_type_destroy(context, name)
+        except exception.NotFound:
+            LOG.exception(_('Volume type %s not found for deletion') % name)
+            raise exception.ApiError(_("Unknown volume type: %s") % name)
+
+
+def purge(context, name):
+    """Removes volume types from database."""
+    if name is None:
+        raise exception.InvalidVolumeType(volume_type=name)
+    else:
+        try:
+            db.volume_type_purge(context, name)
+        except exception.NotFound:
+            LOG.exception(_('Volume type %s not found for purge') % name)
+            raise exception.ApiError(_("Unknown volume type: %s") % name)
+
+
+def get_all_types(context, inactive=0, search_opts={}):
+    """Get all non-deleted volume_types.
+
+    Pass true as argument if you want deleted volume types returned also.
+
+    """
+    vol_types = db.volume_type_get_all(context, inactive)
+
+    if search_opts:
+        LOG.debug(_("Searching by: %s") % str(search_opts))
+
+        def _check_extra_specs_match(vol_type, searchdict):
+            for k, v in searchdict.iteritems():
+                if k not in vol_type['extra_specs'].keys()\
+                   or vol_type['extra_specs'][k] != v:
+                    return False
+            return True
+
+        # search_option to filter_name mapping.
+        filter_mapping = {'extra_specs': _check_extra_specs_match}
+
+        result = {}
+        for type_name, type_args in vol_types.iteritems():
+            # go over all filters in the list
+            for opt, values in search_opts.iteritems():
+                try:
+                    filter_func = filter_mapping[opt]
+                except KeyError:
+                    # no such filter - ignore it, go to next filter
+                    continue
+                else:
+                    if filter_func(type_args, values):
+                        # if one of conditions didn't match - remove
+                        result[type_name] = type_args
+                        break
+        vol_types = result
+    return vol_types
+
+
+def get_volume_type(context, id):
+    """Retrieves single volume type by id."""
+    if id is None:
+        raise exception.InvalidVolumeType(volume_type=id)
+
+    try:
+        return db.volume_type_get(context, id)
+    except exception.DBError:
+        raise exception.ApiError(_("Unknown volume type: %s") % id)
+
+
+def get_volume_type_by_name(context, name):
+    """Retrieves single volume type by name."""
+    if name is None:
+        raise exception.InvalidVolumeType(volume_type=name)
+
+    try:
+        return db.volume_type_get_by_name(context, name)
+    except exception.DBError:
+        raise exception.ApiError(_("Unknown volume type: %s") % name)