pyrelukko 0.3.0__tar.gz → 0.5.0__tar.gz

{pyrelukko-0.3.0 → pyrelukko-0.5.0}/.gitlab-ci.yml

@@ -13,6 +13,19 @@ variables:
       Remove this when you trigger by hand an image build and want it to use
       the new built image with Git short sha tag (X icon on the right)!
     value: "latest"
+  RUN_PYTEST:
+    description: Used in rules, if "true" and web triggered run the pytests.
+    value: "false"
+    options:
+    - "false"
+    - "true"
+  RELUKKO_HOSTNAME: relukko
+  RELUKKO_BIND_PORT: 3000
+  RELUKKO_API_KEY: "somerandomkey"
+  POSTGRES_USER: relukko
+  POSTGRES_PASSWORD: okkuler
+  POSTGRES_DB: relukko
+  POSTGRES_HOSTNAME: postgres
 #  RUN_DOCS_PUBLISH:
 #    description: >-
 #      Used in rules, if "true" and web triggered it generates the docs and
@@ -22,6 +35,7 @@ variables:
 #    - "false"
 #    - "true"
 
+
 build-py-rf-image:
   stage: build
   image: docker:25
@@ -56,6 +70,7 @@ build-py-rf-image:
     - if: $CI_PIPELINE_SOURCE == "web" && $BUILD_IMAGE == "true"
       when: always
 
+
 run-pylint:
   stage: test
   image: "${CI_REGISTRY_IMAGE}/${IMAGE_NAME}:${IMAGE_TAG}"
@@ -79,7 +94,26 @@ run-pylint:
 
 run-pytest:
   stage: test
-  image: "${CI_REGISTRY_IMAGE}/${IMAGE_NAME}:${IMAGE_TAG}"
+  services:
+    - name: postgres:16
+      alias: postgres
+    - name: registry.gitlab.com/relukko/relukko:latest
+      alias: relukko
+      variables:
+        DATABASE_URL: "postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB}"
+        RELUKKO_USER: "relukko"
+        RELUKKO_PASSWORD: "relukko"
+        RELUKKO_BIND_ADDR: "0.0.0.0"
+        HEALTHCHECK_TCP_PORT: "${RELUKKO_BIND_PORT}"
+  variables:
+    FF_NETWORK_PER_BUILD: 1
+    CI_HAS_RELUKKO: true
+    CI_RELUKKO_BASE_URL: "http://${RELUKKO_HOSTNAME}:${RELUKKO_BIND_PORT}"
+    CI_RELUKKO_API_KEY: "${RELUKKO_API_KEY}"
+  parallel:
+    matrix:
+      - PIPELINE_PY_VERSION: ['3.11', '3.12', '3.13']
+  image: "registry.gitlab.com/relukko/py-tox-images/py-$PIPELINE_PY_VERSION-tox"
   rules:
     - if: $CI_PIPELINE_SOURCE == "merge_request_event" && $CI_COMMIT_BRANCH != $CI_DEFAULT_BRANCH
       changes:
@@ -91,6 +125,8 @@ run-pytest:
         - src/**/*.py
         - tests/test_*.py
         - tests/conftest.py
+    - if: $CI_PIPELINE_SOURCE == "web" && $RUN_PYTEST == "true"
+      when: always
   before_script:
     - echo "Running PyTest."
   script:

{pyrelukko-0.3.0 → pyrelukko-0.5.0}/PKG-INFO

@@ -1,17 +1,20 @@
 Metadata-Version: 2.3
 Name: pyrelukko
-Version: 0.3.0
+Version: 0.5.0
 Summary: Relukko client.
 Author-email: Reto Zingg <g.d0b3rm4n@gmail.com>
-Requires-Python: >=3.12
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Topic :: Internet :: WWW/HTTP
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: requests >=2.32.3
-Requires-Dist: websockets >= 13.1
+Requires-Dist: websockets >= 14.1
 Project-URL: Homepage, https://gitlab.com/relukko/pyrelukko
 Project-URL: Issues, https://gitlab.com/relukko/pyrelukko/-/issues
 

pyrelukko-0.5.0/cicd/run_pytest.sh

@@ -0,0 +1,15 @@
+#!/bin/bash
+
+# SCRIPT_DIR=$(dirname "$(readlink -f "$0")")
+# REPO_DIR="${SCRIPT_DIR}/.."
+
+# Main script execution
+main() {
+    # pytest --junit-xml "${REPO_DIR}/pytest-junit.xml"
+    tox run --skip-missing-interpreters
+}
+
+# Execute the main function
+main
+
+# vim:set softtabstop=4 shiftwidth=4 tabstop=4 expandtab:

