Merge lp:~jml/pkgme-devportal/restore-download-file into lp:pkgme-devportal

[Jonathan Lange]

Add download_file back to devportalbinary.database

download_file was being imported by pkgme-service from devportalbinary.database.

Another branch is in progress, removing this particular dependency. In the mean
time, this branch should land, restoring the behaviour so we can bump pkgme-service
to use latest devportal without probs.

[Jonathan Lange (jml)]

Rubberstamp! Proposer approves of own proposal.

review: Approve

=== modified file 'NEWS'
--- NEWS	2012-11-13 11:25:44 +0000
+++ NEWS	2012-11-13 14:53:23 +0000
@@ -12,6 +12,9 @@
     maintain a database of library dependencies based on published packages
     from Launchpad has been removed.  (Jonathan Lange)
 
+  * ``aptfile`` backend has been removed.  (Jonathan Lange)
+
+
 0.4.11 (2012-10-29)
 ===================
 
 
=== removed file 'devportalbinary/aptfile.py'
--- devportalbinary/aptfile.py	2012-11-13 11:25:44 +0000
+++ devportalbinary/aptfile.py	1970-01-01 00:00:00 +0000
@@ -1,226 +0,0 @@
-# Copyright 2012 Canonical Ltd.  This software is licensed under the
-# GNU Affero General Public License version 3 (see the file LICENSE).
-
-# XXX: Remove this.  No longer used.
-
-__all__ = [
-    'AptFilePackageDatabase',
-    ]
-
-import gzip
-import urllib
-import argparse
-import os
-import re
-
-
-def make_arg_parser():
-    p = argparse.ArgumentParser()
-    p.add_argument('--cache-dir', type=str, default='cache')
-    p.add_argument('output_file', type=argparse.FileType('w'))
-    return p
-
-
-so_filename_re = re.compile(r'\.so(\.[0-9]+)*$')
-def export_database(db, stream):
-    for library, package, arch in db.iter_database():
-        if so_filename_re.search(library):
-            stream.write(','.join([package, library, package, arch]))
-            stream.write('\n')
-            stream.flush()
-
-
-def dump_apt_file_db():
-    parser = make_arg_parser()
-    args = parser.parse_args()
-    if not os.path.isdir(args.cache_dir):
-        os.path.makedirs(args.cache_dir)
-    db = AptFilePackageDatabase(args.cache_dir)
-    export_database(db, args.output_file)
-    return 0
-
-
-def iter_contents_file(contents):
-    """ Yield (full-library-path, set-of-pkgnames) from a Contents file.
-
-    It expects a line starting with "FILE" that tells it when the header ends
-    and the actual content starts.
-    """
-    found_start_marker = False
-    for line in contents:
-        if not found_start_marker:
-            if line.startswith("FILE"):
-                found_start_marker = True
-            continue
-        (path, sep, pkgs) = [s.strip() for s in line.rpartition(" ")]
-        # pkgs is formated a bit funny, e.g. universe/pkgname
-        pkgs = set([os.path.basename(pkg) for pkg in pkgs.split(",")])
-        yield (path, pkgs)
-
-
-class AptFilePackageDatabase(object):
-    """Really dumb database that just uses apt-file for local testing """
-
-    # we could also read /etc/ld.so.conf.d/*.conf but this maybe different on
-    # different distroseries especially if
-    #    server-distroseries != target-distroseries
-    #  (I wish there was ldconfig --print-search-dirs)
-    LD_SEARCH_PATH = [
-        # standards
-        "lib",
-        "usr/lib",
-        "usr/local/lib",
-        # old biarch
-        "lib32",
-        "usr/lib32",
-        # new multiarch
-        "lib/i686-linux-gnu",
-        "lib/i386-linux-gnu",
-        "lib/x86_64-linux-gnu",
-        "usr/lib/i386-linux-gnu",
-        "usr/lib/i686-linux-gnu",
-        "usr/lib/x86_64-linux-gnu",
-        # ?
-        "usr/lib/x86_64-linux-gnu/fakechroot",
-        "usr/lib/x86_64-linux-gnu/mesa",
-        "usr/lib/x86_64-linux-gnu/mesa-egl",
-        "usr/lib/i386-linux-gnu/mesa",
-        ]
-
-    DISTROSERIES = "oneiric"
-
-    # If db_type is set to this in the config, that means use this database.
-    DB_TYPE =  'aptfile'
-
-    CONTENTS_FILE_URL_LOCATION = (
-        "http://archive.ubuntu.com/ubuntu/dists/%(distroseries)s/"
-        "Contents-%(arch)s.gz")
-
-    CONTENTS_FILE = "Contents-%(distroseries)s-%(arch)s"
-
-    def __init__(self, cachedir):
-        self.cachedir = os.path.expanduser(cachedir)
-        self._distroseries_arch_cache = {}
-
-    @classmethod
-    def from_options(cls, options):
-        return cls(options.database_aptfile_cachedir)
-
-    def _get_lib_to_pkgs_mapping(self, distroseries, arch):
-        """Returns a dict of { library-name : set([pkg1,pkg2])
-
-        This function will return a dict to lookup library-name to package
-        dependencies for the given distroseries and architecture
-        """
-        if not (distroseries, arch) in self._distroseries_arch_cache:
-            self._distroseries_arch_cache[(distroseries, arch)] = \
-                      self._get_mapping_from_contents_file(distroseries, arch)
-        return self._distroseries_arch_cache[(distroseries, arch)]
-
-    def _get_contents_file_cache_path(self, distroseries, arch):
-        """Return the path in the cache for the given distroseries, arch """
-        return os.path.join(
-            self.cachedir, self.CONTENTS_FILE % {
-                'distroseries': distroseries, 'arch': arch})
-
-    def _get_contents_file_server_url(self, distroseries, arch):
-        """Return the remote server URL for the given distroseries, arch """
-        return self.CONTENTS_FILE_URL_LOCATION % {
-            'distroseries': distroseries, 'arch': arch}
-
-    def _get_mapping_from_contents_file(self, distroseries, arch):
-        """Return lib,pkgs mapping from contents file for distroseries, arch
-
-        This expects the contents file to be in the cachedir already.
-        """
-        lib_to_pkgs = {}
-        path = self._get_contents_file_cache_path(distroseries, arch)
-        with open(path) as f:
-            for path, pkgs in self._iter_contents_file(f):
-                basename = os.path.basename(path)
-                if not basename in lib_to_pkgs:
-                    lib_to_pkgs[basename] = set()
-                lib_to_pkgs[basename] |= pkgs
-        return lib_to_pkgs
-
-    def _download_contents_file_compressed(self, distroseries, arch):
-        """Downloads the content file for distroseries, arch into target """
-        # XXX: we may eventually want to merge the Contents files from
-        #      the -updates repository too in addition to the main archive
-        url = self._get_contents_file_server_url(distroseries, arch)
-        target = self._get_contents_file_cache_path(distroseries, arch)
-        compressed_target = target + os.path.splitext(url)[1]
-        # download
-        urllib.urlretrieve(url, compressed_target)
-        return compressed_target
-
-    def _iter_contents_file(self, in_file):
-        for path, pkgs in iter_contents_file(in_file):
-            if os.path.dirname(path) in self.LD_SEARCH_PATH:
-                yield path, pkgs
-
-    def _prune_contents_gz_file(self, infile, outfile):
-        """Read a compressed Contents.gz and write out a pruned version.
-
-        This will use iter_contents_file to go over infile and write
-        the relevant lines that are in the LD_SEARCH_PATH to outfile.
-        """
-        with open(outfile, "w") as outf, gzip.open(infile) as inf:
-            # first write the header
-            outf.write("FILE  LOCATION\n")
-            # then iter over all relevant lines and write them out
-            for path, pkgs in self._iter_contents_file(inf):
-                outf.write("%s %s\n" % (path, ",".join(pkgs)))
-
-    def _download_and_prepare_contents_file_if_needed(self, distroseries, arch):
-        """Ensure there is a usable Contents file in the cachedir
-
-        This will download, uncompress and prune a Conents file for
-        distroseries, arch so that get_dependencies works.
-        """
-        # mvo: We can (and should eventually) do etag/if-modified-since
-        #      matching here. But its not really important as long as
-        #      we package for stable distroseries as the Contents file
-        #      will not change
-        path = self._get_contents_file_cache_path(distroseries, arch)
-        if not os.path.exists(path):
-            compressed_contents = self._download_contents_file_compressed(
-                distroseries, arch)
-            # and prune from ~300mb to 1mb uncompressed as we are only
-            # interested in the library path parts
-            self._prune_contents_gz_file(compressed_contents, path)
-            os.remove(compressed_contents)
-
-    def iter_database(self, architectures=('i386', 'amd64'),
-                      distroseries=None):
-        """Export the database.
-
-        Yields (library, package, arch) tuples for everything that we can
-        find.
-        """
-        # XXX: Untested
-        if distroseries is None:
-            distroseries = self.DISTROSERIES
-        for arch in architectures:
-            self._download_and_prepare_contents_file_if_needed(
-                distroseries, arch)
-            mapping = self._get_lib_to_pkgs_mapping(distroseries, arch)
-            for library in mapping:
-                for package in mapping[library]:
-                    yield library, package, arch
-
-    def get_multiple_dependencies(self, library_names, arch):
-        """Get the binary packages that provide libraries.
-
-        :return: (deps, missing), where ``deps`` is a dict mapping library
-            names to sets of packages that provide them, and ``missing`` is a
-            set of library names for which no dependencies could be found.
-        """
-        self._download_and_prepare_contents_file_if_needed(
-            self.DISTROSERIES, arch)
-        lib_to_pkgs = self._get_lib_to_pkgs_mapping(self.DISTROSERIES, arch)
-        deps = ((lib, lib_to_pkgs.get(lib)) for lib in library_names)
-        return dict((lib, dep) for (lib, dep) in deps if dep)
-
-    def close(self):
-        pass
 
