add SQLAlchemy storage backend

- add sqastore.DatabaseStore and unittests
- update API unittests for use in database tests
- black code formatting
- update README

Author: miraculixx

.github/workflows/python-app.yml

@@ -28,7 +28,7 @@ jobs:
         python -m pip install --upgrade pip
         pip install flake8 pytest
         pip install -r requirements.txt
-        pip install -e .
+        pip install -e .[sqla]
     - name: Lint with flake8
       run: |
         # stop the build if there are Python syntax errors or undefined names

.gitignore

@@ -135,3 +135,4 @@ configurable_http_proxy/version.txt
 /.idea/misc.xml
 /.idea/modules.xml
 /.idea/vcs.xml
+*sqlite*

README.md

@@ -27,6 +27,7 @@ The following items are supported:
 - Customizable storage backends
 - PID file writing
 - Logging
+- Configurable storage backend
 
 The following options are not supported (yet):
 
@@ -35,3 +36,28 @@ The following options are not supported (yet):
 - Change Origin: `--change-origin`
 - Rewrites in Location header: `--protocol-rewrite` and `--auto-rewrite`
 - Metrics server: `--metrics-port` and `--metrics-ip`
+
+
+## Database-backed storage backend
+
+Using a DBMS instead of the default in-memory store enables chp to be replicated
+in a High Availability scenario. 
+
+To use a DBMS as the storage backend:
+
+Install DBMS support
+
+        $ pip install configurable-http-proxy[sqla]
+
+Set the CHP_DATABASE_URL env var to any db URL supported by SQLAlchemy.
+The default is "sqlite://chp.sqlite".
+
+        $ export CHP_DATABASE_URL="sqlite:///chp.sqlite"
+        $ configurable-http-proxy --storage-backend configurable_http_proxy.dbstore.DatabaseStore
+
+Optionally you may set the table name by setting the CHP_DATABASE_TABLE.
+The default is 'chp_routes'
+
+        $ export CHP_DATABASE_TABLE="chp_routes"
+
+ 

configurable_http_proxy/dbstore.py

@@ -0,0 +1,160 @@
+import logging
+import os
+from datetime import datetime
+
+from dataset import connect
+
+from configurable_http_proxy.store import BaseStore
+
+log = logging.getLogger(__name__)
+
+
+class DatabaseStore(BaseStore):
+    """A DBMS storage backend for configurable-http-proxy
+
+    This enables chp to run multiple times and serve routes from a central
+    DBMS. It uses SQLAlchemy as the database backend.
+
+    Usage:
+        Set the CHP_DATABASE_URL env var to any db URL supported by SQLAlchemy.
+        The default is "sqlite://chp.sqlite".
+
+        $ export CHP_DATABASE_URL="sqlite:///chp.sqlite"
+        $ configurable-http-proxy --storage-backend configurable_http_proxy.dbstore.DatabaseStore
+
+        Optionally you may set the table name by setting the CHP_DATABASE_TABLE.
+        The default is 'chp_routes'
+
+        $ export CHP_DATABASE_TABLE="chp_routes"
+
+    See Also:
+        * Valid URLs https://docs.sqlalchemy.org/en/14/core/engines.html#database-urls
+    """
+
+    default_db_url = "sqlite:///chp.sqlite"
+    default_db_table = "chp_routes"
+
+    def __init__(self):
+        super().__init__()
+        db_url = os.environ.get("CHP_DATABASE_URL", self.default_db_url)
+        db_table = os.environ.get("CHP_DATABASE_TABLE", self.default_db_table)
+        self.routes: TableTrie = TableTrie(db_url, table=db_table)
+        log.info(f"Using database {db_url}")
+        for route, data in self.get_all().items():
+            log.info(f'Restoring {route} => {data.get("target", "<no target>")}')
+
+    def clean(self):
+        # remove all information stored so far
+        self.routes.clean()
+
+    def get_target(self, path: str):
+        # return the data for the most specific matching route
+        return self.routes.get(self.clean_path(path), trie=True)
+
+    def get_all(self):
+        # return all routes as route => data
+        return self.routes.all()
+
+    def add(self, path: str, data):
+        # add a new route /path, storing data
+        if self.get(path):
+            self.update(path, data)
+        else:
+            self.routes.add(path, data)
+
+    def update(self, path: str, data):
+        # update an existing route
+        self.routes.update(self.clean_path(path), data)
+
+    def remove(self, path: str):
+        # remove an existing route
+        path = self.clean_path(path)
+        route = self.routes.get(path)
+        if route:
+            self.routes.remove(path)
+        return route
+
+    def get(self, path):
+        # return the data for the exact match
+        return self.routes.get(self.clean_path(path))
+
+
+class TableTrie:
+    # A databased URLTrie-alike
+    def __init__(self, url, table=None):
+        table = table or "chp_routes"
+        self.db = connect(url)
+        self.table = self.db[table]
+
+    def get(self, path, trie=False):
+        # return the data store for path
+        # -- if trie is False (default), will return data for the exact path
+        # -- if trie is True, will return the data and the matching prefix
+        try_routes = self._split_routes(path) if trie else [path]
+        for path in try_routes:
+            doc = self.table.find_one(path=path)
+            if doc:
+                data = self._from_json(doc["data"] if not trie else doc)
+                if trie:
+                    data["prefix"] = path
+                break
+        else:
+            data = None
+        return attrdict(data) if data else None
+
+    def add(self, path, data):
+        # add the data for the given exact path
+        self.table.insert(self._clean_json({"path": path, "data": data}))
+
+    def update(self, path, data):
+        # update the data for the given exact path
+        doc = self.table.find_one(path=path)
+        doc["data"].update(data)
+        self.table.update(self._clean_json(doc), "id")
+
+    def remove(self, path):
+        # remove all matching routes for the given path
+        for path in self._split_routes(path):
+            self.table.delete(path=path)
+
+    def all(self):
+        # return all data for all paths
+        return self._from_json({item["path"]: item["data"] for item in self.table.find()})
+
+    def _clean_json(self, data):
+        # simple converter for serializable data
+        for k, v in dict(data).items():
+            if isinstance(v, datetime):
+                data[k] = f"_dt_:{v.isoformat()}"
+            if isinstance(v, dict):
+                data[k] = self._clean_json(v)
+        return data
+
+    def _from_json(self, data):
+        # simple converter from serialized data
+        for k, v in dict(data).items():
+            if isinstance(v, str) and v.startswith("_dt_:"):
+                data[k] = datetime.fromisoformat(v.split(":", 1)[-1])
+            if isinstance(v, dict):
+                data[k] = self._from_json(v)
+        return data
+
+    def _split_routes(self, path):
+        # generator for reverse tree of routes
+        # e.g. /path/to/document
+        # => yields /path/to/document, /path/to, /path, /
+        levels = path.split("/")
+        for i, e in enumerate(levels):
+            yield "/".join(levels[: len(levels) - i + 1])
+        # always yield top level route
+        yield "/"
+
+    def clean(self):
+        self.table.delete()
+
+
+class attrdict(dict):
+    # enable .attribute for dicts
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.__dict__ = self