{pyrelukko-0.3.0 → pyrelukko-0.5.0}/container/requirements.txt

@@ -1,3 +1,5 @@
 pylint==3.3.1
 pylint-json2html==0.5.0
 pytest==8.3.3
+requests==2.32.3
+websockets==13.1

{pyrelukko-0.3.0 → pyrelukko-0.5.0}/pyproject.toml

@@ -7,17 +7,20 @@ readme = "README.md"
 
 # https://pypi.org/pypi?%3Aaction=list_classifiers
 classifiers = [
-    "Development Status :: 3 - Alpha",
+    "Development Status :: 4 - Beta",
     "Intended Audience :: Developers",
     "License :: OSI Approved :: MIT License",
     "Topic :: Internet :: WWW/HTTP",
     "Topic :: Software Development :: Libraries :: Python Modules",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
 ]
-requires-python = ">=3.12"
+requires-python = ">=3.10"
 dynamic = ["version", "description"]
 dependencies = [
     "requests >=2.32.3",
-    "websockets >= 13.1",
+    "websockets >= 14.1",
 ]
 
 [tool.flit.sdist]
@@ -41,14 +44,14 @@ pythonpath = [
 
 [tool.tox]
 requires = ["tox>=4.23"]
-env_list = ["3.13", "3.12"]
+env_list = ["3.11", "3.12", "3.13"]
 
 [tool.tox.env_run_base]
 description = "Run test under {base_python}"
-commands = [["pytest"]]
+commands = [["pytest", "--junit-xml", "pytest-junit.xml"]]
 deps = ["httpx", "pytest", "testcontainers"]
-set_env = { VIRTUALENV_DISCOVERY = "pyenv" }
-pass_env = [ "TESTCONTAINERS_DOCKER_SOCKET_OVERRIDE", "DOCKER_HOST" ]
+# set_env = { VIRTUALENV_DISCOVERY = "pyenv" }
+pass_env = [ "TESTCONTAINERS_DOCKER_SOCKET_OVERRIDE", "DOCKER_HOST", "CI_HAS_RELUKKO", "CI_RELUKKO_*" ]
 
 [tool.pylint.main]
 # Files or directories to be skipped. They should be base names, not paths.

{pyrelukko-0.3.0 → pyrelukko-0.5.0}/src/pyrelukko/pyrelukko.py

@@ -33,9 +33,18 @@ RETRY_KWARGS = [
     'delay',
     'backoff',
     'max_delay',
-    'exceptions'
+    'exceptions',
 ]
 
+OWN_KWARGS = [
+    'acquire_wait_for_timeout',
+    'acquire_modulo',
+    'ws_ping_interval',
+    'ws_ping_timeout',
+    'ws_wait_for_timeout',
+]
+OWN_KWARGS.extend(RETRY_KWARGS)
+
 logger = logging.getLogger(__name__)
 
 
@@ -66,7 +75,12 @@ class RelukkoClient:
         )
         self._setup_session(api_key, **kwargs)
         self._setup_http_adapters_retry(**kwargs)
-        self._setup_pyrelukko_retry(**kwargs)
+        self.ws_wait_for_timeout = 2
+        self.ws_ping_interval = 60
+        self.ws_ping_timeout = 20
+        self.acquire_wait_for_timeout = 2
+        self.acquire_modulo = 100
+        self._setup_pyrelukko_kwargs(**kwargs)
 
         self.base_url = self._setup_base_url(base_url)
         self.ws_url = self._setup_ws_url(str(self.base_url))
@@ -90,10 +104,10 @@ class RelukkoClient:
         self.base_url = self._setup_base_url(base_url or self.base_url)
         self.ws_url = self._setup_ws_url(str(self.base_url))
         self._setup_ssl_ctx(**kwargs)
-        self._setup_pyrelukko_retry(**kwargs)
+        self._setup_pyrelukko_kwargs(**kwargs)
 
-    def _setup_pyrelukko_retry(self, **kwargs):
-        for kwarg in RETRY_KWARGS:
+    def _setup_pyrelukko_kwargs(self, **kwargs):
+        for kwarg in OWN_KWARGS:
             setattr(
                 self,
                 kwarg,
@@ -174,14 +188,17 @@ class RelukkoClient:
             additional_headers=additional_headers,
             ssl=self.ssl_ctx,
             logger=logger,
+            ping_interval=self.ws_ping_interval,
+            ping_timeout=self.ws_ping_timeout,
         ) as websocket:
             while self.ws_running.is_set():
                 try:
