Merge into db-devel : flags : Code : Launchpad itself

Status:	Merged
Approved by:	Robert Collins on 2010-07-22
Approved revision:	no longer in the source branch.
Merged at revision:	9573
Proposed branch:	lp:~mbp/launchpad/flags
Merge into:	lp:launchpad/db-devel
Diff against target:	300 lines (+264/-0) 7 files modified lib/lp/services/features/__init__.py (+10/-0) lib/lp/services/features/flags.py (+85/-0) lib/lp/services/features/model.py (+42/-0) lib/lp/services/features/scopes.py (+5/-0) lib/lp/services/features/tests/__init__.py (+2/-0) lib/lp/services/features/tests/test_db_settings.py (+25/-0) lib/lp/services/features/tests/test_flags.py (+95/-0)
To merge this branch:	bzr merge lp:~mbp/launchpad/flags
Related bugs:	Link a bug report

Reviewer	Review Type	Date Requested	Status
Robert Collins (community)		2010-07-21	Approve on 2010-07-22
Review via email: mp+30581@code.launchpad.net

Commit message

Add FeatureController to read feature flags from the db

Description of the change

Second instalment of https://dev.launchpad.net/LEP/FeatureFlags

This adds a class that tells you about active features in a particular scope. It would be usable as is but I will do more to automatically give you the right context in a web app request, etc.

Revision history for this message

Robert Collins (lifeless) wrote on 2010-07-22:

#

Download full text (5.4 KiB)

I think referencing the LEP in the docstring is ok but not a substitute for including the docs in the tree - better to include the information in the module so that people don't need a web connection to understand whats going on.

I like the intended performance notes - please put them in the docstring so the API docs will show them.

I would perhaps say '
53 + This presents a higher-level interface over the storm model objects,
54 + oriented only towards readers.
55 +
56 + At this level flag names and scope names are presented as strings for
57 + easier use in Python code, though the values remain unicode. They
58 + should always be ascii like Python identifiers.
'

As
This presents an interface optimised for use in code making conditional choices based on the feature flags. At this level ....

This -
165 + # the Launchpad Collection knows how to find a good store to start from,
166 +

is a bit weird to mention.

169 === added file 'lib/lp/services/features/scopes.py'
170 --- lib/lp/services/features/scopes.py 1970-01-01 00:00:00 +0000
171 +++ lib/lp/services/features/scopes.py 2010-07-21 21:16:48 +0000
172 @@ -0,0 +1,5 @@
173 +# Copyright 2010 Canonical Ltd. This software is licensed under the
174 +# GNU Affero General Public License version 3 (see the file LICENSE).
175 +
176 +"""Look up current feature flags.
177 +"""

This seems unused - you might want to trim it for now.

179 === added directory 'lib/lp/services/features/tests'
180 === added file 'lib/lp/services/features/tests/__init__.py'
181 --- lib/lp/services/features/tests/__init__.py 1970-01-01 00:00:00 +0000
182 +++ lib/lp/services/features/tests/__init__.py 2010-07-21 21:16:48 +0000
183 @@ -0,0 +1,4 @@
184 +# Copyright 2010 Canonical Ltd. This software is licensed under the
185 +# GNU Affero General Public License version 3 (see the file LICENSE).
186 +
187 +pass

The pass isn't needed :)

189 === added file 'lib/lp/services/features/tests/test_db_settings.py'
190 --- lib/lp/services/features/tests/test_db_settings.py 1970-01-01 00:00:00 +0000
191 +++ lib/lp/services/features/tests/test_db_settings.py 2010-07-21 21:16:48 +0000
192 @@ -0,0 +1,26 @@
193 +# Copyright 2010 Canonical Ltd. This software is licensed under the
194 +# GNU Affero General Public License version 3 (see the file LICENSE).
195 +
196 +"""Tests for feature settings coming from the database"""
197 +
198 +
199 +from __future__ import with_statement
200 +__metaclass__ = type
201 +
202 +import testtools

Launchpad has a TestCase of its own you should use.

204 +from canonical.testing import layers
205 +from lp.services.features.model import (
206 + FeatureFlag,
207 + FeatureFlagCollection,
208 + )
209 +
210 +
211 +class TestFeatureModel(testtools.TestCase):
212 +
213 + layer = layers.DatabaseFunctionalLayer
214 +
215 + def test_defaultEmptyCollection(self):
216 + # there are no settings in the sampledata
217 + coll = FeatureFlagCollection()
218 + self.assertTrue(coll.select().is_empty())

