Merge lp:~james-w/pkgme-devportal/stormify into lp:pkgme-devportal

[James Westby]

Hi,

This branch stormifies the code, in order to support postgres as well
as sqlite.

It's not the prettiest thing ever, and the postgres code is under-tested, but
I didn't want to deal with using a postgres fixture.

The unicode() changes are so that postgres types match up, and should be
fine as package names and library file names are (have to be?) ascii.

Thanks,

James

[Jonathan Lange (jml)]

On Mon, Dec 5, 2011 at 9:02 PM, James Westby <email address hidden> wrote:
> James Westby has proposed merging lp:~james-w/pkgme-binary/stormify into lp:pkgme-binary.
>
> Requested reviews:
>  pkgme binary committers (pkgme-binary-dev)
>
> For more details, see:
> https://code.launchpad.net/~james-w/pkgme-binary/stormify/+merge/84529
>
> Hi,
>
> This branch stormifies the code, in order to support postgres as well
> as sqlite.
>
> It's not the prettiest thing ever, and the postgres code is under-tested, but
> I didn't want to deal with using a postgres fixture.
>
> The unicode() changes are so that postgres types match up, and should be
> fine as package names and library file names are (have to be?) ascii.
>
> Thanks,
>
> James
>
> --
> https://code.launchpad.net/~james-w/pkgme-binary/stormify/+merge/84529
> Your team pkgme binary committers is requested to review the proposed merge of lp:~james-w/pkgme-binary/stormify into lp:pkgme-binary.
>
> === modified file 'README'
> --- README      2011-11-21 16:19:48 +0000
> +++ README      2011-12-05 21:01:26 +0000
> @@ -6,6 +6,9 @@
...

These changes are much appreciated.

> === modified file 'devportalbinary/database.py'
> --- devportalbinary/database.py 2011-10-25 16:45:08 +0000
> +++ devportalbinary/database.py 2011-12-05 21:01:26 +0000
...
> @@ -201,38 +201,129 @@
>     db.update_source_package(source_package_name, symbols)
>
>
> +class PackageDBSchema(schema.Schema):
> +
> +    class database(schema.Section):
> +        db_type = schema.StringOption(default='sqlite',
> +                help=('The database to use, one of "sqlite", or "postgres"'))
> +        host = schema.StringOption(
> +                help='The database host (for postgres)')
> +        port = schema.StringOption(
> +                help='The database port (for postgres)')
> +        username = schema.StringOption(
> +                help='The database username (for postgres)')
> +        password = schema.StringOption(
> +                help='The database password (for postgres)')
> +        path = schema.StringOption(
> +                help='The path to the database file (for sqlite)')
> +
> +
>  class PackageDatabase(object):
>
> +    SQLITE = 'sqlite'
> +    POSTGRES = 'postgres'
> +
>     ENV_VAR = 'PKGME_LIB_DEPS_DB_PATH'

Why didn't you delete ENV_VAR?

