matrice-inference 0.1.2__py3-none-any.whl

matrice_inference/server/stream/app_deployment.py

@@ -0,0 +1,228 @@
+
+from typing import Dict, List, Optional
+import time
+import logging
+from matrice_common.session import Session
+from matrice_inference.server.stream.utils import CameraConfig
+
+
+class AppDeployment:
+    """Handles app deployment configuration and camera setup for streaming pipeline."""
+    
+    def __init__(self, session: Session, app_deployment_id: str, connection_timeout: int = 1200):  # Increased from 300 to 1200
+        self.app_deployment_id = app_deployment_id
+        self.rpc = session.rpc
+        self.session = session
+        self.connection_timeout = connection_timeout
+        self.logger = logging.getLogger(__name__)
+    
+    def get_input_topics(self) -> List[Dict]:
+        """Get input topics for the app deployment."""
+        try:
+            response = self.rpc.get(f"/v1/inference/get_input_topics_by_app_deployment_id/{self.app_deployment_id}")
+            if response.get("success", False):
+                return response.get("data", [])
+            else:
+                self.logger.error(f"Failed to get input topics: {response.get('message', 'Unknown error')}")
+                return []
+        except Exception as e:
+            self.logger.error(f"Exception getting input topics: {str(e)}")
+            return []
+    
+    def get_output_topics(self) -> List[Dict]:
+        """Get output topics for the app deployment."""
+        try:
+            response = self.rpc.get(f"/v1/inference/get_output_topics_by_app_deployment_id/{self.app_deployment_id}")
+            if response.get("success", False):
+                return response.get("data", [])
+            else:
+                self.logger.error(f"Failed to get output topics: {response.get('message', 'Unknown error')}")
+                return []
+        except Exception as e:
+            self.logger.error(f"Exception getting output topics: {str(e)}")
+            return []
+    
+    def get_camera_configs(self) -> Dict[str, CameraConfig]:
+        """
+        Get camera configurations for the streaming pipeline.
+        
+        Returns:
+            Dict[str, CameraConfig]: Dictionary mapping camera_id to CameraConfig
+        """
+        camera_configs = {}
+        
+        try:
+            # Get input and output topics
+            input_topics = self.get_input_topics()
+            output_topics = self.get_output_topics()
+            
+            if not input_topics:
+                self.logger.warning("No input topics found for app deployment")
+                return camera_configs
+            
+            # Create mapping of camera_id to output topic
+            output_topic_map = {}
+            for output_topic in output_topics:
+                camera_id = output_topic.get("cameraId")
+                if camera_id:
+                    output_topic_map[camera_id] = output_topic
+            
+            # Process each input topic to create camera config
+            for input_topic in input_topics:
+                try:
+                    camera_id = input_topic.get("cameraId")
+                    if not camera_id:
+                        self.logger.warning("Input topic missing camera ID, skipping")
+                        continue
+                    
+                    # Get corresponding output topic
+                    output_topic = output_topic_map.get(camera_id)
+                    if not output_topic:
+                        self.logger.warning(f"No output topic found for camera {camera_id}, skipping")
+                        continue
+                    
+                    # Get connection info for this server
+                    server_id = input_topic.get("serverId")
+                    server_type = input_topic.get("serverType", "redis").lower()
+                    
+                    if not server_id:
+                        self.logger.warning(f"No server ID found for camera {camera_id}, skipping")
+                        continue
+                    
+                    connection_info = self.get_and_wait_for_connection_info(server_type, server_id)
+                    if not connection_info:
+                        self.logger.error(f"Could not get connection info for camera {camera_id}, skipping")
+                        continue
+                    
+                    # Create stream config
+                    stream_config = connection_info.copy()
+                    stream_config["stream_type"] = server_type
+                    
+                    # Create camera config
+                    camera_config = CameraConfig(
+                        camera_id=camera_id,
+                        input_topic=input_topic.get("topicName"),
+                        output_topic=output_topic.get("topicName"),
+                        stream_config=stream_config,
+                        enabled=True
+                    )
+                    
+                    camera_configs[camera_id] = camera_config
+                    self.logger.info(f"Created camera config for {camera_id} using {server_type}")
+                    
+                except Exception as e:
+                    self.logger.error(f"Error creating config for camera {camera_id}: {str(e)}")
+                    continue
+            
+            self.logger.info(f"Successfully created {len(camera_configs)} camera configurations")
+            return camera_configs
+            
+        except Exception as e:
+            self.logger.error(f"Error getting camera configs: {str(e)}")
+            return camera_configs
+    
+    def get_and_wait_for_connection_info(self, server_type: str, server_id: str) -> Optional[Dict]:
+        """Get the connection information for the streaming gateway."""
+        def _get_kafka_connection_info():
+            try:
+                response = self.rpc.get(f"/v1/actions/get_kafka_server/{server_id}")
+                if response.get("success", False):
+                    data = response.get("data")
+                    if (
+                        data
+                        and data.get("ipAddress")
+                        and data.get("port")
+                        and data.get("status") == "running"
+                    ):
+                        return {
+                            'bootstrap_servers': f'{data["ipAddress"]}:{data["port"]}',
+                            'sasl_mechanism': 'SCRAM-SHA-256',
+                            'sasl_username': 'matrice-sdk-user',
+                            'sasl_password': 'matrice-sdk-password',
+                            'security_protocol': 'SASL_PLAINTEXT'
+                        }
+                    else:
+                        self.logger.debug("Kafka connection information is not complete, waiting...")
+                        return None
+                else:
+                    self.logger.debug("Failed to get Kafka connection information: %s", response.get("message", "Unknown error"))
+                    return None
+            except Exception as exc:
+                self.logger.debug("Exception getting Kafka connection info: %s", str(exc))
+                return None
+
+        def _get_redis_connection_info():
+            try:
+                response = self.rpc.get(f"/v1/actions/redis_servers/{server_id}")
+                if response.get("success", False):
+                    data = response.get("data")
+                    if (
+                        data
+                        and data.get("host")
+                        and data.get("port")
+                        and data.get("status") == "running"
+                    ):
+                        return {
+                            'host': data["host"],
+                            'port': int(data["port"]),
+                            'password': data.get("password", ""),
+                            'username': data.get("username"),
+                            'db': data.get("db", 0),
+                            'connection_timeout': 120  # Increased from 30 to 120
+                        }
+                    else:
+                        self.logger.debug("Redis connection information is not complete, waiting...")
+                        return None
+                else:
+                    self.logger.debug("Failed to get Redis connection information: %s", response.get("message", "Unknown error"))
+                    return None
+            except Exception as exc:
+                self.logger.debug("Exception getting Redis connection info: %s", str(exc))
+                return None
+
+        start_time = time.time()
+        last_log_time = 0
+        
+        while True:
+            current_time = time.time()
+            
+            # Get connection info based on server type
+            connection_info = None
+            if server_type == "kafka":
+                connection_info = _get_kafka_connection_info()
+            elif server_type == "redis":
+                connection_info = _get_redis_connection_info()
+            else:
+                raise ValueError(f"Unsupported server type: {server_type}")
+            
+            # If we got valid connection info, return it
+            if connection_info:
+                self.logger.info("Successfully retrieved %s connection information", server_type)
+                return connection_info
+            
+            # Check timeout
+            if current_time - start_time > self.connection_timeout:
+                error_msg = f"Timeout waiting for {server_type} connection information after {self.connection_timeout} seconds"
+                self.logger.error(error_msg)
+                
+                # Log the last response for debugging
+                try:
+                    if server_type == "kafka":
+                        response = self.rpc.get(f"/v1/actions/get_kafka_server/{server_id}")
+                    else:
+                        response = self.rpc.get(f"/v1/actions/redis_servers/{server_id}")
+                    self.logger.error("Last response received: %s", response)
+                except Exception as exc:
+                    self.logger.error("Failed to get last response for debugging: %s", str(exc))
+                
+                return None  # Return None instead of raising exception to allow graceful handling
+            
+            # Log waiting message every 10 seconds to avoid spam
+            if current_time - last_log_time >= 10:
+                elapsed = current_time - start_time
+                remaining = self.connection_timeout - elapsed
+                self.logger.info("Waiting for %s connection information... (%.1fs elapsed, %.1fs remaining)", 
+                           server_type, elapsed, remaining)
+                last_log_time = current_time
+            
+            time.sleep(1)

