ipc-framework 1.0.0__py3-none-any.whl

ipc_framework/examples/file_client.py

@@ -0,0 +1,211 @@
+#!/usr/bin/env python3
+"""
+File Sharing Client Example
+
+This example demonstrates how to use the IPC framework for file sharing operations.
+It shows request/response patterns and status monitoring.
+"""
+
+import time
+import random
+import threading
+from .. import FrameworkClient, Message, MessageType
+
+
+class FileClient:
+    def __init__(self, client_name: str, host: str = "localhost", port: int = 8888):
+        self.client_name = client_name
+        self.client = FrameworkClient("file_share", host, port)
+        self.uploaded_files = []
+    
+    def connect(self):
+        """Connect to the file sharing server"""
+        if self.client.connect():
+            print(f"File client '{self.client_name}' connected")
+            
+            # Subscribe to status updates
+            self.client.subscribe("status", self.handle_status_update)
+            return True
+        else:
+            print("Failed to connect to server")
+            return False
+    
+    def handle_status_update(self, message: Message):
+        """Handle file operation status updates"""
+        payload = message.payload
+        msg_type = payload.get('type', 'unknown')
+        
+        if msg_type == 'upload_progress':
+            filename = payload.get('filename', 'unknown')
+            progress = payload.get('progress', 0)
+            status = payload.get('status', 'unknown')
+            print(f"[STATUS] Upload {filename}: {progress}% - {status}")
+    
+    def upload_file(self, filename: str, size: int):
+        """Upload a file (simulated)"""
+        print(f"Uploading file: {filename} ({size} bytes)")
+        
+        self.client.request("upload", {
+            'filename': filename,
+            'size': size,
+            'client': self.client_name,
+            'connection_id': self.client.connection_id
+        })
+        
+        self.uploaded_files.append(filename)
+        print(f"Upload request sent for {filename}")
+    
+    def download_file(self, filename: str) -> bool:
+        """Download a file and wait for response"""
+        print(f"Requesting download: {filename}")
+        
+        response = self.client.send_request("download", {
+            'filename': filename,
+            'client': self.client_name,
+            'connection_id': self.client.connection_id
+        }, timeout=5.0)
+        
+        if response:
+            payload = response.payload
+            download_url = payload.get('download_url', 'N/A')
+            expires_at = payload.get('expires_at', 0)
+            expires_in = int(expires_at - time.time())
+            
+            print(f"Download ready:")
+            print(f"  File: {filename}")
+            print(f"  URL: {download_url}")
+            print(f"  Expires in: {expires_in} seconds")
+            return True
+        else:
+            print(f"Download request timed out for {filename}")
+            return False
+    
+    def list_files(self):
+        """List uploaded files"""
+        if self.uploaded_files:
+            print("Uploaded files:")
+            for i, filename in enumerate(self.uploaded_files, 1):
+                print(f"  {i}. {filename}")
+        else:
+            print("No files uploaded yet")
+    
+    def disconnect(self):
+        """Disconnect from the server"""
+        self.client.disconnect()
+        print(f"File client '{self.client_name}' disconnected")
+
+
+def simulate_file_operations():
+    """Simulate various file operations"""
+    # Create multiple clients
+    clients = []
+    for i in range(3):
+        client = FileClient(f"Client_{i+1}")
+        if client.connect():
+            clients.append(client)
+        time.sleep(0.5)
+    
+    if not clients:
+        print("No clients could connect")
+        return
+    
+    print(f"\n=== Starting file operations with {len(clients)} clients ===\n")
+    
+    # Simulate file uploads
+    sample_files = [
+        ("document.pdf", 1024000),
+        ("image.jpg", 2048000),
+        ("video.mp4", 50000000),
+        ("data.csv", 512000),
+        ("code.zip", 1536000)
+    ]
+    
+    # Each client uploads some files
+    for client in clients:
+        num_files = random.randint(1, 3)
+        selected_files = random.sample(sample_files, num_files)
+        
+        for filename, size in selected_files:
+            client.upload_file(f"{client.client_name}_{filename}", size)
+            time.sleep(1)
+    
+    time.sleep(2)
+    print("\n=== Upload phase completed ===\n")
+    
+    # Simulate downloads
+    for client in clients:
+        print(f"\n--- {client.client_name} downloads ---")
+        client.list_files()
+        
+        # Try to download some files
+        for other_client in clients:
+            if other_client != client and other_client.uploaded_files:
+                file_to_download = random.choice(other_client.uploaded_files)
+                success = client.download_file(file_to_download)
+                time.sleep(1)
+    
+    print("\n=== File operations completed ===")
+    
+    # Disconnect all clients
+    for client in clients:
+        client.disconnect()
+
+
+def interactive_mode():
+    """Run in interactive mode"""
+    client_name = input("Enter client name: ").strip() or "InteractiveClient"
+    client = FileClient(client_name)
+    
+    if not client.connect():
+        return
+    
+    print("\n=== File Sharing Client ===")
+    print("Commands:")
+    print("  upload <filename> <size>  - Upload a file")
+    print("  download <filename>       - Download a file")
+    print("  list                      - List uploaded files")
+    print("  quit                      - Exit")
+    
+    try:
+        while True:
+            command = input(f"\n[{client_name}] > ").strip().split()
+            
+            if not command:
+                continue
+            
+            cmd = command[0].lower()
+            
+            if cmd == 'quit':
+                break
+            elif cmd == 'upload' and len(command) >= 3:
+                filename = command[1]
+                try:
+                    size = int(command[2])
+                    client.upload_file(filename, size)
+                except ValueError:
+                    print("Invalid size. Please enter a number.")
+            elif cmd == 'download' and len(command) >= 2:
+                filename = command[1]
+                client.download_file(filename)
+            elif cmd == 'list':
+                client.list_files()
+            else:
+                print("Invalid command or missing arguments")
+    
+    except KeyboardInterrupt:
+        pass
+    finally:
+        client.disconnect()
+
+
+def main():
+    import sys
+    
+    if len(sys.argv) > 1 and sys.argv[1] == 'sim':
+        simulate_file_operations()
+    else:
+        interactive_mode()
+
+
+if __name__ == "__main__":
+    main() 

