Merge lp:~rackspace-titan/nova/ram-limits into lp:~hudson-openstack/nova/trunk

[Mark Washenberger]

Several changes designed to bring the openstack api 1.1 closer to spec
- add ram limits to the nova compute quotas
- enable injected file limits and injected file size limits to be overridden in the quota database table
- expose quota limits as absolute limits in the openstack api 1.1 limits resource
- add support for controlling 'unlimited' quotas to nova-manage

[Brian Waldon (bcwaldon)]

Great work, guys. I found some style issues:

119: the name ram_count is a bit awkward. Change it to ram_total (or something better)?

139: Is there no cleaner way to accomplish this?

198: The function name in nova/quota.py "get_quota" should be made plural (get_project_quotas?). It even uses a db api method that refers to multiple quotas. Thoughts?

216: Can you change num_ram and num_cores to required_ram and required_cores? It would help with function readability. Same goes for num_gigabytes in the allowed_volumes function.

review: Needs Fixing

[Mark Washenberger (markwash)]

I agree with all of those. But for

> 119: the name ram_count is a bit awkward. Change it to ram_total (or something better)?

I can't see a way to clean this up that is in scope here.

The others, I have corrected. Let me know if you see any other issues.

[Brian Waldon (bcwaldon)]

> I agree with all of those. But for
>
> > 119: the name ram_count is a bit awkward. Change it to ram_total (or
> something better)?
>
> I can't see a way to clean this up that is in scope here.
>
> The others, I have corrected. Let me know if you see any other issues.

Looks good. I assume you meant to refer to my comments about line 139 above...

review: Approve

[Mark Washenberger (markwash)]

> Looks good. I assume you meant to refer to my comments about line 139 above...

Yes. Sorry, that was what I meant.

[Dan Prince (dan-prince)]

Hey Mark.

This code works however if an end user actually hits the limit the error message (returned in the quota) exception is somewhat misleading.

If I do something like this:

I have 1 node:

root@nova1:~# nova list
+----+----------+--------+-----------+------------+
| ID | Name | Status | Public IP | Private IP |
+----+----------+--------+-----------+------------+
| 1 | Server 1 | ACTIVE | | 172.19.1.2 |
+----+----------+--------+-----------+------------+

I set my limits really low:

root@nova1:~# nova-manage project quota admin ram 1000
metadata_items: 128
instances: 10
injected_file_content_bytes: 10240
injected_files: 5
volumes: 10
gigabytes: 1000
cores: 20
ram: 1000
floating_ips: 10

I then get an exception that looks like this:

root@nova1:~# nova boot --flavor 1 --image 3 test
InstanceLimitExceeded: Instance quota exceeded. You can only run -2 more instances of this type. (HTTP 500)

---

Can we update the exception handling in the compute API so that this error message is related to the actual limit that is being hit.

review: Needs Fixing

[Dan Prince (dan-prince)]

The error I get on the EC2 side is a bit different:

root@nova1:~# euca-run-instances -t m1.small -k test ami-00000003
InstanceLimitExceeded: InstanceLimitExceeded: Instance quota exceeded. You can only run -0 more instances of this type.

--

In both cases (using either the OSAPI or the EC2 API) I am hitting a RAM limit.

[Dan Prince (dan-prince)]

Never mind on the EC2 error being different. The reason it didn't match was because I used 'm1.small' instead of 'm1.tiny' (which would have match flavor ID 1 in my installation).

We just need to fix the quota error message when a RAM limit is hit.

[Mark Washenberger (markwash)]

Nice catch! It doesn't look like I cause this misbehavior, but this seems as good a time as any to fix it. So I did.

[Dan Prince (dan-prince)]

Hi Mark,

Okay. Your latest commit resolves the issue w/ the negative numbers in the error messages returned from the API when you hit a quota. Thanks!

---

Couple more things:

1) Why did you choose not to implement absolute limits for the v1.0 view (/v1.0/limits). I believe it is in the SPEC? I'd really like to have the absolute limits on the v1.0 call as well.

2) The HTTP return codes when you actually hit a quota limit are a weird mix. I get a 500 level error code when I hit a RAM limit (the one you are adding this this merge prop). Just for fun I tried another one for the personality limit and I got an HTTP 400 error code. Looking at the SPEC again it looks like we should actually be returning a HTTP 413 'overLimit' error code. Perhaps this is something to handle outside the scope of this merge prop but I thought it worth mentioning since it would make sense that all the limit exceeded quotas should probably return a similar HTTP error code.

