Merge lp:~allenap/launchpad/cache-experiment into lp:launchpad

[Gavin Panella]

New module propertycache to replace cachedproperty. It provides a cleaner interface to inspect and modify the cache.

This is a proposed replacement for the cachedproperty module. It provides a cleaner interface for inspecting and modifying the cache, and even makes cache implementations pluggable (via adaption). In use it's pretty simple and unsurprising.

See the documentation at the top of lib/lp/services/propertycache.py for a concise demonstration of how it works.

I haven't converted all uses of the existing cachedproperty yet, only those places which actually manipulate the cache (i.e. call sites for cache_property clear_property and clear_cachedproperties). I'll do that in a follow-up branch if this one is accepted.

[Henning Eggers (henninge)]

Hi Gavin,
this is a great improvement to the API for dealing with cached properties. I like it very much. Thank your for submitting it and being open to my comments.

As this is a parallel implementation, I don't see a problem with landing it. Still, I ask you to present this on the dev mailing list to see if people see problems with it, like an after-imp discussion since you didn't have a pre-imp about this.

Cheers,
Henning

review: Approve (code)

[Tim Penhey (thumper)]

I think this interface is very good. It looks nice to use too.

review: Approve

[Robert Collins (lifeless)]

Thanks for doing this Gavin.

Please convert everything across so we don't have two implementations
half-migrated.

As the author of the extended cachedproperty API you are replacing,
I'd like to say that you read my mind about further enchancements - a
dict like object with a trivial clear-the-cache facility is perfect.
Thanks.

I don't think a post-implementation discussion is needed - we're all
on the reviewers list after all.

However, I think it would be awesome for you to:
 - announce it on the list with some quick examples so people know how
to use it.
 - update dev.lp.net/Performance, which I think mentions cachedproperty.

Thanks,
Rob

[Gavin Panella (allenap)]

Tim, Rob: thank you for your responses :)

I was worried that I was going to be treading on your toes Rob, so I'm glad you're happy with the result.

dev.lp.net/Performance talks about memoised data, but not specifically about cachedproperty, so I think that's okay.

I'll start a new branch to convert the rest of the tree now.

[Henning Eggers (henninge)]

> I don't think a post-implementation discussion is needed - we're all
> on the reviewers list after all.

I think there is too much noise on that list to serve that purpose. But your and Tim's comments here show that Gavin's mail to the list has served its purpose to include more developers in this change. Thank you! ;)

Henning

=== modified file 'lib/canonical/configure.zcml'
--- lib/canonical/configure.zcml	2010-08-17 15:05:44 +0000
+++ lib/canonical/configure.zcml	2010-08-23 16:19:43 +0000
@@ -15,16 +15,7 @@
     <include package="canonical.launchpad" file="permissions.zcml" />
     <include package="canonical.launchpad.webapp" file="meta.zcml" />
     <include package="lazr.restful" file="meta.zcml" />
-    <include package="lp.services.database" />
-    <include package="lp.services.inlinehelp" file="meta.zcml" />
-    <include package="lp.services.openid" />
-    <include package="lp.services.job" />
-    <include package="lp.services.memcache" />
-    <include package="lp.services.profile" />
-    <include package="lp.services.features" />
-    <include package="lp.services.scripts" />
-    <include package="lp.services.worlddata" />
-    <include package="lp.services.salesforce" />
+    <include package="lp.services" />
     <include package="lazr.uri" />
     <include package="canonical.librarian" />
 

=== modified file 'lib/canonical/database/sqlbase.py'
--- lib/canonical/database/sqlbase.py	2010-08-16 00:40:47 +0000
+++ lib/canonical/database/sqlbase.py	2010-08-23 16:19:43 +0000
@@ -2,39 +2,6 @@
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
 __metaclass__ = type
