Merge lp:~jelmer/launchpad/600153-main-archive-builds-on-restricted into lp:launchpad

[Jelmer Vernooij]

Always allow main archives to build on restricted architectures.

This updates Archive.enabled_restricted_architectures to always include all restricted architectures for main archives, as we only want to restrict PPA's and copy architectures in this way for the moment.

Brief pre-imp call with Julian.

Tests:

./bin/test lp.soyuz.tests.test_archive

[Jeroen T. Vermeulen (jtv)]

Reviewed per IRC. Notes:

 * Run "make lint" before you submit the MP!

 * No seriously, run "make lint"!

 * Pass exception message to exception constructor. Putting it in _fmt seems unsafe.

 * There's no need for proper docstrings on test methods.

 * capitalize and punctuate error strings

Otherwise, you're good to go.

Jeroen

review: Approve

=== modified file 'lib/lp/soyuz/interfaces/archive.py'
--- lib/lp/soyuz/interfaces/archive.py	2010-06-29 15:00:35 +0000
+++ lib/lp/soyuz/interfaces/archive.py	2010-06-30 16:48:32 +0000
@@ -18,6 +18,7 @@
     'CannotCopy',
     'CannotSwitchPrivacy',
     'ComponentNotFound',
+    'CannotRestrictArchitectures',
     'CannotUploadToPPA',
     'CannotUploadToPocket',
     'DistroSeriesNotFound',
@@ -142,6 +143,10 @@
     webservice_error(400) # Bad request.
 
 
+class CannotRestrictArchitectures(Exception):
+    """The architectures for this archive can not be restricted."""
+
+
 class CannotUploadToArchive(Exception):
     """A reason for not being able to upload to an archive."""
     webservice_error(403) # Forbidden.

=== modified file 'lib/lp/soyuz/model/archive.py'
--- lib/lp/soyuz/model/archive.py	2010-06-29 13:49:39 +0000
+++ lib/lp/soyuz/model/archive.py	2010-06-30 16:48:32 +0000
@@ -63,9 +63,9 @@
 from lp.soyuz.interfaces.archive import (
     AlreadySubscribed, ArchiveDependencyError, ArchiveDisabled,
     ArchiveNotPrivate, ArchivePurpose, ArchiveStatus, CannotCopy,
-    CannotSwitchPrivacy, CannotUploadToPPA, CannotUploadToPocket,
-    DistroSeriesNotFound, IArchive, IArchiveSet, IDistributionArchive,
-    InsufficientUploadRights, InvalidPocketForPPA,
+    CannotRestrictArchitectures, CannotSwitchPrivacy, CannotUploadToPPA,
+    CannotUploadToPocket, DistroSeriesNotFound, IArchive, IArchiveSet,
+    IDistributionArchive, InsufficientUploadRights, InvalidPocketForPPA,
     InvalidPocketForPartnerArchive, InvalidComponent, IPPA,
     MAIN_ARCHIVE_PURPOSES, NoRightsForArchive, NoRightsForComponent,
     NoSuchPPA, NoTokensForTeams, PocketNotFound, VersionRequiresName,
@@ -1554,13 +1554,28 @@
             LibraryFileContent.id == LibraryFileAlias.contentID).config(
                 distinct=True))
 
-    def _get_enabled_restricted_families(self):
+    def _getEnabledRestrictedFamilies(self):
+        """Retrieve the restricted architecture families this archive can
+        build on."""
+        # Main archives are always allowed to build on restricted 
+        # architectures.
+        if self.is_main:
+            return getUtility(IProcessorFamilySet).getRestricted()
         archive_arch_set = getUtility(IArchiveArchSet)
         restricted_families = archive_arch_set.getRestrictedfamilies(self)
         return [family for (family, archive_arch) in restricted_families 
                 if archive_arch is not None]
 
-    def _set_enabled_restricted_families(self, value):
+    def _setEnabledRestrictedFamilies(self, value):
+        """Set the restricted architecture families this archive can
+        build on."""
+        # Main archives are always allowed to build on restricted 
+        # architectures.
+        if self.is_main:
+            proc_family_set = getUtility(IProcessorFamilySet)
+            if set(value) != set(proc_family_set.getRestricted()):
+                raise CannotRestrictArchitectures("Main archives can not "
+                        "be restricted to certain architectures")
         archive_arch_set = getUtility(IArchiveArchSet)
         restricted_families = archive_arch_set.getRestrictedfamilies(self)
         for (family, archive_arch) in restricted_families:
