fustor-sender-http 0.8.1__tar.gz

fustor_sender_http-0.8.1/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: fustor-sender-http
+Version: 0.8.1
+Summary: Fustor HTTP Sender - Transport layer for Agent to Fusion communication
+Author-email: Huajin Wang <wanghuajin999@163.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/excelwang/fustor/tree/master/extensions/sender-http
+Project-URL: Bug Tracker, https://github.com/excelwang/fustor/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: fustor-core
+Requires-Dist: fustor-fusion-sdk
+
+# fustor-sender-http
+
+HTTP Sender for Fustor Agent - implements the transport layer for Agent to Fusion communication.
+
+## Overview
+
+This package provides an HTTP-based implementation of the `Sender` transport abstraction. It uses the Fusion SDK client to communicate with Fusion's REST API.
+
+## Installation
+
+```bash
+pip install fustor-sender-http
+```
+
+## Usage
+
+```python
+from fustor_sender_http import HTTPSender
+
+sender = HTTPSender(
+    sender_id="my-sender",
+    endpoint="http://fusion.example.com:8000",
+    credential={"api_key": "your-api-key"}
+)
+
+# Create session
+await sender.connect()
+session = await sender.create_session("my-task-id")
+
+# Send events
+await sender.send_events(events, source_type="message")
+
+# Heartbeat
+await sender.heartbeat()
+
+# Cleanup
+await sender.close()
+```
+
+## Entry Points
+
+This package registers itself as:
+- `fustor.senders:http` - New sender registry
+- `fustor_agent.drivers.senders:fusion` - Legacy sender registry (backward compat)
+
+## Migration from fustor-sender-fusion
+
+The `fustor-sender-fusion` package is deprecated. To migrate:
+
+1. Replace `from fustor_sender_fusion import FusionDriver` with `from fustor_sender_http import HTTPSender`
+2. Update configuration to use `sender` instead of `sender` terminology
+3. The `HTTPSender` class implements the new `Sender` interface but maintains API compatibility

fustor_sender_http-0.8.1/README.md

@@ -0,0 +1,52 @@
+# fustor-sender-http
+
+HTTP Sender for Fustor Agent - implements the transport layer for Agent to Fusion communication.
+
+## Overview
+
+This package provides an HTTP-based implementation of the `Sender` transport abstraction. It uses the Fusion SDK client to communicate with Fusion's REST API.
+
+## Installation
+
+```bash
+pip install fustor-sender-http
+```
+
+## Usage
+
+```python
+from fustor_sender_http import HTTPSender
+
+sender = HTTPSender(
+    sender_id="my-sender",
+    endpoint="http://fusion.example.com:8000",
+    credential={"api_key": "your-api-key"}
+)
+
+# Create session
+await sender.connect()
+session = await sender.create_session("my-task-id")
+
+# Send events
+await sender.send_events(events, source_type="message")
+
+# Heartbeat
+await sender.heartbeat()
+
+# Cleanup
+await sender.close()
+```
+
+## Entry Points
+
+This package registers itself as:
+- `fustor.senders:http` - New sender registry
+- `fustor_agent.drivers.senders:fusion` - Legacy sender registry (backward compat)
+
+## Migration from fustor-sender-fusion
+
+The `fustor-sender-fusion` package is deprecated. To migrate:
+
+1. Replace `from fustor_sender_fusion import FusionDriver` with `from fustor_sender_http import HTTPSender`
+2. Update configuration to use `sender` instead of `sender` terminology
+3. The `HTTPSender` class implements the new `Sender` interface but maintains API compatibility

fustor_sender_http-0.8.1/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["setuptools>=61.0", "setuptools-scm>=8.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "fustor-sender-http"
+dynamic = ["version"]
+description = "Fustor HTTP Sender - Transport layer for Agent to Fusion communication"
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "fustor-core",
+    "fustor-fusion-sdk",
+]
+
+[[project.authors]]
+name = "Huajin Wang"
+email = "wanghuajin999@163.com"
+
+[project.urls]
+Homepage = "https://github.com/excelwang/fustor/tree/master/extensions/sender-http"
+"Bug Tracker" = "https://github.com/excelwang/fustor/issues"
+
+# New entry point for V2 architecture
+[project.entry-points."fustor_agent.drivers.senders"]
+fusion = "fustor_sender_http:HTTPSender"
+
+
+
+[tool.setuptools_scm]
+root = "../.."
+version_scheme = "post-release"
+local_scheme = "dirty-tag"
+
+[tool.setuptools.packages.find]
+where = ["src"]