review: Needs Fixing

[Mark Washenberger (markwash)]

>
> 1) Why did you choose not to implement absolute limits for the v1.0 view
> (/v1.0/limits). I believe it is in the SPEC? I'd really like to have the
> absolute limits on the v1.0 call as well.

For some reason I thought the 1.0 api was out of scope for our current task--but that doesn't really make any sense to me now. I will try to add these limits to 1.0 now.

>
> 2) The HTTP return codes when you actually hit a quota limit are a weird mix.
> I get a 500 level error code when I hit a RAM limit (the one you are adding
> this this merge prop). Just for fun I tried another one for the personality
> limit and I got an HTTP 400 error code. Looking at the SPEC again it looks
> like we should actually be returning a HTTP 413 'overLimit' error code.
> Perhaps this is something to handle outside the scope of this merge prop but I
> thought it worth mentioning since it would make sense that all the limit
> exceeded quotas should probably return a similar HTTP error code.

I agree that this is a problem. Like you suggested, I would like for us to do a review of these error conditions and address them in a separate bug and branch. I think that makes sense especially since the discrepancy you mentioned is not introduced in my branch.

[Dan Prince (dan-prince)]

Thanks Mark.

Looks good. I filed a ticket for the 413 issue here: https://bugs.launchpad.net/nova/+bug/785812

review: Approve

[Chris Behrens (cbehrens)]

I just see a minor style thing that's different than most of the rest of nova when dictionaries are created. Take the 'limit_names' dict around line 59 for example. If matching the rest of nova, it would look like this:

limit_names = {"ram": ["maxTotalRAMSize"],
               "instances": ["maxTotalInstances"],
               "cores": ["maxTotalCores"],
               "metadata_items": ["maxServerMeta", "maxImageMeta"],
               "injected_files": ["maxPersonality"],
               "injected_file_content_bytes": ["maxPersonalitySize"]}

I see this a number of other places. (Personally, I like your style, but I feel I should point out how the nova code looks..)

[Mark Washenberger (markwash)]

Thanks for checking!

Based on my grepping, my style occurs 327 times in the nova libraries, and the other style occurs 410 times. Relatively even in my judgement. I also do not see a reference to this style choice either way in HACKING. Finally, I prefer my style because adding something to the end of the dict is a one line diff, whereas in the other style it is often 2 lines of change.

[Trey Morris (tr3buchet)]

May be a bit off here, but is there any chance we could have '0' mean 'unlimited'? This way there'd be no type checking and there would never be any converting to None and back. I don't know about you guys, but when I see an integer limit of 0 I usually assume it means no limit.

[Mark Washenberger (markwash)]

Trey,

Right now the database and the config flags disagree (one says -1 == unlimited, the db says Null == unlimited). After reading your comment that seems more and more like a wart that should be eliminated.

However, I am a bit uncomfortable with making 0 the standard for unlimited, since it does seem like a valid limit in some cases. Suppose a deployer doesn't like floating ips and thus literally wants to limit them to zero for projects? There are also future quota cases where 0 might make sense.

How do you feel about standardizing on -1 instead of 0? And having that reflected in both the flags and the db entries?

[Vish Ishaya (vishvananda)]

lgtm.

review: Approve

[OpenStack Infra (hudson-openstack)]

The attempt to merge lp:~rackspace-titan/nova/ram-limits into lp:nova failed. Below is the output from the failed tests.

AccountsTest
    test_account_create OK
    test_account_delete OK
    test_account_update OK
    test_get_account OK
AdminAPITest
    test_admin_disabled OK
    test_admin_enabled OK
APITest
    test_exceptions_are_converted_to_faults OK
Test
    test_authorize_token OK
    test_authorize_user OK
    test_bad_token OK
    test_bad_user_bad_key OK
    test_bad_user_good_key OK
    test_no_user OK
    test_token_expiry OK
TestFunctional
    test_token_doesnotexist OK
    test_token_expiry OK
TestLimiter
    test_authorize_token OK
LimiterTest
    test_limiter_custom_max_limit OK
    test_limiter_limit_and_offset OK
    test_limiter_limit_medium OK
    test_limiter_limit_over_max OK
    test_limiter_limit_zero OK
    test_limiter_negative_limit OK
    test_limiter_negative_offset OK
    test_limiter_nothing OK
    test_limiter_offset_bad OK
    test_limiter_offset_blank OK
    test_limiter_offset_medium OK
    test_limiter_offset_over_max OK
    test_limiter_offset_zero OK
