Create corol_wrapper.py

corol_wrapper.py

@@ -0,0 +1,193 @@
+#!/usr/bin/env python3
+"""
+Coral Server Python Wrapper
+Starts and manages the coral-server on port 5555
+"""
+
+import os
+import sys
+import subprocess
+import signal
+import time
+import logging
+from threading import Thread
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger('coral-wrapper')
+
+class CoralServerWrapper:
+    def __init__(self, port=5555, jar_path='coral-server.jar'):
+        self.port = int(os.environ.get('CORAL_PORT', port))
+        self.jar_path = jar_path
+        self.process = None
+        self.running = False
+        
+    def check_java_version(self):
+        """Verify Java version is > 17"""
+        try:
+            result = subprocess.run(
+                ['java', '-version'], 
+                capture_output=True, 
+                text=True
+            )
+            version_info = result.stderr or result.stdout
+            logger.info(f"Java version: {version_info.split()[2].strip('\"')}")
+            
+            # Extract major version
+            version_str = version_info.split()[2].strip('"')
+            major_version = int(version_str.split('.')[0])
+            
+            if major_version < 17:
+                logger.error(f"Java version {major_version} is < 17. Please upgrade.")
+                return False
+            return True
+        except Exception as e:
+            logger.error(f"Error checking Java version: {e}")
+            return False
+    
+    def start_server(self):
+        """Start the coral-server"""
+        if not self.check_java_version():
+            sys.exit(1)
+        
+        try:
+            # Java command to run coral-server
+            java_cmd = [
+                'java',
+                '-Xmx512m',
+                '-Xms256m',
+                '-XX:+UseContainerSupport',
+                '-XX:MaxRAMPercentage=75.0',
+                '-jar',
+                self.jar_path,
+                '--sse-server-ktor',
+                str(self.port)
+            ]
+            
+            logger.info(f"Starting coral-server on port {self.port}...")
+            logger.info(f"Command: {' '.join(java_cmd)}")
+            
+            # Start the process
+            self.process = subprocess.Popen(
+                java_cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                universal_newlines=True,
+                bufsize=1
+            )
+            
+            self.running = True
+            
+            # Start thread to monitor output
+            output_thread = Thread(target=self.monitor_output)
+            output_thread.daemon = True
+            output_thread.start()
+            
+            # Wait a moment to ensure server starts
+            time.sleep(3)
+            
+            if self.process.poll() is None:
+                logger.info(f"✓ Coral-server started successfully on port {self.port}")
+                logger.info(f"  Server URL: http://localhost:{self.port}")
+            else:
+                logger.error("Server failed to start")
+                self.running = False
+                sys.exit(1)
+                
+        except FileNotFoundError:
+            logger.error(f"JAR file not found: {self.jar_path}")
+            sys.exit(1)
+        except Exception as e:
+            logger.error(f"Error starting server: {e}")
+            sys.exit(1)
+    
+    def monitor_output(self):
+        """Monitor and log server output"""
+        try:
+            for line in iter(self.process.stdout.readline, ''):
+                if line:
+                    logger.info(f"[coral-server] {line.strip()}")
+                if not self.running:
+                    break
+        except Exception as e:
+            logger.error(f"Error monitoring output: {e}")
+    
+    def stop_server(self):
+        """Stop the coral-server gracefully"""
+        if self.process and self.running:
+            logger.info("Stopping coral-server...")
+            self.running = False
+            
+            # Send SIGTERM for graceful shutdown
+            self.process.terminate()
+            
+            # Wait for process to end (max 10 seconds)
+            try:
+                self.process.wait(timeout=10)
+                logger.info("✓ Coral-server stopped gracefully")
+            except subprocess.TimeoutExpired:
+                logger.warning("Force killing coral-server...")
+                self.process.kill()
+                self.process.wait()
+                logger.info("✓ Coral-server force stopped")
+    
+    def restart_server(self):
+        """Restart the coral-server"""
+        logger.info("Restarting coral-server...")
+        self.stop_server()
+        time.sleep(2)
+        self.start_server()
+    
+    def health_check(self):
+        """Check if server is healthy"""
+        if self.process and self.process.poll() is None:
+            return True
+        return False
+    
+    def run(self):
+        """Main run method - starts server and handles signals"""
+        # Setup signal handlers
+        signal.signal(signal.SIGTERM, self.signal_handler)
+        signal.signal(signal.SIGINT, self.signal_handler)
+        
+        # Start the server
+        self.start_server()
+        
+        # Keep running and monitor health
+        try:
+            while self.running:
+                time.sleep(5)
+                if not self.health_check():
+                    logger.error("Server health check failed!")
+                    logger.info("Attempting restart...")
+                    self.restart_server()
+        except KeyboardInterrupt:
+            logger.info("Received interrupt signal")
+        finally:
+            self.stop_server()
+    
+    def signal_handler(self, signum, frame):
+        """Handle shutdown signals"""
+        logger.info(f"Received signal {signum}")
+        self.running = False
+
+def main():
+    """Main entry point"""
+    logger.info("="*50)
+    logger.info("Coral Server Python Wrapper")
+    logger.info("="*50)
+    
+    # Get configuration from environment
+    port = os.environ.get('CORAL_PORT', 5555)
+    jar_path = os.environ.get('CORAL_JAR_PATH', 'coral-server.jar')
+    
+    # Create and run wrapper
+    wrapper = CoralServerWrapper(port=port, jar_path=jar_path)
+    wrapper.run()
+
+if __name__ == "__main__":
+    main()