Merge ~pappacena/launchpad:snap-pillar-ui into launchpad:master

[Thiago F. Pappacena]

UI to associate a project pillar to Snaps on +admin view, and replacing "private" Snap flag with "information_type".

[Colin Watson (cjwatson)]

review: Needs Fixing

[Thiago F. Pappacena (pappacena)]

Pushed the requested changes. This should be ready for another round of review.

[Colin Watson (cjwatson)]

review: Approve

diff --git a/lib/lp/registry/personmerge.py b/lib/lp/registry/personmerge.py
index 50e0f91..949e8d9 100644
--- a/lib/lp/registry/personmerge.py
+++ b/lib/lp/registry/personmerge.py
@@ -1,4 +1,4 @@
-# Copyright 2009-2018 Canonical Ltd.  This software is licensed under the
+# Copyright 2009-2021 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
 """Person/team merger implementation."""
diff --git a/lib/lp/snappy/browser/snap.py b/lib/lp/snappy/browser/snap.py
index 3b06a89..9759e66 100644
--- a/lib/lp/snappy/browser/snap.py
+++ b/lib/lp/snappy/browser/snap.py
@@ -1,4 +1,4 @@
-# Copyright 2015-2020 Canonical Ltd.  This software is licensed under the
+# Copyright 2015-2021 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
 """Snap views."""
@@ -48,10 +48,12 @@ from lp.app.browser.tales import format_link
 from lp.app.enums import PRIVATE_INFORMATION_TYPES
 from lp.app.interfaces.informationtype import IInformationType
 from lp.app.interfaces.launchpad import ILaunchpadCelebrities
+from lp.app.vocabularies import InformationTypeVocabulary
 from lp.app.widgets.itemswidgets import (
     LabeledMultiCheckBoxWidget,
     LaunchpadDropdownWidget,
     LaunchpadRadioWidget,
+    LaunchpadRadioWidgetWithDescription,
     )
 from lp.buildmaster.interfaces.processor import IProcessorSet
 from lp.code.browser.widgets.gitref import GitRefWidget
@@ -343,7 +345,8 @@ class ISnapEditSchema(Interface):
     use_template(ISnap, include=[
         'owner',
         'name',
-        'private',
+        'information_type',
+        'project',
         'require_virtualized',
         'allow_internet',
         'build_source_tarball',
@@ -351,6 +354,7 @@ class ISnapEditSchema(Interface):
         'auto_build_channels',
         'store_upload',
         ])
+
     store_distro_series = Choice(
         vocabulary='SnappyDistroSeries', required=True,
         title='Series')