ActionExtensionTest
    test_extended_action OK
    test_invalid_action OK
    test_invalid_action_body OK
ExtensionControllerTest
    test_get_by_alias OK
    test_index OK
ExtensionManagerTest
    test_get_resources OK
RequestExtensionTest
    test_get_resources_with_mgr OK
    test_get_resources_with_stub_mgr OK
ResourceExtensionTest
    test_get_resources OK
    test_get_resources_with_controller OK
    test_no_extension_present OK
TestFaults
    test_400_fault_json OK
    test_400_fault_xml OK
...

[lp:~rackspace-titan/nova/ram-limits]

1079. By Mark Washenberger on 2011-05-25

pep8 fixes

[Brian Waldon (bcwaldon)]

Re-approving since Mark fixed the pep8 issues

=== modified file 'bin/nova-manage'
--- bin/nova-manage	2011-05-25 15:58:17 +0000
+++ bin/nova-manage	2011-05-25 19:53:25 +0000
@@ -417,12 +417,16 @@
         arguments: project_id [key] [value]"""
         ctxt = context.get_admin_context()
         if key:
+            if value.lower() == 'unlimited':
+                value = None
             try:
                 db.quota_update(ctxt, project_id, key, value)
             except exception.ProjectQuotaNotFound:
                 db.quota_create(ctxt, project_id, key, value)
-        project_quota = quota.get_quota(ctxt, project_id)
+        project_quota = quota.get_project_quotas(ctxt, project_id)
         for key, value in project_quota.iteritems():
+            if value is None:
+                value = 'unlimited'
             print '%s: %s' % (key, value)
 
     def remove(self, project_id, user_id):

=== modified file 'nova/api/openstack/limits.py'
--- nova/api/openstack/limits.py	2011-05-03 16:25:19 +0000
+++ nova/api/openstack/limits.py	2011-05-25 19:53:25 +0000
@@ -30,6 +30,7 @@
 
 from webob.dec import wsgify
 
+from nova import quota
 from nova import wsgi
 from nova.api.openstack import common
 from nova.api.openstack import faults
@@ -64,7 +65,8 @@
         """
         Return all global and rate limit information.
         """
-        abs_limits = {}
+        context = req.environ['nova.context']
+        abs_limits = quota.get_project_quotas(context, context.project_id)
         rate_limits = req.environ.get("nova.limits", [])
 
         builder = self._get_view_builder(req)

=== modified file 'nova/api/openstack/views/limits.py'
--- nova/api/openstack/views/limits.py	2011-05-06 18:13:27 +0000
+++ nova/api/openstack/views/limits.py	2011-05-25 19:53:25 +0000
@@ -45,6 +45,34 @@
 
         return output
 
+    def _build_absolute_limits(self, absolute_limits):
+        """Builder for absolute limits
+
+        absolute_limits should be given as a dict of limits.
+        For example: {"ram": 512, "gigabytes": 1024}.
+
+        """
+        limit_names = {
+            "ram": ["maxTotalRAMSize"],
+            "instances": ["maxTotalInstances"],
+            "cores": ["maxTotalCores"],
+            "metadata_items": ["maxServerMeta", "maxImageMeta"],
+            "injected_files": ["maxPersonality"],
+            "injected_file_content_bytes": ["maxPersonalitySize"],
+        }
+        limits = {}
+        for name, value in absolute_limits.iteritems():
+            if name in limit_names and value is not None:
+                for name in limit_names[name]:
+                    limits[name] = value
+        return limits
+
+    def _build_rate_limits(self, rate_limits):
+        raise NotImplementedError()
+
+    def _build_rate_limit(self, rate_limit):
+        raise NotImplementedError()
+
 
 class ViewBuilderV10(ViewBuilder):
     """Openstack API v1.0 limits view builder."""
@@ -63,9 +91,6 @@
             "resetTime": rate_limit["resetTime"],
         }
 
-    def _build_absolute_limits(self, absolute_limit):
-        return {}
-
 
 class ViewBuilderV11(ViewBuilder):
     """Openstack API v1.1 limits view builder."""
@@ -104,6 +129,3 @@
             "unit": rate_limit["unit"],
             "next-available": rate_limit["resetTime"],
         }
-
-    def _build_absolute_limits(self, absolute_limit):
-        return {}

=== modified file 'nova/compute/api.py'
--- nova/compute/api.py	2011-05-24 22:51:29 +0000
+++ nova/compute/api.py	2011-05-25 19:53:25 +0000
@@ -95,14 +95,15 @@
         """
         if injected_files is None:
             return