I'd make that statement stronger: there should be no settings...

220 === added file 'lib/lp/services/features/tests/test_flags.py'
221 --- lib/lp/services/fea...

I think referencing the LEP in the docstring is ok but not a substitute for including the docs in the tree - better to include the information in the module so that people don't need a web connection to understand whats going on.

I like the intended performance notes - please put them in the docstring so the API docs will show them.

I would perhaps say '
53	+    This presents a higher-level interface over the storm model objects,
54	+    oriented only towards readers.
55	+
56	+    At this level flag names and scope names are presented as strings for
57	+    easier use in Python code, though the values remain unicode.  They
58	+    should always be ascii like Python identifiers.
'

As
This presents an interface optimised for use in code making conditional choices based on the feature flags. At this level ....

This - 
165	+    # the Launchpad Collection knows how to find a good store to start from,
166	+

is a bit weird to mention.

169	=== added file 'lib/lp/services/features/scopes.py'
170	--- lib/lp/services/features/scopes.py	1970-01-01 00:00:00 +0000
171	+++ lib/lp/services/features/scopes.py	2010-07-21 21:16:48 +0000
172	@@ -0,0 +1,5 @@
173	+# Copyright 2010 Canonical Ltd.  This software is licensed under the
174	+# GNU Affero General Public License version 3 (see the file LICENSE).
175	+
176	+"""Look up current feature flags.
177	+"""

This seems unused - you might want to trim it for now.
	
179	=== added directory 'lib/lp/services/features/tests'
180	=== added file 'lib/lp/services/features/tests/__init__.py'
181	--- lib/lp/services/features/tests/__init__.py	1970-01-01 00:00:00 +0000
182	+++ lib/lp/services/features/tests/__init__.py	2010-07-21 21:16:48 +0000
183	@@ -0,0 +1,4 @@
184	+# Copyright 2010 Canonical Ltd.  This software is licensed under the
185	+# GNU Affero General Public License version 3 (see the file LICENSE).
186	+
187	+pass

The pass isn't needed :)

189	=== added file 'lib/lp/services/features/tests/test_db_settings.py'
190	--- lib/lp/services/features/tests/test_db_settings.py	1970-01-01 00:00:00 +0000
191	+++ lib/lp/services/features/tests/test_db_settings.py	2010-07-21 21:16:48 +0000
192	@@ -0,0 +1,26 @@
193	+# Copyright 2010 Canonical Ltd.  This software is licensed under the
194	+# GNU Affero General Public License version 3 (see the file LICENSE).
195	+
196	+"""Tests for feature settings coming from the database"""
197	+
198	+
199	+from __future__ import with_statement
200	+__metaclass__ = type
201	+
202	+import testtools

Launchpad has a TestCase of its own you should use.

204	+from canonical.testing import layers
205	+from lp.services.features.model import (
206	+    FeatureFlag,
207	+    FeatureFlagCollection,
208	+    )
209	+
210	+
211	+class TestFeatureModel(testtools.TestCase):
212	+
213	+    layer = layers.DatabaseFunctionalLayer
214	+
215	+    def test_defaultEmptyCollection(self):
216	+        # there are no settings in the sampledata
217	+        coll = FeatureFlagCollection()
218	+        self.assertTrue(coll.select().is_empty())

I'd make that statement stronger: there should be no settings...

220	=== added file 'lib/lp/services/features/tests/test_flags.py'
221	--- lib/lp/services/features/tests/test_flags.py	1970-01-01 00:00:00 +0000
222	+++ lib/lp/services/features/tests/test_flags.py	2010-07-21 21:16:48 +0000
223	@@ -0,0 +1,103 @@
224	+# Copyright 2010 Canonical Ltd.  This software is licensed under the
225	+# GNU Affero General Public License version 3 (see the file LICENSE).
226	+
227	+"""Tests for feature flags.
228	+
229	+"""

Personally I prefer single-line docstrings as
"""fooo ... """

232	+from __future__ import with_statement
233	+__metaclass__ = type
234	+
235	+import testtools
236	+
237	+from canonical.testing import layers
238	+
239	+from lp.services.features import flags, model
240	+
241	+
242	+notification_name = 'notification.global.text'
243	+notification_value = u'\N{SNOWMAN} stormy Launchpad weather ahead'
244	+example_scope = 'beta_user'
245	+
246	+class TestFeatureFlags(testtools.TestCase):