-                    ws_message = await asyncio.wait_for(websocket.recv(), timeout=2)
+                    ws_message = await asyncio.wait_for(
+                        websocket.recv(), timeout=self.ws_wait_for_timeout)
                     if ws_message:
                         logger.debug("Received message: '%s'", ws_message)
                         msg: Dict = json.loads(ws_message)
-                        if msg.get('deletions'):
+                        if msg.get('deleted'):
                             # Signal the HTTP thread to wake up
                             self.message_received.set()
                 except TimeoutError:
@@ -199,19 +216,25 @@ class RelukkoClient:
         """
 
         start_time = time.time()
-
+        loop_counter = 0
+        got_message = False
+        res = None
         while True:
             elapsed_time = time.time() - start_time
             if elapsed_time > max_run_time:
                 self.ws_running.clear()
                 _thread_store.insert(0, None)
                 return
-
-            res = self._make_request(
-                url=url, method="POST", payload=payload)
+            # If self.message_recieved is True try to get lock ASAP!
+            # Otherwise only in every Xth run in case websocket broke.
+            if got_message or loop_counter % self.acquire_modulo == 0:
+                res = self._make_request(
+                    url=url, method="POST", payload=payload)
+            loop_counter += 1
             if res is None:
                 # Conflict 409
-                self.message_received.wait(timeout=30)
+                got_message = self.message_received.wait(
+                    timeout=self.acquire_wait_for_timeout)
                 self.message_received.clear()
             else:
                 _thread_store.insert(0, res)
@@ -277,7 +300,8 @@ class RelukkoClient:
 
         thread_store = []
         http_thread = threading.Thread(
-            target=self._acquire_relukko, args=(url, max_run_time, payload, thread_store))
+            target=self._acquire_relukko,
+            args=(url, max_run_time, payload, thread_store))
         http_thread.start()
         http_thread.join()
         self.ws_listener.join()

{pyrelukko-0.3.0 → pyrelukko-0.5.0}/src/pyrelukko/testcontainers.py

@@ -6,7 +6,7 @@ Testcontainers to be used in PyTests, for a fixture see tests/conftest.py
 @pytest.fixture(scope="session")
 def relukko_backend():
     with Network() as rl_net:
-        with RelukkoDbContainer(net=rl_net, initdb_dir=INITDB_DIR,
+        with RelukkoDbContainer(net=rl_net,
             image="postgres:16", hostname="relukkodb") as _db:
             db_url = "postgresql://relukko:relukko@relukkodb/relukko"
             with RelukkoContainer(rl_net, db_url=db_url) as backend:
@@ -15,7 +15,6 @@ def relukko_backend():
                 yield relukko, backend
 """
 import socket
-from pathlib import Path
 
 from testcontainers.core.network import Network
 from testcontainers.core.waiting_utils import wait_container_is_ready
@@ -25,7 +24,7 @@ from testcontainers.postgres import PostgresContainer
 
 class RelukkoContainer(ServerContainer):
     def __init__(self, net: Network,
-                 image="registry.gitlab.com/relukko/relukko:0.10.0", db_url=None):
+                 image="registry.gitlab.com/relukko/relukko:latest", db_url=None):
         self.db_url = db_url
         self.net = net
         super(RelukkoContainer, self).__init__(image=image, port=3000)
@@ -48,7 +47,6 @@ class RelukkoContainer(ServerContainer):
 class RelukkoDbContainer(PostgresContainer):
     def __init__(
             self, net: Network,
-            initdb_dir: Path,
             image: str = "postgres:latest",
             port: int = 5432,
             username: str | None = None,
@@ -57,11 +55,9 @@ class RelukkoDbContainer(PostgresContainer):
             driver: str | None = "psycopg2",
             **kwargs) -> None:
         self.net = net
-        self.initdb_dir = initdb_dir
         super().__init__(image, port, username, password, dbname, driver, **kwargs)
 
     def _configure(self) -> None:
-        self.with_volume_mapping(self.initdb_dir, "/docker-entrypoint-initdb.d", "Z")
         self.with_env("POSTGRES_USER", "relukko")
         self.with_env("POSTGRES_PASSWORD", "relukko")
         self.with_env("POSTGRES_DB", "relukko")

{pyrelukko-0.3.0 → pyrelukko-0.5.0}/src/pyrelukko/version.py

@@ -1,2 +1,2 @@
 # pylint: disable=all
-__version__ = "0.3.0"
+__version__ = "0.5.0"

{pyrelukko-0.3.0 → pyrelukko-0.5.0}/tests/conftest.py

@@ -1,3 +1,4 @@
+import os
 import socket
 import ssl
 import threading