-        limit = quota.allowed_injected_files(context)
+        limit = quota.allowed_injected_files(context, len(injected_files))
         if len(injected_files) > limit:
             raise quota.QuotaError(code="OnsetFileLimitExceeded")
         path_limit = quota.allowed_injected_file_path_bytes(context)
-        content_limit = quota.allowed_injected_file_content_bytes(context)
         for path, content in injected_files:
             if len(path) > path_limit:
                 raise quota.QuotaError(code="OnsetFilePathLimitExceeded")
+            content_limit = quota.allowed_injected_file_content_bytes(
+                                                    context, len(content))
             if len(content) > content_limit:
                 raise quota.QuotaError(code="OnsetFileContentLimitExceeded")
 
@@ -149,9 +150,13 @@
             pid = context.project_id
             LOG.warn(_("Quota exceeeded for %(pid)s,"
                     " tried to run %(min_count)s instances") % locals())
-            raise quota.QuotaError(_("Instance quota exceeded. You can only "
-                                     "run %s more instances of this type.") %
-                                   num_instances, "InstanceLimitExceeded")
+            if num_instances <= 0:
+                message = _("Instance quota exceeded. You cannot run any "
+                            "more instances of this type.")
+            else:
+                message = _("Instance quota exceeded. You can only run %s "
+                            "more instances of this type.") % num_instances
+            raise quota.QuotaError(message, "InstanceLimitExceeded")
 
         self._check_metadata_properties_quota(context, metadata)
         self._check_injected_file_quota(context, injected_files)

=== modified file 'nova/db/api.py'
--- nova/db/api.py	2011-05-11 18:32:28 +0000
+++ nova/db/api.py	2011-05-25 19:53:25 +0000
@@ -403,7 +403,7 @@
 
 
 def instance_data_get_for_project(context, project_id):
-    """Get (instance_count, core_count) for project."""
+    """Get (instance_count, total_cores, total_ram) for project."""
     return IMPL.instance_data_get_for_project(context, project_id)
 
 

=== modified file 'nova/db/sqlalchemy/api.py'
--- nova/db/sqlalchemy/api.py	2011-05-16 22:36:42 +0000
+++ nova/db/sqlalchemy/api.py	2011-05-25 19:53:25 +0000
@@ -803,12 +803,13 @@
 def instance_data_get_for_project(context, project_id):
     session = get_session()
     result = session.query(func.count(models.Instance.id),
-                           func.sum(models.Instance.vcpus)).\
+                           func.sum(models.Instance.vcpus),
+                           func.sum(models.Instance.memory_mb)).\
                      filter_by(project_id=project_id).\
                      filter_by(deleted=False).\
                      first()
     # NOTE(vish): convert None to 0
-    return (result[0] or 0, result[1] or 0)
+    return (result[0] or 0, result[1] or 0, result[2] or 0)
 
 
 @require_context
@@ -1499,7 +1500,7 @@
 ###################
 
 
-@require_admin_context
+@require_context
 def quota_get(context, project_id, resource, session=None):
     if not session:
         session = get_session()
@@ -1513,7 +1514,7 @@
     return result
 
 
-@require_admin_context
+@require_context
 def quota_get_all_by_project(context, project_id):
     session = get_session()
     result = {'project_id': project_id}

=== modified file 'nova/quota.py'
--- nova/quota.py	2011-05-11 18:01:41 +0000
+++ nova/quota.py	2011-05-25 19:53:25 +0000
@@ -28,6 +28,8 @@
                      'number of instances allowed per project')
 flags.DEFINE_integer('quota_cores', 20,
                      'number of instance cores allowed per project')
+flags.DEFINE_integer('quota_ram', 50 * 1024,
+                     'megabytes of instance ram allowed per project')
 flags.DEFINE_integer('quota_volumes', 10,
                      'number of volumes allowed per project')
 flags.DEFINE_integer('quota_gigabytes', 1000,
@@ -44,14 +46,28 @@
                      'number of bytes allowed per injected file path')
 
 