ditto on the test case.

248	+    layer = layers.DatabaseFunctionalLayer
249	+
250	+    def test_defaultFlags(self):
251	+        # the sample db has no flags set
252	+        control = flags.FeatureController([])
253	+        self.assertEqual({},
254	+            control.getAllFlags())

256	+    def test_simpleFlags(self):
257	+        # with some flags set in the db, you can query them through the
258	+        # FeatureController
259	+        flag = model.FeatureFlag(
260	+            scope=unicode(example_scope),
261	+            flag=unicode(notification_name),
262	+            value=notification_value,
263	+            priority=100)
264	+        model.FeatureFlagCollection().store.add(flag)
265	+        control = flags.FeatureController(['beta_user'])
266	+        self.assertEqual(notification_value,
267	+            control.getFlag(notification_name))

One thing to consider is what should be in the controller and what in the model class - I'd say that non tuned-for-conditionals code should be in the model class, so you don't need the controller to have write knowledge: let it be totally tuning and optimised ui.

275	+    def test_getAllFlags(self):
276	+        # can fetch all the active flags, and it gives back only the
277	+        # highest-priority settings

.... for a given feature?

With that in mind - please land. Note that we're in testfix now so you may need a bit of a gap for that to be fixed.

review: Approve

Revision history for this message

Martin Pool (mbp) wrote on 2010-07-22:

#

Download full text (11.4 KiB)

Incremental diff:

* facade loads everything at construction time
* remove write facade methods

=== modified file 'lib/lp/services/features/flags.py'
--- lib/lp/services/features/flags.py 2010-07-22 10:48:14 +0000
+++ lib/lp/services/features/flags.py 2010-07-22 12:28:32 +0000
@@ -6,21 +6,16 @@
__metaclass__ = type

-from lp.services.features import model
+from lp.services.features.model import (
+ getFeatureStore,
+ FeatureFlag,
+ )

from storm.locals import (
Desc,
)

-# Intended performance: when this object is first constructed, it will read
-# the whole current feature flags from the database. This will take a few ms.
-# The controller is then supposed to be held in a thread-local for the
-# duration of the request. The scopes can be changed over the lifetime of the
-# controller, because we might not know enough to determine all the active
-# scopes when the object's first created. This isn't validated to work yet.
-
-
class FeatureController(object):
"""A FeatureController tells application code what features are active.

@@ -30,18 +25,21 @@
of the current web request, or the user for whom a job is being run, or
something similar.

- This presents a higher-level facade that is independent of how the flags
- are stored. At the moment they are stored in the database but callers
- shouldn't need to know about that: they could go into memcachedb or
- elsewhere in future.
+ FeatureController presents a high level interface for application code to
+ query flag values, without it needing to know that they are stored in the database.

     At this level flag names and scope names are presented as strings for
     easier use in Python code, though the values remain unicode. They
     should always be ascii like Python identifiers.

- One instance of this should be constructed for the lifetime of code that
- has consistent configuration values. For instance there will be one per web
- app request.
+ One instance of FeatureController should be constructed for the lifetime
+ of code that has consistent configuration values. For instance there will
+ be one per web app request.
+
+ Intended performance: when this object is first constructed, it will read
+ the whole current feature flags from the database. This will take a few ms.
+ The controller is then supposed to be held in a thread-local for the
+ duration of the request.

     See <https://dev.launchpad.net/LEP/FeatureFlags>
     """
@@ -49,34 +47,33 @@
     def __init__(self, scopes):
         """Construct a new view of the features for a set of scopes.
         """
- self._store = model.getFeatureStore()
- self.scopes = self._preenScopes(scopes)
+ self._store = getFeatureStore()
+ self._scopes = self._preenScopes(scopes)
+ self._cached_flags = self._queryAllFlags()

- def setScopes(self, scopes):
- self.scopes = self._preenScopes(scopes)
+ def getScopes(self):
+ return frozenset(self._scopes)