@@ -520,8 +524,12 @@ class SnapAddView(
             kwargs = {'git_ref': self.context}
         else:
             kwargs = {'branch': self.context}
-        private = not getUtility(
-            ISnapSet).isValidPrivacy(False, data['owner'], **kwargs)
+        # XXX pappacena 2021-03-01: We should consider the pillar's branch
+        # sharing policy when setting the information_type.
+        # Once we move the information_type and pillar edition from the
+        # admin view to the create/edit views, we should change this.
+        information_type = getUtility(ISnapSet).getSnapSuggestedPrivacy(
+            data['owner'], **kwargs)
         if not data.get('auto_build', False):
             data['auto_build_archive'] = None
             data['auto_build_pocket'] = None
@@ -532,7 +540,8 @@ class SnapAddView(
             auto_build_archive=data['auto_build_archive'],
             auto_build_pocket=data['auto_build_pocket'],
             auto_build_channels=data['auto_build_channels'],
-            processors=data['processors'], private=private,
+            information_type=information_type,
+            processors=data['processors'],
             build_source_tarball=data['build_source_tarball'],
             store_upload=data['store_upload'],
             store_series=data['store_distro_series'].snappy_series,
@@ -559,6 +568,16 @@ class BaseSnapEditView(LaunchpadEditFormView, SnapAuthorizeMixin):
 
     schema = ISnapEditSchema
 
+    def getInformationTypesToShow(self):
+        """Get the information types to display on the edit form.
+
+        We display a customised set of information types: anything allowed
+        by the repository's model, plus the current type.
+        """
+        allowed_types = set(self.context.getAllowedInformationTypes(self.user))
+        allowed_types.add(self.context.information_type)
+        return allowed_types
+
     @property
     def cancel_url(self):
         return canonical_url(self.context)
@@ -612,25 +631,36 @@ class BaseSnapEditView(LaunchpadEditFormView, SnapAuthorizeMixin):
 
     def validate(self, data):
         super(BaseSnapEditView, self).validate(data)
-        if data.get('private', self.context.private) is False:
-            if 'private' in data or 'owner' in data:
+        info_type = data.get('information_type', self.context.information_type)
+        editing_info_type = 'information_type' in data
+        private = info_type in PRIVATE_INFORMATION_TYPES
+        if private is False:
+            # These are the requirements for public snaps.
+            if 'information_type' in data or 'owner' in data:
                 owner = data.get('owner', self.context.owner)
                 if owner is not None and owner.private:
                     self.setFieldError(
-                        'private' if 'private' in data else 'owner',
+                        'information_type' if editing_info_type else 'owner',
                         'A public snap cannot have a private owner.')
-            if 'private' in data or 'branch' in data:
+            if 'information_type' in data or 'branch' in data:
                 branch = data.get('branch', self.context.branch)
                 if branch is not None and branch.private:
                     self.setFieldError(
-                        'private' if 'private' in data else 'branch',
+                        'information_type' if editing_info_type else 'branch',
                         'A public snap cannot have a private branch.')
-            if 'private' in data or 'git_ref' in data:
+            if 'information_type' in data or 'git_ref' in data:
                 ref = data.get('git_ref', self.context.git_ref)
                 if ref is not None and ref.private:
                     self.setFieldError(
-                        'private' if 'private' in data else 'git_ref',
+                        'information_type' if editing_info_type else 'git_ref',
                         'A public snap cannot have a private repository.')
+        else:
+            # Requirements for private snaps.
+            project = data.get('project', self.context.project)
+            if project is None:
+                msg = ('Private snap recipes must be associated '
+                       'with a project.')
+                self.setFieldError('project', msg)
 
     def _needStoreReauth(self, data):
         """Does this change require reauthorizing to the store?"""
@@ -696,16 +726,40 @@ class SnapAdminView(BaseSnapEditView):
 
     page_title = 'Administer'
 
-    field_names = ['private', 'require_virtualized', 'allow_internet']
+    # XXX pappacena 2021-02-19: Once we have the whole privacy work in
+    # place, we should move "project" and "information_type" from +admin
+    # page to +edit, to allow common users to edit this.
+    field_names = [
+        'project', 'information_type', 'require_virtualized', 'allow_internet']
+
+    # See `setUpWidgets` method.
+    custom_widget_information_type = CustomWidgetFactory(
+        LaunchpadRadioWidgetWithDescription,
+        vocabulary=InformationTypeVocabulary(types=[]))
+
+    @property
+    def initial_values(self):
+        """Set initial values for the form."""
+        # XXX pappacena 2021-02-12: Until we back fill information_type
+        # database column, it will be NULL, but snap.information_type
+        # property has a fallback to check "private" property. This should
+        # be removed once we back fill snap.information_type.
+        return {'information_type': self.context.information_type}
+
+    def setUpWidgets(self):
+        super(SnapAdminView, self).setUpWidgets()
+        info_type_widget = self.widgets['information_type']
+        info_type_widget.vocabulary = InformationTypeVocabulary(
+            types=self.getInformationTypesToShow())
 
     def validate(self, data):
         super(SnapAdminView, self).validate(data)
         # BaseSnapEditView.validate checks the rules for 'private' in
         # combination with other attributes.
-        if data.get('private', None) is True:
+        if data.get('information_type', None) in PRIVATE_INFORMATION_TYPES:
             if not getFeatureFlag(SNAP_PRIVATE_FEATURE_FLAG):
                 self.setFieldError(
-                    'private',
+                    'information_type',
                     'You do not have permission to create private snaps.')
 
 
diff --git a/lib/lp/snappy/browser/tests/test_snap.py b/lib/lp/snappy/browser/tests/test_snap.py
index 3e48162..5f33900 100644
--- a/lib/lp/snappy/browser/tests/test_snap.py
+++ b/lib/lp/snappy/browser/tests/test_snap.py
@@ -2,7 +2,7 @@
 # NOTE: The first line above must stay first; do not move the copyright
 # notice to the top.  See http://www.python.org/dev/peps/pep-0263/.
 #
-# Copyright 2015-2020 Canonical Ltd.  This software is licensed under the
+# Copyright 2015-2021 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
 """Test snap package views."""
@@ -85,6 +85,7 @@ from lp.testing import (
     admin_logged_in,
     BrowserTestCase,
     login,
+    login_admin,
     login_person,
     person_logged_in,
     TestCaseWithFactory,
@@ -400,6 +401,64 @@ class TestSnapAddView(BaseTestSnapView):
             extract_text(find_tag_by_id(browser.contents, "privacy"))
         )
 
+    def test_create_new_snap_private_team_with_private_branch(self):
+        # Creating snaps from private branch should make the snap follow its
+        # privacy setting.
+        self.useFixture(BranchHostingFixture(blob=b""))
+        login_person(self.person)
+        private_team = self.factory.makeTeam(
+            name='super-private', owner=self.person,
+            visibility=PersonVisibility.PRIVATE)
+        branch = self.factory.makeAnyBranch(
+            owner=self.person, registrant=self.person,
+            information_type=InformationType.PRIVATESECURITY)
+
+        browser = self.getViewBrowser(
+            branch, view_name="+new-snap", user=self.person)
+        browser.getControl(name="field.name").value = "private-snap"
+        browser.getControl("Owner").value = ['super-private']
+        browser.getControl("Create snap package").click()
+
+        content = find_main_content(browser.contents)
+        self.assertEqual("private-snap", extract_text(content.h1))
+        self.assertEqual(
+            'This snap contains Private information',
+            extract_text(find_tag_by_id(browser.contents, "privacy"))
+        )
+        login_admin()
+        snap = getUtility(ISnapSet).getByName(private_team, 'private-snap')
+        self.assertEqual(
+            InformationType.PRIVATESECURITY, snap.information_type)
+
+    def test_create_new_snap_private_team_with_private_git_repo(self):
+        # Creating snaps from private repos should make the snap follow its
+        # privacy setting.
+        self.useFixture(BranchHostingFixture(blob=b""))
+        login_person(self.person)
+        private_team = self.factory.makeTeam(
+            name='super-private', owner=self.person,
+            visibility=PersonVisibility.PRIVATE)
+        [git_ref] = self.factory.makeGitRefs(
+            owner=self.person, registrant=self.person,
+            information_type=InformationType.PRIVATESECURITY)
+
+        browser = self.getViewBrowser(
+            git_ref, view_name="+new-snap", user=self.person)
+        browser.getControl(name="field.name").value = "private-snap"
+        browser.getControl("Owner").value = ['super-private']
+        browser.getControl("Create snap package").click()
+
+        content = find_main_content(browser.contents)
+        self.assertEqual("private-snap", extract_text(content.h1))
+        self.assertEqual(
+            'This snap contains Private information',
+            extract_text(find_tag_by_id(browser.contents, "privacy"))
+        )
+        login_admin()
+        snap = getUtility(ISnapSet).getByName(private_team, 'private-snap')
+        self.assertEqual(
+            InformationType.PRIVATESECURITY, snap.information_type)
+
     def test_create_new_snap_build_source_tarball(self):
         # We can create a new snap and ask for it to build a source tarball.
         self.useFixture(BranchHostingFixture(blob=b""))
@@ -655,22 +714,43 @@ class TestSnapAdminView(BaseTestSnapView):
             member_of=[getUtility(ILaunchpadCelebrities).commercial_admin])
         login_person(self.person)
         snap = self.factory.makeSnap(registrant=self.person)
+        project = self.factory.makeProduct(name='my-project')
         self.assertTrue(snap.require_virtualized)
+        self.assertIsNone(snap.project)
         self.assertFalse(snap.private)
         self.assertTrue(snap.allow_internet)
 
+        private = InformationType.PRIVATESECURITY.name
         browser = self.getViewBrowser(snap, user=commercial_admin)
         browser.getLink("Administer snap package").click()
+        browser.getControl(name='field.project').value = "my-project"
         browser.getControl("Require virtualized builders").selected = False
-        browser.getControl("Private").selected = True
+        browser.getControl(name="field.information_type").value = private
         browser.getControl("Allow external network access").selected = False
         browser.getControl("Update snap package").click()
 
         login_person(self.person)
+        self.assertEqual(project, snap.project)
         self.assertFalse(snap.require_virtualized)
         self.assertTrue(snap.private)
         self.assertFalse(snap.allow_internet)
 
+    def test_admin_snap_private_without_project(self):
+        # Cannot make snap private if it doesn't have a project associated.
+        login_person(self.person)
+        snap = self.factory.makeSnap(registrant=self.person)
+        commercial_admin = self.factory.makePerson(
+            member_of=[getUtility(ILaunchpadCelebrities).commercial_admin])
+        private = InformationType.PRIVATESECURITY.name
+        browser = self.getViewBrowser(snap, user=commercial_admin)
+        browser.getLink("Administer snap package").click()
+        browser.getControl(name='field.project').value = ''
+        browser.getControl(name="field.information_type").value = private
+        browser.getControl("Update snap package").click()
+        self.assertEqual(
+            'Private snap recipes must be associated with a project.',
+            extract_text(find_tags_by_class(browser.contents, "message")[1]))
+
     def test_admin_snap_privacy_mismatch(self):
         # Cannot make snap public if it still contains private information.
         login_person(self.person)
@@ -682,9 +762,10 @@ class TestSnapAdminView(BaseTestSnapView):
         # can reach this snap because it's owned by a private team.
         commercial_admin = self.factory.makePerson(
             member_of=[getUtility(ILaunchpadCelebrities).commercial_admin])
+        public = InformationType.PUBLIC.name
         browser = self.getViewBrowser(snap, user=commercial_admin)
         browser.getLink("Administer snap package").click()
-        browser.getControl("Private").selected = False
+        browser.getControl(name="field.information_type").value = public
         browser.getControl("Update snap package").click()
         self.assertEqual(
             'A public snap cannot have a private owner.',
diff --git a/lib/lp/snappy/interfaces/snap.py b/lib/lp/snappy/interfaces/snap.py
index 9b19b1b..8ac5838 100644
--- a/lib/lp/snappy/interfaces/snap.py
+++ b/lib/lp/snappy/interfaces/snap.py
@@ -67,6 +67,7 @@ from lazr.restful.fields import (
     Reference,
     ReferenceChoice,
     )
+from lazr.restful.interface import copy_field
 from six.moves import http_client
 from zope.interface import (
     Attribute,
@@ -570,6 +571,12 @@ class ISnapView(Interface):
         # Really ISnapBuild, patched in lp.snappy.interfaces.webservice.
         value_type=Reference(schema=Interface), readonly=True)))
 