@@ -1569,8 +1584,8 @@
             if family not in value and archive_arch is not None:
                 Store.of(self).remove(archive_arch)
 
-    enabled_restricted_families = property(_get_enabled_restricted_families,
-                                           _set_enabled_restricted_families)
+    enabled_restricted_families = property(_getEnabledRestrictedFamilies,
+                                           _setEnabledRestrictedFamilies)
 
 
 class ArchiveSet:

=== modified file 'lib/lp/soyuz/tests/test_archive.py'
--- lib/lp/soyuz/tests/test_archive.py	2010-06-29 13:20:28 +0000
+++ lib/lp/soyuz/tests/test_archive.py	2010-06-30 16:48:32 +0000
@@ -21,8 +21,8 @@
 from lp.registry.interfaces.pocket import PackagePublishingPocket
 from lp.services.job.interfaces.job import JobStatus
 from lp.soyuz.interfaces.archive import (IArchiveSet, ArchivePurpose,
-    ArchiveStatus, CannotSwitchPrivacy, InvalidPocketForPartnerArchive,
-    InvalidPocketForPPA)
+    ArchiveStatus, CannotRestrictArchitectures, CannotSwitchPrivacy,
+    InvalidPocketForPartnerArchive, InvalidPocketForPPA)
 from lp.services.worlddata.interfaces.country import ICountrySet
 from lp.soyuz.interfaces.archivearch import IArchiveArchSet
 from lp.soyuz.interfaces.binarypackagename import IBinaryPackageNameSet
@@ -753,29 +753,45 @@
         self.archive_arch_set = getUtility(IArchiveArchSet)
         self.arm = getUtility(IProcessorFamilySet).getByName('arm')
 
+    def test_main_archive_can_use_restricted(self):
+        # Main archives for distributions can always use restricted 
+        # architectures.
+        distro = self.factory.makeDistribution()
+        self.assertContentEqual([self.arm],
+            distro.main_archive.enabled_restricted_families)
+
+    def test_main_archive_can_not_be_restricted(self):
+        # A main archive can not be restricted to certain architectures.
+        distro = self.factory.makeDistribution()
+        # Restricting to all restricted architectures is fine
+        distro.main_archive.enabled_restricted_families = [self.arm]
+        def restrict():
+            distro.main_archive.enabled_restricted_families = []
+        self.assertRaises(CannotRestrictArchitectures, restrict)
+
     def test_default(self):
         """By default, ARM builds are not allowed as ARM is restricted."""
         self.assertEquals(0,
             self.archive_arch_set.getByArchive(
                 self.archive, self.arm).count())
-        self.assertEquals([], list(self.archive.enabled_restricted_families))
+        self.assertContentEqual([], self.archive.enabled_restricted_families)
 
     def test_get_uses_archivearch(self):
         """Adding an entry to ArchiveArch for ARM and an archive will
         enable enabled_restricted_families for arm for that archive."""
-        self.assertEquals([], list(self.archive.enabled_restricted_families))
+        self.assertContentEqual([], self.archive.enabled_restricted_families)
         self.archive_arch_set.new(self.archive, self.arm)
-        self.assertEquals([self.arm], 
-                list(self.archive.enabled_restricted_families))
+        self.assertContentEqual([self.arm], 
+                self.archive.enabled_restricted_families)
 
     def test_get_returns_restricted_only(self):
         """Adding an entry to ArchiveArch for something that is not 
         restricted does not make it show up in enabled_restricted_families.
         """
-        self.assertEquals([], list(self.archive.enabled_restricted_families))
+        self.assertContentEqual([], self.archive.enabled_restricted_families)
         self.archive_arch_set.new(self.archive,
             getUtility(IProcessorFamilySet).getByName('amd64'))
-        self.assertEquals([], list(self.archive.enabled_restricted_families))
+        self.assertContentEqual([], self.archive.enabled_restricted_families)
 
     def test_set(self):
         """The property remembers its value correctly and sets ArchiveArch."""
@@ -790,7 +806,7 @@
         self.assertEquals(0,
             self.archive_arch_set.getByArchive(
                 self.archive, self.arm).count())
-        self.assertEquals([], list(self.archive.enabled_restricted_families))
+        self.assertContentEqual([], self.archive.enabled_restricted_families)
 
 
 class TestArchiveTokens(TestCaseWithFactory):