def getFlag(self, flag_name):
- rs = (self._store
- .find(model.FeatureFlag,
- mod...

Incremental diff:

* facade loads everything at construction time
 * remove write facade methods

=== modified file 'lib/lp/services/features/flags.py'
--- lib/lp/services/features/flags.py	2010-07-22 10:48:14 +0000
+++ lib/lp/services/features/flags.py	2010-07-22 12:28:32 +0000
@@ -6,21 +6,16 @@
 __metaclass__ = type
 
 
-from lp.services.features import model
+from lp.services.features.model import (
+    getFeatureStore,
+    FeatureFlag,
+    )
 
 from storm.locals import (
     Desc,
     )
 
 
-# Intended performance: when this object is first constructed, it will read
-# the whole current feature flags from the database.  This will take a few ms.
-# The controller is then supposed to be held in a thread-local for the
-# duration of the request.  The scopes can be changed over the lifetime of the
-# controller, because we might not know enough to determine all the active
-# scopes when the object's first created.   This isn't validated to work yet.
-    
-
 class FeatureController(object):
     """A FeatureController tells application code what features are active.
 
@@ -30,18 +25,21 @@
       of the current web request, or the user for whom a job is being run, or
       something similar.
 
-    This presents a higher-level facade that is independent of how the flags
-    are stored.  At the moment they are stored in the database but callers
-    shouldn't need to know about that: they could go into memcachedb or
-    elsewhere in future.
+    FeatureController presents a high level interface for application code to
+    query flag values, without it needing to know that they are stored in the database.
 
     At this level flag names and scope names are presented as strings for
     easier use in Python code, though the values remain unicode.  They
     should always be ascii like Python identifiers.
 
-    One instance of this should be constructed for the lifetime of code that
-    has consistent configuration values.  For instance there will be one per web
-    app request.
+    One instance of FeatureController should be constructed for the lifetime
+    of code that has consistent configuration values.  For instance there will
+    be one per web app request.
+
+    Intended performance: when this object is first constructed, it will read
+    the whole current feature flags from the database.  This will take a few ms.
+    The controller is then supposed to be held in a thread-local for the
+    duration of the request.
 
     See <https://dev.launchpad.net/LEP/FeatureFlags>
     """
@@ -49,34 +47,33 @@
     def __init__(self, scopes):
         """Construct a new view of the features for a set of scopes.
         """
-        self._store = model.getFeatureStore()
-        self.scopes = self._preenScopes(scopes)
+        self._store = getFeatureStore()
+        self._scopes = self._preenScopes(scopes)
+        self._cached_flags = self._queryAllFlags()
 
-    def setScopes(self, scopes):
-        self.scopes = self._preenScopes(scopes)
+    def getScopes(self):
+        return frozenset(self._scopes)
 
     def getFlag(self, flag_name):
-        rs = (self._store
-                .find(model.FeatureFlag,
-                    model.FeatureFlag.scope.is_in(self.scopes),
-                    model.FeatureFlag.flag == unicode(flag_name))
-                .order_by(Desc(model.FeatureFlag.priority)))
-        row = rs.first()
-        if row is None:
-            return None
-        else:
-            return row.value
+        return self._cached_flags.get(flag_name)
 
     def getAllFlags(self):
         """Get the feature flags active for the current scopes.
         
         :returns: dict from flag_name (unicode) to value (unicode).
         """
+        return dict(self._cached_flags)
+
+    def _queryAllFlags(self):
+        d = {}
         rs = (self._store
-                .find(model.FeatureFlag,
-                    model.FeatureFlag.scope.is_in(self.scopes))
-                .order_by(model.FeatureFlag.priority))
-        return dict((str(f.flag), f.value) for f in rs)
+                .find(FeatureFlag,
+                    FeatureFlag.scope.is_in(self._scopes))
+                .order_by(FeatureFlag.priority)
+                .values(FeatureFlag.flag, FeatureFlag.value))
+        for flag, value in rs:
+            d[str(flag)] = value
+        return d
 
     def _preenScopes(self, scopes):
         # for convenience turn strings to unicode
@@ -89,16 +86,3 @@
             else:
                 raise TypeError("invalid scope: %r" % s)
         return us
-
-    def addSetting(self, scope, flag, value, priority):
-        """Add a setting for a flag.
-
-        Note that flag settings are global in the database: they affect all
-        FeatureControllers connected to this database, and they will persist
-        if the database transaction is committed.
-        """
-        flag_obj = model.FeatureFlag(scope=unicode(scope),
-            flag=unicode(flag),
-            value=value,
-            priority=priority)
-        self._store.add(flag_obj)

=== modified file 'lib/lp/services/features/model.py'
--- lib/lp/services/features/model.py	2010-07-22 10:48:14 +0000
+++ lib/lp/services/features/model.py	2010-07-22 10:58:57 +0000
@@ -1,7 +1,9 @@
 # Copyright 2010 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
-__all__ = ['FeatureFlag'
+__all__ = [
+    'FeatureFlag',
+    'getFeatureStore',
     ]
 
 __metaclass__ = type

=== modified file 'lib/lp/services/features/tests/__init__.py'
--- lib/lp/services/features/tests/__init__.py	2010-07-21 11:05:14 +0000
+++ lib/lp/services/features/tests/__init__.py	2010-07-22 11:51:22 +0000
@@ -1,4 +1,2 @@
 # Copyright 2010 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
-
-pass

=== modified file 'lib/lp/services/features/tests/test_db_settings.py'
--- lib/lp/services/features/tests/test_db_settings.py	2010-07-22 10:48:14 +0000
+++ lib/lp/services/features/tests/test_db_settings.py	2010-07-22 11:56:18 +0000
@@ -7,16 +7,15 @@
 from __future__ import with_statement
 __metaclass__ = type
 
-import testtools
-
 from canonical.testing import layers
+from lp.testing import TestCase
 from lp.services.features.model import (
     getFeatureStore,
     FeatureFlag,
     )
 
 
-class TestFeatureModel(testtools.TestCase):
+class TestFeatureModel(TestCase):
 
     layer = layers.DatabaseFunctionalLayer

=== modified file 'lib/lp/services/features/tests/test_flags.py'
--- lib/lp/services/features/tests/test_flags.py	2010-07-22 10:48:14 +0000
+++ lib/lp/services/features/tests/test_flags.py	2010-07-22 12:27:38 +0000
@@ -1,20 +1,21 @@
 # Copyright 2010 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
-"""Tests for feature flags.
-
-"""
+"""Tests for feature flags."""
 
 
 from __future__ import with_statement
 __metaclass__ = type
 
 import os
-import testtools
 
 from canonical.testing import layers
+from lp.testing import TestCase
 
 from lp.services.features import flags, model
+from lp.services.features.flags import (
+    FeatureController,
+    )
 
 
 notification_name = 'notification.global.text'
@@ -22,7 +23,14 @@
 example_scope = 'beta_user'
 
 
-class TestFeatureFlags(testtools.TestCase):
+testdata = [
+    (example_scope, notification_name, notification_value, 100),
+    ('default', 'ui.icing', u'3.0', 100),
+    ('beta_user', 'ui.icing', u'4.0', 300),
+    ]
+
+
+class TestFeatureFlags(TestCase):
 
     layer = layers.DatabaseFunctionalLayer
 
@@ -32,35 +40,32 @@
             from storm.tracer import debug
             debug(True)
 
+    def populateStore(self):
+        store = model.getFeatureStore()
+        for (scope, flag, value, priority) in testdata:
+            store.add(model.FeatureFlag(
+                scope=unicode(scope),
+                flag=unicode(flag),
+                value=value,
+                priority=priority))
+
     def test_defaultFlags(self):
         # the sample db has no flags set
-        control = flags.FeatureController([])
+        control = FeatureController([])
         self.assertEqual({},
             control.getAllFlags())
 
-    def test_simpleFlags(self):
-        # with some flags set in the db, you can query them through the
-        # FeatureController
-        flag = model.FeatureFlag(
-            scope=unicode(example_scope),
-            flag=unicode(notification_name),
-            value=notification_value,
-            priority=100)
-        model.getFeatureStore().add(flag)
-        control = flags.FeatureController(['beta_user'])
-        self.assertEqual(notification_value,
-            control.getFlag(notification_name))
-
-    def test_setFlags(self):
-        # you can also set flags through a facade
-        control = self.makePopulatedController()
-        self.assertEqual(notification_value,
-            control.getFlag(notification_name))
+    def test_getFlag(self):
+        self.populateStore()
+        control = FeatureController(['default'])
+        self.assertEqual(u'3.0',
+            control.getFlag('ui.icing'))
 
     def test_getAllFlags(self):
         # can fetch all the active flags, and it gives back only the
         # highest-priority settings
-        control = self.makeControllerWithOverrides()
+        self.populateStore()
+        control = FeatureController(['default', 'beta_user'])
         self.assertEqual(
             {'ui.icing': '4.0',
              notification_name: notification_value},
@@ -69,43 +74,22 @@
     def test_overrideFlag(self):
         # if there are multiple settings for a flag, and they match multiple
         # scopes, the priorities determine which is matched
-        control = self.makeControllerWithOverrides()
-        control.setScopes(['default'])
+        self.populateStore()
+        default_control = FeatureController(['default'])
         self.assertEqual(
             u'3.0',
-            control.getFlag('ui.icing'))
-        control.setScopes(['default', 'beta_user'])
+            default_control.getFlag('ui.icing'))
+        beta_control = FeatureController(['default', 'beta_user'])
         self.assertEqual(
             u'4.0',
-            control.getFlag('ui.icing'))
+            beta_control.getFlag('ui.icing'))
 
     def test_undefinedFlag(self):
         # if the flag is not defined, we get None
-        control = self.makeControllerWithOverrides()
+        self.populateStore()
+        control = FeatureController(['default', 'beta_user'])
         self.assertIs(None,
             control.getFlag('unknown_flag'))
-        control.setScopes([])
+        no_scope_flags = FeatureController([])
         self.assertIs(None,
-            control.getFlag('ui.icing'))
-
-    def makePopulatedController(self):
-        # make a controller with some test flags
-        control = flags.FeatureController(['beta_user'])
-        control.addSetting(
-            scope=example_scope, flag=notification_name,
-            value=notification_value, priority=100)
-        return control
-
-    def makeControllerWithOverrides(self):
-        control = self.makePopulatedController()
-        control.addSetting(
-            scope='default',
-            flag='ui.icing',
-            value=u'3.0',
-            priority=100)
-        control.addSetting(
-            scope='beta_user',
-            flag='ui.icing',
-            value=u'4.0',
-            priority=300)
-        return control
+            no_scope_flags.getFlag('ui.icing'))

