cgse-core 0.17.2__py3-none-any.whl → 0.17.4__py3-none-any.whl

egse/confman/confman_acs.py

@@ -1,35 +0,0 @@
-import multiprocessing
-
-from egse.async_control import AsyncControlServer
-from egse.confman import AsyncConfigurationManagerProtocol
-from egse.log import logging
-from egse.settings import Settings
-
-logger = logging.getLogger("egse.confman")
-
-settings = Settings.load("Configuration Manager Control Server")
-
-PROCESS_NAME = "cm_acs"
-
-
-class AsyncConfigurationManager(AsyncControlServer):
-    def __init__(self):
-        multiprocessing.current_process().name = PROCESS_NAME
-
-        super().__init__()
-
-        self.logger = logger
-        self.service_name = PROCESS_NAME
-        self.service_type = settings.SERVICE_TYPE
-
-        self.device_protocol = AsyncConfigurationManagerProtocol(self)
-
-        self.logger.debug(f"Binding ZeroMQ socket to {self.device_protocol.get_bind_address()}")
-
-        self.device_protocol.bind(self.dev_ctrl_cmd_sock)
-
-        self.poller.register(self.dev_ctrl_cmd_sock, zmq.POLLIN)
-
-        self.set_hk_delay(10.0)
-
-        self.logger.info(f"CM housekeeping saved every {self.hk_delay / 1000:.1f} seconds.")

egse/metricshub/server.py