configurable_http_proxy_test/test_api.py

@@ -1,18 +1,16 @@
 import datetime
 import json
+import os
 
 from tornado.testing import AsyncHTTPTestCase
 
 from configurable_http_proxy.configproxy import PythonProxy
 from configurable_http_proxy_test.testutil import pytest_regex
 
 
-class TestAPI(AsyncHTTPTestCase):
-    def get_app(self):
-        self.proxy = PythonProxy({"auth_token": "secret"})
-        self.proxy.add_route("/", {"target": "http://127.0.0.1:54321"})
-        return self.proxy.api_app
-
+class APITestsMixin:
+    # test cases for TestAPI
+    # -- this allows to reuse test cases for MemoryStore and DatabaseStore backends
     def fetch(self, path, raise_error=True, with_auth=True, **kwargs):
         headers = kwargs.pop("headers", {})
         if with_auth:
@@ -147,8 +145,28 @@ def test_get_routes_with_inactive_since(self):
 
         resp = self.fetch(f"/api/routes?inactiveSince={hour_ago.isoformat()}")
         reply = json.loads(resp.body)
-        assert set(reply.keys()) == {'/yesterday'}
+        assert set(reply.keys()) == {"/yesterday"}
 
         resp = self.fetch(f"/api/routes?inactiveSince={hour_from_now.isoformat()}")
         reply = json.loads(resp.body)
-        assert set(reply.keys()) == {'/', '/today', '/yesterday'}
+        assert set(reply.keys()) == {"/", "/today", "/yesterday"}
+
+
+class TestAPI_MemoryStore(APITestsMixin, AsyncHTTPTestCase):
+    # actual test case
+    def get_app(self):
+        self.proxy = PythonProxy({"auth_token": "secret"})
+        self.proxy.add_route("/", {"target": "http://127.0.0.1:54321"})
+        return self.proxy.api_app
+
+
+class TestAPI_DatabaseStore(APITestsMixin, AsyncHTTPTestCase):
+    def get_app(self):
+        os.environ["CHP_DATABASE_URL"] = "sqlite:///chp_test.sqlite"
+        self.proxy = PythonProxy(
+            {"auth_token": "secret", "storage_backend": "configurable_http_proxy.dbstore.DatabaseStore"}
+        )
+        self.proxy._routes.clean()
+        assert self.proxy._routes.get_all() == {}
+        self.proxy.add_route("/", {"target": "http://127.0.0.1:54321"})
+        return self.proxy.api_app

configurable_http_proxy_test/test_store.py

@@ -1,10 +1,12 @@
-from configurable_http_proxy.store import MemoryStore
+import os
 
+from configurable_http_proxy.dbstore import DatabaseStore
+from configurable_http_proxy.store import MemoryStore
 
-class TestMemoryStore:
-    def setup_method(self, method):
-        self.subject = MemoryStore()
 
+class StoreTestMixin:
+    # test cases for the storage
+    # -- this allows to reuse tests for MemoryStore and DatabaseStore
     def test_get(self):
         self.subject.add("/myRoute", {"test": "value"})
         route = self.subject.get("/myRoute")
@@ -73,3 +75,15 @@ def test_has_route(self):
     def test_has_route_path_not_found(self):
         route = self.subject.get("/wut")
         assert route is None
+
+
+class TestMemoryStore(StoreTestMixin):
+    def setup_method(self, method):
+        self.subject = MemoryStore()
+
+
+class TestDataBaseStore(StoreTestMixin):
+    def setup_method(self, method):
+        os.environ["CHP_DATABASE_URL"] = "sqlite:///chp_test.sqlite"
+        self.subject = DatabaseStore()
+        self.subject.clean()

setup.py

@@ -19,6 +19,9 @@
         },
         setup_requires=["setuptools_scm"],
         install_requires=open(os.path.join(BASE_PATH, "requirements.txt")).readlines(),
+        extras_require={
+            "sqla": ["dataset"],
+        },
         python_requires=">=3.6",
         include_package_data=True,
         zip_safe=False,