cleanup dead code from launchpad days

We had a bunch of utility code sitting around from the days
of Launchpad groups. This removes a bunch of dead code that
wasn't referenced anywhere

Change-Id: Ib903cea86741dbe5e465e1b1425890dd4f23cef5

2 files changed, 0 insertions, 393 deletions

diff --git a/apps/patchmetrics/tests/utils.py b/apps/patchmetrics/tests/utils.py
deleted file mode 100644
index 4579732..0000000
--- a/apps/patchmetrics/tests/utils.py
+++ /dev/null
@@ -1,200 +0,0 @@
-import operator
-
-from django.test import TestCase
-
-from patchwork.models import Person
-from patchmetrics.utils import (
-    is_member,
-    sync_memberships,
-    get_sub_teams,
-    sync_launchpad_memberships_for,
-    )
-from patchmetrics.tests.factory import PatchMetricsObjectFactory
-
-
-class FakeTeam(object):
-    def __init__(self, name=None, subteams=[]):
-        self.name = name
-        self.sub_teams = []
-        for name in subteams:
-            team = FakeTeam(name=name)
-            self.sub_teams.append(team)
-
-
-class FakePerson(object):
-
-    def __init__(self, teams, email="a@b.com"):
-        self.super_teams = []
-        self.email = email
-        for name in teams:
-            team = FakeTeam(name=name)
-            self.super_teams.append(team)
-
-
-class TestSyncMembership(TestCase):
-
-    def setUp(self):
-        super(TestSyncMembership, self).setUp()
-        self.factory = PatchMetricsObjectFactory()
-
-    def test_get_sub_teams(self):
-        expected = sorted(['infra', 'kernel', 'android'])
-        linaro = FakeTeam(subteams=expected)
-        subteams = get_sub_teams(linaro)
-        self.assertEqual(expected, sorted(subteams.keys()))
-        self.assertEqual(
-            expected, sorted([team.name for team in subteams.values()]))
-
-    def test_get_sub_teams_skips_some_teams(self):
-        expected = sorted(['infra', 'kernel', 'android'])
-        teams_to_skip = [
-            'linaro-project-management',
-            'linaro-oceo',
-            'linaro-oevp',]
-        input = expected + teams_to_skip
-        linaro = FakeTeam(subteams=input)
-        subteams = get_sub_teams(linaro)
-        self.assertEqual(expected, sorted(subteams.keys()))
-        self.assertEqual(
-            expected, sorted([team.name for team in subteams.values()]))
-
-    def test_is_member(self):
-        person = FakePerson(['linaro', 'infra', 'android'])
-        self.assertTrue(
-            is_member(person, dict(multimedia=1, linaro=0)))
-        self.assertFalse(
-            is_member(person, ['multimedia', 'kernel']))
-
-    def test_sync_launchpad_memberships_for(self):
-        from patchmetrics import utils
-        linaro = FakeTeam("linaro", ["subteam"])
-        subteam = FakeTeam("subteam")
-        emails = sorted(['foo@example.com', 'baz@example.com'])
-
-        def get_lp_person_by_email(lp, email):
-            return FakePerson(['subteam'], email)
-
-        original_get_lp_person_by_email = utils.get_lp_person_by_email
-        utils.get_lp_person_by_email = get_lp_person_by_email
-
-        def sync_memberships(memberships):
-            """fake sync_memberships used to test membeships.
-
-            We don't check that FakeTeam and FakePerson objects match
-            because they are often created in a way that is difficult
-            to test, so we test some unique characteristics instead.
-            """
-
-            # We have only created 1 subteam
-            self.assertEqual(len(memberships.keys()), 1)
-
-            # The subteam should have the correct name
-            team = memberships.keys()[0]
-            self.assertEqual(team.name, subteam.name)
-
-            # Now collect all email addresses stored in memberships
-            found_emails = []
-            for member in memberships[team].keys():
-                found_emails += memberships[team][member]
-
-            self.assertEqual(sorted(found_emails), emails)
-
-        original_sync_memberships = utils.sync_memberships
-        utils.sync_memberships = sync_memberships
-
-        def sync_openid_urls():
-            pass
-
-        original_sync_openid_urls = utils.sync_openid_urls
-        utils.sync_openid_urls = sync_openid_urls
-
-        try:
-            sync_launchpad_memberships_for(emails, linaro, None)
-
-        finally:
-            utils.get_lp_person_by_email = original_get_lp_person_by_email
-            utils.sync_memberships = original_sync_memberships
-            utils.sync_openid_urls = original_sync_openid_urls
-
-    def test_sync_new_team(self):
-        person = self.factory.makePerson()
-        emails = sorted([person.email, 'new@example.com'])
-        memberships = {
-            # This will cause the creation of a new team, a new user (as
-            # a member of the team) and a new person for the unseen email
-            # address. The new user will also be linked to the existing
-            # person.
-            FakeTeamOrMember(name='non-existing-team'): {
-                FakeTeamOrMember(person.name, person.name): emails}}
-
-        created_memberships = sync_memberships(memberships)
-        self.assertEqual(1, len(created_memberships))
-        [membership] = created_memberships
-        self.assertEqual('non-existing-team', membership.team.name)
-        self.assertEqual(person.user, membership.member)
-
-        people = Person.objects.filter(user=membership.member)
-        self.assertEqual(emails, sorted([person.email for person in people]))
-
-    def test_sync_just_add_members(self):
-        team = self.factory.makeTeam()
-        emails = sorted(['name1@example.com', 'random@example.com'])
-        memberships = {
-            # This will cause two persons (one for each email address) to
-            # be created as well as a user (linking them together), which is
-            # added as a member of the team created above.
-            FakeTeamOrMember(name=team.name): {
-                FakeTeamOrMember('random-name1'): emails}}
-
-        created_memberships = sync_memberships(memberships)
-        self.assertEqual(1, len(created_memberships))
-        [membership] = created_memberships
-        self.assertEqual(team.name, membership.team.name)
-        self.assertEqual('name1@example.com', membership.member.email)
-
-        people = Person.objects.filter(user=membership.member)
-        self.assertEqual(emails, sorted([person.email for person in people]))
-
-    def test_sync_nothing_to_create(self):
-        membership = self.factory.makeTeamMembership()
-        member = membership.member
-        memberships = {
-            # This won't cause anything to be created as the membership
-            # already exists in our DB.
-            membership.team: {
-                FakeTeamOrMember(member.username): [member.email]}}
-
-        created_memberships = sync_memberships(memberships)
-
-        self.assertEqual([], list(created_memberships))
-
-    def test_sync_name_fixme(self):
-        person = self.factory.makePerson(is_user=False)
-        team = self.factory.makeTeam()
-
-        emails = [self.factory.getUniqueEmailAddress()]
-        memberships = {
-            # This will cause the creation of a Person for the unseen email
-            # address in 'emails', a user account linked to this new person
-            # entry and to the existing one (which has the same name as the
-            # new), as well as a team membership for the new user on the team
-            # created above.
-            team: {FakeTeamOrMember(person.name, person.name): emails}}
-
-        created_memberships = sync_memberships(memberships)
-        self.assertEqual(1, len(created_memberships))
-        [membership] = created_memberships
-        self.assertEqual(team.name, membership.team.name)
-        self.assertEqual(emails[0], membership.member.email)
-
-        people = Person.objects.filter(user=membership.member)
-        all_emails = sorted(emails + [person.email])
-        self.assertEqual(
-            all_emails, sorted([person.email for person in people]))
-
-
-class FakeTeamOrMember(object):
-
-    def __init__(self, name, display_name='Random name'):
-        self.name = name
-        self.display_name = display_name
diff --git a/apps/patchmetrics/utils.py b/apps/patchmetrics/utils.py
index 2713424..c900c41 100644
--- a/apps/patchmetrics/utils.py
+++ b/apps/patchmetrics/utils.py
@@ -1,6 +1,4 @@
 import logging