ipc_framework/examples/monitoring_client.py

@@ -0,0 +1,252 @@
+#!/usr/bin/env python3
+"""
+Monitoring Client Example
+
+This example demonstrates how to use the IPC framework for system monitoring.
+It shows metrics reporting and alert subscription patterns.
+"""
+
+import time
+import random
+import threading
+from .. import FrameworkClient, Message, MessageType
+
+try:
+    import psutil
+    HAS_PSUTIL = True
+except ImportError:
+    HAS_PSUTIL = False
+
+
+class MonitoringClient:
+    def __init__(self, client_name: str, host: str = "localhost", port: int = 8888):
+        self.client_name = client_name
+        self.client = FrameworkClient("monitoring", host, port)
+        self.running = False
+        self.metrics_thread = None
+    
+    def connect(self):
+        """Connect to the monitoring server"""
+        if self.client.connect():
+            print(f"Monitoring client '{self.client_name}' connected")
+            
+            # Subscribe to alerts
+            self.client.subscribe("alerts", self.handle_alert)
+            return True
+        else:
+            print("Failed to connect to server")
+            return False
+    
+    def handle_alert(self, message: Message):
+        """Handle system alerts"""
+        payload = message.payload
+        alert_type = payload.get('type', 'unknown')
+        
+        if alert_type == 'high_cpu_alert':
+            metric = payload.get('metric', 'unknown')
+            value = payload.get('value', 0)
+            threshold = payload.get('threshold', 0)
+            severity = payload.get('severity', 'info')
+            
+            print(f"\n🚨 ALERT [{severity.upper()}]: {alert_type}")
+            print(f"   Metric: {metric}")
+            print(f"   Current: {value}%")
+            print(f"   Threshold: {threshold}%")
+            print(f"   Time: {time.strftime('%H:%M:%S')}")
+    
+    def send_metric(self, metric_name: str, value: float):
+        """Send a metric to the monitoring system"""
+        self.client.notify("metrics", {
+            'metric': metric_name,
+            'value': value,
+            'client': self.client_name,
+            'timestamp': time.time()
+        })
+    
+    def get_system_metrics(self) -> dict:
+        """Get current system metrics"""
+        if HAS_PSUTIL:
+            try:
+                return {
+                    'cpu_usage': psutil.cpu_percent(interval=1),
+                    'memory_usage': psutil.virtual_memory().percent,
+                    'disk_usage': psutil.disk_usage('/').percent,
+                    'load_average': psutil.getloadavg()[0] * 100,  # 1-minute load average as percentage
+                }
+            except Exception:
+                pass
+        
+        # Fallback with simulated metrics if psutil not available or fails
+        return {
+            'cpu_usage': random.uniform(10, 95),
+            'memory_usage': random.uniform(30, 80),
+            'disk_usage': random.uniform(40, 70),
+            'load_average': random.uniform(5, 50),
+        }
+    
+    def start_monitoring(self, interval: float = 5.0):
+        """Start continuous monitoring"""
+        self.running = True
+        
+        def monitor_loop():
+            while self.running:
+                try:
+                    metrics = self.get_system_metrics()
+                    
+                    for metric_name, value in metrics.items():
+                        self.send_metric(metric_name, value)
+                        print(f"[{self.client_name}] {metric_name}: {value:.1f}%")
+                    
+                    print(f"[{self.client_name}] Metrics sent at {time.strftime('%H:%M:%S')}")
+                    time.sleep(interval)
+                    
+                except Exception as e:
+                    print(f"Error in monitoring loop: {e}")
+                    time.sleep(interval)
+        
+        self.metrics_thread = threading.Thread(target=monitor_loop, daemon=True)
+        self.metrics_thread.start()
+        print(f"Started monitoring with {interval}s interval")
+    
+    def stop_monitoring(self):
+        """Stop monitoring"""
+        self.running = False
+        if self.metrics_thread and self.metrics_thread.is_alive():
+            self.metrics_thread.join(timeout=1.0)
+        print("Monitoring stopped")
+    
+    def send_custom_metric(self, name: str, value: float):
+        """Send a custom metric"""
+        self.send_metric(name, value)
+        print(f"Custom metric sent: {name} = {value}")
+    
+    def disconnect(self):
+        """Disconnect from the server"""
+        self.stop_monitoring()
+        self.client.disconnect()
+        print(f"Monitoring client '{self.client_name}' disconnected")
+
+
+def simulate_monitoring():
+    """Simulate multiple monitoring clients"""
+    clients = []
+    
+    # Create monitoring clients for different "servers"
+    server_names = ["web-server-1", "db-server", "api-gateway"]
+    
+    for server_name in server_names:
+        client = MonitoringClient(server_name)
+        if client.connect():
+            clients.append(client)
+            # Start monitoring with different intervals
+            client.start_monitoring(interval=random.uniform(3, 7))
+        time.sleep(0.5)
+    
+    if not clients:
+        print("No monitoring clients could connect")
+        return
+    
+    print(f"\n=== Started monitoring {len(clients)} systems ===")
+    print("Monitoring will run for 30 seconds...")
+    print("Watch for alerts when CPU usage exceeds 80%")
+    
+    try:
+        time.sleep(30)
+    except KeyboardInterrupt:
+        print("\nStopping simulation...")
+    
+    # Stop all monitoring
+    for client in clients:
+        client.disconnect()
+    
+    print("\n=== Monitoring simulation completed ===")
+
+
+def interactive_mode():
+    """Run in interactive mode"""
+    client_name = input("Enter monitoring client name: ").strip() or "MonitoringClient"
+    client = MonitoringClient(client_name)
+    
+    if not client.connect():
+        return
+    
+    print("\n=== Monitoring Client ===")
+    print("Commands:")
+    print("  start [interval]     - Start automatic monitoring (default 5s)")
+    print("  stop                 - Stop automatic monitoring")
+    print("  metric <name> <val>  - Send custom metric")
+    print("  status               - Show current system metrics")
+    print("  quit                 - Exit")
+    
+    auto_monitoring = False
+    
+    try:
+        while True:
+            if not auto_monitoring:
+                command = input(f"\n[{client_name}] > ").strip().split()
+            else:
+                # In auto monitoring mode, just wait for input with timeout
+                print(f"\n[{client_name}] (auto-monitoring) > ", end="", flush=True)
+                command = input().strip().split()
+            
+            if not command:
+                continue
+            
+            cmd = command[0].lower()
+            
+            if cmd == 'quit':
+                break
+            elif cmd == 'start':
+                if not auto_monitoring:
+                    interval = 5.0
+                    if len(command) > 1:
+                        try:
+                            interval = float(command[1])
+                        except ValueError:
+                            print("Invalid interval, using 5 seconds")
+                    client.start_monitoring(interval)
+                    auto_monitoring = True
+                else:
+                    print("Monitoring is already running. Use 'stop' first.")
+            elif cmd == 'stop':
+                if auto_monitoring:
+                    client.stop_monitoring()
+                    auto_monitoring = False
+                else:
+                    print("Monitoring is not running")
+            elif cmd == 'metric' and len(command) >= 3:
+                try:
+                    name = command[1]
+                    value = float(command[2])
+                    client.send_custom_metric(name, value)
+                except ValueError:
+                    print("Invalid metric value")
+            elif cmd == 'status':
+                metrics = client.get_system_metrics()
+                print("Current system metrics:")
+                for name, value in metrics.items():
+                    print(f"  {name}: {value:.1f}%")
+            else:
+                print("Invalid command or missing arguments")
+    
+    except KeyboardInterrupt:
+        pass
+    finally:
+        client.disconnect()
+
+
+def main():
+    import sys
+    
+    print("System Monitoring Client")
+    print("This example requires 'psutil' for real system metrics.")
+    print("If not available, simulated metrics will be used.\n")
+    
+    if len(sys.argv) > 1 and sys.argv[1] == 'sim':
+        simulate_monitoring()
+    else:
+        interactive_mode()
+
+
+if __name__ == "__main__":
+    main() 

ipc_framework/exceptions.py

@@ -0,0 +1,43 @@
+"""
+Custom exceptions for the IPC Framework
+"""
+
+
+class IPCError(Exception):
+    """Base exception for IPC Framework"""
+    pass
+
+
+class ConnectionError(IPCError):
+    """Raised when connection-related errors occur"""
+    pass
+
+
+class RoutingError(IPCError):
+    """Raised when message routing fails"""
+    pass
+
+
+class AuthenticationError(IPCError):
+    """Raised when authentication fails"""
+    pass
+
+
+class ChannelError(IPCError):
+    """Raised when channel operations fail"""
+    pass
+
+
+class ApplicationError(IPCError):
+    """Raised when application operations fail"""
+    pass
+
+
+class SerializationError(IPCError):
+    """Raised when message serialization/deserialization fails"""
+    pass
+
+
+class TimeoutError(IPCError):
+    """Raised when operations timeout"""
+    pass 

ipc_framework/py.typed

@@ -0,0 +1,2 @@
+# Marker file for PEP 561.
+# The ipc_framework package supports type hints.