diff --git a/PKG-INFO b/PKG-INFO
index 24e8e772..127685b4 100644
--- a/PKG-INFO
+++ b/PKG-INFO
@@ -1,153 +1,153 @@
 Metadata-Version: 2.1
 Name: swh.storage
-Version: 0.0.124
+Version: 0.0.125
 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: 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
-Project-URL: Source, https://forge.softwareheritage.org/source/swh-storage
 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: schemata
 Provides-Extra: listener
 Provides-Extra: testing
diff --git a/swh.storage.egg-info/PKG-INFO b/swh.storage.egg-info/PKG-INFO
index 24e8e772..127685b4 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.124
+Version: 0.0.125
 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: 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
-Project-URL: Source, https://forge.softwareheritage.org/source/swh-storage
 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: schemata
 Provides-Extra: listener
 Provides-Extra: testing
diff --git a/swh/storage/api/server.py b/swh/storage/api/server.py
index 3ab7b7ed..2d924251 100644
--- a/swh/storage/api/server.py
+++ b/swh/storage/api/server.py
@@ -1,409 +1,414 @@
 # Copyright (C) 2015-2017  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 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."""
-    cfg = config.load_named_config(config_path, DEFAULT_CONFIG)
-    app.config.update(cfg)
+    global api_cfg
+    if not api_cfg:
+        api_cfg = config.load_named_config(config_path, DEFAULT_CONFIG)
+        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))
 
 
 if __name__ == '__main__':
     launch()
diff --git a/version.txt b/version.txt
index 8c41ac61..cebb9e2e 100644
--- a/version.txt
+++ b/version.txt
@@ -1 +1 @@
-v0.0.124-0-ge2c4d38
\ No newline at end of file
+v0.0.125-0-ga94451a
\ No newline at end of file