-
-import warnings
-from datetime import datetime
-import re
-from textwrap import dedent
-import psycopg2
-from psycopg2.extensions import (
-    ISOLATION_LEVEL_AUTOCOMMIT, ISOLATION_LEVEL_READ_COMMITTED,
-    ISOLATION_LEVEL_SERIALIZABLE)
-import pytz
-import storm
-from storm.databases.postgres import compile as postgres_compile
-from storm.expr import State
-from storm.expr import compile as storm_compile
-from storm.locals import Storm, Store
-from storm.zope.interfaces import IZStorm
-
-from sqlobject.sqlbuilder import sqlrepr
-import transaction
-
-from twisted.python.util import mergeFunctionMetadata
-
-from zope.component import getUtility
-from zope.interface import implements
-from zope.security.proxy import removeSecurityProxy
-
-from lazr.restful.interfaces import IRepresentationCache
-
-from canonical.cachedproperty import clear_cachedproperties
-from canonical.config import config, dbconfig
-from canonical.database.interfaces import ISQLBase
-
-
 __all__ = [
     'alreadyInstalledMsg',
     'begin',
@@ -63,7 +30,49 @@
     'SQLBase',
     'sqlvalues',
     'StupidCache',
-    'ZopelessTransactionManager',]
+    'ZopelessTransactionManager',
+]
+
+
+from datetime import datetime
+import re
+from textwrap import dedent
+import warnings
+
+from lazr.restful.interfaces import IRepresentationCache
+import psycopg2
+from psycopg2.extensions import (
+    ISOLATION_LEVEL_AUTOCOMMIT,
+    ISOLATION_LEVEL_READ_COMMITTED,
+    ISOLATION_LEVEL_SERIALIZABLE,
+    )
+import pytz
+from sqlobject.sqlbuilder import sqlrepr
+import storm
+from storm.databases.postgres import compile as postgres_compile
+from storm.expr import (
+    compile as storm_compile,
+    State,
+    )
+from storm.locals import (
+    Store,
+    Storm,
+    )
+from storm.zope.interfaces import IZStorm
+import transaction
+from twisted.python.util import mergeFunctionMetadata
+from zope.component import getUtility
+from zope.interface import implements
+from zope.security.proxy import removeSecurityProxy
+
+from canonical.cachedproperty import clear_cachedproperties
+from canonical.config import (
+    config,
+    dbconfig,
+    )
+from canonical.database.interfaces import ISQLBase
+from lp.services.propertycache import IPropertyCacheManager
+
 
 # Default we want for scripts, and the PostgreSQL default. Note psycopg1 will
 # use SERIALIZABLE unless we override, but psycopg2 will not.
@@ -259,10 +268,14 @@
 
     def __storm_invalidated__(self):
         """Flush cached properties."""
-        # Note this is not directly tested; but the entire test suite blows up
-        # awesomely if its broken : its entirely unclear where tests for this
-        # should be -- RBC 20100816.
+        # XXX: RobertCollins 2010-08-16 bug=622648: Note this is not directly
+        # tested, but the entire test suite blows up awesomely if it's broken.
+        # It's entirely unclear where tests for this should be.
+
+        # While canonical.cachedproperty and lp.services.propertycache are
+        # both in use, we must clear the caches for both.
         clear_cachedproperties(self)
+        IPropertyCacheManager(self).clear()
 
 
 alreadyInstalledMsg = ("A ZopelessTransactionManager with these settings is "

=== modified file 'lib/lp/registry/doc/personlocation.txt'
--- lib/lp/registry/doc/personlocation.txt	2009-11-15 01:05:49 +0000
+++ lib/lp/registry/doc/personlocation.txt	2010-08-23 16:19:43 +0000
@@ -119,10 +119,11 @@
 have been pre-cached so that we don't hit the database everytime we
 access a person's .location property.
 
-    >>> from zope.security.proxy import removeSecurityProxy
+    >>> from lp.services.propertycache import IPropertyCache
     >>> for mapped in guadamen.getMappedParticipants():
-    ...     mapped = removeSecurityProxy(mapped)
-    ...     if not verifyObject(IPersonLocation, mapped._location):
+    ...     cache = IPropertyCache(mapped)
+    ...     if ("location" not in cache or
+    ...         not verifyObject(IPersonLocation, cache.location)):
     ...         print 'No cached location on %s' % mapped.name
 
 The mapped_participants methods takes a optional argument to limit the

=== modified file 'lib/lp/registry/doc/teammembership.txt'
--- lib/lp/registry/doc/teammembership.txt	2010-08-20 01:29:08 +0000
+++ lib/lp/registry/doc/teammembership.txt	2010-08-23 16:19:43 +0000
@@ -1008,8 +1008,8 @@
     >>> from canonical.launchpad.interfaces import IMasterObject
     >>> IMasterObject(bad_user.account).status = AccountStatus.SUSPENDED
     >>> IMasterObject(bad_user.preferredemail).status = EmailAddressStatus.OLD
-    >>> from canonical.cachedproperty import clear_property
-    >>> clear_property(removeSecurityProxy(bad_user), '_preferredemail_cached')
+    >>> from lp.services.propertycache import IPropertyCache
+    >>> del IPropertyCache(removeSecurityProxy(bad_user)).preferredemail
     >>> transaction.commit()
 
     >>> [m.displayname for m in t3.allmembers]

=== modified file 'lib/lp/registry/model/distribution.py'
--- lib/lp/registry/model/distribution.py	2010-08-22 19:26:46 +0000
+++ lib/lp/registry/model/distribution.py	2010-08-23 16:19:43 +0000
@@ -33,10 +33,6 @@
     implements,
     )
 