matrice_inference/server/stream/consumer_worker.py

@@ -0,0 +1,201 @@
+# Import moved to method where it's needed to avoid circular imports
+from matrice_inference.server.stream.utils import CameraConfig, StreamMessage
+import asyncio
+import json
+import time
+import logging
+import threading
+import queue
+from datetime import datetime, timezone
+import logging
+
+class ConsumerWorker:
+    """Handles message consumption from streams."""
+    
+    def __init__(self, camera_id: str, worker_id: int, stream_config: dict, input_topic: str,
+                 inference_queue: queue.PriorityQueue, message_timeout: float,
+                 camera_config: CameraConfig):
+        self.camera_id = camera_id
+        self.worker_id = worker_id
+        self.stream_config = stream_config
+        self.input_topic = input_topic
+        self.inference_queue = inference_queue
+        self.message_timeout = message_timeout
+        self.camera_config = camera_config
+        self.running = False
+        self.stream = None  # Will be created in worker thread's event loop
+        self.logger = logging.getLogger(f"{__name__}.consumer.{camera_id}.{worker_id}")
+    
+    def start(self):
+        """Start the consumer worker in a separate thread."""
+        self.running = True
+        thread = threading.Thread(target=self._run, name=f"Consumer-{self.camera_id}-{self.worker_id}", daemon=False)
+        thread.start()
+        return thread
+    
+    def stop(self):
+        """Stop the consumer worker."""
+        self.running = False
+    
+    def _run(self):
+        """Main consumer loop."""
+        # Create a new event loop for this worker thread
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        
+        self.logger.info(f"Started consumer worker for camera {self.camera_id}")
+        
+        try:
+            # Initialize stream in this event loop
+            loop.run_until_complete(self._initialize_stream())
+            
+            while self.running and self.camera_config.enabled:
+                try:
+                    # Get message from stream
+                    message_data = loop.run_until_complete(
+                        self._get_message_safely()
+                    )
+                    
+                    if not message_data:
+                        continue
+                    
+                    # Parse and create task
+                    self._process_message(message_data)
+                        
+                except Exception as e:
+                    self.logger.error(f"Consumer error: {e}")
+                    time.sleep(1.0)
+        
+        finally:
+            # Clean up stream
+            if self.stream:
+                try:
+                    loop.run_until_complete(self.stream.async_close())
+                except Exception as e:
+                    self.logger.error(f"Error closing stream: {e}")
+            loop.close()
+            self.logger.info(f"Consumer worker stopped for camera {self.camera_id}")
+
+    async def _initialize_stream(self):
+        """Initialize MatriceStream in the current event loop."""
+        try:
+            from matrice_common.stream.matrice_stream import MatriceStream, StreamType
+            
+            # Determine stream type
+            stream_type = StreamType.KAFKA if self.stream_config.get("stream_type", "kafka").lower() == "kafka" else StreamType.REDIS
+            
+            # Create stream configuration
+            if stream_type == StreamType.KAFKA:
+                stream_params = {
+                    "bootstrap_servers": self.stream_config.get("bootstrap_servers", "localhost:9092"),
+                    "sasl_username": self.stream_config.get("sasl_username", "matrice-sdk-user"),
+                    "sasl_password": self.stream_config.get("sasl_password", "matrice-sdk-password"),
+                    "sasl_mechanism": self.stream_config.get("sasl_mechanism", "SCRAM-SHA-256"),
+                    "security_protocol": self.stream_config.get("security_protocol", "SASL_PLAINTEXT"),
+                }
+            else:  # Redis
+                stream_params = {
+                    "host": self.stream_config.get("host", "localhost"),
+                    "port": self.stream_config.get("port", 6379),
+                    "password": self.stream_config.get("password"),
+                    "username": self.stream_config.get("username"),
+                    "db": self.stream_config.get("db", 0),
+                    "connection_timeout": self.stream_config.get("connection_timeout", 120),
+                }
+            
+            # Create and setup stream
+            self.stream = MatriceStream(stream_type, **stream_params)
+            await self.stream.async_setup(self.input_topic, f"inference_consumer_{self.camera_id}_{self.worker_id}")
+            # TODO: Add app name to the consumer group id to make sure it processing once only
+            
+            self.logger.info(f"Initialized {stream_type.value} stream for consumer worker {self.worker_id}")
+            
+        except Exception as e:
+            self.logger.error(f"Failed to initialize stream for consumer worker: {e}")
+            raise
+
+    async def _get_message_safely(self):
+        """Safely get message from stream in the current event loop."""
+        try:
+            if not self.stream:
+                self.logger.error("Stream not initialized")
+                return None
+            return await self.stream.async_get_message(self.message_timeout)
+        except Exception as e:
+            # Handle stream issues gracefully
+            self.logger.debug(f"Error getting message from stream: {e}")
+            return None
+    
+    def _process_message(self, message_data):
+        """Process incoming message and add to inference queue."""
+        try:
+            # Parse message data - handle camera streamer format
+            if isinstance(message_data.get("data"), bytes):
+                data = json.loads(message_data["data"].decode("utf-8"))
+            else:
+                data = message_data.get("data", {})
+            
+            # Handle camera streamer input format
+            input_stream = data.get("input_stream", {})
+            if not input_stream:
+                # Fallback to direct format
+                input_stream = data
+            
+            # Create stream message
+            stream_msg = StreamMessage(
+                camera_id=self.camera_id,
+                message_key=message_data.get("key", data.get("input_name", f"{self.camera_id}_{int(time.time())}")),
+                data=data,
+                timestamp=datetime.now(timezone.utc),
+                priority=1
+            )
+            
+            # Ensure extra_params is a dictionary
+            extra_params = data.get("extra_params", {})
+            if not isinstance(extra_params, dict):
+                self.logger.warning(f"extra_params is not a dict, converting from {type(extra_params)}: {extra_params}")
+                if isinstance(extra_params, list):
+                    # Convert list to dict if possible
+                    if len(extra_params) == 0:
+                        extra_params = {}
+                    elif all(isinstance(item, dict) for item in extra_params):
+                        # Merge all dictionaries in the list
+                        merged_params = {}
+                        for item in extra_params:
+                            merged_params.update(item)
+                        extra_params = merged_params
+                    else:
+                        extra_params = {}
+                else:
+                    extra_params = {}
+
+            # Determine frame_id (prefer value from upstream gateway; otherwise fallback to message key)
+            frame_id = data.get("frame_id")
+            if not frame_id:
+                frame_id = message_data.get("key", data.get("input_name", f"{self.camera_id}_{int(time.time() * 1000)}"))
+
+            # Attach frame_id into input_stream for propagation if not present
+            try:
+                if isinstance(input_stream, dict) and "frame_id" not in input_stream:
+                    input_stream["frame_id"] = frame_id
+            except Exception:
+                pass
+
+            # Create inference task with camera streamer format
+            task_data = {
+                "message": stream_msg,
+                "input_stream": input_stream,  # Pass the full input_stream
+                "stream_key": f"{self.camera_id}_{stream_msg.message_key}",
+                "extra_params": extra_params,
+                "camera_config": self.camera_config.__dict__,
+                "frame_id": frame_id
+            }
+            
+            # Add to inference queue with timestamp as tie-breaker for priority queue comparison
+            self.inference_queue.put((stream_msg.priority, time.time(), task_data))
+            
+        except json.JSONDecodeError as e:
+            self.logger.error(f"Failed to parse message JSON: {e}")
+        except Exception as e:
+            self.logger.error(f"Error processing message: {e}")
+