@@ -1,271 +0,0 @@
-# async_gateway.py
-import asyncio
-import time
-from datetime import datetime
-
-import zmq
-import zmq.asyncio
-from influxdb_client_3 import InfluxDBClient3
-from influxdb_client_3 import Point
-
-
-class AsyncMetricsHub:
-    def __init__(
-        self,
-        influx_client,  # FIXME: should be a plugin
-        zmq_endpoint="tcp://*:5555",  # FIXME: should also come from a plugin
-        batch_size=500,
-        flush_interval=2.0,
-    ):
-        self.influx_client = influx_client
-        self.batch_size = batch_size
-        self.flush_interval = flush_interval
-
-        # AsyncIO ZeroMQ context
-        self.context = zmq.asyncio.Context()
-        self.socket = self.context.socket(zmq.PULL)
-        self.socket.bind(zmq_endpoint)
-
-        # Configure socket
-        self.socket.setsockopt(zmq.RCVHWM, 10000)
-
-        # AsyncIO queue for data points
-        self.data_queue = asyncio.Queue(maxsize=10000)
-
-        # Stats
-        self.stats = {"received": 0, "written": 0, "errors": 0, "queue_size": 0}
-
-        print(f"🚀 AsyncIO Gateway listening on {zmq_endpoint}")
-
-    async def start(self):
-        """Start the gateway with concurrent tasks"""
-        try:
-            # Run receiver and batch processor concurrently
-            await asyncio.gather(
-                self._receive_data(), self._batch_processor(), self._stats_reporter(), return_exceptions=True
-            )
-        except Exception as e:
-            print(f"❌ Gateway error: {e}")
-        finally:
-            await self._cleanup()
-
-    async def _receive_data(self):
-        """Receive data from ZeroMQ and add to queue"""
-        print("📡 Starting data receiver...")
-
-        while True:
-            try:
-                # Receive message (non-blocking with timeout)
-                message = await self.socket.recv_json()
-
-                # Process message
-                point = await self._process_message(message)
-                if point:
-                    # Add to queue (non-blocking)
-                    try:
-                        await asyncio.wait_for(self.data_queue.put(point), timeout=0.1)
-                        self.stats["received"] += 1
-                    except asyncio.TimeoutError:
-                        # Queue full, drop point
-                        self.stats["errors"] += 1
-                        print("⚠️ Queue full, dropping point")
-
-            except Exception as e:
-                print(f"❌ Error receiving data: {e}")
-                self.stats["errors"] += 1
-                await asyncio.sleep(0.1)
-
-    async def _process_message(self, message):
-        """Process incoming message asynchronously"""
-        try:
-            # Validate message
-            if "device_id" not in message or "data" not in message:
-                return None
-
-            # Create InfluxDB point
-            point = Point("sensor_data")
-            point.tag("device_id", message["device_id"])
-
-            # Add timestamp
-            if "timestamp" in message:
-                point.time(message["timestamp"])
-
-            # Add sensor data
-            sensor_data = message["data"]
-            for key, value in sensor_data.items():
-                if isinstance(value, (int, float)):
-                    point.field(key, value)
-                else:
-                    point.tag(key, str(value))
-
-            return point
-
-        except Exception as e:
-            print(f"❌ Error processing message: {e}")
-            return None
-
-    async def _batch_processor(self):
-        """Batch processor using asyncio"""
-        print("📦 Starting batch processor...")
-
-        batch = []
-        last_flush = time.time()
-
-        while True:
-            try:
-                # Try to get data points for batch
-                timeout = max(0.1, self.flush_interval - (time.time() - last_flush))
-
-                try:
-                    # Get point with timeout
-                    point = await asyncio.wait_for(self.data_queue.get(), timeout=timeout)
-                    batch.append(point)
-
-                except asyncio.TimeoutError:
-                    # No data received, check if we should flush anyway
-                    pass
-
-                # Update queue size stat
-                self.stats["queue_size"] = self.data_queue.qsize()
-
-                # Check flush conditions
-                should_flush = len(batch) >= self.batch_size or (
-                    batch and time.time() - last_flush >= self.flush_interval
-                )
-
-                if should_flush and batch:
-                    await self._flush_batch(batch)
-                    batch.clear()
-                    last_flush = time.time()
-
-            except Exception as e:
-                print(f"❌ Batch processor error: {e}")
-                await asyncio.sleep(1)
-
-    async def _flush_batch(self, batch):
-        """Flush batch to InfluxDB asynchronously"""
-        if not batch:
-            return
-
-        try:
-            start_time = time.time()
-
-            # Run InfluxDB write in thread pool to avoid blocking
-            loop = asyncio.get_event_loop()
-            await loop.run_in_executor(None, self.influx_client.write, batch)
-
-            write_time = time.time() - start_time
-            self.stats["written"] += len(batch)
-
-            points_per_second = len(batch) / write_time if write_time > 0 else 0
-            print(f"✅ Wrote {len(batch)} points ({points_per_second:.0f} pts/s)")
-
-        except Exception as e:
-            print(f"❌ Failed to write batch: {e}")
-            self.stats["errors"] += len(batch)
-
-    async def _stats_reporter(self):
-        """Periodic stats reporting"""
-        while True:
-            await asyncio.sleep(10)  # Report every 10 seconds
-            print(
-                f"📊 Stats: Received={self.stats['received']}, "
-                f"Written={self.stats['written']}, "
-                f"Queue={self.stats['queue_size']}, "
-                f"Errors={self.stats['errors']}"
-            )
-
-    async def _cleanup(self):
-        """Cleanup resources"""
-        print("🧹 Cleaning up...")
-
-        # Flush remaining data
-        remaining_batch = []
-        while not self.data_queue.empty():
-            try:
-                point = await asyncio.wait_for(self.data_queue.get(), timeout=0.1)
-                remaining_batch.append(point)
-            except asyncio.TimeoutError:
-                break
-
-        if remaining_batch:
-            await self._flush_batch(remaining_batch)
-
-        self.socket.close()
-        self.context.term()
-        print("✅ Cleanup complete")
-
-
-# Device process (also async)
-class AsyncDeviceDataSender:
-    def __init__(self, gateway_endpoint="tcp://localhost:5555", device_id="device_001"):
-        self.device_id = device_id
-        self.context = zmq.asyncio.Context()
-        self.socket = self.context.socket(zmq.PUSH)
-        self.socket.connect(gateway_endpoint)
-        self.socket.setsockopt(zmq.LINGER, 0)
-        self.socket.setsockopt(zmq.SNDHWM, 1000)
-
-    async def send_data_point(self, sensor_data):
-        """Send data point asynchronously"""
-        message = {"device_id": self.device_id, "timestamp": datetime.utcnow().isoformat(), "data": sensor_data}
-
-        try:
-            await self.socket.send_json(message, flags=zmq.NOBLOCK)
-            return True
-        except zmq.Again:
-            # Queue full
-            return False
-
-    async def close(self):
-        self.socket.close()
-        self.context.term()
-
-
-# Usage examples
-async def device_data_loop():
-    """Example device data collection loop"""
-    sender = AsyncDeviceDataSender(device_id="sensor_001")
-
-    try:
-        while True:
-            # Your sensor reading logic here
-            sensor_data = {
-                "temperature": 23.5 + (time.time() % 10),  # Mock data
-                "humidity": 45.0 + (time.time() % 5),
-                "pressure": 1013.25,
-            }
-
-            success = await sender.send_data_point(sensor_data)
-            if not success:
-                print("⚠️ Failed to send data point")
-
-            await asyncio.sleep(0.1)  # 10Hz
-
-    except KeyboardInterrupt:
-        print("🛑 Stopping device loop...")
-    finally:
-        await sender.close()
-
-
-async def run_gateway():
-    """Run the gateway service"""
-    # Initialize InfluxDB client
-    influx_client = InfluxDBClient3(host="your-influxdb-host", token="your-token", database="your-database")
-
-    gateway = AsyncInfluxGateway(influx_client=influx_client, batch_size=250, flush_interval=1.0)
-
-    await gateway.start()
-
-
-# Main execution
-if __name__ == "__main__":
-    try:
-        # Run gateway
-        asyncio.run(run_gateway())
-
-        # Or run device simulator
-        # asyncio.run(device_data_loop())
-
-    except KeyboardInterrupt:
-        print("👋 Goodbye!")