Revision history for this message

Martin Pool (mbp) wrote on 2010-07-23:

#

ec2 disappeared into thin air, perhaps because of smtp setup problems. Would someone please submit this on my behalf?

Launchpad itself

Merge lp:~mbp/launchpad/flags into lp:launchpad/db-devel

Commit message

Description of the change

Preview Diff

Subscribers

 === added directory 'lib/lp/services/features'
 === added file 'lib/lp/services/features/__init__.py'
 --- lib/lp/services/features/__init__.py	1970-01-01 00:00:00 +0000
 +++ lib/lp/services/features/__init__.py	2010-07-25 09:39:52 +0000
@@ -0,0 +1,10 @@
++# Copyright 2010 Canonical Ltd.  This software is licensed under the
++# GNU Affero General Public License version 3 (see the file LICENSE).
++
++"""lp.services.features provide dynamically configurable feature flags.
++
++These can be turned on and off by admins, and can affect particular
++defined scopes such as "beta users" or "production servers."
++
++See <https://dev.launchpad.net/LEP/FeatureFlags>
++"""
 === added file 'lib/lp/services/features/flags.py'
 --- lib/lp/services/features/flags.py	1970-01-01 00:00:00 +0000
 +++ lib/lp/services/features/flags.py	2010-07-25 09:39:52 +0000