=== modified file 'devportalbinary/database.py'
--- devportalbinary/database.py	2012-11-13 11:28:53 +0000
+++ devportalbinary/database.py	2012-11-13 14:53:23 +0000
@@ -1,134 +1,13 @@
 # Copyright 2011 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
-from storm.expr import And, Column, Select, Table
-from storm.locals import create_database, Store
-from storm.uri import URI as StormURI
-
-from .aptfile import AptFilePackageDatabase
-from .configuration import (
-    CONF_FILE_ENV_VAR,
-    get_config_file_path,
-    load_configuration,
-    )
+from .configuration import load_configuration
+from .utils import download_file
 
 from libdep_service_client.client import Client
 
-
-class URI(StormURI):
-    """A stand-in for Storm's URI class.
-
-    This class implements the same interface as `storm.uri.URI`, except
-    that the constructor has a different signature. Storm's version takes
-    a string and parses it, this version can be used when you already
-    have a parsed version and just need to create the object.
-    """
-
-    # XXX: Only used by PackageDatabase, which is flagged for deletion.
-
-    def __init__(self, scheme=None, host=None, port=None, username=None,
-                 password=None, database=None, options=None):
-        self.scheme = scheme
-        self.host = host
-        self.port = port
-        self.username = username
-        self.password = password
-        self.database = database
-        self.options = options
-        if self.options is None:
-            self.options = dict()
-
-
-class PackageDatabase(object):
-
-    # XXX: No longer used within pkgme-devportal
-
-    SQLITE = 'sqlite'
-    POSTGRES = 'postgres'
-
-    def __init__(self, store):
-        self._store = store
-
-    @classmethod
-    def _get_storm_sqlite_connection_uri(cls, opts):
-        raise ValueError(
-            "SQLite is no longer supported, you must migrate to postgresql.")
-
-    @classmethod
-    def _get_storm_postgres_connection_uri(cls, opts):
-        if not getattr(opts, 'database_db_name', None):
-            raise ValueError(
-                "Can't create database, no connection info available. "
-                "You must specify %s. Looked in %s. "
-                "Perhaps %s is set incorrectly?" % (
-                    'db_name', get_config_file_path(), CONF_FILE_ENV_VAR))
-        return URI(scheme=opts.database_db_type,
-                   username=opts.database_username,
-                   password=opts.database_password,
-                   host=opts.database_host,
-                   port=opts.database_port,
-                   database=opts.database_db_name)
-
-    @classmethod
-    def _get_storm_connection_uri(cls, opts):
-        if opts.database_db_type == cls.POSTGRES:
-            return cls._get_storm_postgres_connection_uri(opts)
-        elif opts.database_db_type == cls.SQLITE:
-            return cls._get_storm_sqlite_connection_uri(opts)
-        else:
-            raise AssertionError(
-                "Unsupported database: %s" % opts.database_db_type)
-
-    @classmethod
-    def get_db_info_from_config(cls, opts):
-        return cls._get_storm_connection_uri(opts)
-
-    @classmethod
-    def get_store_from_config(cls, opts):
-        """Create a storm store based on a config file.
-
-        This method will create a storm store based
-        on the information in ``~/.config/pkgme-binary/conf``
-
-        :return: a tuple of (store, store_type), where store_type
-            is one of cls.SQLITE or cls.POSTGRES, indicating what
-            is at the other end of the store.
-        """
-        connection_info = cls.get_db_info_from_config(opts)
-        database = create_database(connection_info)
-        return Store(database)
-
-    @classmethod
-    def from_options(cls, options):
-        return cls(cls.get_store_from_config(options))
-
-    def _get_query(self, library_names, arch):
-        return Select(
-            [Column('library'), Column('dependency')],
-            And(Column('architecture') == arch,
-                Column('library').is_in(map(unicode, library_names))),
-            Table('libdep'))
-
-    def get_multiple_dependencies(self, library_names, arch):
-        """Get the binary packages that provide libraries.
-
-        :return: (deps, missing), where ``deps`` is a dict mapping library
-            names to sets of packages that provide them, and ``missing`` is a
-            set of library names for which no dependencies could be found.
-        """
-        arch = unicode(arch)
-        result = self._store.execute(self._get_query(library_names, arch))
-        found = {}
-        for row in result:
-            [lib, dependency] = row
-            if lib in found:
-                found[lib].add(dependency)
-            else:
-                found[lib] = set([dependency])
-        return found
-
-    def close(self):
-        self._store.close()
+# Shut up pyflakes.  Imported because other things use this.
+download_file
 
 
 class LibdepServiceClient(object):