egse/notifyhub/test.py

@@ -1,303 +0,0 @@
-import asyncio
-import logging
-import random
-import time
-import uuid
-
-import pytest
-
-from .services import ServiceMessaging
-
-
-class UserService:
-    def __init__(self):
-        # Compose with messaging capability
-        self.messaging = ServiceMessaging("user-service")
-        self.users = {}  # Simple in-memory store
-        self.logger = logging.getLogger("egse.user-service")
-
-    async def create_user(self, email: str, name: str) -> str:
-        """Create a user and publish event"""
-        user_id = str(uuid.uuid4())
-
-        # Business logic
-        user_data = {"id": user_id, "email": email, "name": name, "created_at": time.time()}
-        self.users[user_id] = user_data
-
-        self.logger.info(f"Created user: {name} ({email})")
-
-        # Publish event
-        await self.messaging.publish_event("user_created", {"user_id": user_id, "email": email, "name": name})
-
-        return user_id
-
-    async def update_user(self, user_id: str, updates: dict):
-        """Update user and publish event"""
-        if user_id not in self.users:
-            raise ValueError("User not found")
-
-        # Business logic
-        self.users[user_id].update(updates)
-
-        # Publish event
-        await self.messaging.publish_event("user_updated", {"user_id": user_id, "updates": updates})
-
-    async def close(self):
-        await self.messaging.disconnect()
-
-
-class EmailService:
-    def __init__(self):
-        # Compose with messaging capability - subscribe to events we care about
-        self.messaging = ServiceMessaging(
-            "email-service", subscriptions=["user_created", "user_updated", "order_placed"]
-        )
-
-        # Register handlers
-        self.messaging.register_handler("user_created", self.handle_user_created)
-        self.messaging.register_handler("user_updated", self.handle_user_updated)
-        self.messaging.register_handler("order_placed", self.handle_order_placed)
-
-        self.logger = logging.getLogger("egse.email-service")
-
-    async def handle_user_created(self, event_data: dict):
-        """Handle new user creation"""
-        user_data = event_data["data"]
-        email = user_data["email"]
-        name = user_data["name"]
-
-        self.logger.info(f"Sending welcome email to {name}")
-
-        # Simulate email sending
-        await self._send_email(to=email, subject="Welcome!", template="welcome", data={"name": name})
-
-    async def handle_user_updated(self, event_data: dict):
-        """Handle user updates"""
-        user_data = event_data["data"]
-        user_id = user_data["user_id"]
-
-        self.logger.info(f"User {user_id} was updated")
-        # Could send update notification email
-
-    async def handle_order_placed(self, event_data: dict):
-        """Handle order placement"""
-        order_data = event_data["data"]
-        customer_email = order_data["customer_email"]
-        order_id = order_data["order_id"]
-
-        await self._send_email(
-            to=customer_email, subject="Order Confirmation", template="order_confirmation", data={"order_id": order_id}
-        )
-
-    async def _send_email(self, to: str, subject: str, template: str, data: dict):
-        """Simulate sending email"""
-        await asyncio.sleep(0.1)  # Simulate network delay
-        self.logger.info(f"✉️  Sent '{subject}' to {to}")
-
-    async def start(self):
-        """Start listening for events"""
-        await self.messaging.start_listening()
-
-    async def close(self):
-        await self.messaging.disconnect()
-
-
-# Order Service - both publishes and subscribes
-class OrderService:
-    def __init__(self):
-        # This service both publishes and subscribes
-        self.messaging = ServiceMessaging(
-            "order-service",
-            subscriptions=["user_created"],  # Maybe we want to track new users
-        )
-
-        # Register handlers
-        self.messaging.register_handler("user_created", self.handle_new_user)
-
-        self.orders = {}
-        self.user_orders = {}  # Track orders per user
-        self.logger = logging.getLogger("egse.order-service")
-
-    async def handle_new_user(self, event_data: dict):
-        """Handle new user - could send promo code"""
-        user_data = event_data["data"]
-        user_id = user_data["user_id"]
-
-        self.user_orders[user_id] = []
-        self.logger.info(f"Tracking new user: {user_id}")
-
-    async def place_order(self, user_id: str, items: list[dict], customer_email: str):
-        """Place an order and publish event"""
-        order_id = str(uuid.uuid4())
-
-        # Business logic
-        order_data = {
-            "id": order_id,
-            "user_id": user_id,
-            "items": items,
-            "customer_email": customer_email,
-            "total": sum(item["price"] * item["quantity"] for item in items),
-            "created_at": time.time(),
-        }
-
-        self.orders[order_id] = order_data
-
-        if user_id in self.user_orders:
-            self.user_orders[user_id].append(order_id)
-
-        self.logger.info(f"Order placed: {order_id} for user {user_id}")
-
-        # Publish event
-        await self.messaging.publish_event(
-            "order_placed",
-            {"order_id": order_id, "user_id": user_id, "customer_email": customer_email, "total": order_data["total"]},
-        )
-
-        return order_id
-
-    async def start(self):
-        """Start listening for events"""
-        await self.messaging.start_listening()
-
-    async def close(self):
-        await self.messaging.disconnect()
-
-
-# Analytics Service - subscribes to multiple events
-class AnalyticsService:
-    def __init__(self):
-        self.messaging = ServiceMessaging(
-            "analytics-service", subscriptions=["user_created", "order_placed", "user_updated"]
-        )
-
-        # Register handlers
-        self.messaging.register_handler("user_created", self.track_user_signup)
-        self.messaging.register_handler("order_placed", self.track_order)
-        self.messaging.register_handler("user_updated", self.track_user_update)
-
-        self.metrics = {"users_created": 0, "orders_placed": 0, "total_revenue": 0.0}
-        self.logger = logging.getLogger("egse.analytics-service")
-
-    async def track_user_signup(self, event_data: dict):
-        """Track user signup"""
-        self.metrics["users_created"] += 1
-        self.logger.info(f"📊 Users created: {self.metrics['users_created']}")
-
-    async def track_order(self, event_data: dict):
-        """Track order placement"""
-        order_data = event_data["data"]
-        total = order_data["total"]
-
-        self.metrics["orders_placed"] += 1
-        self.metrics["total_revenue"] += total
-
-        self.logger.info(f"📊 Orders: {self.metrics['orders_placed']}, Revenue: ${self.metrics['total_revenue']:.2f}")
-
-    async def track_user_update(self, event_data: dict):
-        """Track user updates"""
-        self.logger.info("📊 User update tracked")
-
-    async def start(self):
-        await self.messaging.start_listening()
-
-    async def close(self):
-        await self.messaging.disconnect()
-
-
-async def run_microservices_demo():
-    """Run the complete microservices system"""
-
-    # Create services
-    user_service = UserService()
-    email_service = EmailService()
-    order_service = OrderService()
-    analytics_service = AnalyticsService()
-
-    # Start subscriber services
-    tasks = [
-        asyncio.create_task(email_service.start()),
-        asyncio.create_task(order_service.start()),
-        asyncio.create_task(analytics_service.start()),
-    ]
-
-    # Demo scenario
-    async def demo_workflow():
-        await asyncio.sleep(1)  # Let services connect
-
-        # Create some users
-        user1_id = await user_service.create_user("alice@example.com", "Alice Smith")
-        user2_id = await user_service.create_user("bob@example.com", "Bob Jones")
-
-        await asyncio.sleep(0.5)
-
-        # Place some orders
-        await order_service.place_order(
-            user1_id, [{"name": "Widget", "price": 29.99, "quantity": 2}], "alice@example.com"
-        )
-
-        await order_service.place_order(
-            user2_id, [{"name": "Gadget", "price": 19.99, "quantity": 1}], "bob@example.com"
-        )
-
-        await asyncio.sleep(0.5)
-
-        # Update a user
-        await user_service.update_user(user1_id, {"name": "Alice Johnson"})
-
-        await asyncio.sleep(2)
-
-        # Stress test, send hundreds of notifications
-
-        for x in range(100):
-            # Place some orders
-            await order_service.place_order(
-                user1_id,
-                [{"name": "Widget", "price": 29.99 + x * 3.14, "quantity": random.choice([1, 2, 3, 4])}],
-                "alice@example.com",
-            )
-
-            await order_service.place_order(
-                user2_id,
-                [{"name": "Gadget", "price": 19.99 + x * 1.23, "quantity": random.choice([1, 2, 3, 4])}],
-                "bob@example.com",
-            )
-
-        # Cleanup
-        await user_service.close()
-        await email_service.close()
-        await order_service.close()
-        await analytics_service.close()
-
-    async def _cleanup_running_tasks():
-        # Cancel all running tasks
-        for task in tasks:
-            if not task.done():
-                print(f"Cancelling task {task.get_name()}.")
-                task.cancel()
-
-        # Wait for tasks to complete their cancellation
-        if tasks:
-            try:
-                await asyncio.gather(*tasks, return_exceptions=True)
-            except asyncio.CancelledError as exc:
-                print(f"Caught {type(exc).__name__}: {exc}.")
-                pass
-
-    tasks.append(asyncio.create_task(demo_workflow()))
-
-    try:
-        await asyncio.gather(*tasks)
-    except KeyboardInterrupt:
-        print("Shutting down...")
-
-    await _cleanup_running_tasks()
-
-
-@pytest.mark.asyncio
-def test_notify_hub(): ...
-
-
-if __name__ == "__main__":
-    from egse.logger import setup_logging
-
-    asyncio.run(run_microservices_demo())