matrice_inference/server/stream/frame_cache.py

@@ -0,0 +1,127 @@
+import logging
+import threading
+import queue
+
+
+try:
+    import redis  # type: ignore
+except Exception:  # pragma: no cover
+    redis = None  # type: ignore
+
+
+class RedisFrameCache:
+    """Non-blocking Redis cache for frames keyed by frame_id.
+
+    Stores base64 string content under key 'stream:frames:{frame_id}' with field 'frame'.
+    Each insert sets or refreshes the TTL.
+    """
+
+    def __init__(
+        self,
+        host: str = "localhost",
+        port: int = 6379,
+        db: int = 0,
+        password: str = None,
+        username: str = None,
+        ttl_seconds: int = 300,
+        prefix: str = "stream:frames:",
+        max_queue: int = 10000,
+        worker_threads: int = 2,
+        connect_timeout: float = 2.0,
+        socket_timeout: float = 0.5,
+    ) -> None:
+        self.logger = logging.getLogger(__name__ + ".frame_cache")
+        self.ttl_seconds = int(ttl_seconds)
+        self.prefix = prefix
+        self.queue: "queue.Queue" = queue.Queue(maxsize=max_queue)
+        self.threads = []
+        self.running = False
+        self._client = None
+        self._worker_threads = max(1, int(worker_threads))
+
+        if redis is None:
+            self.logger.warning("redis package not installed; frame caching disabled")
+            return
+
+        try:
+            self._client = redis.Redis(
+                host=host,
+                port=port,
+                db=db,
+                password=password,
+                username=username,
+                socket_connect_timeout=connect_timeout,
+                socket_timeout=socket_timeout,
+                health_check_interval=30,
+                retry_on_timeout=True,
+                decode_responses=True,  # store strings directly
+            )
+        except Exception as e:
+            self.logger.warning("Failed to init Redis client: %s", e)
+            self._client = None
+
+    def start(self) -> None:
+        if not self._client or self.running:
+            return
+        self.running = True
+        for i in range(self._worker_threads):
+            t = threading.Thread(target=self._worker, name=f"FrameCache-{i}", daemon=True)
+            t.start()
+            self.threads.append(t)
+
+    def stop(self) -> None:
+        if not self.running:
+            return
+        self.running = False
+        for _ in self.threads:
+            try:
+                self.queue.put_nowait(None)
+            except Exception:
+                pass
+        for t in self.threads:
+            try:
+                t.join(timeout=2.0)
+            except Exception:
+                pass
+        self.threads.clear()
+
+    def put(self, frame_id: str, base64_content: str) -> None:
+        """Enqueue a cache write for the given frame.
+
+        - frame_id: unique identifier
+        - base64_content: base64-encoded image string
+        """
+        if not self._client or not self.running:
+            return
+        if not frame_id or not base64_content:
+            return
+        try:
+            key = f"{self.prefix}{frame_id}"
+            self.queue.put_nowait((key, base64_content))
+        except queue.Full:
+            # Drop silently; never block pipeline
+            self.logger.debug("Frame cache queue full; dropping frame_id=%s", frame_id)
+
+    def _worker(self) -> None:
+        while self.running:
+            try:
+                item = self.queue.get(timeout=0.5)
+            except queue.Empty:
+                continue
+            if item is None:
+                break
+            key, base64_content = item
+            try:
+                # Store base64 string in a Redis hash field 'frame', then set TTL
+                # Mimics the Go backend behavior
+                self._client.hset(key, "frame", base64_content)
+                self._client.expire(key, self.ttl_seconds)
+            except Exception as e:
+                self.logger.debug("Failed to cache frame %s: %s", key, e)
+            finally:
+                try:
+                    self.queue.task_done()
+                except Exception:
+                    pass
+
+