-from canonical.cachedproperty import (
-    cachedproperty,
-    clear_property,
-    )
 from canonical.database.constants import UTC_NOW
 from canonical.database.datetimecol import UtcDateTimeCol
 from canonical.database.enumcol import EnumCol
@@ -63,17 +59,11 @@
     ILaunchpadCelebrities,
     )
 from canonical.launchpad.interfaces.lpstorm import IStore
-from lp.registry.model.announcement import MakesAnnouncements
-from lp.soyuz.model.archive import Archive
-from lp.soyuz.model.binarypackagename import BinaryPackageName
-from lp.soyuz.model.binarypackagerelease import (
-    BinaryPackageRelease)
 from canonical.launchpad.validators.name import (
     sanitize_name,
     valid_name,
     )
 from canonical.launchpad.webapp.url import urlparse
-from canonical.lazr.utils import safe_hasattr
 from lp.answers.interfaces.faqtarget import IFAQTarget
 from lp.answers.interfaces.questioncollection import (
     QUESTION_STATUS_DEFAULT_SEARCH,
@@ -159,6 +149,10 @@
 from lp.registry.model.structuralsubscription import (
     StructuralSubscriptionTargetMixin,
     )
+from lp.services.propertycache import (
+    cachedproperty,
+    IPropertyCache,
+    )
 from lp.soyuz.interfaces.archive import (
     ArchivePurpose,
     ArchiveStatus,
@@ -524,7 +518,7 @@
             return (2, self.name)
         return (3, self.name)
 
-    @cachedproperty('_cached_series')
+    @cachedproperty
     def series(self):
         """See `IDistribution`."""
         ret = Store.of(self).find(
@@ -1760,7 +1754,8 @@
 
         # May wish to add this to the series rather than clearing the cache --
         # RBC 20100816.
-        clear_property(self, '_cached_series')
+        del IPropertyCache(self).series
+
         return series
 
     @property

=== modified file 'lib/lp/registry/model/person.py'
--- lib/lp/registry/model/person.py	2010-08-22 17:13:25 +0000
+++ lib/lp/registry/model/person.py	2010-08-23 16:19:43 +0000
@@ -91,11 +91,6 @@
     removeSecurityProxy,
     )
 
-from canonical.cachedproperty import (
-    cache_property,
-    cachedproperty,
-    clear_property,
-    )
 from canonical.config import config
 from canonical.database import postgresql
 from canonical.database.constants import UTC_NOW
@@ -266,6 +261,10 @@
     TeamMembershipSet,
     TeamParticipation,
     )
+from lp.services.propertycache import (
+    cachedproperty,
+    IPropertyCache,
+    )
 from lp.services.salesforce.interfaces import (
     ISalesforceVoucherProxy,
     REDEEMABLE_VOUCHER_STATUSES,
@@ -499,7 +498,7 @@
 
     personal_standing_reason = StringCol(default=None)
 
-    @cachedproperty('_languages_cache')
+    @cachedproperty
     def languages(self):
         """See `IPerson`."""
         results = Store.of(self).find(
@@ -513,19 +512,19 @@
 
         :raises AttributeError: If the cache doesn't exist.
         """
-        return self._languages_cache
+        return IPropertyCache(self).languages
 
     def setLanguagesCache(self, languages):
         """Set this person's cached languages.
 
         Order them by name if necessary.
         """
-        cache_property(self, '_languages_cache', sorted(
-            languages, key=attrgetter('englishname')))
+        IPropertyCache(self).languages = sorted(
+            languages, key=attrgetter('englishname'))
 
     def deleteLanguagesCache(self):
         """Delete this person's cached languages, if it exists."""
-        clear_property(self, '_languages_cache')
+        del IPropertyCache(self).languages
 
     def addLanguage(self, language):
         """See `IPerson`."""
@@ -592,7 +591,7 @@
             Or(OAuthRequestToken.date_expires == None,
                OAuthRequestToken.date_expires > UTC_NOW))
 
-    @cachedproperty('_location')
+    @cachedproperty
     def location(self):
         """See `IObjectWithLocation`."""
         return PersonLocation.selectOneBy(person=self)
@@ -628,7 +627,8 @@
         """See `ISetLocation`."""
         assert not self.is_team, 'Cannot edit team location.'
         if self.location is None:
-            self._location = PersonLocation(person=self, visible=visible)
+            IPropertyCache(self).location = PersonLocation(
+                person=self, visible=visible)
         else:
             self.location.visible = visible
 
@@ -646,7 +646,7 @@
             self.location.last_modified_by = user
             self.location.date_last_modified = UTC_NOW
         else:
-            self._location = PersonLocation(
+            IPropertyCache(self).location = PersonLocation(
                 person=self, time_zone=time_zone, latitude=latitude,
                 longitude=longitude, last_modified_by=user)
 
@@ -1148,7 +1148,7 @@
         result = result.order_by(KarmaCategory.title)
         return [karma_cache for (karma_cache, category) in result]
 
-    @cachedproperty('_karma_cached')
+    @cachedproperty
     def karma(self):
         """See `IPerson`."""
         # May also be loaded from _all_members
@@ -1169,7 +1169,7 @@
 
         return self.is_valid_person
 
-    @cachedproperty('_is_valid_person_cached')
+    @cachedproperty
     def is_valid_person(self):
         """See `IPerson`."""
         if self.is_team:
@@ -1663,6 +1663,7 @@
 
         def prepopulate_person(row):
             result = row[0]
+            cache = IPropertyCache(result)
             index = 1
             #-- karma caching
             if need_karma:
@@ -1672,27 +1673,27 @@
                     karma_total = 0
                 else:
                     karma_total = karma.karma_total
-                cache_property(result, '_karma_cached', karma_total)
+                cache.karma = karma_total
             #-- ubuntu code of conduct signer status caching.
             if need_ubuntu_coc:
                 signed = row[index]
                 index += 1
-                cache_property(result, '_is_ubuntu_coc_signer_cached', signed)
+                cache.is_ubuntu_coc_signer = signed
             #-- location caching
             if need_location:
                 location = row[index]
                 index += 1
-                cache_property(result, '_location', location)
+                cache.location = location
             #-- archive caching
             if need_archive:
                 archive = row[index]
                 index += 1
-                cache_property(result, '_archive_cached', archive)
+                cache.archive = archive
             #-- preferred email caching
             if need_preferred_email:
                 email = row[index]
                 index += 1
-                cache_property(result, '_preferredemail_cached', email)
+                cache.preferredemail = email
             #-- validity caching
             if need_validity:
                 # valid if:
@@ -1702,7 +1703,7 @@
                     # -- preferred email found
                     and result.preferredemail is not None)
                 index += 1
-                cache_property(result, '_is_valid_person_cached', valid)
+                cache.is_valid_person = valid
             return result
         return DecoratedResultSet(raw_result,
             result_decorator=prepopulate_person)
@@ -1730,7 +1731,7 @@
         result = self._getMembersWithPreferredEmails()
         person_list = []
         for person, email in result:
-            cache_property(person, '_preferredemail_cached', email)
+            IPropertyCache(person).preferredemail = email
             person_list.append(person)
         return person_list
 
@@ -1865,7 +1866,7 @@
         # fetches the rows when they're needed.
         locations = self._getMappedParticipantsLocations(limit=limit)
         for location in locations:
-            location.person._location = location
+            IPropertyCache(location.person).location = location
         participants = set(location.person for location in locations)
         # Cache the ValidPersonCache query for all mapped participants.
         if len(participants) > 0:
@@ -2007,7 +2008,7 @@
         self.account_status = AccountStatus.DEACTIVATED
         self.account_status_comment = comment
         IMasterObject(self.preferredemail).status = EmailAddressStatus.NEW
-        clear_property(self, '_preferredemail_cached')
+        del IPropertyCache(self).preferredemail
         base_new_name = self.name + '-deactivatedaccount'
         self.name = self._ensureNewName(base_new_name)
 
@@ -2397,7 +2398,7 @@
         if email_address is not None:
             email_address.status = EmailAddressStatus.VALIDATED
             email_address.syncUpdate()
-        clear_property(self, '_preferredemail_cached')
+        del IPropertyCache(self).preferredemail
 
     def setPreferredEmail(self, email):
         """See `IPerson`."""
@@ -2434,9 +2435,9 @@
         IMasterObject(email).syncUpdate()
 
         # Now we update our cache of the preferredemail.
-        cache_property(self, '_preferredemail_cached', email)
+        IPropertyCache(self).preferredemail = email
 
-    @cachedproperty('_preferredemail_cached')
+    @cachedproperty
     def preferredemail(self):
         """See `IPerson`."""
         emails = self._getEmailsByStatus(EmailAddressStatus.PREFERRED)
@@ -2601,7 +2602,7 @@
             distribution.main_archive, self)
         return permissions.count() > 0
 
-    @cachedproperty('_is_ubuntu_coc_signer_cached')
+    @cachedproperty
     def is_ubuntu_coc_signer(self):
         """See `IPerson`."""
         # Also assigned to by self._all_members.
@@ -2631,7 +2632,7 @@
         sCoC_util = getUtility(ISignedCodeOfConductSet)
         return sCoC_util.searchByUser(self.id, active=False)
 
-    @cachedproperty('_archive_cached')
+    @cachedproperty
     def archive(self):
         """See `IPerson`."""
         return getUtility(IArchiveSet).getPPAOwnedByPerson(self)
@@ -2955,8 +2956,8 @@
                 # Populate the previously empty 'preferredemail' cached
                 # property, so the Person record is up-to-date.
                 if master_email.status == EmailAddressStatus.PREFERRED:
-                    cache_property(account_person, '_preferredemail_cached',
-                        master_email)
+                    cache = IPropertyCache(account_person)
+                    cache.preferredemail = master_email
                 return account_person
             # There is no associated `Person` to the email `Account`.
             # This is probably because the account was created externally

=== modified file 'lib/lp/registry/tests/test_distribution.py'
--- lib/lp/registry/tests/test_distribution.py	2010-08-22 19:26:46 +0000
+++ lib/lp/registry/tests/test_distribution.py	2010-08-23 16:19:43 +0000
@@ -18,6 +18,7 @@
 from lp.registry.tests.test_distroseries import (
     TestDistroSeriesCurrentSourceReleases,
     )
+from lp.services.propertycache import IPropertyCache
 from lp.soyuz.interfaces.distributionsourcepackagerelease import (
     IDistributionSourcePackageRelease,
     )
@@ -83,27 +84,26 @@
         distribution = removeSecurityProxy(
             self.factory.makeDistribution('foo'))
 
+        cache = IPropertyCache(distribution)
+
         # Not yet cached.
-        missing = object()
-        cached_series = getattr(distribution, '_cached_series', missing)
-        self.assertEqual(missing, cached_series)
+        self.assertNotIn("series", cache)
 
         # Now cached.
         series = distribution.series
-        self.assertTrue(series is distribution._cached_series)
+        self.assertIs(series, cache.series)
 
         # Cache cleared.
         distribution.newSeries(
             name='bar', displayname='Bar', title='Bar', summary='',
             description='', version='1', parent_series=None,
             owner=self.factory.makePerson())
-        cached_series = getattr(distribution, '_cached_series', missing)
-        self.assertEqual(missing, cached_series)
+        self.assertNotIn("series", cache)
 
         # New cached value.
         series = distribution.series
         self.assertEqual(1, len(series))
-        self.assertTrue(series is distribution._cached_series)
+        self.assertIs(series, cache.series)
 
 
 class SeriesByStatusTests(TestCaseWithFactory):

=== added file 'lib/lp/services/configure.zcml'
--- lib/lp/services/configure.zcml	1970-01-01 00:00:00 +0000
+++ lib/lp/services/configure.zcml	2010-08-23 16:19:43 +0000
@@ -0,0 +1,19 @@
+<!-- Copyright 2010 Canonical Ltd.  This software is licensed under the
+     GNU Affero General Public License version 3 (see the file LICENSE).
+-->
+
+<configure xmlns="http://namespaces.zope.org/zope">
+  <adapter factory=".propertycache.get_default_cache"/>
+  <adapter factory=".propertycache.PropertyCacheManager"/>
+  <adapter factory=".propertycache.DefaultPropertyCacheManager"/>
+  <include package=".database" />
+  <include package=".features" />
+  <include package=".inlinehelp" file="meta.zcml" />
+  <include package=".job" />
+  <include package=".memcache" />
+  <include package=".openid" />
+  <include package=".profile" />
+  <include package=".salesforce" />
+  <include package=".scripts" />
+  <include package=".worlddata" />
+</configure>

=== added file 'lib/lp/services/doc/propertycache.txt'
--- lib/lp/services/doc/propertycache.txt	1970-01-01 00:00:00 +0000
+++ lib/lp/services/doc/propertycache.txt	2010-08-23 16:19:43 +0000
@@ -0,0 +1,153 @@
+Cached Properties in propertycache
+==================================
+
+    >>> from lp.services.propertycache import (
+    ...     cachedproperty,
+    ...     IPropertyCache,
+    ...     IPropertyCacheManager,
+    ...     )
+
+Cached properties are for situations where a property is computed once
+and then returned each time it is asked for.
+
+    >>> from itertools import count
+    >>> counter = count(1)
+
+    >>> class Foo:
+    ...     @cachedproperty
+    ...     def bar(self):
+    ...         return next(counter)
+
+    >>> foo = Foo()
+
+The property cache can be obtained via adaption.
+
+    >>> cache = IPropertyCache(foo)
+
+Initially it is empty. Caches can be iterated over to reveal the names
+of the values cached within.
+
+    >>> list(cache)
+    []
+
+After accessing a cached property the cache is no longer empty.
+
+    >>> foo.bar
+    1
+    >>> list(cache)
+    ['bar']
+    >>> cache.bar
+    1
+
+Attempting to access an unknown name from the cache is an error.
+
+    >>> cache.baz
+    Traceback (most recent call last):
+    ...
+    AttributeError: 'DefaultPropertyCache' object has no attribute 'baz'
+
+Values in the cache can be deleted.
+
+    >>> del cache.bar
+    >>> list(cache)
+    []
+
+Accessing the cached property causes its populate function to be
+called again.
+
+    >>> foo.bar
+    2
+    >>> cache.bar
+    2
+
+Values in the cache can be set and updated.
+
+    >>> cache.bar = 456
+    >>> foo.bar
+    456
+
+Caches respond to membership tests.
+
+    >>> "bar" in cache
+    True
+
+    >>> del cache.bar
+
+    >>> "bar" in cache
+    False
+
+It is safe to delete names from the cache even if there is no value
+cached.
+
+    >>> del cache.bar
+    >>> del cache.bar
+
+A cache manager can be used to empty the cache.
+
+    >>> manager = IPropertyCacheManager(cache)
+
+    >>> cache.bar = 123
+    >>> cache.baz = 456
+    >>> sorted(cache)
+    ['bar', 'baz']
+
+    >>> manager.clear()
+    >>> list(cache)
+    []
+
+A cache manager can be obtained by adaption from non-cache objects
+too.
+
+    >>> manager = IPropertyCacheManager(foo)
+    >>> manager.cache is cache
+    True
+
+
+The cachedproperty decorator
+----------------------------
+
+A cached property can be declared with or without an explicit name. If
+not provided it will be derived from the decorated object. This name
+is the name under which values will be cached.
+
+    >>> class Foo:
+    ...     @cachedproperty("a_in_cache")
+    ...     def a(self):
+    ...         return 1234
+    ...     @cachedproperty
+    ...     def b(self):
+    ...         return 5678
+
+    >>> foo = Foo()
+
+`a` was declared with an explicit name of "a_in_cache" so it is known
+as "a_in_cache" in the cache.
+
+    >>> from lp.services.propertycache import CachedProperty
+
+    >>> isinstance(Foo.a, CachedProperty)
+    True
+    >>> Foo.a.name
+    'a_in_cache'
+    >>> Foo.a.populate
+    <function a at 0x...>
+
+    >>> foo.a
+    1234
+    >>> IPropertyCache(foo).a_in_cache
+    1234
+
+`b` was defined without an explicit name so it is known as "b" in the
+cache too.
+
+    >>> isinstance(Foo.b, CachedProperty)
+    True
+    >>> Foo.b.name
+    'b'
+    >>> Foo.b.populate
+    <function b at 0x...>
+
+    >>> foo.b
+    5678
+    >>> IPropertyCache(foo).b
+    5678

=== added file 'lib/lp/services/propertycache.py'
--- lib/lp/services/propertycache.py	1970-01-01 00:00:00 +0000
+++ lib/lp/services/propertycache.py	2010-08-23 16:19:43 +0000
@@ -0,0 +1,174 @@
+# Copyright 2010 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""
+Cached properties for situations where a property is computed once and then
+returned each time it is asked for.
+
+See `doc/propertycache.txt` for documentation.
+"""
+
+__metaclass__ = type
+__all__ = [
+    'IPropertyCache',
+    'IPropertyCacheManager',
+    'cachedproperty',
+    ]
+
+from functools import partial
+
+from zope.component import (
+    adapter,
+    adapts,
+    )
+from zope.interface import (
+    implementer,
+    implements,
+    Interface,
+    )
+from zope.schema import Object
+from zope.security.proxy import removeSecurityProxy
+
+
+class IPropertyCache(Interface):
+
+    def __getattr__(name):
+        """Return the cached value corresponding to `name`.
+
+        Raise `AttributeError` if no value is cached.
+        """
+
+    def __setattr__(name, value):
+        """Cache `value` for `name`."""
+
+    def __delattr__(name):
+        """Delete value for `name`.
+
+        If no value is cached for `name` this is a no-op.
+        """
+
+    def __contains__(name):
+        """Whether or not `name` is cached."""
+
+    def __iter__():
+        """Iterate over the cached names."""
+
+
+class IPropertyCacheManager(Interface):
+
+    cache = Object(IPropertyCache)
+
+    def clear():
+        """Empty the cache."""
+
+
+class DefaultPropertyCache:
+    """A simple cache."""
+
+    implements(IPropertyCache)
+
+    # __getattr__ -- well, __getattribute__ -- and __setattr__ are inherited
+    # from object.
+
+    def __delattr__(self, name):
+        """See `IPropertyCache`."""
+        self.__dict__.pop(name, None)
+
+    def __contains__(self, name):
+        """See `IPropertyCache`."""
+        return name in self.__dict__
+
+    def __iter__(self):
+        """See `IPropertyCache`."""
+        return iter(self.__dict__)
+
+
+@adapter(Interface)
+@implementer(IPropertyCache)
+def get_default_cache(target):
+    """Adapter to obtain a `DefaultPropertyCache` for any object."""
+    naked_target = removeSecurityProxy(target)
+    try:
+        return naked_target._property_cache
+    except AttributeError:
+        naked_target._property_cache = DefaultPropertyCache()
+        return naked_target._property_cache
+
+
+class PropertyCacheManager:
+    """A simple `IPropertyCacheManager`.
+
+    Should work for any `IPropertyCache` instance.
+    """
+
+    implements(IPropertyCacheManager)
+    adapts(Interface)
+
+    def __init__(self, target):
+        self.cache = IPropertyCache(target)
+
+    def clear(self):
+        """See `IPropertyCacheManager`."""
+        for name in list(self.cache):
+            delattr(self.cache, name)
+
+
+class DefaultPropertyCacheManager:
+    """A `IPropertyCacheManager` specifically for `DefaultPropertyCache`.
+
+    The implementation of `clear` is more efficient.
+    """
+
+    implements(IPropertyCacheManager)
+    adapts(DefaultPropertyCache)
+
+    def __init__(self, cache):
+        self.cache = cache
+
+    def clear(self):
+        self.cache.__dict__.clear()
+
+
+class CachedProperty:
+    """Cached property descriptor.
+
+    Provides only the `__get__` part of the descriptor protocol. Setting and
+    clearing cached values should be done explicitly via `IPropertyCache`
+    instances.
+    """
+
+    def __init__(self, populate, name):
+        """Initialize this instance.
+
+        `populate` is a callable responsible for providing the value when this
+        property has not yet been cached.
+
+        `name` is the name under which this property will cache itself.
+        """
+        self.populate = populate
+        self.name = name
+
+    def __get__(self, instance, cls):
+        if instance is None:
+            return self
+        cache = IPropertyCache(instance)
+        try:
+            return getattr(cache, self.name)
+        except AttributeError:
+            value = self.populate(instance)
+            setattr(cache, self.name, value)
+            return value
+
+
+def cachedproperty(name_or_function):
+    """Decorator to create a cached property.
+
+    See `doc/propertycache.txt` for usage.
+    """
+    if isinstance(name_or_function, basestring):
+        name = name_or_function
+        return partial(CachedProperty, name=name)
+    else:
+        name = name_or_function.__name__
+        populate = name_or_function
+        return CachedProperty(name=name, populate=populate)

=== modified file 'lib/lp/services/tests/test_doc.py'
--- lib/lp/services/tests/test_doc.py	2010-08-20 20:31:18 +0000
+++ lib/lp/services/tests/test_doc.py	2010-08-23 16:19:43 +0000
@@ -9,6 +9,7 @@
 
 from canonical.launchpad.testing.systemdocs import LayeredDocFileSuite
 from canonical.testing import BaseLayer
+from canonical.testing import LaunchpadZopelessLayer
 from lp.services.testing import build_test_suite
 
 
@@ -19,6 +20,9 @@
     'limitedlist.txt': LayeredDocFileSuite(
         '../doc/limitedlist.txt',
         layer=BaseLayer),
+    'propertycache.txt': LayeredDocFileSuite(
+        '../doc/propertycache.txt',
+        layer=LaunchpadZopelessLayer),
     }
 
 

=== modified file 'lib/lp/soyuz/model/archive.py'
--- lib/lp/soyuz/model/archive.py	2010-08-20 20:31:18 +0000
+++ lib/lp/soyuz/model/archive.py	2010-08-23 16:19:43 +0000
@@ -38,7 +38,6 @@
     implements,
     )
 
-from canonical.cachedproperty import clear_property
 from canonical.config import config
 from canonical.database.constants import UTC_NOW
 from canonical.database.datetimecol import UtcDateTimeCol
@@ -89,6 +88,7 @@
 from lp.registry.interfaces.sourcepackagename import ISourcePackageNameSet
 from lp.registry.model.teammembership import TeamParticipation
 from lp.services.job.interfaces.job import JobStatus
+from lp.services.propertycache import IPropertyCache
 from lp.soyuz.adapters.archivedependencies import expand_dependencies
 from lp.soyuz.adapters.packagelocation import PackageLocation
 from lp.soyuz.interfaces.archive import (
@@ -1834,7 +1834,7 @@
                 signing_key = owner.archive.signing_key
             else:
                 # owner.archive is a cached property and we've just cached it.
-                clear_property(owner, '_archive_cached')
+                del IPropertyCache(owner).archive
 
         new_archive = Archive(
             owner=owner, distribution=distribution, name=name,