@@ -0,0 +1,85 @@
++# Copyright 2010 Canonical Ltd.  This software is licensed under the
++# GNU Affero General Public License version 3 (see the file LICENSE).
++
++__all__ = ['FeatureController']
++
++__metaclass__ = type
++
++
++from lp.services.features.model import (
++    getFeatureStore,
++    FeatureFlag,
++    )
++
++
++class FeatureController(object):
++    """A FeatureController tells application code what features are active.
++
++    It does this by meshing together two sources of data:
++    - feature flags, typically set by an administrator into the database
++    - feature scopes, which would typically be looked up based on attributes
++      of the current web request, or the user for whom a job is being run, or
++      something similar.
++
++    FeatureController presents a high level interface for application code to
++    query flag values, without it needing to know that they are stored in the
++    database.
++
++    At this level flag names and scope names are presented as strings for
++    easier use in Python code, though the values remain unicode.  They
++    should always be ascii like Python identifiers.
++
++    One instance of FeatureController should be constructed for the lifetime
++    of code that has consistent configuration values.  For instance there will
++    be one per web app request.
++
++    Intended performance: when this object is first constructed, it will read
++    the whole current feature flags from the database.  This will take a few
++    ms.  The controller is then supposed to be held in a thread-local for the
++    duration of the request.
++
++    See <https://dev.launchpad.net/LEP/FeatureFlags>
++    """
++
++    def __init__(self, scopes):
++        """Construct a new view of the features for a set of scopes.
++        """
++        self._store = getFeatureStore()
++        self._scopes = self._preenScopes(scopes)
++        self._cached_flags = self._queryAllFlags()
++
++    def getScopes(self):
++        return frozenset(self._scopes)
++
++    def getFlag(self, flag_name):
++        return self._cached_flags.get(flag_name)
++
++    def getAllFlags(self):
++        """Get the feature flags active for the current scopes.
++
++        :returns: dict from flag_name (unicode) to value (unicode).
++        """
++        return dict(self._cached_flags)
++
++    def _queryAllFlags(self):
++        d = {}
++        rs = (self._store
++                .find(FeatureFlag,
++                    FeatureFlag.scope.is_in(self._scopes))
++                .order_by(FeatureFlag.priority)
++                .values(FeatureFlag.flag, FeatureFlag.value))
++        for flag, value in rs:
++            d[str(flag)] = value
++        return d
++
++    def _preenScopes(self, scopes):
++        # for convenience turn strings to unicode
++        us = []
++        for s in scopes:
++            if isinstance(s, unicode):
++                us.append(s)
++            elif isinstance(s, str):
++                us.append(unicode(s))
++            else:
++                raise TypeError("invalid scope: %r" % s)
++        return us
 === added file 'lib/lp/services/features/model.py'
 --- lib/lp/services/features/model.py	1970-01-01 00:00:00 +0000
 +++ lib/lp/services/features/model.py	2010-07-25 09:39:52 +0000
