diff --git a/PKG-INFO b/PKG-INFO
index 497c1b27..92b710fc 100644
--- a/PKG-INFO
+++ b/PKG-INFO
@@ -1,153 +1,153 @@
 Metadata-Version: 2.1
 Name: swh.storage
-Version: 0.0.126
+Version: 0.0.127
 Summary: Software Heritage storage manager
 Home-page: https://forge.softwareheritage.org/diffusion/DSTO/
 Author: Software Heritage developers
 Author-email: swh-devel@inria.fr
 License: UNKNOWN
+Project-URL: Bug Reports, https://forge.softwareheritage.org/maniphest
 Project-URL: Source, https://forge.softwareheritage.org/source/swh-storage
 Project-URL: Funding, https://www.softwareheritage.org/donate
-Project-URL: Bug Reports, https://forge.softwareheritage.org/maniphest
 Description: swh-storage
         ===========
         
         Abstraction layer over the archive, allowing to access all stored source code
         artifacts as well as their metadata.
         
         See the
         [documentation](https://docs.softwareheritage.org/devel/swh-storage/index.html)
         for more details.
         
         Tests
         -----
         
         Python tests for this module include tests that cannot be run without a local
         Postgres database. You are not obliged to run those tests though:
         
         - `make test`:      will run all tests
         - `make test-nodb`: will run only tests that do not need a local DB
         - `make test-db`:   will run only tests that do need a local DB
         
         If you do want to run DB-related tests, you should ensure you have access zith
         sufficient privileges to a Postgresql database.
         
         ### Using your system database
         
         You need to ensure that your user is authorized to create and drop DBs, and in
         particular DBs named "softwareheritage-test" and "softwareheritage-dev"
         
         Note: the testdata repository (swh-storage-testdata) is not required any more.
         
         ### Using pifpaf
         
         [pifpaf](https://github.com/jd/pifpaf) is a suite of fixtures and a
         command-line tool that allows to start and stop daemons for a quick throw-away
         usage.
         
         It can be used to run tests that need a Postgres database without any other
         configuration reauired nor the need to have special access to a running
         database:
         
         ```bash
         
         $ pifpaf run postgresql make test-db
         [snip]
         ----------------------------------------------------------------------
         Ran 124 tests in 56.203s
         
         OK
         ```
         
         Note that pifpaf is not yet available as a Debian package, so you may have to
         install it in a venv.
         
         
         Development
         -----------
         
         A test server could locally be running for tests.
         
         ### Sample configuration
         
         In either /etc/softwareheritage/storage/storage.yml,
         ~/.config/swh/storage.yml or ~/.swh/storage.yml:
         
         ```
         storage:
           cls: local
           args:
             db: "dbname=softwareheritage-dev user=<user>"
             objstorage:
               cls: pathslicing
               args:
                 root: /home/storage/swh-storage/
                 slicing: 0:2/2:4/4:6
         ```
         
         which means, this uses:
         
         - a local storage instance whose db connection is to
           softwareheritage-dev local instance
         
         - the objstorage uses a local objstorage instance whose:
         
           - root path is /home/storage/swh-storage
         
           - slicing scheme is 0:2/2:4/4:6. This means that the identifier of
             the content (sha1) which will be stored on disk at first level
             with the first 2 hex characters, the second level with the next 2
             hex characters and the third level with the next 2 hex
             characters. And finally the complete hash file holding the raw
             content. For example: 00062f8bd330715c4f819373653d97b3cd34394c
             will be stored at 00/06/2f/00062f8bd330715c4f819373653d97b3cd34394c
         
         Note that the 'root' path should exist on disk.
         
         
         ### Run server
         
         Command:
         ```
         python3 -m swh.storage.api.server ~/.config/swh/storage.yml
         ```
         
         This runs a local swh-storage api at 5002 port.
         
         
         ### And then what?
         
         In your upper layer (loader-git, loader-svn, etc...), you can define a
         remote storage with this snippet of yaml configuration.
         
         ```
         storage:
           cls: remote
           args:
             url: http://localhost:5002/
         ```
         
         You could directly define a local storage with the following snippet:
         
         ```
         storage:
           cls: local
           args:
             db: service=swh-dev
             objstorage:
               cls: pathslicing
               args:
                 root: /home/storage/swh-storage/
                 slicing: 0:2/2:4/4:6
         ```
         
 Platform: UNKNOWN
 Classifier: Programming Language :: Python :: 3
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Operating System :: OS Independent
 Classifier: Development Status :: 5 - Production/Stable
 Description-Content-Type: text/markdown
 Provides-Extra: testing
-Provides-Extra: listener
 Provides-Extra: schemata
+Provides-Extra: listener
diff --git a/setup.py b/setup.py
index 0258a2f9..bf702a2a 100755
--- a/setup.py
+++ b/setup.py
@@ -1,71 +1,75 @@
 #!/usr/bin/env python3
 # Copyright (C) 2015-2018  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 from setuptools import setup, find_packages
 
 from os import path
 from io import open
 
 here = path.abspath(path.dirname(__file__))
 
 # Get the long description from the README file
 with open(path.join(here, 'README.md'), encoding='utf-8') as f:
     long_description = f.read()
 
 
 def parse_requirements(name=None):
     if name:
         reqf = 'requirements-%s.txt' % name
     else:
         reqf = 'requirements.txt'
 
     requirements = []
     if not path.exists(reqf):
         return requirements
 
     with open(reqf) as f:
         for line in f.readlines():
             line = line.strip()
             if not line or line.startswith('#'):
                 continue
             requirements.append(line)
     return requirements
 
 
 setup(
     name='swh.storage',
     description='Software Heritage storage manager',
     long_description=long_description,
     long_description_content_type='text/markdown',
     author='Software Heritage developers',
     author_email='swh-devel@inria.fr',
     url='https://forge.softwareheritage.org/diffusion/DSTO/',
     packages=find_packages(),
     scripts=[
         'bin/swh-storage-add-dir',
     ],
+    entry_points='''
+        [console_scripts]
+        swh-storage=swh.storage.cli:main
+    ''',
     setup_requires=['vcversioner'],
     install_requires=parse_requirements() + parse_requirements('swh'),
     extras_require={
         'testing': parse_requirements('test'),
         'schemata': ['SQLAlchemy'],
         'listener': ['kafka_python'],
     },
     vcversioner={},
     include_package_data=True,
     classifiers=[
         "Programming Language :: Python :: 3",
         "Intended Audience :: Developers",
         "License :: OSI Approved :: GNU General Public License v3 (GPLv3)",
         "Operating System :: OS Independent",
         "Development Status :: 5 - Production/Stable",
     ],
     project_urls={
         'Bug Reports': 'https://forge.softwareheritage.org/maniphest',
         'Funding': 'https://www.softwareheritage.org/donate',
         'Source': 'https://forge.softwareheritage.org/source/swh-storage',
     },
 )
diff --git a/swh.storage.egg-info/PKG-INFO b/swh.storage.egg-info/PKG-INFO
index 497c1b27..92b710fc 100644
--- a/swh.storage.egg-info/PKG-INFO
+++ b/swh.storage.egg-info/PKG-INFO
@@ -1,153 +1,153 @@
 Metadata-Version: 2.1
 Name: swh.storage
-Version: 0.0.126
+Version: 0.0.127
 Summary: Software Heritage storage manager
 Home-page: https://forge.softwareheritage.org/diffusion/DSTO/
 Author: Software Heritage developers
 Author-email: swh-devel@inria.fr
 License: UNKNOWN
+Project-URL: Bug Reports, https://forge.softwareheritage.org/maniphest
 Project-URL: Source, https://forge.softwareheritage.org/source/swh-storage
 Project-URL: Funding, https://www.softwareheritage.org/donate
-Project-URL: Bug Reports, https://forge.softwareheritage.org/maniphest
 Description: swh-storage
         ===========
         
         Abstraction layer over the archive, allowing to access all stored source code
         artifacts as well as their metadata.
         
         See the
         [documentation](https://docs.softwareheritage.org/devel/swh-storage/index.html)
         for more details.
         
         Tests
         -----
         
         Python tests for this module include tests that cannot be run without a local
         Postgres database. You are not obliged to run those tests though:
         
         - `make test`:      will run all tests
         - `make test-nodb`: will run only tests that do not need a local DB
         - `make test-db`:   will run only tests that do need a local DB
         
         If you do want to run DB-related tests, you should ensure you have access zith
         sufficient privileges to a Postgresql database.
         
         ### Using your system database
         
         You need to ensure that your user is authorized to create and drop DBs, and in
         particular DBs named "softwareheritage-test" and "softwareheritage-dev"
         
         Note: the testdata repository (swh-storage-testdata) is not required any more.
         
         ### Using pifpaf
         
         [pifpaf](https://github.com/jd/pifpaf) is a suite of fixtures and a
         command-line tool that allows to start and stop daemons for a quick throw-away
         usage.
         
         It can be used to run tests that need a Postgres database without any other
         configuration reauired nor the need to have special access to a running
         database:
         
         ```bash
         
         $ pifpaf run postgresql make test-db
         [snip]
         ----------------------------------------------------------------------
         Ran 124 tests in 56.203s
         
         OK
         ```
         
         Note that pifpaf is not yet available as a Debian package, so you may have to
         install it in a venv.
         
         
         Development
         -----------
         
         A test server could locally be running for tests.
         
         ### Sample configuration
         
         In either /etc/softwareheritage/storage/storage.yml,
         ~/.config/swh/storage.yml or ~/.swh/storage.yml:
         
         ```
         storage:
           cls: local
           args:
             db: "dbname=softwareheritage-dev user=<user>"
             objstorage:
               cls: pathslicing
               args:
                 root: /home/storage/swh-storage/
                 slicing: 0:2/2:4/4:6
         ```
         
         which means, this uses:
         
         - a local storage instance whose db connection is to
           softwareheritage-dev local instance
         
         - the objstorage uses a local objstorage instance whose:
         
           - root path is /home/storage/swh-storage
         
           - slicing scheme is 0:2/2:4/4:6. This means that the identifier of
             the content (sha1) which will be stored on disk at first level
             with the first 2 hex characters, the second level with the next 2
             hex characters and the third level with the next 2 hex
             characters. And finally the complete hash file holding the raw
             content. For example: 00062f8bd330715c4f819373653d97b3cd34394c
             will be stored at 00/06/2f/00062f8bd330715c4f819373653d97b3cd34394c
         
         Note that the 'root' path should exist on disk.
         
         
         ### Run server
         
         Command:
         ```
         python3 -m swh.storage.api.server ~/.config/swh/storage.yml
         ```
         
         This runs a local swh-storage api at 5002 port.
         
         
         ### And then what?
         
         In your upper layer (loader-git, loader-svn, etc...), you can define a
         remote storage with this snippet of yaml configuration.
         
         ```
         storage:
           cls: remote
           args:
             url: http://localhost:5002/
         ```
         
         You could directly define a local storage with the following snippet:
         
         ```
         storage:
           cls: local
           args:
             db: service=swh-dev
             objstorage:
               cls: pathslicing
               args:
                 root: /home/storage/swh-storage/
                 slicing: 0:2/2:4/4:6
         ```
         
 Platform: UNKNOWN
 Classifier: Programming Language :: Python :: 3
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Operating System :: OS Independent
 Classifier: Development Status :: 5 - Production/Stable
 Description-Content-Type: text/markdown
 Provides-Extra: testing
-Provides-Extra: listener
 Provides-Extra: schemata
+Provides-Extra: listener
diff --git a/swh.storage.egg-info/SOURCES.txt b/swh.storage.egg-info/SOURCES.txt
index 8f4ac60e..f8ba450c 100644
--- a/swh.storage.egg-info/SOURCES.txt
+++ b/swh.storage.egg-info/SOURCES.txt
@@ -1,195 +1,199 @@
 MANIFEST.in
 Makefile
 Makefile.local
 README.md
 requirements-swh.txt
 requirements.txt
 setup.py
 version.txt
 bin/swh-storage-add-dir
 sql/.gitignore
 sql/Makefile
 sql/TODO
 sql/clusters.dot
 sql/bin/db-upgrade
 sql/bin/dot_add_content
 sql/doc/json/.gitignore
 sql/doc/json/Makefile
 sql/doc/json/entity.lister_metadata.schema.json
 sql/doc/json/entity.metadata.schema.json
 sql/doc/json/entity_history.lister_metadata.schema.json
 sql/doc/json/entity_history.metadata.schema.json
 sql/doc/json/fetch_history.result.schema.json
 sql/doc/json/list_history.result.schema.json
 sql/doc/json/listable_entity.list_params.schema.json
 sql/doc/json/origin_visit.metadata.json
 sql/doc/json/tool.tool_configuration.schema.json
 sql/json/.gitignore
 sql/json/Makefile
 sql/json/entity.lister_metadata.schema.json
 sql/json/entity.metadata.schema.json
 sql/json/entity_history.lister_metadata.schema.json
 sql/json/entity_history.metadata.schema.json
 sql/json/fetch_history.result.schema.json
 sql/json/list_history.result.schema.json
 sql/json/listable_entity.list_params.schema.json
 sql/json/origin_visit.metadata.json
 sql/json/tool.tool_configuration.schema.json
 sql/upgrades/015.sql
 sql/upgrades/016.sql
 sql/upgrades/017.sql
 sql/upgrades/018.sql
 sql/upgrades/019.sql
 sql/upgrades/020.sql
 sql/upgrades/021.sql
 sql/upgrades/022.sql
 sql/upgrades/023.sql
 sql/upgrades/024.sql
 sql/upgrades/025.sql
 sql/upgrades/026.sql
 sql/upgrades/027.sql
 sql/upgrades/028.sql
 sql/upgrades/029.sql
 sql/upgrades/030.sql
 sql/upgrades/032.sql
 sql/upgrades/033.sql
 sql/upgrades/034.sql
 sql/upgrades/035.sql
 sql/upgrades/036.sql
 sql/upgrades/037.sql
 sql/upgrades/038.sql
 sql/upgrades/039.sql
 sql/upgrades/040.sql
 sql/upgrades/041.sql
 sql/upgrades/042.sql
 sql/upgrades/043.sql
 sql/upgrades/044.sql
 sql/upgrades/045.sql
 sql/upgrades/046.sql
 sql/upgrades/047.sql
 sql/upgrades/048.sql
 sql/upgrades/049.sql
 sql/upgrades/050.sql
 sql/upgrades/051.sql
 sql/upgrades/052.sql
 sql/upgrades/053.sql
 sql/upgrades/054.sql
 sql/upgrades/055.sql
 sql/upgrades/056.sql
 sql/upgrades/057.sql
 sql/upgrades/058.sql
 sql/upgrades/059.sql
 sql/upgrades/060.sql
 sql/upgrades/061.sql
 sql/upgrades/062.sql
 sql/upgrades/063.sql
 sql/upgrades/064.sql
 sql/upgrades/065.sql
 sql/upgrades/066.sql
 sql/upgrades/067.sql
 sql/upgrades/068.sql
 sql/upgrades/069.sql
 sql/upgrades/070.sql
 sql/upgrades/071.sql
 sql/upgrades/072.sql
 sql/upgrades/073.sql
 sql/upgrades/074.sql
 sql/upgrades/075.sql
 sql/upgrades/076.sql
 sql/upgrades/077.sql
 sql/upgrades/078.sql
 sql/upgrades/079.sql
 sql/upgrades/080.sql
 sql/upgrades/081.sql
 sql/upgrades/082.sql
 sql/upgrades/083.sql
 sql/upgrades/084.sql
 sql/upgrades/085.sql
 sql/upgrades/086.sql
 sql/upgrades/087.sql
 sql/upgrades/088.sql
 sql/upgrades/089.sql
 sql/upgrades/090.sql
 sql/upgrades/091.sql
 sql/upgrades/092.sql
 sql/upgrades/093.sql
 sql/upgrades/094.sql
 sql/upgrades/095.sql
 sql/upgrades/096.sql
 sql/upgrades/097.sql
 sql/upgrades/098.sql
 sql/upgrades/099.sql
 sql/upgrades/100.sql
 sql/upgrades/101.sql
 sql/upgrades/102.sql
 sql/upgrades/103.sql
 sql/upgrades/104.sql
 sql/upgrades/105.sql
 sql/upgrades/106.sql
 sql/upgrades/107.sql
 sql/upgrades/108.sql
 sql/upgrades/109.sql
 sql/upgrades/110.sql
 sql/upgrades/111.sql
 sql/upgrades/112.sql
 sql/upgrades/113.sql
 sql/upgrades/114.sql
 sql/upgrades/115.sql
 sql/upgrades/116.sql
 sql/upgrades/117.sql
 sql/upgrades/118.sql
 sql/upgrades/119.sql
 sql/upgrades/120.sql
 sql/upgrades/121.sql
 sql/upgrades/122.sql
 sql/upgrades/123.sql
 sql/upgrades/124.sql
 sql/upgrades/125.sql
 sql/upgrades/126.sql
 sql/upgrades/127.sql
 sql/upgrades/128.sql
 sql/upgrades/129.sql
 swh/__init__.py
 swh.storage.egg-info/PKG-INFO
 swh.storage.egg-info/SOURCES.txt
 swh.storage.egg-info/dependency_links.txt
+swh.storage.egg-info/entry_points.txt
 swh.storage.egg-info/requires.txt
 swh.storage.egg-info/top_level.txt
 swh/storage/__init__.py
+swh/storage/cli.py
 swh/storage/common.py
 swh/storage/converters.py
 swh/storage/db.py
 swh/storage/exc.py
 swh/storage/in_memory.py
 swh/storage/listener.py
 swh/storage/storage.py
 swh/storage/algos/__init__.py
 swh/storage/algos/diff.py
 swh/storage/algos/dir_iterators.py
 swh/storage/algos/revisions_walker.py
 swh/storage/algos/snapshot.py
 swh/storage/api/__init__.py
 swh/storage/api/client.py
 swh/storage/api/server.py
+swh/storage/api/wsgi.py
 swh/storage/schemata/__init__.py
 swh/storage/schemata/distribution.py
 swh/storage/sql/10-swh-init.sql
 swh/storage/sql/20-swh-enums.sql
 swh/storage/sql/30-swh-schema.sql
 swh/storage/sql/40-swh-func.sql
 swh/storage/sql/60-swh-indexes.sql
 swh/storage/sql/70-swh-triggers.sql
 swh/storage/tests/__init__.py
 swh/storage/tests/generate_data_test.py
 swh/storage/tests/storage_testing.py
 swh/storage/tests/test_api_client.py
 swh/storage/tests/test_converters.py
 swh/storage/tests/test_db.py
 swh/storage/tests/test_in_memory.py
 swh/storage/tests/test_listener.py
+swh/storage/tests/test_server.py
 swh/storage/tests/test_storage.py
 swh/storage/tests/algos/__init__.py
 swh/storage/tests/algos/test_diff.py
 swh/storage/tests/algos/test_dir_iterator.py
 swh/storage/tests/algos/test_revisions_walker.py
 swh/storage/tests/algos/test_snapshot.py
\ No newline at end of file
diff --git a/swh.storage.egg-info/entry_points.txt b/swh.storage.egg-info/entry_points.txt
new file mode 100644
index 00000000..4044d792
--- /dev/null
+++ b/swh.storage.egg-info/entry_points.txt
@@ -0,0 +1,4 @@
+
+        [console_scripts]
+        swh-storage=swh.storage.cli:main
+    
\ No newline at end of file
diff --git a/swh/storage/api/server.py b/swh/storage/api/server.py
index 2d924251..48996b12 100644
--- a/swh/storage/api/server.py
+++ b/swh/storage/api/server.py
@@ -1,414 +1,434 @@
-# Copyright (C) 2015-2017  The Software Heritage developers
+# Copyright (C) 2015-2019  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
+import os
 import json
 import logging
-import click
 
 from flask import request
 
 from swh.core import config
 from swh.storage import get_storage as get_swhstorage
 from swh.core.api import (SWHServerAPIApp, decode_request,
                           error_handler,
                           encode_data_server as encode_data)
 
-DEFAULT_CONFIG_PATH = 'storage/storage'
-DEFAULT_CONFIG = {
-    'storage': ('dict', {
-        'cls': 'local',
-        'args': {
-            'db': 'dbname=softwareheritage-dev',
-            'objstorage': {
-                'cls': 'pathslicing',
-                'args': {
-                    'root': '/srv/softwareheritage/objects',
-                    'slicing': '0:2/2:4/4:6',
-                },
-            },
-        },
-    })
-}
-
-
 app = SWHServerAPIApp(__name__)
 storage = None
 
 
 @app.errorhandler(Exception)
 def my_error_handler(exception):
     return error_handler(exception, encode_data)
 
 
 def get_storage():
     global storage
     if not storage:
         storage = get_swhstorage(**app.config['storage'])
 
     return storage
 
 
 @app.route('/')
 def index():
     return '''<html>
 <head><title>Software Heritage storage server</title></head>
 <body>
 <p>You have reached the
 <a href="https://www.softwareheritage.org/">Software Heritage</a>
 storage server.<br />
 See its
 <a href="https://docs.softwareheritage.org/devel/swh-storage/">documentation
 and API</a> for more information</p>
 </html>'''
 
 
 @app.route('/check_config', methods=['POST'])
 def check_config():
     return encode_data(get_storage().check_config(**decode_request(request)))
 
 
 @app.route('/content/missing', methods=['POST'])
 def content_missing():
     return encode_data(get_storage().content_missing(
         **decode_request(request)))
 
 
 @app.route('/content/missing/sha1', methods=['POST'])
 def content_missing_per_sha1():
     return encode_data(get_storage().content_missing_per_sha1(
         **decode_request(request)))
 
 
 @app.route('/content/present', methods=['POST'])
 def content_find():
     return encode_data(get_storage().content_find(**decode_request(request)))
 
 
 @app.route('/content/add', methods=['POST'])
 def content_add():
     return encode_data(get_storage().content_add(**decode_request(request)))
 
 
 @app.route('/content/update', methods=['POST'])
 def content_update():
     return encode_data(get_storage().content_update(**decode_request(request)))
 
 
 @app.route('/content/data', methods=['POST'])
 def content_get():
     return encode_data(get_storage().content_get(**decode_request(request)))
 
 
 @app.route('/content/metadata', methods=['POST'])
 def content_get_metadata():
     return encode_data(get_storage().content_get_metadata(
         **decode_request(request)))
 
 
 @app.route('/content/range', methods=['POST'])
 def content_get_range():
     return encode_data(get_storage().content_get_range(
         **decode_request(request)))
 
 
 @app.route('/directory/missing', methods=['POST'])
 def directory_missing():
     return encode_data(get_storage().directory_missing(
         **decode_request(request)))
 
 
 @app.route('/directory/add', methods=['POST'])
 def directory_add():
     return encode_data(get_storage().directory_add(**decode_request(request)))
 
 
 @app.route('/directory/path', methods=['POST'])
 def directory_entry_get_by_path():
     return encode_data(get_storage().directory_entry_get_by_path(
         **decode_request(request)))
 
 
 @app.route('/directory/ls', methods=['GET'])
 def directory_ls():
     dir = request.args['directory'].encode('utf-8', 'surrogateescape')
     rec = json.loads(request.args.get('recursive', 'False').lower())
     return encode_data(get_storage().directory_ls(dir, recursive=rec))
 
 
 @app.route('/revision/add', methods=['POST'])
 def revision_add():
     return encode_data(get_storage().revision_add(**decode_request(request)))
 
 
 @app.route('/revision', methods=['POST'])
 def revision_get():
     return encode_data(get_storage().revision_get(**decode_request(request)))
 
 
 @app.route('/revision/log', methods=['POST'])
 def revision_log():
     return encode_data(get_storage().revision_log(**decode_request(request)))
 
 
 @app.route('/revision/shortlog', methods=['POST'])
 def revision_shortlog():
     return encode_data(get_storage().revision_shortlog(
         **decode_request(request)))
 
 
 @app.route('/revision/missing', methods=['POST'])
 def revision_missing():
     return encode_data(get_storage().revision_missing(
         **decode_request(request)))
 
 
 @app.route('/release/add', methods=['POST'])
 def release_add():
     return encode_data(get_storage().release_add(**decode_request(request)))
 
 
 @app.route('/release', methods=['POST'])
 def release_get():
     return encode_data(get_storage().release_get(**decode_request(request)))
 
 
 @app.route('/release/missing', methods=['POST'])
 def release_missing():
     return encode_data(get_storage().release_missing(
         **decode_request(request)))
 
 
 @app.route('/object/find_by_sha1_git', methods=['POST'])
 def object_find_by_sha1_git():
     return encode_data(get_storage().object_find_by_sha1_git(
         **decode_request(request)))
 
 
 @app.route('/snapshot/add', methods=['POST'])
 def snapshot_add():
     return encode_data(get_storage().snapshot_add(**decode_request(request)))
 
 
 @app.route('/snapshot', methods=['POST'])
 def snapshot_get():
     return encode_data(get_storage().snapshot_get(**decode_request(request)))
 
 
 @app.route('/snapshot/by_origin_visit', methods=['POST'])
 def snapshot_get_by_origin_visit():
     return encode_data(get_storage().snapshot_get_by_origin_visit(
         **decode_request(request)))
 
 
 @app.route('/snapshot/latest', methods=['POST'])
 def snapshot_get_latest():
     return encode_data(get_storage().snapshot_get_latest(
         **decode_request(request)))
 
 
 @app.route('/snapshot/count_branches', methods=['POST'])
 def snapshot_count_branches():
     return encode_data(get_storage().snapshot_count_branches(
         **decode_request(request)))
 
 
 @app.route('/snapshot/get_branches', methods=['POST'])
 def snapshot_get_branches():
     return encode_data(get_storage().snapshot_get_branches(
         **decode_request(request)))
 
 
 @app.route('/origin/get', methods=['POST'])
 def origin_get():
     return encode_data(get_storage().origin_get(**decode_request(request)))
 
 
 @app.route('/origin/get_range', methods=['POST'])
 def origin_get_range():
     return encode_data(get_storage().origin_get_range(
         **decode_request(request)))
 
 
 @app.route('/origin/search', methods=['POST'])
 def origin_search():
     return encode_data(get_storage().origin_search(**decode_request(request)))
 
 
 @app.route('/origin/count', methods=['POST'])
 def origin_count():
     return encode_data(get_storage().origin_count(**decode_request(request)))
 
 
 @app.route('/origin/add_multi', methods=['POST'])
 def origin_add():
     return encode_data(get_storage().origin_add(**decode_request(request)))
 
 
 @app.route('/origin/add', methods=['POST'])
 def origin_add_one():
     return encode_data(get_storage().origin_add_one(**decode_request(request)))
 
 
 @app.route('/origin/visit/get', methods=['POST'])
 def origin_visit_get():
     return encode_data(get_storage().origin_visit_get(
         **decode_request(request)))
 
 
 @app.route('/origin/visit/getby', methods=['POST'])
 def origin_visit_get_by():
     return encode_data(
         get_storage().origin_visit_get_by(**decode_request(request)))
 
 
 @app.route('/origin/visit/add', methods=['POST'])
 def origin_visit_add():
     return encode_data(get_storage().origin_visit_add(
         **decode_request(request)))
 
 
 @app.route('/origin/visit/update', methods=['POST'])
 def origin_visit_update():
     return encode_data(get_storage().origin_visit_update(
         **decode_request(request)))
 
 
 @app.route('/person', methods=['POST'])
 def person_get():
     return encode_data(get_storage().person_get(**decode_request(request)))
 
 
 @app.route('/fetch_history', methods=['GET'])
 def fetch_history_get():
     return encode_data(get_storage().fetch_history_get(request.args['id']))
 
 
 @app.route('/fetch_history/start', methods=['POST'])
 def fetch_history_start():
     return encode_data(
         get_storage().fetch_history_start(**decode_request(request)))
 
 
 @app.route('/fetch_history/end', methods=['POST'])
 def fetch_history_end():
     return encode_data(
         get_storage().fetch_history_end(**decode_request(request)))
 
 
 @app.route('/entity/add', methods=['POST'])
 def entity_add():
     return encode_data(
         get_storage().entity_add(**decode_request(request)))
 
 
 @app.route('/entity/get', methods=['POST'])
 def entity_get():
     return encode_data(
         get_storage().entity_get(**decode_request(request)))
 
 
 @app.route('/entity', methods=['GET'])
 def entity_get_one():
     return encode_data(get_storage().entity_get_one(request.args['uuid']))
 
 
 @app.route('/entity/from_lister_metadata', methods=['POST'])
 def entity_from_lister_metadata():
     return encode_data(get_storage().entity_get_from_lister_metadata(
         **decode_request(request)))
 
 
 @app.route('/tool/data', methods=['POST'])
 def tool_get():
     return encode_data(get_storage().tool_get(
         **decode_request(request)))
 
 
 @app.route('/tool/add', methods=['POST'])
 def tool_add():
     return encode_data(get_storage().tool_add(
         **decode_request(request)))
 
 
 @app.route('/origin/metadata/add', methods=['POST'])
 def origin_metadata_add():
     return encode_data(get_storage().origin_metadata_add(**decode_request(
                                                        request)))
 
 
 @app.route('/origin/metadata/get', methods=['POST'])
 def origin_metadata_get_by():
     return encode_data(get_storage().origin_metadata_get_by(**decode_request(
                                                        request)))
 
 
 @app.route('/provider/add', methods=['POST'])
 def metadata_provider_add():
     return encode_data(get_storage().metadata_provider_add(**decode_request(
                                                        request)))
 
 
 @app.route('/provider/get', methods=['POST'])
 def metadata_provider_get():
     return encode_data(get_storage().metadata_provider_get(**decode_request(
                                                        request)))
 
 
 @app.route('/provider/getby', methods=['POST'])
 def metadata_provider_get_by():
     return encode_data(get_storage().metadata_provider_get_by(**decode_request(
                                                        request)))
 
 
 @app.route('/stat/counters', methods=['GET'])
 def stat_counters():
     return encode_data(get_storage().stat_counters())
 
 
 @app.route('/algos/diff_directories', methods=['POST'])
 def diff_directories():
     return encode_data(get_storage().diff_directories(
         **decode_request(request)))
 
 
 @app.route('/algos/diff_revisions', methods=['POST'])
 def diff_revisions():
     return encode_data(get_storage().diff_revisions(**decode_request(request)))
 
 
 @app.route('/algos/diff_revision', methods=['POST'])
 def diff_revision():
     return encode_data(get_storage().diff_revision(**decode_request(request)))
 
 
 api_cfg = None
 
 
-def run_from_webserver(environ, start_response,
-                       config_path=DEFAULT_CONFIG_PATH):
-    """Run the WSGI app from the webserver, loading the configuration."""
+def load_and_check_config(config_file, type='local'):
+    """Check the minimal configuration is set to run the api or raise an
+       error explanation.
+
+    Args:
+        config_file (str): Path to the configuration file to load
+        type (str): configuration type. For 'local' type, more
+                    checks are done.
+
+    Raises:
+        Error if the setup is not as expected
+
+    Returns:
+        configuration as a dict
+
+    """
+    if not config_file:
+        raise EnvironmentError('Configuration file must be defined')
+
+    if not os.path.exists(config_file):
+        raise FileNotFoundError('Configuration file %s does not exist' % (
+            config_file, ))
+
+    cfg = config.read(config_file)
+    if 'storage' not in cfg:
+        raise KeyError("Missing '%storage' configuration")
+
+    if type == 'local':
+        vcfg = cfg['storage']
+        cls = vcfg.get('cls')
+        if cls != 'local':
+            raise EnvironmentError(
+                "The storage backend can only be started with a 'local' "
+                "configuration")
+
+        args = vcfg['args']
+        for key in ('db', 'objstorage'):
+            if not args.get(key):
+                raise ValueError(
+                    "Invalid configuration; missing '%s' config entry" % key)
+
+    return cfg
+
+
+def make_app_from_configfile():
+    """Run the WSGI app from the webserver, loading the configuration from
+       a configuration file.
+
+       SWH_CONFIG_FILENAME environment variable defines the
+       configuration path to load.
+
+    """
     global api_cfg
     if not api_cfg:
-        api_cfg = config.load_named_config(config_path, DEFAULT_CONFIG)
+        config_file = os.environ.get('SWH_CONFIG_FILENAME')
+        api_cfg = load_and_check_config(config_file)
         app.config.update(api_cfg)
     handler = logging.StreamHandler()
     app.logger.addHandler(handler)
-    return app(environ, start_response)
-
-
-@click.command()
-@click.argument('config-path', required=1)
-@click.option('--host', default='0.0.0.0', help="Host to run the server")
-@click.option('--port', default=5002, type=click.INT,
-              help="Binding port of the server")
-@click.option('--debug/--nodebug', default=True,
-              help="Indicates if the server should run in debug mode")
-def launch(config_path, host, port, debug):
-    app.config.update(config.read(config_path, DEFAULT_CONFIG))
-    app.run(host, port=int(port), debug=bool(debug))
+    return app
 
 
 if __name__ == '__main__':
-    launch()
+    print('Deprecated. Use swh-storage')
diff --git a/swh/storage/api/wsgi.py b/swh/storage/api/wsgi.py
new file mode 100644
index 00000000..02c4901f
--- /dev/null
+++ b/swh/storage/api/wsgi.py
@@ -0,0 +1,8 @@
+# Copyright (C) 2019  The Software Heritage developers
+# See the AUTHORS file at the top-level directory of this distribution
+# License: GNU General Public License version 3, or any later version
+# See top-level LICENSE file for more information
+
+from .server import make_app_from_configfile
+
+application = make_app_from_configfile()
diff --git a/swh/storage/cli.py b/swh/storage/cli.py
new file mode 100644
index 00000000..4c9e1aeb
--- /dev/null
+++ b/swh/storage/cli.py
@@ -0,0 +1,25 @@
+# Copyright (C) 2015-2019  The Software Heritage developers
+# See the AUTHORS file at the top-level directory of this distribution
+# License: GNU General Public License version 3, or any later version
+# See top-level LICENSE file for more information
+
+import click
+
+from swh.storage.api.server import load_and_check_config, app
+
+
+@click.command()
+@click.argument('config-path', required=1)
+@click.option('--host', default='0.0.0.0', help="Host to run the server")
+@click.option('--port', default=5002, type=click.INT,
+              help="Binding port of the server")
+@click.option('--debug/--nodebug', default=True,
+              help="Indicates if the server should run in debug mode")
+def launch(config_path, host, port, debug):
+    api_cfg = load_and_check_config(config_path, type='any')
+    app.config.update(api_cfg)
+    app.run(host, port=int(port), debug=bool(debug))
+
+
+if __name__ == '__main__':
+    launch()
diff --git a/swh/storage/tests/test_server.py b/swh/storage/tests/test_server.py
new file mode 100644
index 00000000..989275ca
--- /dev/null
+++ b/swh/storage/tests/test_server.py
@@ -0,0 +1,129 @@
+# Copyright (C) 2019  The Software Heritage developers
+# See the AUTHORS file at the top-level directory of this distribution
+# License: GNU General Public License version 3, or any later version
+# See top-level LICENSE file for more information
+
+import copy
+import pytest
+import yaml
+
+from swh.storage.api.server import load_and_check_config
+
+
+def prepare_config_file(tmpdir, content, name='config.yml'):
+    """Prepare configuration file in `$tmpdir/name` with content `content`.
+
+    Args:
+        tmpdir (LocalPath): root directory
+        content (str/dict): Content of the file either as string or as a dict.
+                            If a dict, converts the dict into a yaml string.
+        name (str): configuration filename
+
+    Returns
+        path (str) of the configuration file prepared.
+
+    """
+    config_path = tmpdir / name
+    if isinstance(content, dict):  # convert if needed
+        content = yaml.dump(content)
+    config_path.write_text(content, encoding='utf-8')
+    # pytest on python3.5 does not support LocalPath manipulation, so
+    # convert path to string
+    return str(config_path)
+
+
+def test_load_and_check_config_no_configuration():
+    """Inexistant configuration files raises"""
+    with pytest.raises(EnvironmentError) as e:
+        load_and_check_config(None)
+
+    assert e.value.args[0] == 'Configuration file must be defined'
+
+    config_path = '/some/inexistant/config.yml'
+    with pytest.raises(FileNotFoundError) as e:
+        load_and_check_config(config_path)
+
+    assert e.value.args[0] == 'Configuration file %s does not exist' % (
+        config_path, )
+
+
+def test_load_and_check_config_wrong_configuration(tmpdir):
+    """Wrong configuration raises"""
+    config_path = prepare_config_file(tmpdir, 'something: useless')
+    with pytest.raises(KeyError) as e:
+        load_and_check_config(config_path)
+
+    assert e.value.args[0] == 'Missing \'%storage\' configuration'
+
+
+def test_load_and_check_config_remote_config_local_type_raise(tmpdir):
+    """'local' configuration without 'local' storage raises"""
+    config = {
+        'storage': {
+            'cls': 'remote',
+            'args': {}
+        }
+    }
+    config_path = prepare_config_file(tmpdir, config)
+    with pytest.raises(EnvironmentError) as e:
+        load_and_check_config(config_path, type='local')
+
+    assert (
+        e.value.args[0] ==
+        "The storage backend can only be started with a 'local' configuration"
+    )
+
+
+def test_load_and_check_config_local_incomplete_configuration(tmpdir):
+    """Incomplete 'local' configuration should raise"""
+    config = {
+        'storage': {
+            'cls': 'local',
+            'args': {
+                'db': 'database',
+                'objstorage': 'object_storage'
+            }
+        }
+    }
+
+    for key in ('db', 'objstorage'):
+        c = copy.deepcopy(config)
+        c['storage']['args'].pop(key)
+        config_path = prepare_config_file(tmpdir, c)
+        with pytest.raises(ValueError) as e:
+            load_and_check_config(config_path)
+
+        assert (
+            e.value.args[0] ==
+            "Invalid configuration; missing '%s' config entry" % key
+        )
+
+
+def test_load_and_check_config_local_config_fine(tmpdir):
+    """'Remote configuration is fine"""
+    config = {
+        'storage': {
+            'cls': 'local',
+            'args': {
+                'db': 'db',
+                'objstorage': 'something',
+            }
+        }
+    }
+    config_path = prepare_config_file(tmpdir, config)
+    cfg = load_and_check_config(config_path, type='local')
+    assert cfg == config
+
+
+def test_load_and_check_config_remote_config_fine(tmpdir):
+    """'Remote configuration is fine"""
+    config = {
+        'storage': {
+            'cls': 'remote',
+            'args': {}
+        }
+    }
+    config_path = prepare_config_file(tmpdir, config)
+    cfg = load_and_check_config(config_path, type='any')
+
+    assert cfg == config
diff --git a/version.txt b/version.txt
index 17a26db3..e92a08f8 100644
--- a/version.txt
+++ b/version.txt
@@ -1 +1 @@
-v0.0.126-0-g006d102
\ No newline at end of file
+v0.0.127-0-g95b0b42
\ No newline at end of file