-def get_quota(context, project_id):
-    rval = {'instances': FLAGS.quota_instances,
-            'cores': FLAGS.quota_cores,
-            'volumes': FLAGS.quota_volumes,
-            'gigabytes': FLAGS.quota_gigabytes,
-            'floating_ips': FLAGS.quota_floating_ips,
-            'metadata_items': FLAGS.quota_metadata_items}
-
+def _get_default_quotas():
+    defaults = {
+        'instances': FLAGS.quota_instances,
+        'cores': FLAGS.quota_cores,
+        'ram': FLAGS.quota_ram,
+        'volumes': FLAGS.quota_volumes,
+        'gigabytes': FLAGS.quota_gigabytes,
+        'floating_ips': FLAGS.quota_floating_ips,
+        'metadata_items': FLAGS.quota_metadata_items,
+        'injected_files': FLAGS.quota_max_injected_files,
+        'injected_file_content_bytes':
+            FLAGS.quota_max_injected_file_content_bytes,
+    }
+    # -1 in the quota flags means unlimited
+    for key in defaults.keys():
+        if defaults[key] == -1:
+            defaults[key] = None
+    return defaults
+
+
+def get_project_quotas(context, project_id):
+    rval = _get_default_quotas()
     quota = db.quota_get_all_by_project(context, project_id)
     for key in rval.keys():
         if key in quota:
@@ -65,71 +81,81 @@
     return quota - used
 
 
-def allowed_instances(context, num_instances, instance_type):
-    """Check quota and return min(num_instances, allowed_instances)."""
+def allowed_instances(context, requested_instances, instance_type):
+    """Check quota and return min(requested_instances, allowed_instances)."""
     project_id = context.project_id
     context = context.elevated()