@@ -0,0 +1,42 @@
++# Copyright 2010 Canonical Ltd.  This software is licensed under the
++# GNU Affero General Public License version 3 (see the file LICENSE).
++
++__all__ = [
++    'FeatureFlag',
++    'getFeatureStore',
++    ]
++
++__metaclass__ = type
++
++from zope.component import getUtility
++from storm.locals import Int, Storm, Unicode, DateTime
++
++from canonical.launchpad.webapp.interfaces import (
++    DEFAULT_FLAVOR, IStoreSelector, MAIN_STORE)
++
++
++def getFeatureStore():
++    """Get Storm store to access feature definitions."""
++    # TODO: This is copied so many times in Launchpad; maybe it should be more
++    # general?
++    return getUtility(IStoreSelector).get(MAIN_STORE, DEFAULT_FLAVOR)
++
++
++class FeatureFlag(Storm):
++    """Database setting of a particular flag in a scope"""
++
++    __storm_table__ = 'FeatureFlag'
++    __storm_primary__ = "scope", "flag"
++
++    scope = Unicode(allow_none=False)
++    flag = Unicode(allow_none=False)
++    priority = Int(allow_none=False)
++    value = Unicode(allow_none=False)
++    date_modified = DateTime()
++
++    def __init__(self, scope, priority, flag, value):
++        super(FeatureFlag, self).__init__()
++        self.scope = scope
++        self.priority = priority
++        self.flag = flag
++        self.value = value
 === added file 'lib/lp/services/features/scopes.py'
 --- lib/lp/services/features/scopes.py	1970-01-01 00:00:00 +0000
 +++ lib/lp/services/features/scopes.py	2010-07-25 09:39:52 +0000
@@ -0,0 +1,5 @@
++# Copyright 2010 Canonical Ltd.  This software is licensed under the
++# GNU Affero General Public License version 3 (see the file LICENSE).
++
++"""Look up current feature flags.
++"""
 === added directory 'lib/lp/services/features/tests'
 === added file 'lib/lp/services/features/tests/__init__.py'
 --- lib/lp/services/features/tests/__init__.py	1970-01-01 00:00:00 +0000
 +++ lib/lp/services/features/tests/__init__.py	2010-07-25 09:39:52 +0000
