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

@@ -0,0 +1,40 @@
+# This workflow will install Python dependencies, run tests and lint with a single version of Python
+# For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions
+
+name: Python application
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Python 3.10
+      uses: actions/setup-python@v3
+      with:
+        python-version: "3.10"
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install flake8 pytest
+        pip install -r requirements.txt
+        pip install -e .[sqla]
+    - name: Lint with flake8
+      run: |
+        # stop the build if there are Python syntax errors or undefined names
+        flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
+        # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
+        flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
+    - name: Test with pytest
+      run: |
+        pytest

.gitignore

@@ -130,3 +130,9 @@ dmypy.json
 
 # Project specific
 configurable_http_proxy/version.txt
+/.idea/configurable-http-proxy.iml
+/.idea/inspectionProfiles/profiles_settings.xml
+/.idea/misc.xml
+/.idea/modules.xml
+/.idea/vcs.xml
+*sqlite*

.idea/.gitignore

@@ -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"
+
+ 

README.md

@@ -0,0 +1,167 @@
+import json
+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, order_by="id")
+            if doc:
+                if not trie:
+                    data = self._from_json(doc["data"])
+                else:
+                    data = doc
+                    data["data"] = self._from_json(doc["data"])
+                    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({"path": path, "data": self._to_json(data)})
+
+    def update(self, path, data):
+        # update the data for the given exact path
+        doc = self.table.find_one(path=path, order_by="id")
+        doc["data"] = self._from_json(doc["data"])
+        doc["data"].update(data)
+        doc["data"] = self._to_json(doc["data"])
+        self.table.update(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 {item["path"]: self._from_json(item["data"]) for item in self.table.find(order_by="id")}
+
+    def _to_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()}"
+            elif isinstance(v, dict):
+                data[k] = self._to_json(v)
+        return json.dumps(data)
+
+    def _from_json(self, data):
+        # simple converter from serialized data
+        data = json.loads(data) if isinstance(data, (str, bytes)) else data
+        for k, v in dict(data).items():
+            if isinstance(v, str) and v.startswith("_dt_:"):
+                data[k] = datetime.fromisoformat(v.split(":", 1)[-1])
+            elif 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/dbstore.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_api.py

@@ -32,7 +32,7 @@ async def get(self, path=None):
         }
         self.set_status(200)
         self.set_header("Content-Type", "application/json")
-        if self.get_argument("with_set_cookie"):
+        if self.get_argument("with_set_cookie", None):
             # Values that set-cookie can take:
             # https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie
             values = {

configurable_http_proxy_test/test_proxy.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()

configurable_http_proxy_test/test_store.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,