@@ -159,10 +38,5 @@
 
 def get_dependency_database():
     """Return an object that can get dependencies."""
-    # XXX: Remove AptFilePackageDatabase from here and simplify the method.
-    databases = {
-        AptFilePackageDatabase.DB_TYPE: AptFilePackageDatabase.from_options,
-        LibdepServiceClient.DB_TYPE: LibdepServiceClient.from_options,
-        }
     options = load_configuration()
-    return databases[options.database_db_type](options)
+    return LibdepServiceClient.from_options(options)
 
=== modified file 'devportalbinary/testing.py'
--- devportalbinary/testing.py	2012-11-13 11:12:08 +0000
+++ devportalbinary/testing.py	2012-11-13 14:53:23 +0000
@@ -1,7 +1,6 @@
 # Copyright 2011-2012 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
-from contextlib import closing
 import json
 import os
 import random
@@ -21,11 +20,6 @@
     Fixture,
     TempDir,
     )
-from postgresfixture import ClusterFixture
-from storm.locals import create_database, Store
-from testresources import (
-    FixtureResource as _FixtureResource,
-    )
 from testtools import TestCase
 from treeshape import (
     from_rough_spec,
@@ -33,11 +27,7 @@
     )
 
 from devportalbinary.binary import MetadataBackend