> +    CONF_FILE = '~/.config/pkgme-binary/conf'
>
> -    def __init__(self, sqlite_database):
> -        self._sqlite = sqlite_database
> +    def __init__(self, store):
> +        self._store = store
>
>     @classmethod
> -    def create(cls, sqlite_path=None):
> -        if sqlite_path is None:
> +    def _get_storm_sqlite_connection_string(cls, opts):
> +        if not opts.database_path:
>             try:
> -                sqlite_path = os.environ[cls.ENV_VAR]
> +                opts.database_path = os.environ[cls.ENV_VAR]
>             except KeyError:
>                 raise ValueError(
>                     "Cannot create database, no path given and %s not set"
>                     % (cls.ENV_VAR,))
> -        c = sqlite3.connect(sqlite_path)
> -        c.cursor().execute(
> -            "CREATE TABLE IF NOT EXISTS libdep ("
> -            "source_pac...

[James Westby (james-w)]

> > +    SQLITE = 'sqlite'
> > +    POSTGRES = 'postgres'
> > +
> >     ENV_VAR = 'PKGME_LIB_DEPS_DB_PATH'
>
> Why didn't you delete ENV_VAR?

It's still used as a fallback. I can delete that code if we want
to just go straight for the config file approach?

> > +    @classmethod
> > +    def get_store_from_config(cls):
> > +        """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``
> > +
> > +        If that file doesn't exist, or it doesn't contain
> > +        information about setting up a database then this
> > +        method will return None.
> > +        """
>
> Really? It looks like it will always return a tuple.

Good catch, I wrote that docstring before writing any code, and
then changed my approach. I'll fix it up.

> We could probably factor this into using different classes to
> represent the different types of database. Would avoid the 'if' here
> and maybe having to pass around the database type. Probably for a
> later branch though.

I think that would be a good change, I'll defer it for now.

> >     def setUp(self):
> >         super(DatabaseFixture, self).setUp()
> > +        # Set a temporary homedir so that any config on the user's
> > +        # machine isn't picked up and the environment variable is used
> > +        # instead.
> > +        self.useFixture(TempHomeDirFixture())
> >         tempdir = self.useFixture(TempDir())
> >         db_path = os.path.join(tempdir.path, 'test-db')
> > -        self.useFixture(EnvironmentVariableFixture(PackageDatabase.ENV_VAR,
> db_path))
> > -        self.db = PackageDatabase.create(db_path)
> > +        config_file_path = os.path.expanduser(PackageDatabase.CONF_FILE)
> > +        os.makedirs(os.path.dirname(config_file_path))
> > +        with open(config_file_path, 'w') as f:
> > +            f.write('[database]\ndb_type=sqlite\npath=%s\n' % db_path)
> > +        self.db = PackageDatabase.create()
> > +
>
> It's a pity we can't use an in-memory database.

Yeah, this is used for testing across processes so there's
not a lot we can do there I don't think. We should restrict
the number of tests that use it to a minimum though I think.

> This should probably be submitted upstream.

I'll do that.

> As far as I can tell, self.home_dir is unused. Best then to not set it.

Good idead.

> Test coverage is good.
>
> In summary,
> * Delete ENV_VAR
> * Change get_store_from_config's docstring to be correct.

What do you think about dropping support for the env var? I kept it
so that any deployment would keep working across the change, but
we can probably have Tom incorporate this change as he'll want it
for postgres support anyway.

Thanks,

James

[Jonathan Lange (jml)]

On Tue, Dec 6, 2011 at 4:08 PM, James Westby <email address hidden> wrote:
>
>> > +    SQLITE = 'sqlite'
>> > +    POSTGRES = 'postgres'
>> > +
>> >     ENV_VAR = 'PKGME_LIB_DEPS_DB_PATH'
>>
>> Why didn't you delete ENV_VAR?
>
> It's still used as a fallback. I can delete that code if we want
> to just go straight for the config file approach?
>
...
>> Test coverage is good.
>>
>> In summary,
>>  * Delete ENV_VAR
>>  * Change get_store_from_config's docstring to be correct.
>
> What do you think about dropping support for the env var? I kept it
> so that any deployment would keep working across the change, but
> we can probably have Tom incorporate this change as he'll want it
> for postgres support anyway.
>

Let's leave it in there, and then delete once we've deployed with the
config file.

 approve

jml

=== modified file 'README'
--- README	2011-11-21 16:19:48 +0000
+++ README	2011-12-05 21:01:26 +0000
@@ -6,6 +6,9 @@
 
  * pkgme
  * bzr
+ * storm
+ * configglue
+ * launchpadlib (if running fetch-symbol-files)
 
 Tests
 -----
@@ -13,8 +16,43 @@
  * fixtures
  * testtools
 
+Configuration File
+==================
+
+Behaviour can be controlled by a config file at
+
+  $HOME/.config/pkgme-binary/conf
+
+Currently one section is supported for configuring database access.
+This can either be sqlite or postgres.
+
+SQLite
+------
+
+The file should look something like::
+
+  [database]
+  db_type = sqlite
+  path = /path/to/file.db
+
+Postgres
+--------
+
+The file should look something like::
+
+  [database]
+  db_type = postgres
+  host = <db host>
+  port = <db port>
+  username = <db username>
+  password = <db password>
+
+When using postgres it expects to be able to use a database
+called "pkgme_binary_dependencies" but tables within this
+database will be created by the tool itself.
+
 Acceptance tests
-----------------
+================
 
 There is an acceptance test suite that is not run as part of the
 unit tests. You can run these tests with

=== modified file 'acceptance/tests/__init__.py'
--- acceptance/tests/__init__.py	2011-11-15 17:27:30 +0000
+++ acceptance/tests/__init__.py	2011-12-05 21:01:26 +0000
@@ -1,13 +1,13 @@
 import os
 import shutil
 
-from fixtures import EnvironmentVariableFixture, Fixture, MonkeyPatch
+from fixtures import Fixture, MonkeyPatch
 from testtools import TestCase
 
 import pkgme
 from pkgme.testing import PathExists, TempdirFixture
 
-from devportalbinary.database import PackageDatabase
+from devportalbinary.testing import DatabaseFixture
 
 
 class TestData(Fixture):
@@ -24,17 +24,6 @@
         shutil.copytree(source_path, self.path)
 
 
-class DependencyDatabase(Fixture):
-
-    def setUp(self):
-        Fixture.setUp(self)
-        tempdir = self.useFixture(TempdirFixture())
-        db_path = os.path.join(tempdir.path, 'db')
-        self.useFixture(
-            EnvironmentVariableFixture(PackageDatabase.ENV_VAR, db_path))
-        self.db = PackageDatabase.create()
-
-
 class AcceptanceTests(TestCase):
 
     def setUp(self):
@@ -63,7 +52,7 @@
 
     def test_gtk(self):
         """Runs successfully for a basic GTK+ application."""
-        dep_db = self.useFixture(DependencyDatabase())
+        dep_db = self.useFixture(DatabaseFixture())
         test_data = self.useFixture(TestData("gtk"))
         self.run_pkgme(test_data)
         self.assertThat(

=== modified file 'devportalbinary/database.py'
--- devportalbinary/database.py	2011-10-25 16:45:08 +0000
+++ devportalbinary/database.py	2011-12-05 21:01:26 +0000
@@ -5,22 +5,22 @@
 from itertools import chain
 import os
 import shutil
-import sqlite3
 import tempfile
 from urllib2 import urlopen
 
 from bzrlib import urlutils
+from configglue import glue, schema
 from launchpadlib import (
     uris,
     )
 from launchpadlib.launchpad import Launchpad
 from pkgme.run_script import run_subprocess
+from storm.locals import create_database, Store
 
 
 APPLICATION_NAME = 'pkgme-binary'
 SERVICE_ROOT = uris.LPNET_SERVICE_ROOT
 
-
 def get_lp():
     return Launchpad.login_anonymously(APPLICATION_NAME, SERVICE_ROOT, tempfile.mkdtemp())
 
@@ -201,38 +201,129 @@
     db.update_source_package(source_package_name, symbols)
 
 
+class PackageDBSchema(schema.Schema):
+
+    class database(schema.Section):
+        db_type = schema.StringOption(default='sqlite',
+                help=('The database to use, one of "sqlite", or "postgres"'))
+        host = schema.StringOption(
+                help='The database host (for postgres)')
+        port = schema.StringOption(
+                help='The database port (for postgres)')
+        username = schema.StringOption(
+                help='The database username (for postgres)')
+        password = schema.StringOption(
+                help='The database password (for postgres)')
+        path = schema.StringOption(
+                help='The path to the database file (for sqlite)')
+
+
 class PackageDatabase(object):
 
+    SQLITE = 'sqlite'
+    POSTGRES = 'postgres'
+
     ENV_VAR = 'PKGME_LIB_DEPS_DB_PATH'
+    CONF_FILE = '~/.config/pkgme-binary/conf'
 
-    def __init__(self, sqlite_database):
-        self._sqlite = sqlite_database
+    def __init__(self, store):
+        self._store = store
 
     @classmethod
-    def create(cls, sqlite_path=None):
-        if sqlite_path is None:
+    def _get_storm_sqlite_connection_string(cls, opts):
+        if not opts.database_path:
             try:
-                sqlite_path = os.environ[cls.ENV_VAR]
+                opts.database_path = os.environ[cls.ENV_VAR]
             except KeyError:
                 raise ValueError(
                     "Cannot create database, no path given and %s not set"
                     % (cls.ENV_VAR,))
-        c = sqlite3.connect(sqlite_path)
-        c.cursor().execute(
-            "CREATE TABLE IF NOT EXISTS libdep ("
-            "source_package_name TEXT, "
-            "library TEXT, "
-            "dependency TEXT, "
-            "CONSTRAINT libdep_uniq UNIQUE (source_package_name, "
-            "library, dependency))")
-        return cls(c)
+        return '%s:%s' % (opts.database_db_type, opts.database_path)
+
+    @classmethod
+    def _get_storm_postgres_connection_string(cls, opts):
+        for attr in ('database_host', 'database_port',
+                'database_username', 'database_password'):
+            if not getattr(opts, attr, None):
+                raise AssertionError(
+                    "You must specify %s for %s" % (
+                        attr, opts.database_db_type))
+        return '%s://%s:%s@%s:%s/pkgme_binary_dependencies' % (
+                    opts.database_db_type, opts.database_username,
+                    opts.database_password, opts.database_host,
+                    opts.database_port)
+
+    @classmethod
+    def _get_storm_connection_string(cls, opts):
+        if opts.database_db_type == cls.SQLITE:
+            return cls._get_storm_sqlite_connection_string(opts)
+        elif opts.database_db_type == cls.POSTGRES:
+            return cls._get_storm_postgres_connection_string(opts)
+        else:
+            raise AssertionError(
+                "Unsupported database: %s" % opts.database_db_type)
+
+    @classmethod
+    def get_db_info_from_config(cls):
+        config_location = os.path.expanduser(cls.CONF_FILE)
+        config_files = []
+        if os.path.exists(config_location):
+            config_files.append(config_location)
+        theglue = glue.configglue(PackageDBSchema, config_files)
+        opts = theglue.options
+        connection_string = cls._get_storm_connection_string(opts)
+        return connection_string, opts.database_db_type
+
+    @classmethod
+    def get_store_from_config(cls):
+        """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``
+
+        If that file doesn't exist, or it doesn't contain
+        information about setting up a database then this
+        method will return None.
+        """
+        connection_string, store_type = cls.get_db_info_from_config()
+        database = create_database(connection_string)
+        return Store(database), store_type
+
+    @classmethod
+    def create(cls, store=None, store_type='sqlite'):
+        if store is None:
+            store, store_type = cls.get_store_from_config()
+        if store_type == 'sqlite':
+            store.execute(
+                "CREATE TABLE IF NOT EXISTS libdep ("
+                "source_package_name TEXT, "
+                "library TEXT, "
+                "dependency TEXT, "
+                "CONSTRAINT libdep_uniq UNIQUE (source_package_name, "
+                "library, dependency))")
+        elif store_type == 'postgres':
+            # Postgres only supports IF NOT EXISTS starting from 9.1
+            exists = store.execute(
+                "SELECT COUNT(relname) FROM pg_class WHERE "
+                "relname = 'libdep'").get_one()[0]
+            if not exists:
+                store.execute(
+                    "CREATE TABLE libdep ("
+                    "source_package_name TEXT, "
+                    "library TEXT, "
+                    "dependency TEXT, "
+                    "CONSTRAINT libdep_uniq UNIQUE (source_package_name, "
+                    "library, dependency))")
+        else:
+            raise AssertionError("Unsupported database type: %s" % store_type)
+        store.commit()
+        return cls(store)
 
     def get_dependencies(self, library_name):
         """Get the binary packagaes that provide 'library_name'."""
-        c = self._sqlite.cursor()
-        c.execute("SELECT dependency FROM libdep WHERE library = ?",
-                  (library_name,))
-        return set([dependency for [dependency] in c])
+        result = self._store.execute("SELECT dependency FROM libdep WHERE library = ?",
+                  (unicode(library_name),))
+        return set([dependency for [dependency] in result])
 
     def insert_new_library(self, source_package_name, library_name, dependency):
         """Insert a library and its needed dependency into the database.
@@ -241,9 +332,8 @@
         :param dependency: A binary package dependency, possibly including
             version.
         """
-        c = self._sqlite.cursor()
-        c.execute("INSERT INTO libdep VALUES (?, ?, ?)",
-                  (source_package_name, library_name, dependency))
+        self._store.execute("INSERT INTO libdep VALUES (?, ?, ?)",
+                  (unicode(source_package_name), unicode(library_name), unicode(dependency)))
 
     def update_source_package(self, source_package_name, symbols):
         """Update the database with the symbols from 'source_package_name'.
@@ -254,14 +344,13 @@
             representation is a list of tuples of library and
             dependency. e.g. [[(libfoo, foo), ...], ...].
         """
-        c = self._sqlite.cursor()
-        c.execute("DELETE FROM libdep WHERE source_package_name = ?",
-                  (source_package_name,))
+        self._store.execute("DELETE FROM libdep WHERE source_package_name = ?",
+                  (unicode(source_package_name),))
         for symbols in symbols:
             for library, dependency in symbols:
                 self.insert_new_library(
                     source_package_name, library, dependency)
-        self._sqlite.commit()
+        self._store.commit()
 
 
 def main(source_package_name):

=== modified file 'devportalbinary/testing.py'
--- devportalbinary/testing.py	2011-10-24 22:01:46 +0000
+++ devportalbinary/testing.py	2011-12-05 21:01:26 +0000
@@ -17,7 +17,28 @@
 
     def setUp(self):
         super(DatabaseFixture, self).setUp()
+        # Set a temporary homedir so that any config on the user's
+        # machine isn't picked up and the environment variable is used
+        # instead.
+        self.useFixture(TempHomeDirFixture())
         tempdir = self.useFixture(TempDir())
         db_path = os.path.join(tempdir.path, 'test-db')
-        self.useFixture(EnvironmentVariableFixture(PackageDatabase.ENV_VAR, db_path))
-        self.db = PackageDatabase.create(db_path)
+        config_file_path = os.path.expanduser(PackageDatabase.CONF_FILE)
+        os.makedirs(os.path.dirname(config_file_path))
+        with open(config_file_path, 'w') as f:
+            f.write('[database]\ndb_type=sqlite\npath=%s\n' % db_path)
+        self.db = PackageDatabase.create()
+
+
+class TempHomeDirFixture(Fixture):
+    """Create a temp directory and set it as $HOME.
+
+    This provides a known environment for any test that uses
+    $HOME.
+    """
+
+    def setUp(self):
+        super(TempHomeDirFixture, self).setUp()
+        tempdir = self.useFixture(TempDir())
+        self.path = tempdir.path
+        self.useFixture(EnvironmentVariableFixture("HOME", self.path))

=== modified file 'devportalbinary/tests/test_database.py'
--- devportalbinary/tests/test_database.py	2011-10-24 21:48:58 +0000
+++ devportalbinary/tests/test_database.py	2011-12-05 21:01:26 +0000
@@ -6,6 +6,7 @@
     TempDir,
     )
 from pkgme.testing import PathExists
+from storm.locals import create_database, Store
 from testtools import TestCase
 from testtools.matchers import (
     Equals,
@@ -13,6 +14,7 @@
     )
 
 from devportalbinary.database import PackageDatabase
+from devportalbinary.testing import TempHomeDirFixture
 
 
 class ResultsIn(Matcher):
@@ -23,55 +25,62 @@
 
     def match(self, query):
         # XXX: Abstraction violation
-        c = self._db._sqlite.cursor()
-        c.execute(query)
-        results = list(c)
-        return Equals(self._rows).match(results)
+        results = self._db._store.execute(query)
+        return Equals(self._rows).match(list(results))
 
 
 class TestDatabase(TestCase):
 
+    def setUp(self):
+        super(TestDatabase, self).setUp()
+        self.home_dir = self.useFixture(TempHomeDirFixture())
+
+    def get_package_db(self):
+        database = create_database('sqlite:')
+        store = Store(database)
+        return PackageDatabase.create(store, store_type=PackageDatabase.SQLITE)
+
     def test_insert_new_library(self):
-        db = PackageDatabase.create(':memory:')
+        db = self.get_package_db()
         db.insert_new_library('foo-src', 'libfoo.so.0', 'foo')
         self.assertThat(
             "SELECT source_package_name, library, dependency FROM libdep",
             ResultsIn(db, [('foo-src', 'libfoo.so.0', 'foo')]))
 
     def test_double_insert(self):
-        db = PackageDatabase.create(':memory:')
+        db = self.get_package_db()
         db.insert_new_library('foo-src', 'libfoo.so.0', 'foo')
         self.assertRaises(
             IntegrityError,
             db.insert_new_library, 'foo-src', 'libfoo.so.0', 'foo')
 
     def test_differing_dependencies(self):
-        db = PackageDatabase.create(':memory:')
+        db = self.get_package_db()
         db.insert_new_library('foo-src', 'libfoo.so.0', 'foo')
         db.insert_new_library('foo-src', 'libfoo.so.0', 'bar')
         deps = db.get_dependencies('libfoo.so.0')
         self.assertEqual(deps, set(['foo', 'bar']))
 
     def test_get_dependencies(self):
-        db = PackageDatabase.create(':memory:')
+        db = self.get_package_db()
         db.insert_new_library('foo-src', 'libfoo.so.0', 'foo')
         deps = db.get_dependencies('libfoo.so.0')
         self.assertEqual(deps, set(['foo']))
 
     def test_unknown_library(self):
-        db = PackageDatabase.create(':memory:')
+        db = self.get_package_db()
         deps = db.get_dependencies('libfoo.so.0')
         self.assertEqual(deps, set())
 
     def test_update_source_package(self):
-        db = PackageDatabase.create(':memory:')
+        db = self.get_package_db()
         db.update_source_package(
             'foo', [[('libfoo.so.1', 'foo-bin')]])
         deps = db.get_dependencies('libfoo.so.1')
         self.assertEqual(deps, set(['foo-bin']))
 
     def test_update_existing_source_package_no_libraries(self):
-        db = PackageDatabase.create(':memory:')
+        db = self.get_package_db()
         db.update_source_package('foo', [[('libfoo.so.1', 'foo-bin')]])
         # Run again, this time with no symbols, representing that a newer
         # version of the package no longer exports any libraries.
@@ -79,7 +88,24 @@
         deps = db.get_dependencies('libfoo.so.1')
         self.assertEqual(deps, set())
 
+    def write_database_config(self, **kwargs):
+        config_path = os.path.expanduser(PackageDatabase.CONF_FILE)
+        os.makedirs(os.path.dirname(config_path))
+        with open(config_path, 'w') as f:
+            f.write("[database]\n")
+            for key, value in kwargs.items():
+                f.write("%s=%s\n" % (key, value))
+
+    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.write_database_config(db_type='sqlite', path=expected_db_path)
+        connection_string, store_type = PackageDatabase.get_db_info_from_config()
+        self.assertEqual('sqlite', store_type)
+        self.assertEqual('sqlite:%s' % expected_db_path, connection_string)
+
     def test_default_create_from_env_var_db(self):
+        self.useFixture(TempHomeDirFixture())
         tempdir = self.useFixture(TempDir())
         db_path = os.path.join(tempdir.path, 'db')
         self.useFixture(
@@ -88,6 +114,21 @@
         self.assertThat(db_path, PathExists())
 
     def test_default_create_no_env_var_db_set(self):
+        self.useFixture(TempHomeDirFixture())
         self.useFixture(
             EnvironmentVariableFixture(PackageDatabase.ENV_VAR, None))
         self.assertRaises(ValueError, PackageDatabase.create)
+
+    def test_get_db_info_from_config_postgres(self):
+        expected_username = self.getUniqueString()
+        expected_password = self.getUniqueString()
+        expected_host = self.getUniqueString()
+        expected_port = self.getUniqueString()
+        self.write_database_config(db_type='postgres',
+                username=expected_username, password=expected_password,
+                host=expected_host, port=expected_port)
+        connection_string, store_type = PackageDatabase.get_db_info_from_config()
+        self.assertEqual('postgres', store_type)
+        expected_connection_string = "postgres://%s:%s@%s:%s/pkgme_binary_dependencies" % (
+                expected_username, expected_password, expected_host, expected_port)
+        self.assertEqual(expected_connection_string, connection_string)

=== modified file 'setup.py'
--- setup.py	2011-11-23 12:17:04 +0000
+++ setup.py	2011-12-05 21:01:26 +0000
@@ -27,8 +27,10 @@
     test_suite='devportalbinary.tests',
     install_requires = [
         'bzr',
+        'configglue',
         'launchpadlib',
         'pkgme',
+        'storm',
         ],
     entry_points = {
         'console_scripts': [