@@ -0,0 +1,2 @@
++# Copyright 2010 Canonical Ltd.  This software is licensed under the
++# GNU Affero General Public License version 3 (see the file LICENSE).
 === added file 'lib/lp/services/features/tests/test_db_settings.py'
 --- lib/lp/services/features/tests/test_db_settings.py	1970-01-01 00:00:00 +0000
 +++ lib/lp/services/features/tests/test_db_settings.py	2010-07-25 09:39:52 +0000
@@ -0,0 +1,25 @@
++# Copyright 2010 Canonical Ltd.  This software is licensed under the
++# GNU Affero General Public License version 3 (see the file LICENSE).
++
++"""Tests for feature settings coming from the database"""
++
++
++from __future__ import with_statement
++__metaclass__ = type
++
++from canonical.testing import layers
++from lp.testing import TestCase
++from lp.services.features.model import (
++    getFeatureStore,
++    FeatureFlag,
++    )
++
++
++class TestFeatureModel(TestCase):
++
++    layer = layers.DatabaseFunctionalLayer
++
++    def test_defaultEmptyCollection(self):
++        # there are no settings in the sampledata
++        store = getFeatureStore()
++        self.assertTrue(store.find(FeatureFlag).is_empty())
 === added file 'lib/lp/services/features/tests/test_flags.py'
 --- lib/lp/services/features/tests/test_flags.py	1970-01-01 00:00:00 +0000
 +++ lib/lp/services/features/tests/test_flags.py	2010-07-25 09:39:52 +0000
@@ -0,0 +1,95 @@
++# Copyright 2010 Canonical Ltd.  This software is licensed under the
++# GNU Affero General Public License version 3 (see the file LICENSE).
++
++"""Tests for feature flags."""
++
++
++from __future__ import with_statement
++__metaclass__ = type
++
++import os
++
++from canonical.testing import layers
++from lp.testing import TestCase
++
++from lp.services.features import model
++from lp.services.features.flags import (
++    FeatureController,
++    )
++
++
++notification_name = 'notification.global.text'
++notification_value = u'\N{SNOWMAN} stormy Launchpad weather ahead'
++example_scope = 'beta_user'
++
++
++testdata = [
++    (example_scope, notification_name, notification_value, 100),
++    ('default', 'ui.icing', u'3.0', 100),
++    ('beta_user', 'ui.icing', u'4.0', 300),
++    ]
++
++
++class TestFeatureFlags(TestCase):
++
++    layer = layers.DatabaseFunctionalLayer
++
++    def setUp(self):
++        super(TestFeatureFlags, self).setUp()
++        if os.environ.get("STORM_TRACE", None):
++            from storm.tracer import debug
++            debug(True)
++
++    def populateStore(self):
++        store = model.getFeatureStore()
++        for (scope, flag, value, priority) in testdata:
++            store.add(model.FeatureFlag(
++                scope=unicode(scope),
++                flag=unicode(flag),
++                value=value,
++                priority=priority))
++
++    def test_defaultFlags(self):
++        # the sample db has no flags set
++        control = FeatureController([])
++        self.assertEqual({},
++            control.getAllFlags())
++
++    def test_getFlag(self):
++        self.populateStore()
++        control = FeatureController(['default'])
++        self.assertEqual(u'3.0',
++            control.getFlag('ui.icing'))
++
++    def test_getAllFlags(self):
++        # can fetch all the active flags, and it gives back only the
++        # highest-priority settings
++        self.populateStore()
++        control = FeatureController(['default', 'beta_user'])
++        self.assertEqual(
++            {'ui.icing': '4.0',
++             notification_name: notification_value},
++            control.getAllFlags())
++
++    def test_overrideFlag(self):
++        # if there are multiple settings for a flag, and they match multiple
++        # scopes, the priorities determine which is matched
++        self.populateStore()
++        default_control = FeatureController(['default'])
++        self.assertEqual(
++            u'3.0',
++            default_control.getFlag('ui.icing'))
++        beta_control = FeatureController(['default', 'beta_user'])
++        self.assertEqual(
++            u'4.0',
++            beta_control.getFlag('ui.icing'))
++
++    def test_undefinedFlag(self):
++        # if the flag is not defined, we get None
++        self.populateStore()
++        control = FeatureController(['default', 'beta_user'])
++        self.assertIs(None,
++            control.getFlag('unknown_flag'))
++        no_scope_flags = FeatureController([])
++        self.assertIs(None,
++            no_scope_flags.getFlag('ui.icing'))