-from devportalbinary.database import (
-    LibdepServiceClient,
-    PackageDatabase,
-    URI,
-    )
+from devportalbinary.database import LibdepServiceClient
 
 from devportalbinary.configuration import CONF_FILE_ENV_VAR
 
@@ -90,133 +80,6 @@
                              im.size[0], im.size[1], im.format))
 
 
-def get_db_schema_file_path(name):
-    return os.path.join(os.path.dirname(
-        os.path.abspath(__file__)), 'db', name)
-
-
-def get_db_schema_queries(filenames):
-    for filename in filenames:
-        path = get_db_schema_file_path(filename)
-        with open(path) as f:
-            yield f.read()
-
-
-class PostgresDatabaseFixture(Fixture):
-
-    def __init__(self):
-        super(PostgresDatabaseFixture, self).__init__()
-        self.db_name = "libdep"
-
-    def drop_db(self):
-        # stub suggests that dropping all tables would be quicker than
-        # dropping the db when the number of tables is small.
-        # select quote_ident(table_schema) || '.' ||
-        #   quote_ident(table_name) from information_schema.tables
-        #   WHERE table_schema = 'public';
-        self.cluster.dropdb(self.db_name)
-
-    def create_db(self):
-        self.cluster.createdb(self.db_name)
-        queries = [
-            'postgres_schema.sql',
-            'patch-00001.sql',
-            'patch-00002.sql',
-            ]
-        for patch in get_db_schema_queries(queries):
-            self._execute(patch)
-
-    def _execute(self, query):
-        with closing(self.cluster.connect(self.db_name)) as conn:
-            cur = conn.cursor()
-            cur.execute(query)
-            conn.commit()
-
-    def close_connection(self):
-        self.conn.close()
-
-    def open_connection(self):
-        db = create_database(URI(scheme='postgres',
-            host=self.cluster.datadir, database=self.db_name))
-        self.conn = Store(db)
-        self.addCleanup(self.close_connection)
-
-    def reset(self):
-        self.close_connection()
-        self.drop_db()
-        self.create_db()
-        self.open_connection()
-
-    def setUp(self):
-        super(PostgresDatabaseFixture, self).setUp()
-        self.tempdir = self.useFixture(TempDir())
-        self.cluster = self.useFixture(ClusterFixture(self.tempdir.path))
-        self.create_db()
-        self.open_connection()
-
-
-class FixtureResource(_FixtureResource):
-    """The built in FixtureResource doesn't get properly dirtied."""
-    # XXX: workaround for bug 1023423
-
-    def _get_dirty(self):
-        return True
-
-    def _set_dirty(self, new_val):
-        pass
-
-    _dirty = property(_get_dirty, _set_dirty)
-
-
-class PostgresDatabaseResource(FixtureResource):
-
-    def __init__(self):
-        fixture = PostgresDatabaseFixture()
-        super(PostgresDatabaseResource, self).__init__(fixture)
-
-    def reset(self, resource, result=None):
-        resource.reset()
-        return resource
-
-
-postgres_db_resource = PostgresDatabaseResource()
-
-
-class DatabaseConfig(Fixture):
-
-    def __init__(self, db_fixture):
-        super(DatabaseConfig, self).__init__()
-        self.db_fixture = db_fixture
-
-    def setUp(self):
-        super(DatabaseConfig, self).setUp()
-        self.useFixture(
-            ConfigSettings(
-                ('database', {'db_type': 'postgres',
-                              'host': self.db_fixture.cluster.datadir,
-                              'db_name': self.db_fixture.db_name,
-                              })))
-
-
-class DatabaseFixture(Fixture):
-    """Create a temporary database and make it the default.
-
-    Don't use this twice within a test, otherwise you'll get confused.
-    """
-
-    def setUp(self):
-        super(DatabaseFixture, self).setUp()
-        pg_db = self.useFixture(PostgresDatabaseFixture())
-        self.useFixture(DatabaseConfig(pg_db))
-        self.db = PackageDatabase(pg_db.conn)
-        self.addCleanup(self.db.close)
-
-
-def ConfigFileFixture(location):
-    """Use a different configuration file."""
-    return EnvironmentVariableFixture(CONF_FILE_ENV_VAR, location)
-
-
 class ConfigSettings(Fixture):
     """Use a configuration file with different settings."""
 