-    num_cores = num_instances * instance_type['vcpus']
-    used_instances, used_cores = db.instance_data_get_for_project(context,
-                                                                  project_id)
-    quota = get_quota(context, project_id)
-    allowed_instances = _get_request_allotment(num_instances, used_instances,
+    requested_cores = requested_instances * instance_type['vcpus']
+    requested_ram = requested_instances * instance_type['memory_mb']
+    usage = db.instance_data_get_for_project(context, project_id)
+    used_instances, used_cores, used_ram = usage
+    quota = get_project_quotas(context, project_id)
+    allowed_instances = _get_request_allotment(requested_instances,
+                                               used_instances,
                                                quota['instances'])
-    allowed_cores = _get_request_allotment(num_cores, used_cores,
+    allowed_cores = _get_request_allotment(requested_cores, used_cores,
                                            quota['cores'])
+    allowed_ram = _get_request_allotment(requested_ram, used_ram, quota['ram'])
     allowed_instances = min(allowed_instances,
-                            int(allowed_cores // instance_type['vcpus']))
-    return min(num_instances, allowed_instances)
-
-
-def allowed_volumes(context, num_volumes, size):
-    """Check quota and return min(num_volumes, allowed_volumes)."""
+                            allowed_cores // instance_type['vcpus'],
+                            allowed_ram // instance_type['memory_mb'])
+    return min(requested_instances, allowed_instances)
+
+
+def allowed_volumes(context, requested_volumes, size):
+    """Check quota and return min(requested_volumes, allowed_volumes)."""
     project_id = context.project_id
     context = context.elevated()
     size = int(size)
-    num_gigabytes = num_volumes * size
+    requested_gigabytes = requested_volumes * size
     used_volumes, used_gigabytes = db.volume_data_get_for_project(context,
                                                                   project_id)
-    quota = get_quota(context, project_id)
-    allowed_volumes = _get_request_allotment(num_volumes, used_volumes,
+    quota = get_project_quotas(context, project_id)
+    allowed_volumes = _get_request_allotment(requested_volumes, used_volumes,
                                              quota['volumes'])
-    allowed_gigabytes = _get_request_allotment(num_gigabytes, used_gigabytes,
+    allowed_gigabytes = _get_request_allotment(requested_gigabytes,
+                                               used_gigabytes,
                                                quota['gigabytes'])
     allowed_volumes = min(allowed_volumes,
                           int(allowed_gigabytes // size))
-    return min(num_volumes, allowed_volumes)
-
-
-def allowed_floating_ips(context, num_floating_ips):
-    """Check quota and return min(num_floating_ips, allowed_floating_ips)."""
+    return min(requested_volumes, allowed_volumes)
+
+
+def allowed_floating_ips(context, requested_floating_ips):
+    """Check quota and return min(requested, allowed) floating ips."""
     project_id = context.project_id
     context = context.elevated()
     used_floating_ips = db.floating_ip_count_by_project(context, project_id)
-    quota = get_quota(context, project_id)
-    allowed_floating_ips = _get_request_allotment(num_floating_ips,
+    quota = get_project_quotas(context, project_id)
+    allowed_floating_ips = _get_request_allotment(requested_floating_ips,
                                                   used_floating_ips,
                                                   quota['floating_ips'])
-    return min(num_floating_ips, allowed_floating_ips)
-
-
-def allowed_metadata_items(context, num_metadata_items):
-    """Check quota; return min(num_metadata_items,allowed_metadata_items)."""
-    project_id = context.project_id
-    context = context.elevated()
-    quota = get_quota(context, project_id)
-    allowed_metadata_items = _get_request_allotment(num_metadata_items, 0,
-                                                    quota['metadata_items'])
-    return min(num_metadata_items, allowed_metadata_items)
-
-
-def allowed_injected_files(context):
+    return min(requested_floating_ips, allowed_floating_ips)
+
+
+def _calculate_simple_quota(context, resource, requested):
+    """Check quota for resource; return min(requested, allowed)."""
+    quota = get_project_quotas(context, context.project_id)
+    allowed = _get_request_allotment(requested, 0, quota[resource])
+    return min(requested, allowed)
+
+
+def allowed_metadata_items(context, requested_metadata_items):
+    """Return the number of metadata items allowed."""
+    return _calculate_simple_quota(context, 'metadata_items',
+                                   requested_metadata_items)
+
+
+def allowed_injected_files(context, requested_injected_files):
     """Return the number of injected files allowed."""
-    return FLAGS.quota_max_injected_files
-
-
-def allowed_injected_file_content_bytes(context):
+    return _calculate_simple_quota(context, 'injected_files',
+                                   requested_injected_files)
+
+
+def allowed_injected_file_content_bytes(context, requested_bytes):
     """Return the number of bytes allowed per injected file content."""
-    return FLAGS.quota_max_injected_file_content_bytes
+    resource = 'injected_file_content_bytes'
+    return _calculate_simple_quota(context, resource, requested_bytes)
 
 
 def allowed_injected_file_path_bytes(context):

=== modified file 'nova/tests/api/openstack/test_limits.py'
--- nova/tests/api/openstack/test_limits.py	2011-04-30 11:14:20 +0000
+++ nova/tests/api/openstack/test_limits.py	2011-05-25 19:53:25 +0000
@@ -27,6 +27,7 @@
 
 from xml.dom.minidom import parseString
 
+import nova.context
 from nova.api.openstack import limits
 
 
@@ -47,6 +48,13 @@
         self.time = 0.0
         self.stubs = stubout.StubOutForTesting()
         self.stubs.Set(limits.Limit, "_get_time", self._get_time)
+        self.absolute_limits = {}
+
+        def stub_get_project_quotas(context, project_id):
+            return self.absolute_limits
+
+        self.stubs.Set(nova.quota, "get_project_quotas",
+                       stub_get_project_quotas)
 
     def tearDown(self):
         """Run after each test."""
@@ -75,6 +83,8 @@
             "action": "index",
             "controller": "",
         })
+        context = nova.context.RequestContext('testuser', 'testproject')
+        request.environ["nova.context"] = context
         return request
 
     def _populate_limits(self, request):
@@ -86,6 +96,18 @@
         request.environ["nova.limits"] = _limits
         return request
 
+    def _setup_absolute_limits(self):
+        self.absolute_limits = {
+            'instances': 5,
+            'cores': 8,
+            'ram': 2 ** 13,
+            'volumes': 21,
+            'gigabytes': 34,
+            'metadata_items': 55,
+            'injected_files': 89,
+            'injected_file_content_bytes': 144,
+        }
+
     def test_empty_index_json(self):
         """Test getting empty limit details in JSON."""
         request = self._get_index_request()
@@ -103,6 +125,7 @@
         """Test getting limit details in JSON."""
         request = self._get_index_request()
         request = self._populate_limits(request)
+        self._setup_absolute_limits()
         response = request.get_response(self.controller)
         expected = {
             "limits": {
@@ -124,7 +147,15 @@
                     "remaining": 5,
                     "unit": "HOUR",
                 }],
-                "absolute": {},
+                "absolute": {
+                    "maxTotalInstances": 5,
+                    "maxTotalCores": 8,
+                    "maxTotalRAMSize": 2 ** 13,
+                    "maxServerMeta": 55,
+                    "maxImageMeta": 55,
+                    "maxPersonality": 89,
+                    "maxPersonalitySize": 144,
+                },
             },
         }
         body = json.loads(response.body)
@@ -188,6 +219,8 @@
             "action": "index",
             "controller": "",
         })
+        context = nova.context.RequestContext('testuser', 'testproject')
+        request.environ["nova.context"] = context
         return request
 
     def _populate_limits(self, request):
@@ -218,6 +251,11 @@
         """Test getting limit details in JSON."""
         request = self._get_index_request()
         request = self._populate_limits(request)
+        self.absolute_limits = {
+            'ram': 512,
+            'instances': 5,
+            'cores': 21,
+        }
         response = request.get_response(self.controller)
         expected = {
             "limits": {
@@ -257,12 +295,59 @@
                     },
 
                 ],
-                "absolute": {},
+                "absolute": {
+                    "maxTotalRAMSize": 512,
+                    "maxTotalInstances": 5,
+                    "maxTotalCores": 21,
+                    },
             },
         }
         body = json.loads(response.body)
         self.assertEqual(expected, body)
 
+    def _test_index_absolute_limits_json(self, expected):
+        request = self._get_index_request()
+        response = request.get_response(self.controller)
+        body = json.loads(response.body)
+        self.assertEqual(expected, body['limits']['absolute'])
+
+    def test_index_ignores_extra_absolute_limits_json(self):
+        self.absolute_limits = {'unknown_limit': 9001}
+        self._test_index_absolute_limits_json({})
+
+    def test_index_absolute_ram_json(self):
+        self.absolute_limits = {'ram': 1024}
+        self._test_index_absolute_limits_json({'maxTotalRAMSize': 1024})
+
+    def test_index_absolute_cores_json(self):
+        self.absolute_limits = {'cores': 17}
+        self._test_index_absolute_limits_json({'maxTotalCores': 17})
+
+    def test_index_absolute_instances_json(self):
+        self.absolute_limits = {'instances': 19}
+        self._test_index_absolute_limits_json({'maxTotalInstances': 19})
+
+    def test_index_absolute_metadata_json(self):
+        # NOTE: both server metadata and image metadata are overloaded
+        # into metadata_items
+        self.absolute_limits = {'metadata_items': 23}
+        expected = {
+            'maxServerMeta': 23,
+            'maxImageMeta': 23,
+        }
+        self._test_index_absolute_limits_json(expected)
+
+    def test_index_absolute_injected_files(self):
+        self.absolute_limits = {
+            'injected_files': 17,
+            'injected_file_content_bytes': 86753,
+        }
+        expected = {
+            'maxPersonality': 17,
+            'maxPersonalitySize': 86753,
+        }
+        self._test_index_absolute_limits_json(expected)
+
 
 class LimitMiddlewareTest(BaseLimitTestSuite):
     """

=== modified file 'nova/tests/test_quota.py'
--- nova/tests/test_quota.py	2011-05-09 18:44:39 +0000
+++ nova/tests/test_quota.py	2011-05-25 19:53:25 +0000
@@ -104,6 +104,10 @@
         num_instances = quota.allowed_instances(self.context, 100,
             self._get_instance_type('m1.small'))
         self.assertEqual(num_instances, 10)
+        db.quota_create(self.context, self.project.id, 'ram', 3 * 2048)
+        num_instances = quota.allowed_instances(self.context, 100,
+            self._get_instance_type('m1.small'))
+        self.assertEqual(num_instances, 3)
 
         # metadata_items
         too_many_items = FLAGS.quota_metadata_items + 1000
@@ -120,7 +124,8 @@
 
     def test_unlimited_instances(self):
         FLAGS.quota_instances = 2
-        FLAGS.quota_cores = 1000
+        FLAGS.quota_ram = -1
+        FLAGS.quota_cores = -1
         instance_type = self._get_instance_type('m1.small')
         num_instances = quota.allowed_instances(self.context, 100,
                                                 instance_type)
@@ -133,8 +138,25 @@
                                                 instance_type)
         self.assertEqual(num_instances, 101)
 
+    def test_unlimited_ram(self):
+        FLAGS.quota_instances = -1
+        FLAGS.quota_ram = 2 * 2048
+        FLAGS.quota_cores = -1
+        instance_type = self._get_instance_type('m1.small')
+        num_instances = quota.allowed_instances(self.context, 100,
+                                                instance_type)
+        self.assertEqual(num_instances, 2)
+        db.quota_create(self.context, self.project.id, 'ram', None)
+        num_instances = quota.allowed_instances(self.context, 100,
+                                                instance_type)
+        self.assertEqual(num_instances, 100)
+        num_instances = quota.allowed_instances(self.context, 101,
+                                                instance_type)
+        self.assertEqual(num_instances, 101)
+
     def test_unlimited_cores(self):
-        FLAGS.quota_instances = 1000
+        FLAGS.quota_instances = -1
+        FLAGS.quota_ram = -1
         FLAGS.quota_cores = 2
         instance_type = self._get_instance_type('m1.small')
         num_instances = quota.allowed_instances(self.context, 100,
@@ -150,7 +172,7 @@
 
     def test_unlimited_volumes(self):
         FLAGS.quota_volumes = 10
-        FLAGS.quota_gigabytes = 1000
+        FLAGS.quota_gigabytes = -1
         volumes = quota.allowed_volumes(self.context, 100, 1)
         self.assertEqual(volumes, 10)
         db.quota_create(self.context, self.project.id, 'volumes', None)
@@ -160,7 +182,7 @@
         self.assertEqual(volumes, 101)
 
     def test_unlimited_gigabytes(self):
-        FLAGS.quota_volumes = 1000
+        FLAGS.quota_volumes = -1
         FLAGS.quota_gigabytes = 10
         volumes = quota.allowed_volumes(self.context, 100, 1)
         self.assertEqual(volumes, 10)
@@ -274,10 +296,47 @@
                                             image_id='fake',
                                             metadata=metadata)
 
-    def test_allowed_injected_files(self):
-        self.assertEqual(
-                quota.allowed_injected_files(self.context),
-                FLAGS.quota_max_injected_files)
+    def test_default_allowed_injected_files(self):
+        FLAGS.quota_max_injected_files = 55
+        self.assertEqual(quota.allowed_injected_files(self.context, 100), 55)
+
+    def test_overridden_allowed_injected_files(self):
+        FLAGS.quota_max_injected_files = 5
+        db.quota_create(self.context, self.project.id, 'injected_files', 77)
+        self.assertEqual(quota.allowed_injected_files(self.context, 100), 77)
+
+    def test_unlimited_default_allowed_injected_files(self):
+        FLAGS.quota_max_injected_files = -1
+        self.assertEqual(quota.allowed_injected_files(self.context, 100), 100)
+
+    def test_unlimited_db_allowed_injected_files(self):
+        FLAGS.quota_max_injected_files = 5
+        db.quota_create(self.context, self.project.id, 'injected_files', None)
+        self.assertEqual(quota.allowed_injected_files(self.context, 100), 100)
+
+    def test_default_allowed_injected_file_content_bytes(self):
+        FLAGS.quota_max_injected_file_content_bytes = 12345
+        limit = quota.allowed_injected_file_content_bytes(self.context, 23456)
+        self.assertEqual(limit, 12345)
+
+    def test_overridden_allowed_injected_file_content_bytes(self):
+        FLAGS.quota_max_injected_file_content_bytes = 12345
+        db.quota_create(self.context, self.project.id,
+                        'injected_file_content_bytes', 5678)
+        limit = quota.allowed_injected_file_content_bytes(self.context, 23456)
+        self.assertEqual(limit, 5678)
+
+    def test_unlimited_default_allowed_injected_file_content_bytes(self):
+        FLAGS.quota_max_injected_file_content_bytes = -1
+        limit = quota.allowed_injected_file_content_bytes(self.context, 23456)
+        self.assertEqual(limit, 23456)
+
+    def test_unlimited_db_allowed_injected_file_content_bytes(self):
+        FLAGS.quota_max_injected_file_content_bytes = 12345
+        db.quota_create(self.context, self.project.id,
+                        'injected_file_content_bytes', None)
+        limit = quota.allowed_injected_file_content_bytes(self.context, 23456)
+        self.assertEqual(limit, 23456)
 
     def _create_with_injected_files(self, files):
         api = compute.API(image_service=self.StubImageService())
@@ -304,11 +363,6 @@
         self.assertRaises(quota.QuotaError,
                           self._create_with_injected_files, files)
 
-    def test_allowed_injected_file_content_bytes(self):
-        self.assertEqual(
-                quota.allowed_injected_file_content_bytes(self.context),
-                FLAGS.quota_max_injected_file_content_bytes)
-
     def test_max_injected_file_content_bytes(self):
         max = FLAGS.quota_max_injected_file_content_bytes
         content = ''.join(['a' for i in xrange(max)])