-import time
-import urllib2
 import re
 
 from patchmetrics.crowd import (
@@ -9,20 +7,12 @@ from patchmetrics.crowd import (
 )
 from django.contrib.auth.models import User
 from django.db.models import Q
-from django_openid_auth.models import UserOpenID
-from lazr.restfulclient.errors import HTTPError
 from patchmetrics.models import Team
 from patchwork.models import Person
-from xml.dom.minidom import parseString
 
 logging.basicConfig()
 logger = logging.getLogger()
 
-# Time in seconds to wait before performing another HTTP request.
-REQUEST_WAIT = 30
-# Max retries if something goes wrong, but it can be recoverd just retrying.
-MAX_RETRIES = 3
-
 
 def create_team_display_name(team):
     """Very simple and hackish way to create a display name for a team.
@@ -90,107 +80,6 @@ def sync_crowd_memberships(memberships):
     return created_memberships
 
 
-def sync_memberships(memberships):
-    """Make sure the given memberships are represented in our database.
-
-    :param memberships: A dict mapping teams to its members. Each member is in
-        turn represented by a dict mapping its name to all its email
-        addresses. e.g.:
-
-        {Team: {Person: ['member1@example.com', ...], 'member2': [...]}}
-    """
-    created_memberships = []
-    for team, members in memberships.items():
-        try:
-            db_team = Team.objects.get(name=team.name)
-        except Team.DoesNotExist:
-            logger.info(
-                'Creating new team: %s (%s)' % (team.name, team.display_name))
-            db_team = Team(name=team.name, display_name=team.display_name)
-            db_team.save()
-
-        for member, emails in members.items():
-            display_name = member.display_name
-            people = []
-            # Make sure there's one Person entry for every email address.
-            for email in emails:
-                try:
-                    person = Person.objects.get(email=email)
-                except Person.DoesNotExist:
-                    logger.info(
-                        'Creating new person: %s (%s)' % (member.name, email))
-                    person = Person(name=display_name, email=email)
-                    person.save()
-                people.append(person)
-
-            # Get all Person entries that might represent other email
-            # addresses of this same user.
-            people.extend(Person.objects.filter(name=display_name))
-
-            user = get_user(member.name, emails)
-            if user is None:
-                user = User.objects.create_user(
-                    member.name, emails[0], password=None)
-
-            # Now link all the Person entries to the user account.
-            for person in people:
-                person.user = user
-                person.save()
-
-            # And finally, make sure the user is a member of the team.
-            if user not in db_team.members:
-                logger.info('Adding %s as a member of %s)'
-                            % (member.name, db_team.name))
-                membership = db_team.add_member(user)
-                membership.save()
-                created_memberships.append(membership)
-
-    return created_memberships
-
-
-def get_sub_teams(parent_team):
-    """Get all subteams of the given team from Launchpad.
-
-    This function is not recursive, so teams that are more than one level of
-    indirection down will not be picked up. Obviously this can be fixed if
-    it is a problem.
-    """
-
-    teams_to_skip = [
-        'linaro-project-management',
-        'linaro-oceo',
-        'linaro-oevp']
-
-    teams = {}
-    for team in parent_team.sub_teams:
-        if team.name in teams_to_skip:
-            continue
-
-        teams[team.name] = team
-
-    return teams
-
-
-def get_lp_person_by_email(lp, email):
-    return lp.people.getByEmail(email=email)
-
-
-def is_member(person, teams):
-    """Return the teams the given person is a member of."""
-
-    # XXX: The .super_teams property was made for teams, so there's no
-    # guarantee it wil always work for Persons as well.  Need to figure out
-    # whether this is the appropriate way to get all teams a person is a
-    # member of.
-    member_of = []
-    for team in person.super_teams:
-        team_name = team.name
-        if team_name in teams:
-            member_of.append(teams[team_name])
-
-    return member_of
-
-
 def get_user(name, emails):
     """Return the user linked to the person with one of the given emails.
 
@@ -260,85 +149,3 @@ def sync_user_memberships(email_addresses, crowd, whitelisted_groups=[]):
                     memberships[team].append(user)
 
     sync_crowd_memberships(memberships)
-
-
-def sync_launchpad_memberships_for(input_email_addresses, team, lp):
-    """If an input email matches a LP user, add them to the database.
-
-    If an email address matches a user in Launchpad, takes the LP Person
-    object and passes it, along with the matching email address and passes it
-    to sync_memberships, where Persons are matched up with User objects (many
-    Persons can map to a single User). sync_openid_urls then adds OpenID URLs
-    to each User object.
-    """
-    teams = get_sub_teams(team)
-
-    memberships = {}
-    for email in input_email_addresses:
-        email = email.lower()
-
-        try:
-            person = get_lp_person_by_email(lp, email)
-        except HTTPError:
-            # FIXME We should not encounter bad email addresses.
-            # https://bugs.launchpad.net/linaro-patchmetrics/+bug/967290
-            person = None  # Launchpad lookup failed.
-            logger.warning("Launchpad rejected email lookup and returned "
-                           "HTTPError. Offending email address: %s" % email)
-
-        if not person:
-            # No Launchpad entry for this person.
-            continue
-
-        # Counter for the retries to perform in case of an HTTP error 503.
-        retries_count = 0
-        while True:
-            try:
-                member_of = is_member(person, teams)
-                for team in member_of:
-                    if not team in memberships:
-                        memberships[team] = {}
-
-                    memberships[team][person] = [email]
-            except HTTPError, ex:
-                # We should not get an error 503 from Launchpad.
-                # https://bugs.launchpad.net/linaro-patchmetrics/+bug/1012538
-                if ex.status == 503 and retries_count < MAX_RETRIES:
-                    retries_count += 1
-                    time.sleep(REQUEST_WAIT)
-                    continue
-                else:
-                    raise(ex)
-            break
-
-    sync_memberships(memberships)
-    sync_openid_urls()
-
-
-def sync_openid_urls():
-    """Insert OpenID URLs for users missing them
-
-    When sync_memberships creates a User it doesn't do this, so this function
-    just patches up the database with that extra information.
-    """
-    # TODO
-    # Crowd openid urls are like this:
-    # https://login.linaro.org:8443/openidserver/users/email@linaro.org
-    for user in User.objects.all():
-        if UserOpenID.objects.filter(user=user).count() == 0:
-            try:
-                xrds = urllib2.urlopen(
-                    'https://launchpad.net/~%s/+xrds' % user.username).read()
-            except urllib2.HTTPError, e:
-                if e.getcode() == 404:
-                    # User doesn't exist in LP, so not much for us to do.
-                    continue
-                raise
-            dom = parseString(xrds)
-            identity = dom.getElementsByTagName(
-                'LocalID')[0].childNodes[0].data
-            if UserOpenID.objects.filter(claimed_id=identity).count() == 0:
-                print 'Setting openid identity for %s' % user.username
-                openid_identity = UserOpenID(
-                    user=user, claimed_id=identity, display_id=identity)
-                openid_identity.save()