@@ -239,7 +102,8 @@
         tempdir = self.useFixture(TempDir())
         config_file_path = os.path.join(tempdir.path, 'test.cfg')
         write_config_file(config_file_path, self._settings)
-        self.useFixture(ConfigFileFixture(config_file_path))
+        self.useFixture(
+            EnvironmentVariableFixture(CONF_FILE_ENV_VAR, config_file_path))
 
 
 class LibdepFixture(Fixture):
 
=== removed file 'devportalbinary/tests/test_aptfile.py'
--- devportalbinary/tests/test_aptfile.py	2012-10-26 12:21:03 +0000
+++ devportalbinary/tests/test_aptfile.py	1970-01-01 00:00:00 +0000
@@ -1,53 +0,0 @@
-import gzip
-import os
-
-from mock import patch
-from fixtures import TempDir
-from testtools import TestCase
-
-from ..aptfile import AptFilePackageDatabase
-
-
-class AptFilePackageDatabaseTestCase(TestCase):
-
-    # point to our local contents file version that is a tad smaller
-    CONTENTS_CACHE = os.path.join(
-        os.path.dirname(__file__), "data", "apt-file-backend")
-
-    def setUp(self):
-        super(AptFilePackageDatabaseTestCase, self).setUp()
-        self.db = AptFilePackageDatabase(self.CONTENTS_CACHE)
-
-    def test_read_fixture_contents_worked(self):
-        """ test that our fixture Contents file works as expected """
-        # our test DB has 4 entries in the default search path
-        self.assertEqual(
-            len(self.db._get_lib_to_pkgs_mapping("oneiric", "i386")), 4)
-
-    def test_get_dependencies(self):
-        """ Test that data from the fixture dependencies file works """
-        self.assertEqual(
-            self.db.get_multiple_dependencies(["libz.so.1"], 'i386'),
-            ({'libz.so.1': 'zlib1g'}, set()))
-
-    @patch("urllib.urlretrieve")
-    def test_lazy_downloading(self, mock_urlretrieve):
-        """ test that lazy downloading works """
-        def _put_fixture_contents_file_in_place(url, target):
-            with gzip.open(target, "w") as f:
-                f.write("""
-Some header text that is ignored
-FILE                 LOCATION
-usr/lib/libfoo.so.2  pkgfoo,pkgbar
-""")
-        tempdir = self.useFixture(TempDir())
-        db = AptFilePackageDatabase(tempdir.path)
-        mock_urlretrieve.side_effect = _put_fixture_contents_file_in_place
-        self.assertEqual(
-            db.get_multiple_dependencies(["libfoo.so.2"], arch="i386"),
-            ({'libfoo.so.2': set(["pkgfoo", "pkgbar"])}, set()))
-        self.assertEqual(len(db._get_lib_to_pkgs_mapping("oneiric", "i386")), 1)
-
-    def test_close(self):
-        # Test that there is a close method we can call
-        self.db.close()
 