fustor_sender_http-0.8.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

fustor_sender_http-0.8.1/src/fustor_sender_http/__init__.py

@@ -0,0 +1,233 @@
+"""
+Fustor HTTP Sender - Transport layer for Agent to Fusion communication.
+
+This package implements the HTTP transport protocol for sending events
+from Fustor Agent to Fustor Fusion.
+"""
+try:
+    from ._version import version as __version__
+except ImportError:
+    __version__ = "unknown"
+
+import logging
+from typing import Any, Dict, List, Optional
+
+import httpx
+from fustor_core.transport import Sender
+from fustor_core.exceptions import FusionConnectionError
+from fustor_core.event import EventBase
+from fustor_core.exceptions import SessionObsoletedError
+
+
+class HTTPSender(Sender):
+    """
+    HTTP-based Sender implementation for Fustor.
+    
+    Uses the Fusion SDK client to communicate with Fusion's REST API.
+    """
+    
+    def __init__(
+        self,
+        sender_id: str,
+        endpoint: str,
+        credential: Dict[str, Any],
+        config: Optional[Dict[str, Any]] = None
+    ):
+        super().__init__(sender_id, endpoint, credential, config)
+        self.logger = logging.getLogger(f"fustor.sender.http.{sender_id}")
+        
+        # Lazy import to avoid circular dependency
+        from fustor_fusion_sdk.client import FusionClient
+        
+        api_key = credential.get("key") or credential.get("api_key")
+        
+        # Extended configuration
+        timeout = self.config.get("timeout", 30.0)
+        api_version = self.config.get("api_version", "pipe")
+        
+        self.client = FusionClient(
+            base_url=endpoint, 
+            api_key=api_key,
+            timeout=timeout,
+            api_version=api_version
+        )
+    
+    async def connect(self) -> None:
+        """Establish connection (for HTTP, this is a no-op as we use stateless requests)."""
+        self.logger.debug(f"HTTP Sender {self.id} ready for endpoint {self.endpoint}")
+    
+    async def create_session(
+        self, 
+        task_id: str,
+        source_type: Optional[str] = None,
+        session_timeout_seconds: Optional[int] = None,
+        **kwargs
+    ) -> Dict[str, Any]:
+        """
+        Create a new session with Fusion.
+        
+        Args:
+            task_id: Identifier for this sync task
+            source_type: Type of source
+            session_timeout_seconds: Requested timeout
+            
+        Returns:
+            Session metadata including session_id, timeout, role
+        """
+        self.logger.info(f"Creating session for task {task_id}...")
+        try:
+            session_data = await self.client.create_session(
+                task_id, 
+                source_type=source_type,
+                session_timeout_seconds=session_timeout_seconds,
+                client_info=kwargs
+            )
+            
+            if session_data and session_data.get("session_id"):
+                session_id = session_data["session_id"]
+                self.session_id = session_id
+                self.logger.info(
+                    f"Session created: {self.session_id}, "
+                    f"Role: {session_data.get('role')}, "
+                    f"Timeout: {session_data.get('session_timeout_seconds')}s"
+                )
+                return session_id, session_data
+            else:
+                # Should not happen if client raises exception on error, but handling just in case
+                self.logger.error("Failed to create session: Empty response.")
+                raise RuntimeError("Failed to create session with Fusion service: Empty response.")
+
+        except httpx.ConnectError as e:
+            self.logger.warning(f"Failed to create session (Connection Error): {e}")
+            raise FusionConnectionError(f"Failed to create session with Fusion service: {e}") from e
+        except httpx.HTTPStatusError as e:
+            self.logger.error(f"Failed to create session: HTTP {e.response.status_code} - {e.response.text}")
+            raise RuntimeError(f"Failed to create session with Fusion service: HTTP {e.response.status_code} - {e.response.text}") from e
+        except Exception as e:
+            self.logger.error(f"Failed to create session: {e!r}")
+            raise RuntimeError(f"Failed to create session with Fusion service: {e}") from e
+    
+    async def _send_events_impl(
+        self, 
+        events: List[EventBase], 
+        source_type: str = "message",
+        is_end: bool = False,
+        metadata: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """
+        Implementation of sending events to Fusion.
+        Called by the base class template method.
+        """
+        if not self.session_id:
+            self.logger.error("Cannot send events: session_id is not set.")
+            return {"success": False, "error": "No session"}
+        
+        # Convert events to dictionaries for JSON serialization
+        event_dicts = []
+        for event in events:
+            if hasattr(event, 'model_dump'):
+                event_dicts.append(event.model_dump(mode='json'))
+            elif isinstance(event, dict):
+                event_dicts.append(event)
+            else:
+                event_dicts.append(dict(event))
+        
+        total_rows = sum(len(e.get("rows", [])) for e in event_dicts)
+        self.logger.debug(f"[{source_type}] Attempting to push {len(events)} events ({total_rows} rows) to {self.endpoint}")
+        
+        try:
+            success = await self.client.push_events(
+                session_id=self.session_id,
+                events=event_dicts,
+                source_type=source_type,
+                is_snapshot_end=is_end,
+                metadata=metadata
+            )
+            
+            if success:
+                self.logger.info(f"[{source_type}] Sent {len(events)} events ({total_rows} rows).")
+                return {"success": True}
+            else:
+                self.logger.error(f"[{source_type}] Failed to send {len(events)} events.")
+                return {"success": False, "error": "Push failed"}
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code == 419:
+                raise SessionObsoletedError(f"Session {self.session_id} is obsolete (419)")
+            self.logger.error(f"[{source_type}] Failed to send {len(events)} events: {e}")
+            return {"success": False, "error": f"Push failed: {e}"}
+        except Exception as e:
+            self.logger.error(f"[{source_type}] Failed to send {len(events)} events: {e}")
+            return {"success": False, "error": "Push failed"}
+    
+    async def heartbeat(self, can_realtime: bool = False) -> Dict[str, Any]:
+        """
+        Send a heartbeat to maintain session.
+        
+        Returns:
+            Response including current role status
+        """
+        if not self.session_id:
+            self.logger.error("Cannot send heartbeat: session_id is not set.")
+            return {"status": "error", "message": "Session ID not set"}
+        
+        try:
+            result = await self.client.send_heartbeat(self.session_id, can_realtime=can_realtime)
+            
+            if result and result.get("status") == "ok":
+                self.logger.debug("Heartbeat sent successfully.")
+                return result
+            else:
+                msg = result.get("message") if result else "Unknown error"
+                # Fallback: some legacy or non-FastAPI paths might still return 200 with error body
+                if result and result.get("status") == "error":
+                     raise SessionObsoletedError(f"Session {self.session_id} is no longer valid: {msg}")
+                return {"status": "error", "message": msg}
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code == 419:
+                raise SessionObsoletedError(f"Session {self.session_id} is obsolete (419)")
+            self.logger.error(f"Failed to send heartbeat: {e}")
+            return {"status": "error", "message": f"Heartbeat failed: {e}"}
+    
+    async def close_session(self) -> None:
+        """Close the current session gracefully."""
+        if self.session_id:
+            try:
+                await self.client.terminate_session(self.session_id)
+                self.logger.info(f"Session {self.session_id} terminated.")
+            except Exception as e:
+                self.logger.warning(f"Failed to terminate session: {e}")
+            finally:
+                self.session_id = None
+    
+    async def close(self) -> None:
+        """Close the sender and release resources."""
+        await self.close_session()
+        if hasattr(self.client, 'close'):
+            await self.client.close()
+    
+    # --- Consistency signals ---
+    
+    async def signal_audit_start(self) -> bool:
+        """Signal the start of an audit cycle."""
+        return await self.client.signal_audit_start(self.id)
+    
+    async def signal_audit_end(self) -> bool:
+        """Signal the end of an audit cycle."""
+        return await self.client.signal_audit_end(self.id)
+    
+    async def get_sentinel_tasks(self) -> Optional[Dict[str, Any]]:
+        """Query for sentinel verification tasks."""
+        try:
+            return await self.client.get_sentinel_tasks()
+        except Exception as e:
+            self.logger.debug(f"Failed to get sentinel tasks: {e}")
+            return None
+    
+    async def submit_sentinel_results(self, results: Dict[str, Any]) -> bool:
+        """Submit sentinel verification results."""
+        try:
+            return await self.client.submit_sentinel_feedback(results)
+        except Exception as e:
+            self.logger.error(f"Failed to submit sentinel results: {e}")
+            return False
+

fustor_sender_http-0.8.1/src/fustor_sender_http.egg-info/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: fustor-sender-http
+Version: 0.8.1
+Summary: Fustor HTTP Sender - Transport layer for Agent to Fusion communication
+Author-email: Huajin Wang <wanghuajin999@163.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/excelwang/fustor/tree/master/extensions/sender-http
+Project-URL: Bug Tracker, https://github.com/excelwang/fustor/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: fustor-core
+Requires-Dist: fustor-fusion-sdk
+
+# fustor-sender-http
+
+HTTP Sender for Fustor Agent - implements the transport layer for Agent to Fusion communication.
+
+## Overview
+
+This package provides an HTTP-based implementation of the `Sender` transport abstraction. It uses the Fusion SDK client to communicate with Fusion's REST API.
+
+## Installation
+
+```bash
+pip install fustor-sender-http
+```
+
+## Usage
+
+```python
+from fustor_sender_http import HTTPSender
+
+sender = HTTPSender(
+    sender_id="my-sender",
+    endpoint="http://fusion.example.com:8000",
+    credential={"api_key": "your-api-key"}
+)
+
+# Create session
+await sender.connect()
+session = await sender.create_session("my-task-id")
+
+# Send events
+await sender.send_events(events, source_type="message")
+
+# Heartbeat
+await sender.heartbeat()
+
+# Cleanup
+await sender.close()
+```
+
+## Entry Points
+
+This package registers itself as:
+- `fustor.senders:http` - New sender registry
+- `fustor_agent.drivers.senders:fusion` - Legacy sender registry (backward compat)
+
+## Migration from fustor-sender-fusion
+
+The `fustor-sender-fusion` package is deprecated. To migrate:
+
+1. Replace `from fustor_sender_fusion import FusionDriver` with `from fustor_sender_http import HTTPSender`
+2. Update configuration to use `sender` instead of `sender` terminology
+3. The `HTTPSender` class implements the new `Sender` interface but maintains API compatibility

fustor_sender_http-0.8.1/src/fustor_sender_http.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+src/fustor_sender_http/__init__.py
+src/fustor_sender_http.egg-info/PKG-INFO
+src/fustor_sender_http.egg-info/SOURCES.txt
+src/fustor_sender_http.egg-info/dependency_links.txt
+src/fustor_sender_http.egg-info/entry_points.txt
+src/fustor_sender_http.egg-info/requires.txt
+src/fustor_sender_http.egg-info/top_level.txt
+tests/test_http_sender.py

fustor_sender_http-0.8.1/src/fustor_sender_http.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

fustor_sender_http-0.8.1/src/fustor_sender_http.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[fustor_agent.drivers.senders]
+fusion = fustor_sender_http:HTTPSender

fustor_sender_http-0.8.1/src/fustor_sender_http.egg-info/requires.txt

@@ -0,0 +1,2 @@
+fustor-core
+fustor-fusion-sdk

fustor_sender_http-0.8.1/src/fustor_sender_http.egg-info/top_level.txt

@@ -0,0 +1 @@
+fustor_sender_http

fustor_sender_http-0.8.1/tests/test_http_sender.py

@@ -0,0 +1,108 @@
+import pytest
+from unittest.mock import AsyncMock, MagicMock, patch
+from fustor_sender_http import HTTPSender
+from fustor_core.event import EventBase
+from fustor_core.exceptions import SessionObsoletedError
+import httpx
+
+class MockEvent(EventBase):
+    def model_dump(self, mode=None):
+        return {"id": 1, "data": "test"}
+
+@pytest.fixture
+def mock_fusion_client():
+    with patch("fustor_fusion_sdk.client.FusionClient") as MockClient:
+        client_instance = MockClient.return_value
+        client_instance.create_session = AsyncMock()
+        client_instance.push_events = AsyncMock()
+        client_instance.send_heartbeat = AsyncMock()
+        client_instance.terminate_session = AsyncMock()
+        client_instance.signal_audit_start = AsyncMock()
+        client_instance.signal_audit_end = AsyncMock()
+        yield client_instance
+
+@pytest.fixture
+def sender(mock_fusion_client):
+    credential = {"api_key": "test-key"}
+    return HTTPSender("test-sender", "http://localhost", credential)
+
+@pytest.mark.asyncio
+async def test_init(sender, mock_fusion_client):
+    assert sender.id == "test-sender"
+    assert sender.credential["api_key"] == "test-key"
+    # Verify client init happened (implicitly via fixture)
+
+@pytest.mark.asyncio
+async def test_create_session(sender, mock_fusion_client):
+    mock_fusion_client.create_session.return_value = {
+        "session_id": "sess-1",
+        "role": "leader",
+        "session_timeout_seconds": 60
+    }
+    
+    session_id, result = await sender.create_session("task-1", "snapshot", 60)
+    
+    assert result["session_id"] == "sess-1"
+    assert session_id == "sess-1"
+    assert sender.session_id == "sess-1"
+    mock_fusion_client.create_session.assert_called_once_with("task-1", source_type="snapshot", session_timeout_seconds=60, client_info={})
+
+@pytest.mark.asyncio
+async def test_create_session_failure(sender, mock_fusion_client):
+    mock_fusion_client.create_session.return_value = None
+    
+    with pytest.raises(RuntimeError, match="Failed to create session"):
+        await sender.create_session("task-1")
+
+@pytest.mark.asyncio
+async def test_send_events_success(sender, mock_fusion_client):
+    sender.session_id = "sess-1"
+    mock_fusion_client.push_events.return_value = True
+    events = [{"event_type": "INSERT", "table": "t", "rows": []}]
+    
+    result = await sender._send_events_impl(events, "message", False)
+    
+    assert result["success"] is True
+    mock_fusion_client.push_events.assert_called_once()
+    args, kwargs = mock_fusion_client.push_events.call_args
+    assert kwargs["session_id"] == "sess-1"
+    assert len(kwargs["events"]) == 1
+
+@pytest.mark.asyncio
+async def test_send_events_no_session(sender):
+    # No session_id set
+    result = await sender._send_events_impl([], "message")
+    assert result["success"] is False
+    assert result["error"] == "No session"
+
+@pytest.mark.asyncio
+async def test_send_events_obsolete_session(sender, mock_fusion_client):
+    sender.session_id = "sess-1"
+    # Simulate 419 error
+    request = httpx.Request("POST", "http://locahost")
+    response = httpx.Response(419, request=request)
+    mock_fusion_client.push_events.side_effect = httpx.HTTPStatusError("obsolete", request=request, response=response)
+    
+    with pytest.raises(SessionObsoletedError):
+        await sender._send_events_impl([{"event_type": "INSERT", "table": "t", "rows": []}])
+
+@pytest.mark.asyncio
+async def test_heartbeat_success(sender, mock_fusion_client):
+    sender.session_id = "sess-1"
+    mock_fusion_client.send_heartbeat.return_value = {"status": "ok", "role": "follower"}
+    
+    result = await sender.heartbeat()
+    
+    assert result["status"] == "ok"
+    mock_fusion_client.send_heartbeat.assert_called_once_with("sess-1", can_realtime=False)
+
+@pytest.mark.asyncio
+async def test_audit_signals(sender, mock_fusion_client):
+    mock_fusion_client.signal_audit_start.return_value = True
+    mock_fusion_client.signal_audit_end.return_value = True
+    
+    assert await sender.signal_audit_start() is True
+    assert await sender.signal_audit_end() is True
+    
+    mock_fusion_client.signal_audit_start.assert_called_once_with("test-sender")
+    mock_fusion_client.signal_audit_end.assert_called_once_with("test-sender")