@@ -11,19 +12,27 @@ from pyrelukko import RelukkoClient
 from pyrelukko.testcontainers import RelukkoContainer, RelukkoDbContainer
 
 SCRIPT_DIR = Path(__file__).parent.absolute()
-INITDB_DIR = SCRIPT_DIR / "initdb.d"
 
 
 @pytest.fixture(scope="session")
 def relukko_backend():
-    with Network() as rl_net:
-        with RelukkoDbContainer(net=rl_net, initdb_dir=INITDB_DIR,
-            image="postgres:16", hostname="relukkodb") as _db:
-            db_url = "postgresql://relukko:relukko@relukkodb/relukko"
-            with RelukkoContainer(rl_net, db_url=db_url) as backend:
-                relukko = RelukkoClient(
-                    base_url=backend.get_api_url(), api_key="somekey")
-                yield relukko, backend
+    if os.environ.get("CI_HAS_RELUKKO"):
+        # Gitlab does not allow DinD networks, so Relukko runs as a service
+        # in the background of the job.
+        relukko = RelukkoClient(
+            base_url=os.environ['CI_RELUKKO_BASE_URL'],
+            api_key=os.environ['CI_RELUKKO_API_KEY']
+        )
+        yield relukko, None
+    else:
+        with Network() as rl_net:
+            with RelukkoDbContainer(net=rl_net,
+                image="postgres:16", hostname="relukkodb") as _db:
+                db_url = "postgresql://relukko:relukko@relukkodb/relukko"
+                with RelukkoContainer(rl_net, db_url=db_url) as backend:
+                    relukko = RelukkoClient(
+                        base_url=backend.get_api_url(), api_key="somekey")
+                    yield relukko, backend
 
 @pytest.fixture(scope="function")
 def tls_listener():

{pyrelukko-0.3.0 → pyrelukko-0.5.0}/tests/test_relukko.py

@@ -2,7 +2,7 @@ import logging
 import time
 import ssl
 import socket
-from datetime import datetime, timezone
+from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from typing import Dict
 
@@ -59,6 +59,11 @@ def test_init_relukko_client():
     assert relukko.backoff == 2.0
     assert relukko.max_delay is None
     assert relukko.exceptions == (requests.ConnectionError, RelukkoDoRetry)
+    assert relukko.ws_wait_for_timeout == 2
+    assert relukko.ws_ping_interval == 60
+    assert relukko.ws_ping_timeout == 20
+    assert relukko.acquire_wait_for_timeout == 2
+    assert relukko.acquire_modulo == 100
 
     with pytest.raises(ValueError):
         RelukkoClient(base_url=1000, api_key="")
@@ -169,6 +174,11 @@ def test_reconfigure_relukko_client():
     assert relukko.backoff == 2.0
     assert relukko.max_delay is None
     assert relukko.exceptions == (requests.ConnectionError, RelukkoDoRetry)
+    assert relukko.ws_wait_for_timeout == 2
+    assert relukko.ws_ping_interval == 60
+    assert relukko.ws_ping_timeout == 20
+    assert relukko.acquire_wait_for_timeout == 2
+    assert relukko.acquire_modulo == 100
 
 
 def test_reconfigure_relukko_client_extended():
@@ -178,6 +188,11 @@ def test_reconfigure_relukko_client_extended():
     verify_mode = ssl.VerifyMode.CERT_NONE
     verify_flags = ssl.VerifyFlags.VERIFY_DEFAULT
     options = ssl.Options.OP_ALL
+    ws_wait_for_timeout = 27
+    ws_ping_interval = 600
+    ws_ping_timeout = 23
+    acquire_wait_for_timeout = 22
+    acquire_modulo = 202
 
     relukko.reconfigure_relukko(
         base_url="https://relukko", api_key="my-API-key", trust_env=False,
@@ -185,7 +200,10 @@ def test_reconfigure_relukko_client_extended():
         status=96, other=95, backoff_factor=94, backoff_max=1000,
         backoff_jitter=93, raise_on_redirect=False, raise_on_status=False,
         check_hostname=False, hostname_checks_common_name=False,
-        verify_mode=verify_mode, verify_flags=verify_flags, options=options
+        verify_mode=verify_mode, verify_flags=verify_flags, options=options,
+        ws_wait_for_timeout=ws_wait_for_timeout, acquire_modulo=acquire_modulo,
+        ws_ping_interval=ws_ping_interval, ws_ping_timeout=ws_ping_timeout,
+        acquire_wait_for_timeout=acquire_wait_for_timeout,
     )
 
     assert relukko.session.trust_env == False
