relaybus-http 0.0.2__tar.gz

relaybus_http-0.0.2/.gitignore

@@ -0,0 +1,26 @@
+.DS_Store
+*.log
+
+# Go
+*.test
+*.out
+
+# Node/TypeScript
+node_modules/
+dist/
+*.tsbuildinfo
+coverage/
+
+# Python
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.venv/
+venv/
+*.egg-info/
+.pytest_cache/
+
+# IDE
+.idea/
+.vscode/

relaybus_http-0.0.2/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: relaybus-http
+Version: 0.0.2
+Summary: Relaybus HTTP publisher and subscriber
+Requires-Python: >=3.9
+Requires-Dist: relaybus-core
+Description-Content-Type: text/markdown
+
+# relaybus-http (Python)
+
+HTTP publisher and subscriber utilities for Relaybus.
+
+## Install
+
+```
+pip install relaybus-http
+```
+
+## Example
+
+```python
+from relaybus_core import OutgoingMessage
+from relaybus_http import (
+    HttpPublisher,
+    HttpPublisherConnectConfig,
+    HttpSubscriber,
+    HttpSubscriberConfig,
+    HttpSubscriberListenConfig,
+)
+
+subscriber = HttpSubscriber(
+    HttpSubscriberConfig(
+        on_message=lambda msg: print(msg.topic, msg.payload),
+    )
+)
+subscriber.listen(HttpSubscriberListenConfig(port=8088))
+
+publisher = HttpPublisher.connect(
+    HttpPublisherConnectConfig(endpoint="http://localhost:8088/{topic}")
+)
+publisher.publish("relaybus.demo", OutgoingMessage(topic="relaybus.demo", payload=b"hello"))
+```

relaybus_http-0.0.2/README.md

@@ -0,0 +1,34 @@
+# relaybus-http (Python)
+
+HTTP publisher and subscriber utilities for Relaybus.
+
+## Install
+
+```
+pip install relaybus-http
+```
+
+## Example
+
+```python
+from relaybus_core import OutgoingMessage
+from relaybus_http import (
+    HttpPublisher,
+    HttpPublisherConnectConfig,
+    HttpSubscriber,
+    HttpSubscriberConfig,
+    HttpSubscriberListenConfig,
+)
+
+subscriber = HttpSubscriber(
+    HttpSubscriberConfig(
+        on_message=lambda msg: print(msg.topic, msg.payload),
+    )
+)
+subscriber.listen(HttpSubscriberListenConfig(port=8088))
+
+publisher = HttpPublisher.connect(
+    HttpPublisherConnectConfig(endpoint="http://localhost:8088/{topic}")
+)
+publisher.publish("relaybus.demo", OutgoingMessage(topic="relaybus.demo", payload=b"hello"))
+```

relaybus_http-0.0.2/pyproject.toml