+    def getAllowedInformationTypes(user):
+        """Get a list of acceptable `InformationType`s for this snap recipe.
+
+        If the user is a Launchpad admin, any type is acceptable.
+        """
+
 
 class ISnapEdit(IWebhookTarget):
     """`ISnap` methods that require launchpad.Edit permission."""
@@ -672,7 +679,7 @@ class ISnapEditableAttributes(IHasOwner):
         description=_("The owner of this snap package.")))
 
     project = ReferenceChoice(
-        title=_('The project that this Snap is associated with.'),
+        title=_('The project that this Snap is associated with'),
         schema=IProduct, vocabulary='Product',
         required=False, readonly=False)
 
@@ -845,7 +852,7 @@ class ISnapAdminAttributes(Interface):
 
     information_type = exported(Choice(
         title=_("Information type"), vocabulary=InformationType,
-        required=True, readonly=True, default=InformationType.PUBLIC,
+        required=True, readonly=False, default=InformationType.PUBLIC,
         description=_(
             "The type of information contained in this Snap recipe.")))
 
@@ -884,6 +891,7 @@ class ISnapSet(Interface):
 
     @call_with(registrant=REQUEST_USER)
     @operation_parameters(
+        information_type=copy_field(ISnap["information_type"], required=False),
         processors=List(
             value_type=Reference(schema=IProcessor), required=False))
     @export_factory_operation(
@@ -891,15 +899,16 @@ class ISnapSet(Interface):
             "owner", "distro_series", "name", "description", "branch",
             "git_repository", "git_repository_url", "git_path", "git_ref",
             "auto_build", "auto_build_archive", "auto_build_pocket",
-            "private", "store_upload", "store_series", "store_name",
-            "store_channels"])
+            "store_upload", "store_series", "store_name", "store_channels",
+            "project"])
     @operation_for_version("devel")
     def new(registrant, owner, distro_series, name, description=None,
             branch=None, git_repository=None, git_repository_url=None,
             git_path=None, git_ref=None, auto_build=False,
             auto_build_archive=None, auto_build_pocket=None,
             require_virtualized=True, processors=None, date_created=None,
-            private=False, store_upload=False, store_series=None,
+            information_type=InformationType.PUBLIC, store_upload=False,
+            store_series=None,
             store_name=None, store_secrets=None, store_channels=None,
             project=None):
         """Create an `ISnap`."""