@@ -218,16 +236,29 @@ def test_reconfigure_relukko_client_extended():
     assert relukko.backoff == 2.0
     assert relukko.max_delay is None
     assert relukko.exceptions == (requests.ConnectionError, RelukkoDoRetry)
+    assert relukko.ws_wait_for_timeout == ws_wait_for_timeout
+    assert relukko.ws_ping_interval == ws_ping_interval
+    assert relukko.ws_ping_timeout == ws_ping_timeout
+    assert relukko.acquire_wait_for_timeout == acquire_wait_for_timeout
+    assert relukko.acquire_modulo == acquire_modulo
 
 
 def test_init_relukko_client_extented():
     cookies = cookiejar_from_dict({"cookie1": "value1"})
+    ws_wait_for_timeout = 27
+    ws_ping_interval = 600
+    ws_ping_timeout = 23
+    acquire_wait_for_timeout = 22
+    acquire_modulo = 202
 
     relukko = RelukkoClient(
         base_url="http://relukko", api_key="my-API-key", trust_env=False,
         cookies=cookies, total=100, connect=99, read=98, redirect=97,
         status=96, other=95, backoff_factor=94, backoff_max=1000,
         backoff_jitter=93, raise_on_redirect=False, raise_on_status=False,
+        ws_wait_for_timeout=ws_wait_for_timeout, acquire_modulo=acquire_modulo,
+        ws_ping_interval=ws_ping_interval, ws_ping_timeout=ws_ping_timeout,
+        acquire_wait_for_timeout=acquire_wait_for_timeout,
     )
 
     assert relukko.session.trust_env == False
@@ -253,6 +284,11 @@ def test_init_relukko_client_extented():
     assert relukko.backoff == 2.0
     assert relukko.max_delay is None
     assert relukko.exceptions == (requests.ConnectionError, RelukkoDoRetry)
+    assert relukko.ws_wait_for_timeout == ws_wait_for_timeout
+    assert relukko.ws_ping_interval == ws_ping_interval
+    assert relukko.ws_ping_timeout == ws_ping_timeout
+    assert relukko.acquire_wait_for_timeout == acquire_wait_for_timeout
+    assert relukko.acquire_modulo == acquire_modulo
 
 
 def test_init_relukko_client_ssl_ctx():
@@ -351,7 +387,25 @@ def test_acquire_relukko(relukko_backend):
     lock = relukko.acquire_relukko("pylock", "pytest", 30)
     end_time = time.time()
     assert lock is None
-    assert 29 < end_time - start_time < 34
+    assert 29 < end_time - start_time < 37
+
+
+def test_acquire_relukko_with_del(relukko_backend):
+    relukko, _ = relukko_backend
+    lock = relukko.acquire_relukko("Pylock", "pytest", 10)
+    id = lock['id']
+
+    expires_at = datetime.now(timezone.utc) - timedelta(minutes=2, seconds=45)
+    upd_lock = relukko.update_relukko(id, expires_at=expires_at)
+    assert id == upd_lock['id']
+
+    start_time = time.time()
+    lock = relukko.acquire_relukko("Pylock", "pytest", 60)
+    end_time = time.time()
+
+    assert lock is not None
+    assert upd_lock['id'] != lock['id']
+    assert 14 < end_time - start_time < 50
 
 
 def test_delete_relukko(relukko_backend):

pyrelukko-0.3.0/cicd/run_pytest.sh

@@ -1,14 +0,0 @@
-#!/bin/bash
-
-SCRIPT_DIR=$(dirname "$(readlink -f "$0")")
-REPO_DIR="${SCRIPT_DIR}/.."
-
-# Main script execution
-main() {
-    pytest --junit-xml "${REPO_DIR}/pytest-junit.xml"
-}
-
-# Execute the main function
-main
-
-# vim:set softtabstop=4 shiftwidth=4 tabstop=4 expandtab:

pyrelukko-0.3.0/tests/initdb.d/20240930160154_init.up.sql

@@ -1,19 +0,0 @@
--- Add up migration script here
-CREATE EXTENSION moddatetime;
-
-CREATE TABLE locks (
-    id uuid DEFAULT gen_random_uuid(),
-    lock_name VARCHAR NOT NULL,
-    creator VARCHAR,
-    ip INET,
-    expires_at TIMESTAMPTZ NOT NULL DEFAULT NOW() + (10 ||' minutes')::interval ,
-    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-    PRIMARY KEY (id),
-    UNIQUE(lock_name)
-);
-
-CREATE TRIGGER locks_moddatetime
-    BEFORE UPDATE ON locks
-    FOR EACH ROW
-    EXECUTE PROCEDURE moddatetime (updated_at);