@@ -0,0 +1,14 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "relaybus-http"
+version = "0.0.2"
+description = "Relaybus HTTP publisher and subscriber"
+readme = "README.md"
+requires-python = ">=3.9"
+dependencies = ["relaybus-core"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["relaybus_http"]

relaybus_http-0.0.2/relaybus_http/__init__.py

@@ -0,0 +1,159 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable, Dict, Optional
+from urllib.parse import quote, urlparse
+import http.client
+import threading
+from http.server import BaseHTTPRequestHandler, HTTPServer
+
+from relaybus_core import Message, OutgoingMessage, decode_envelope, encode_envelope
+
+
+@dataclass
+class HttpPublisherConfig:
+    endpoint: str
+    doer: Callable[[str, str, Dict[str, str], bytes], int]
+    headers: Optional[Dict[str, str]] = None
+    idempotency_header: str = "Idempotency-Key"
+
+
+@dataclass
+class HttpPublisherConnectConfig:
+    endpoint: str
+    headers: Optional[Dict[str, str]] = None
+    idempotency_header: str = "Idempotency-Key"
+
+
+class HttpPublisher:
+    def __init__(self, config: HttpPublisherConfig) -> None:
+        if not config.endpoint:
+            raise ValueError("endpoint is required")
+        if config.doer is None:
+            raise ValueError("doer is required")
+        self._endpoint = config.endpoint
+        self._doer = config.doer
+        self._headers = config.headers or {}
+        self._idempotency_header = config.idempotency_header
+
+    def publish(self, topic: str, message: OutgoingMessage) -> None:
+        resolved = _resolve_topic(topic, message.topic)
+        body = encode_envelope(
+            OutgoingMessage(
+                topic=resolved,
+                payload=message.payload,
+                id=message.id,
+                ts=message.ts,
+                content_type=message.content_type,
+                meta=message.meta,
+            )
+        )
+        url = _build_endpoint(self._endpoint, resolved)
+        headers = {"Content-Type": "application/json", **self._headers}
+        if message.id:
+            headers[self._idempotency_header] = message.id
+        status = self._doer("POST", url, headers, body)
+        if status < 200 or status >= 300:
+            raise ValueError(f"http status {status}")
+
+    @classmethod
+    def connect(cls, config: HttpPublisherConnectConfig) -> "HttpPublisher":
+        def doer(method: str, url: str, headers: Dict[str, str], body: bytes) -> int:
+            parsed = urlparse(url)
+            if parsed.scheme == "https":
+                conn = http.client.HTTPSConnection(parsed.hostname, parsed.port)
+            else:
+                conn = http.client.HTTPConnection(parsed.hostname, parsed.port)
+            path = parsed.path or "/"
+            conn.request(method, path, body=body, headers=headers)
+            response = conn.getresponse()
+            response.read()
+            status = response.status
+            conn.close()
+            return status
+
+        return cls(
+            HttpPublisherConfig(
+                endpoint=config.endpoint,
+                doer=doer,
+                headers=config.headers,
+                idempotency_header=config.idempotency_header,
+            )
+        )
+
+
+@dataclass
+class HttpSubscriberConfig:
+    on_message: Callable[[Message], None]
+
+
+@dataclass
+class HttpSubscriberListenConfig:
+    port: int
+    host: str = ""
+    timeout: float = 30.0
+
+
+class HttpSubscriber:
+    def __init__(self, config: HttpSubscriberConfig) -> None:
+        self._on_message = config.on_message
+
+    def handle(self, body: bytes | str) -> None:
+        decoded = decode_envelope(body)
+        self._on_message(decoded)
+
+    def listen(self, config: HttpSubscriberListenConfig) -> None:
+        stop_event = threading.Event()
+
+        class Handler(BaseHTTPRequestHandler):
+            def do_POST(self):  # noqa: N802
+                length = int(self.headers.get("Content-Length", "0"))
+                body = self.rfile.read(length)
+                try:
+                    self.server.subscriber.handle(body)
+                    self.send_response(204)
+                    stop_event.set()
+                except Exception:
+                    self.send_response(400)
+                self.end_headers()
+
+        server = HTTPServer((config.host, config.port), Handler)
+        server.subscriber = self
+
+        thread = threading.Thread(target=server.serve_forever, daemon=True)
+        thread.start()
+        if not stop_event.wait(timeout=config.timeout):
+            server.shutdown()
+            server.server_close()
+            thread.join(timeout=1)
+            raise TimeoutError("timeout waiting for message")
+        server.shutdown()
+        server.server_close()
+        thread.join(timeout=1)
+
+
+def _resolve_topic(argument_topic: str, message_topic: Optional[str]) -> str:
+    topic = message_topic or argument_topic
+    if not topic:
+        raise ValueError("topic is required")
+    if argument_topic and message_topic and argument_topic != message_topic:
+        raise ValueError(f"topic mismatch: {message_topic} vs {argument_topic}")
+    return topic
+
+
+def _build_endpoint(endpoint: str, topic: str) -> str:
+    if "{topic}" in endpoint:
+        return endpoint.replace("{topic}", quote(topic))
+    if not topic:
+        return endpoint
+    return endpoint.rstrip("/") + "/" + quote(topic)
+
+
+__all__ = [
+    "HttpPublisher",
+    "HttpPublisherConfig",
+    "HttpPublisherConnectConfig",
+    "HttpSubscriber",
+    "HttpSubscriberConfig",
+    "HttpSubscriberListenConfig",
+]

relaybus_http-0.0.2/tests/test_http.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+import json
+
+import pytest
+
+from relaybus_core import OutgoingMessage, decode_envelope
+from relaybus_http import HttpPublisher, HttpPublisherConfig, HttpSubscriber, HttpSubscriberConfig
+
+
+def test_http_publisher_posts_envelope():
+    calls = []
+
+    def doer(method, url, headers, body):
+        calls.append({"method": method, "url": url, "headers": headers, "body": body})
+        return 204
+
+    publisher = HttpPublisher(
+        HttpPublisherConfig(endpoint="https://example.test/{topic}", doer=doer)
+    )
+    publisher.publish("alpha", OutgoingMessage(topic="alpha", payload=b"hi", id="id-1"))
+
+    assert len(calls) == 1
+    call = calls[0]
+    assert call["url"] == "https://example.test/alpha"
+    assert call["headers"]["Content-Type"] == "application/json"
+    assert call["headers"]["Idempotency-Key"] == "id-1"
+    decoded = decode_envelope(call["body"])
+    assert decoded.id == "id-1"
+
+
+def test_http_publisher_rejects_non_2xx():
+    def doer(method, url, headers, body):
+        return 500
+
+    publisher = HttpPublisher(
+        HttpPublisherConfig(endpoint="https://example.test/{topic}", doer=doer)
+    )
+    with pytest.raises(ValueError, match="http status 500"):
+        publisher.publish("alpha", OutgoingMessage(topic="alpha", payload=b"hi"))
+
+
+def test_http_subscriber_decodes_body():
+    payload = json.dumps(
+        {
+            "v": "v1",
+            "id": "id",
+            "topic": "alpha",
+            "ts": "2024-01-01T00:00:00Z",
+            "content_type": "text/plain",
+            "payload_b64": "aGVsbG8=",
+            "meta": {},
+        }
+    ).encode()
+
+    seen = {}
+
+    def handler(msg):
+        seen["id"] = msg.id
+
+    subscriber = HttpSubscriber(HttpSubscriberConfig(on_message=handler))
+    subscriber.handle(payload)
+
+    assert seen["id"] == "id"
+
+
+def test_http_subscriber_rejects_invalid_json():
+    subscriber = HttpSubscriber(HttpSubscriberConfig(on_message=lambda msg: None))
+    with pytest.raises(ValueError, match="invalid json"):
+        subscriber.handle("{")