@@ -907,8 +916,8 @@ class ISnapSet(Interface):
     def exists(owner, name):
         """Check to see if a matching snap exists."""
 
-    def isValidPrivacy(private, owner, branch=None, git_ref=None):
-        """Whether or not the privacy context is valid."""
+    def getSnapSuggestedPrivacy(owner, branch=None, git_ref=None):
+        """Which privacy a Snap should have based on its creation params."""
 
     def isValidInformationType(
             information_type, owner, branch=None, git_ref=None):
diff --git a/lib/lp/snappy/model/snap.py b/lib/lp/snappy/model/snap.py
index 8ed9215..2c298fb 100644
--- a/lib/lp/snappy/model/snap.py
+++ b/lib/lp/snappy/model/snap.py
@@ -29,6 +29,7 @@ from storm.expr import (
     Not,
     Or,
     Select,
+    SQL,
     )
 from storm.locals import (
     Bool,
@@ -58,11 +59,14 @@ from lp.app.browser.tales import (
     DateTimeFormatterAPI,
     )
 from lp.app.enums import (
+    FREE_INFORMATION_TYPES,
     InformationType,
     PRIVATE_INFORMATION_TYPES,
+    PUBLIC_INFORMATION_TYPES,
     )
 from lp.app.errors import IncompatibleArguments
 from lp.app.interfaces.security import IAuthorization
+from lp.app.interfaces.services import IService
 from lp.buildmaster.enums import BuildStatus
 from lp.buildmaster.interfaces.buildqueue import IBuildQueueSet
 from lp.buildmaster.model.builder import Builder
@@ -95,6 +99,10 @@ from lp.code.interfaces.gitrepository import (
     )
 from lp.code.model.branch import Branch
 from lp.code.model.branchcollection import GenericBranchCollection
+from lp.code.model.branchnamespace import (
+    BRANCH_POLICY_ALLOWED_TYPES,
+    BRANCH_POLICY_REQUIRED_GRANTS,
+    )
 from lp.code.model.gitcollection import GenericGitCollection
 from lp.code.model.gitrepository import GitRepository
 from lp.registry.errors import PrivatePersonLinkageError
@@ -202,6 +210,17 @@ def snap_modified(snap, event):
     removeSecurityProxy(snap).date_last_modified = UTC_NOW
 
 
+def user_has_special_snap_access(user):
+    """Admins have special access.
+
+    :param user: An `IPerson` or None.
+    """
+    if user is None:
+        return False
+    roles = IPersonRoles(user)
+    return roles.in_admin
+
+
 @implementer(ISnapBuildRequest)
 class SnapBuildRequest:
     """See `ISnapBuildRequest`.
@@ -351,13 +370,7 @@ class Snap(Storm, WebhookTargetMixin):
 
     require_virtualized = Bool(name='require_virtualized')
 
-    def _validate_private(self, attr, value):
-        if not getUtility(ISnapSet).isValidPrivacy(
-                value, self.owner, self.branch, self.git_ref):
-            raise SnapPrivacyMismatch
-        return value
-
-    private = Bool(name='private', validator=_validate_private)
+    _private = Bool(name='private')
 
     def _valid_information_type(self, attr, value):
         if not getUtility(ISnapSet).isValidInformationType(
@@ -389,20 +402,18 @@ class Snap(Storm, WebhookTargetMixin):
                  description=None, branch=None, git_ref=None, auto_build=False,
                  auto_build_archive=None, auto_build_pocket=None,
                  auto_build_channels=None, require_virtualized=True,
-                 date_created=DEFAULT, private=False, allow_internet=True,
-                 build_source_tarball=False, store_upload=False,
-                 store_series=None, store_name=None, store_secrets=None,
-                 store_channels=None, project=None):
+                 date_created=DEFAULT, information_type=InformationType.PUBLIC,
+                 allow_internet=True, build_source_tarball=False,
+                 store_upload=False, store_series=None, store_name=None,
+                 store_secrets=None, store_channels=None, project=None):
         """Construct a `Snap`."""
         super(Snap, self).__init__()
 
-        # Set the private flag first so that other validators can perform
+        # Set the information type first so that other validators can perform
         # suitable privacy checks, but pillar should also be set, since it's
         # mandatory for private snaps.
         self.project = project
-        self.private = private
-        self.information_type = (InformationType.PROPRIETARY if private else
-                                 InformationType.PUBLIC)
+        self.information_type = information_type
 
         self.registrant = registrant
         self.owner = owner
@@ -432,7 +443,7 @@ class Snap(Storm, WebhookTargetMixin):
     @property
     def information_type(self):
         if self._information_type is None:
-            return (InformationType.PROPRIETARY if self.private
+            return (InformationType.PROPRIETARY if self._private
                     else InformationType.PUBLIC)
         return self._information_type
 
@@ -441,6 +452,10 @@ class Snap(Storm, WebhookTargetMixin):
         self._information_type = information_type
 
     @property
+    def private(self):
+        return self.information_type not in PUBLIC_INFORMATION_TYPES
+
+    @property
     def valid_webhook_event_types(self):
         return ["snap:build:0.1"]
 
@@ -618,6 +633,24 @@ class Snap(Storm, WebhookTargetMixin):
     def store_channels(self, value):
         self._store_channels = value or None
 
+    def getAllowedInformationTypes(self, user):
+        """See `ISnap`."""
+        if user_has_special_snap_access(user):
+            # Admins can set any type.
+            return set(PUBLIC_INFORMATION_TYPES + PRIVATE_INFORMATION_TYPES)
+        if self.pillar is None:
+            return set(FREE_INFORMATION_TYPES)
+        required_grant = BRANCH_POLICY_REQUIRED_GRANTS[
+            self.project.branch_sharing_policy]
+        if (required_grant is not None
+                and not getUtility(IService, 'sharing').checkPillarAccess(
+                    [self.project], required_grant, self.owner)
+                and (user is None
+                     or not getUtility(IService, 'sharing').checkPillarAccess(
+                            [self.project], required_grant, user))):
+            return []
+        return BRANCH_POLICY_ALLOWED_TYPES[self.project.branch_sharing_policy]
+
     @staticmethod
     def extractSSOCaveats(macaroon):
         locations = [
@@ -1143,10 +1176,11 @@ class SnapSet:
             git_path=None, git_ref=None, auto_build=False,
             auto_build_archive=None, auto_build_pocket=None,
             auto_build_channels=None, require_virtualized=True,
-            processors=None, date_created=DEFAULT, private=False,
-            allow_internet=True, build_source_tarball=False,
-            store_upload=False, store_series=None, store_name=None,
-            store_secrets=None, store_channels=None, project=None):
+            processors=None, date_created=DEFAULT,
+            information_type=InformationType.PUBLIC, allow_internet=True,
+            build_source_tarball=False, store_upload=False,
+            store_series=None, store_name=None, store_secrets=None,
+            store_channels=None, project=None):
         """See `ISnapSet`."""
         if not registrant.inTeam(owner):
             if owner.is_team:
@@ -1183,7 +1217,8 @@ class SnapSet:
         # IntegrityError due to exceptions being raised during object
         # creation and to ensure that everything relevant is in the Storm
         # cache.
-        if not self.isValidPrivacy(private, owner, branch, git_ref):
+        if not self.isValidInformationType(
+                information_type, owner, branch, git_ref):
             raise SnapPrivacyMismatch
 
         store = IMasterStore(Snap)
@@ -1194,7 +1229,7 @@ class SnapSet:
             auto_build_pocket=auto_build_pocket,
             auto_build_channels=auto_build_channels,
             require_virtualized=require_virtualized, date_created=date_created,
-            private=private, allow_internet=allow_internet,
+            information_type=information_type, allow_internet=allow_internet,
             build_source_tarball=build_source_tarball,
             store_upload=store_upload, store_series=store_series,
             store_name=store_name, store_secrets=store_secrets,
@@ -1208,9 +1243,24 @@ class SnapSet:
 
         return snap
 
-    def isValidPrivacy(self, private, owner, branch=None, git_ref=None):
+    def getSnapSuggestedPrivacy(self, owner, branch=None, git_ref=None):
         """See `ISnapSet`."""
-        # Private snaps may contain anything ...
+        # Public snaps with private sources are not allowed.
+        source = branch or git_ref
+        if source is not None and source.private:
+            return source.information_type
+
+        # Public snaps owned by private teams are not allowed.
+        if owner is not None and owner.private:
+            return InformationType.PROPRIETARY
+
+        # XXX pappacena 2021-03-02: We need to consider the pillar's branch
+        # sharing policy here instead of suggesting PUBLIC.
+        return InformationType.PUBLIC
+
+    def isValidInformationType(self, information_type, owner, branch=None,
+                               git_ref=None):
+        private = information_type not in PUBLIC_INFORMATION_TYPES
         if private:
             # If appropriately enabled via feature flag.
             if not getFeatureFlag(SNAP_PRIVATE_FEATURE_FLAG):
@@ -1228,11 +1278,6 @@ class SnapSet:
 
         return True
 
-    def isValidInformationType(self, information_type, owner, branch=None,
-                               git_ref=None):
-        private = information_type in PRIVATE_INFORMATION_TYPES
-        return self.isValidPrivacy(private, owner, branch, git_ref)
-
     def _getByName(self, owner, name):
         return IStore(Snap).find(
             Snap, Snap.owner == owner, Snap.name == name).one()
@@ -1333,15 +1378,22 @@ class SnapSet:
         # XXX cjwatson 2016-11-25: This is in principle a poor query, but we
         # don't yet have the access grant infrastructure to do better, and
         # in any case the numbers involved should be very small.
+        # XXX pappacena 2021-02-12: Once we do the migration to back fill
+        # information_type, we should be able to change this.
+        private_snap = SQL(
+            "CASE information_type"
+            "    WHEN NULL THEN private"
+            "    ELSE information_type NOT IN ?"
+            "END", params=[tuple(i.value for i in PUBLIC_INFORMATION_TYPES)])
         if visible_by_user is None:
-            return Snap.private == False
+            return private_snap == False
         else:
             roles = IPersonRoles(visible_by_user)
             if roles.in_admin or roles.in_commercial_admin:
                 return True
             else:
                 return Or(
-                    Snap.private == False,
+                    private_snap == False,
                     Snap.owner_id.is_in(Select(
                         TeamParticipation.teamID,
                         TeamParticipation.person == visible_by_user)))
diff --git a/lib/lp/snappy/tests/test_snap.py b/lib/lp/snappy/tests/test_snap.py
index cdf8813..755851a 100644
--- a/lib/lp/snappy/tests/test_snap.py
+++ b/lib/lp/snappy/tests/test_snap.py
@@ -166,7 +166,8 @@ class TestSnapFeatureFlag(TestCaseWithFactory):
         self.assertRaises(
             SnapPrivateFeatureDisabled, getUtility(ISnapSet).new,
             person, person, None, None,
-            branch=self.factory.makeAnyBranch(), private=True)
+            branch=self.factory.makeAnyBranch(),
+            information_type=InformationType.PROPRIETARY)
 
 
 class TestSnap(TestCaseWithFactory):
@@ -1419,13 +1420,15 @@ class TestSnapSet(TestCaseWithFactory):
 
     def test_private_snap_information_type_compatibility(self):
         login_admin()
+        private = InformationType.PROPRIETARY
+        public = InformationType.PUBLIC
         private_snap = getUtility(ISnapSet).new(
-            private=True, **self.makeSnapComponents())
+            information_type=private, **self.makeSnapComponents())
         self.assertEqual(
             InformationType.PROPRIETARY, private_snap.information_type)
 
         public_snap = getUtility(ISnapSet).new(
-            private=False, **self.makeSnapComponents())
+            information_type=public, **self.makeSnapComponents())
         self.assertEqual(
             InformationType.PUBLIC, public_snap.information_type)
 
@@ -1433,7 +1436,7 @@ class TestSnapSet(TestCaseWithFactory):
         # Creating private snaps for public sources is allowed.
         [ref] = self.factory.makeGitRefs()
         components = self.makeSnapComponents(git_ref=ref)
-        components['private'] = True
+        components['information_type'] = InformationType.PROPRIETARY
         components['project'] = self.factory.makeProduct()
         snap = getUtility(ISnapSet).new(**components)
         with person_logged_in(components['owner']):
@@ -2519,9 +2522,11 @@ class TestSnapWebservice(TestCaseWithFactory):
         if auto_build_pocket is not None:
             kwargs["auto_build_pocket"] = auto_build_pocket.title
         logout()
+        information_type = (InformationType.PROPRIETARY if private else
+                            InformationType.PUBLIC)
         response = webservice.named_post(
             "/+snaps", "new", owner=owner_url, distro_series=distroseries_url,
-            name="mir", private=private, **kwargs)
+            name="mir", information_type=information_type.title, **kwargs)
         self.assertEqual(201, response.status)
         return webservice.get(response.getHeader("Location")).jsonBody()
 
@@ -2666,7 +2671,8 @@ class TestSnapWebservice(TestCaseWithFactory):
             admin, permission=OAuthPermission.WRITE_PRIVATE)
         admin_webservice.default_api_version = "devel"
         response = admin_webservice.patch(
-            snap_url, "application/json", json.dumps({"private": False}))
+            snap_url, "application/json",
+            json.dumps({"information_type": 'Public'}))
         self.assertEqual(400, response.status)
         self.assertEqual(
             b"Snap recipe contains private information and cannot be public.",
diff --git a/lib/lp/testing/factory.py b/lib/lp/testing/factory.py
index 9712bea..bc89da6 100644
--- a/lib/lp/testing/factory.py
+++ b/lib/lp/testing/factory.py
@@ -4748,10 +4748,10 @@ class BareLaunchpadObjectFactory(ObjectFactory):
                  auto_build_archive=None, auto_build_pocket=None,
                  auto_build_channels=None, is_stale=None,
                  require_virtualized=True, processors=None,
-                 date_created=DEFAULT, private=False, allow_internet=True,
-                 build_source_tarball=False, store_upload=False,
-                 store_series=None, store_name=None, store_secrets=None,
-                 store_channels=None, project=_DEFAULT):
+                 date_created=DEFAULT, private=False, information_type=None,
+                 allow_internet=True, build_source_tarball=False,
+                 store_upload=False, store_series=None, store_name=None,
+                 store_secrets=None, store_channels=None, project=_DEFAULT):
         """Make a new Snap."""
         if registrant is None:
             registrant = self.makePerson()
@@ -4775,13 +4775,18 @@ class BareLaunchpadObjectFactory(ObjectFactory):
             project = self.makeProduct()
         if project is _DEFAULT:
             project = None
+        assert information_type is None or private is None
+        if private is not None:
+            information_type = (InformationType.PUBLIC if not private
+                                else InformationType.PROPRIETARY)
         snap = getUtility(ISnapSet).new(
             registrant, owner, distroseries, name,
             require_virtualized=require_virtualized, processors=processors,
             date_created=date_created, branch=branch, git_ref=git_ref,
             auto_build=auto_build, auto_build_archive=auto_build_archive,
             auto_build_pocket=auto_build_pocket,
-            auto_build_channels=auto_build_channels, private=private,
+            auto_build_channels=auto_build_channels,
+            information_type=information_type,
             allow_internet=allow_internet,
             build_source_tarball=build_source_tarball,
             store_upload=store_upload, store_series=store_series,