=== modified file 'devportalbinary/tests/test_database.py'
--- devportalbinary/tests/test_database.py	2012-11-13 11:22:16 +0000
+++ devportalbinary/tests/test_database.py	2012-11-13 14:53:23 +0000
@@ -1,124 +1,12 @@
-import os
 
-from fixtures import TempDir
-from testresources import ResourcedTestCase
 from testtools import TestCase
-from testtools.matchers import (
-    Equals,
-    Matcher,
-    )
 
-from devportalbinary.database import (
-    AptFilePackageDatabase,
-    get_dependency_database,
-    LibdepServiceClient,
-    load_configuration,
-    PackageDatabase,
-    )
-from devportalbinary.testing import (
-    ConfigFileFixture,
-    ConfigSettings,
-    get_libdep_service_client,
-    postgres_db_resource,
-    )
+from devportalbinary.database import LibdepServiceClient
+from devportalbinary.testing import get_libdep_service_client
 
 from libdep_service_client.client import Client
 
 
-class ResultsIn(Matcher):
-
-    def __init__(self, db, rows):
-        self._db = db
-        self._rows = rows
-
-    def match(self, query):
-        # XXX: Abstraction violation
-        results = self._db._store.execute(query)
-        return Equals(self._rows).match(list(results))
-
-
-class TestDatabase(TestCase, ResourcedTestCase):
-
-    resources = [
-            ('db_fixture', postgres_db_resource),
-            ]
-
-    def get_package_db(self):
-        db = PackageDatabase(self.db_fixture.conn)
-        self.addCleanup(db.close)
-        return db
-
-    def test_unknown_library(self):
-        db = self.get_package_db()
-        deps = db.get_multiple_dependencies(['libfoo.so.0'], 'i386')
-        self.assertEqual(deps, {})
-
-    def test_close(self):
-        # Test that we can close the package db.
-        db = PackageDatabase(self.db_fixture.conn)
-        db.close()
-
-    def test_close_twice(self):
-        # Test that we can close the package db twice with no exception.
-        db = PackageDatabase(self.db_fixture.conn)
-        db.close()
-        db.close()
-
-
-class TestDatabaseConfiguration(TestCase):
-
-    def use_database_config(self, **db_settings):
-        return self.useFixture(ConfigSettings(('database', db_settings)))
-
-    def test_get_db_info_from_config_sqlite(self):
-        other_tempdir = self.useFixture(TempDir())
-        expected_db_path = os.path.join(other_tempdir.path, 'db')
-        self.use_database_config(db_type='sqlite', path=expected_db_path)
-        options = load_configuration()
-        self.assertRaises(ValueError, PackageDatabase.get_db_info_from_config,
-                options)
-
-    def test_default_create_no_config(self):
-        nonexistent = self.getUniqueString()
-        self.useFixture(ConfigFileFixture(nonexistent))
-        self.assertIsInstance(
-            get_dependency_database(), AptFilePackageDatabase)
-
-    def test_default_create_empty_config(self):
-        self.useFixture(ConfigSettings())
-        self.assertIsInstance(
-            get_dependency_database(), AptFilePackageDatabase)
-
-    def test_remote_service(self):
-        base_url = 'http://example.com/libdep-service/'
-        self.use_database_config(db_type='libdep-service', base_url=base_url)
-        db = get_dependency_database()
-        self.assertIsInstance(db, LibdepServiceClient)
-        self.assertEqual(base_url, db._client.base_url)
-
-    def test_get_db_info_from_config_postgres(self):
-        expected_username = self.getUniqueString()
-        expected_password = self.getUniqueString()
-        expected_host = self.getUniqueString()
-        expected_port = self.getUniqueInteger()
-        expected_db_name = self.getUniqueString()
-
-        self.use_database_config(
-            db_type='postgres',
-            username=expected_username,
-            password=expected_password,
-            host=expected_host,
-            port=expected_port,
-            db_name=expected_db_name)
-        options = load_configuration()
-        uri = PackageDatabase.get_db_info_from_config(options)
-        self.assertEqual(expected_db_name, uri.database)
-        self.assertEqual(expected_port, uri.port)
-        self.assertEqual(expected_host, uri.host)
-        self.assertEqual(expected_password, uri.password)
-        self.assertEqual(expected_username, uri.username)
-
-
 class TestLibdepServiceClient(TestCase):
 
     TEST_DATA = [('libfoo', {'i386': {'libfoo': 'libfoo-bin'}})]
 
=== modified file 'setup.py'
--- setup.py	2012-11-13 09:14:39 +0000
+++ setup.py	2012-11-13 14:53:23 +0000
@@ -18,6 +18,8 @@
     )
 from setuptools import setup, find_packages
 
+# XXX: Need to do a trawl to see if we are depending on things that we are no
+# longer using.
 
 __version__ = get_version('devportalbinary/__init__.py')
 
@@ -36,7 +38,6 @@
     install_requires = [
         'bzr',
         'configglue',
-        'launchpadlib',
         'libdep-service-python>=0.0.5',
         'PIL',
         'pkgme>=0.4.1',
@@ -45,7 +46,6 @@
         ],
     entry_points = {
         'console_scripts': [
-            'dump-apt-file-db=devportalbinary.aptfile:dump_apt_file_db',
             'guess-executable=devportalbinary.binary:print_executable',
             'guess-deps=devportalbinary.binary:print_dependencies',
             ],