ipc-framework 1.0.0__py3-none-any.whl

ipc_framework/demo.py

@@ -0,0 +1,268 @@
+#!/usr/bin/env python3
+"""
+IPC Framework Demo
+
+This script demonstrates all the key features of the IPC framework:
+- Multiple applications and channels
+- Different message types (request/response, publish/subscribe, notifications)
+- Connection management
+- Error handling
+
+Run this script to see the framework in action!
+"""
+
+import time
+import threading
+import random
+from . import FrameworkServer, FrameworkClient, MessageType, Message
+
+
+def run_demo():
+    print("🚀 IPC Framework Demo")
+    print("=" * 50)
+    
+    # Step 1: Create and start server
+    print("\n📡 Starting IPC Server...")
+    server = FrameworkServer(host="localhost", port=8888)
+    
+    # Create multiple applications
+    chat_app = server.create_application("chat_app", "Chat Application")
+    file_app = server.create_application("file_share", "File Sharing")
+    monitor_app = server.create_application("monitoring", "System Monitor")
+    
+    # Create channels in each application
+    chat_app.create_channel("general")
+    chat_app.create_channel("announcements")
+    
+    file_app.create_channel("upload")
+    file_app.create_channel("download")
+    
+    monitor_app.create_channel("metrics")
+    monitor_app.create_channel("alerts")
+    
+    # Set up message handlers
+    def chat_handler(message: Message):
+        username = message.payload.get('username', 'Anonymous')
+        text = message.payload.get('text', '')
+        print(f"💬 [Chat] {username}: {text}")
+    
+    def file_handler(message: Message):
+        action = message.payload.get('action', 'unknown')
+        filename = message.payload.get('filename', 'unknown')
+        print(f"📁 [File] {action}: {filename}")
+    
+    def metric_handler(message: Message):
+        metric = message.payload.get('metric', 'unknown')
+        value = message.payload.get('value', 0)
+        print(f"📊 [Metrics] {metric}: {value}%")
+        
+        # Generate alert if CPU high
+        if metric == 'cpu_usage' and value > 80:
+            alert_msg = Message(
+                message_id="",
+                app_id="monitoring",
+                channel_id="alerts",
+                message_type=MessageType.NOTIFICATION,
+                payload={
+                    'type': 'high_cpu_alert',
+                    'metric': metric,
+                    'value': value,
+                    'severity': 'warning'
+                },
+                timestamp=time.time()
+            )
+            server._handle_publish(alert_msg, monitor_app.get_channel("alerts"))
+    
+    # Set handlers
+    chat_app.get_channel("general").set_handler(MessageType.REQUEST, chat_handler)
+    file_app.get_channel("upload").set_handler(MessageType.REQUEST, file_handler)
+    monitor_app.get_channel("metrics").set_handler(MessageType.NOTIFICATION, metric_handler)
+    
+    # Start server
+    server.start()
+    print("✅ Server started successfully!")
+    
+    # Show server status
+    print(f"\n📋 Server Configuration:")
+    for app_id, app_info in server.list_applications().items():
+        print(f"  📱 {app_id} ({app_info['name']})")
+        for channel in app_info['channels']:
+            print(f"    📺 {channel}")
+    
+    time.sleep(1)
+    
+    # Step 2: Create clients and demonstrate features
+    print("\n👥 Creating Clients...")
+    
+    clients = []
+    
+    # Chat clients
+    alice = FrameworkClient("chat_app", host="localhost", port=8888)
+    bob = FrameworkClient("chat_app", host="localhost", port=8888)
+    
+    # File client
+    file_client = FrameworkClient("file_share", host="localhost", port=8888)
+    
+    # Monitoring client
+    monitor_client = FrameworkClient("monitoring", host="localhost", port=8888)
+    
+    # Connect all clients
+    for name, client in [("Alice", alice), ("Bob", bob), ("FileClient", file_client), ("Monitor", monitor_client)]:
+        if client.connect():
+            clients.append((name, client))
+            print(f"✅ {name} connected")
+        else:
+            print(f"❌ {name} failed to connect")
+    
+    time.sleep(1)
+    
+    # Step 3: Demonstrate different message patterns
+    print("\n🎭 Demonstrating Message Patterns...")
+    
+    # 1. Chat messages (Request pattern)
+    print("\n💬 Chat Messages:")
+    alice.request("general", {"username": "Alice", "text": "Hello everyone!"})
+    time.sleep(0.5)
+    bob.request("general", {"username": "Bob", "text": "Hi Alice! How are you?"})
+    time.sleep(0.5)
+    alice.request("general", {"username": "Alice", "text": "I'm great! This IPC framework is awesome!"})
+    time.sleep(1)
+    
+    # 2. File operations
+    print("\n📁 File Operations:")
+    file_client.request("upload", {"action": "upload", "filename": "document.pdf", "size": 1024000})
+    time.sleep(0.5)
+    file_client.request("upload", {"action": "upload", "filename": "image.jpg", "size": 2048000})
+    time.sleep(1)
+    
+    # 3. Monitoring with alerts
+    print("\n📊 System Monitoring:")
+    
+    # Subscribe to alerts
+    def alert_handler(message: Message):
+        alert_type = message.payload.get('type', 'unknown')
+        metric = message.payload.get('metric', 'unknown')
+        value = message.payload.get('value', 0)
+        print(f"🚨 ALERT: {alert_type} - {metric} at {value}%")
+    
+    monitor_client.subscribe("alerts", alert_handler)
+    time.sleep(0.5)  # Give subscription time to register
+    
+    # Send normal metrics
+    monitor_client.notify("metrics", {"metric": "cpu_usage", "value": 45})
+    time.sleep(0.5)
+    monitor_client.notify("metrics", {"metric": "memory_usage", "value": 62})
+    time.sleep(0.5)
+    
+    # Send high CPU to trigger alert
+    monitor_client.notify("metrics", {"metric": "cpu_usage", "value": 85})
+    time.sleep(1)
+    
+    # 4. Publish/Subscribe pattern
+    print("\n📢 Publish/Subscribe Demo:")
+    
+    # Subscribe to announcements
+    def announcement_handler(message: Message):
+        text = message.payload.get('text', '')
+        print(f"📢 ANNOUNCEMENT: {text}")
+    
+    alice.subscribe("announcements", announcement_handler)
+    bob.subscribe("announcements", announcement_handler)
+    time.sleep(0.5)
+    
+    # Publish announcement
+    alice.publish("announcements", {"text": "Server maintenance scheduled for tonight at 11 PM"})
+    time.sleep(1)
+    
+    # Step 4: Show server statistics
+    print("\n📈 Server Statistics:")
+    stats = server.get_stats()
+    print(f"  🔗 Active connections: {stats['total_connections']}")
+    print(f"  📱 Applications: {stats['total_applications']}")
+    
+    for app_id, app_info in server.list_applications().items():
+        channels_info = server.list_channels(app_id)
+        print(f"  📱 {app_id}: {app_info['connections']} connections")
+        for channel_id, channel_info in channels_info.items():
+            print(f"    📺 {channel_id}: {channel_info['subscribers']} subscribers")
+    
+    # Step 5: Demonstrate connection management
+    print("\n🔌 Connection Management Demo:")
+    print("Disconnecting some clients...")
+    
+    alice.disconnect()
+    print("❌ Alice disconnected")
+    time.sleep(0.5)
+    
+    file_client.disconnect()
+    print("❌ FileClient disconnected")
+    time.sleep(1)
+    
+    # Show updated stats
+    stats = server.get_stats()
+    print(f"📊 Updated connections: {stats['total_connections']}")
+    
+    # Step 6: Error handling demo
+    print("\n⚠️  Error Handling Demo:")
+    
+    # Try to send message with disconnected client
+    try:
+        alice.request("general", {"text": "This should fail"})
+    except Exception as e:
+        print(f"🚫 Expected error from disconnected client: {type(e).__name__}")
+    
+    # Try invalid channel
+    try:
+        bob.request("nonexistent_channel", {"text": "This will work but route to nowhere"})
+        print("📝 Message sent to auto-created channel (framework auto-creates channels)")
+    except Exception as e:
+        print(f"❌ Unexpected error: {e}")
+    
+    time.sleep(1)
+    
+    # Step 7: Cleanup
+    print("\n🧹 Cleaning up...")
+    
+    # Disconnect remaining clients
+    for name, client in clients:
+        if client.connected:
+            client.disconnect()
+            print(f"❌ {name} disconnected")
+    
+    # Stop server
+    server.stop()
+    print("🛑 Server stopped")
+    
+    print("\n🎉 Demo completed!")
+    print("\n💡 Key Features Demonstrated:")
+    print("  ✅ Multiple applications with channels (app_id -> channel_id)")
+    print("  ✅ Request/Response pattern")
+    print("  ✅ Publish/Subscribe pattern") 
+    print("  ✅ Notifications and alerts")
+    print("  ✅ Connection management")
+    print("  ✅ Automatic channel creation")
+    print("  ✅ Thread-safe operations")
+    print("  ✅ Error handling")
+    print("  ✅ Server statistics and monitoring")
+    
+    print("\n🚀 Try running the example scripts next:")
+    print("  ipc-server         # Start the server")
+    print("  ipc-chat YourName  # Chat client")
+    print("  ipc-file           # File sharing client")
+    print("  ipc-monitor sim    # Monitoring simulation")
+
+
+def main():
+    """Entry point for the demo command"""
+    try:
+        run_demo()
+    except KeyboardInterrupt:
+        print("\n\n⏹️  Demo interrupted by user")
+    except Exception as e:
+        print(f"\n💥 Demo error: {e}")
+        import traceback
+        traceback.print_exc()
+
+
+if __name__ == "__main__":
+    main() 

ipc_framework/examples/__init__.py

@@ -0,0 +1,13 @@
+"""
+Examples subpackage for IPC Framework
+
+This package contains example implementations demonstrating various
+features of the IPC Framework.
+"""
+
+__all__ = [
+    "basic_server",
+    "chat_client", 
+    "file_client",
+    "monitoring_client"
+] 

ipc_framework/examples/basic_server.py

@@ -0,0 +1,209 @@
+#!/usr/bin/env python3
+"""
+Basic IPC Server Example
+
+This example demonstrates how to create an IPC server with multiple applications
+and channels, showing the hierarchical structure of app_id -> channel_id.
+"""
+
+import time
+import threading
+from .. import FrameworkServer, MessageType, Message
+
+
+def setup_chat_application(server: FrameworkServer):
+    """Setup a chat application with multiple channels"""
+    app = server.create_application("chat_app", "Chat Application")
+    
+    # Create channels
+    general_channel = app.create_channel("general")
+    tech_channel = app.create_channel("tech_talk")
+    random_channel = app.create_channel("random")
+    
+    # Set up message handlers
+    def handle_chat_message(message: Message):
+        print(f"[{message.channel_id}] Chat message from {message.payload.get('username', 'Anonymous')}: {message.payload.get('text', '')}")
+        
+        # Broadcast to all subscribers in this channel
+        broadcast_msg = Message(
+            message_id="",
+            app_id=message.app_id,
+            channel_id=message.channel_id,
+            message_type=MessageType.NOTIFICATION,
+            payload={
+                'type': 'chat_message',
+                'username': message.payload.get('username', 'Anonymous'),
+                'text': message.payload.get('text', ''),
+                'timestamp': message.timestamp
+            },
+            timestamp=time.time()
+        )
+        server._handle_publish(broadcast_msg, app.get_channel(message.channel_id))
+    
+    def handle_user_join(message: Message):
+        username = message.payload.get('username', 'Anonymous')
+        print(f"[{message.channel_id}] User {username} joined")
+        
+        # Notify other users
+        join_msg = Message(
+            message_id="",
+            app_id=message.app_id,
+            channel_id=message.channel_id,
+            message_type=MessageType.NOTIFICATION,
+            payload={
+                'type': 'user_joined',
+                'username': username,
+                'timestamp': time.time()
+            },
+            timestamp=time.time()
+        )
+        server._handle_publish(join_msg, app.get_channel(message.channel_id))
+    
+    # Set handlers for all channels
+    for channel_id in ["general", "tech_talk", "random"]:
+        channel = app.get_channel(channel_id)
+        channel.set_handler(MessageType.REQUEST, handle_chat_message)
+        channel.set_handler(MessageType.NOTIFICATION, handle_user_join)
+
+
+def setup_file_sharing_application(server: FrameworkServer):
+    """Setup a file sharing application"""
+    app = server.create_application("file_share", "File Sharing Service")
+    
+    # Create channels for different file operations
+    upload_channel = app.create_channel("upload")
+    download_channel = app.create_channel("download")
+    status_channel = app.create_channel("status")
+    
+    def handle_file_upload(message: Message):
+        filename = message.payload.get('filename', 'unknown')
+        size = message.payload.get('size', 0)
+        print(f"[file_share:upload] File upload request: {filename} ({size} bytes)")
+        
+        # Simulate file processing
+        status_msg = Message(
+            message_id="",
+            app_id=message.app_id,
+            channel_id="status",
+            message_type=MessageType.NOTIFICATION,
+            payload={
+                'type': 'upload_progress',
+                'filename': filename,
+                'progress': 100,
+                'status': 'completed'
+            },
+            timestamp=time.time()
+        )
+        server._handle_publish(status_msg, app.get_channel("status"))
+    
+    def handle_file_download(message: Message):
+        filename = message.payload.get('filename', 'unknown')
+        print(f"[file_share:download] File download request: {filename}")
+        
+        # Send response back to requester
+        response = Message(
+            message_id="",
+            app_id=message.app_id,
+            channel_id=message.channel_id,
+            message_type=MessageType.RESPONSE,
+            payload={
+                'filename': filename,
+                'download_url': f"http://example.com/files/{filename}",
+                'expires_at': time.time() + 3600  # 1 hour
+            },
+            timestamp=time.time(),
+            reply_to=message.message_id
+        )
+        
+        # Find the connection that sent the request and send response
+        connection_id = message.payload.get('connection_id')
+        if connection_id:
+            connection = server.connection_manager.get_connection(connection_id)
+            if connection:
+                server.send_to_connection(connection, response)
+    
+    upload_channel.set_handler(MessageType.REQUEST, handle_file_upload)
+    download_channel.set_handler(MessageType.REQUEST, handle_file_download)
+
+
+def setup_monitoring_application(server: FrameworkServer):
+    """Setup a monitoring application"""
+    app = server.create_application("monitoring", "System Monitoring")
+    
+    metrics_channel = app.create_channel("metrics")
+    alerts_channel = app.create_channel("alerts")
+    
+    def handle_metric_report(message: Message):
+        metric_name = message.payload.get('metric', 'unknown')
+        value = message.payload.get('value', 0)
+        print(f"[monitoring:metrics] Metric {metric_name}: {value}")
+        
+        # Check for alerts
+        if metric_name == "cpu_usage" and value > 80:
+            alert_msg = Message(
+                message_id="",
+                app_id=message.app_id,
+                channel_id="alerts",
+                message_type=MessageType.NOTIFICATION,
+                payload={
+                    'type': 'high_cpu_alert',
+                    'metric': metric_name,
+                    'value': value,
+                    'threshold': 80,
+                    'severity': 'warning'
+                },
+                timestamp=time.time()
+            )
+            server._handle_publish(alert_msg, app.get_channel("alerts"))
+    
+    metrics_channel.set_handler(MessageType.NOTIFICATION, handle_metric_report)
+
+
+def main():
+    # Create and configure the server
+    server = FrameworkServer(host="localhost", port=8888)
+    
+    print("Setting up IPC Framework Server...")
+    
+    # Setup different applications
+    setup_chat_application(server)
+    setup_file_sharing_application(server)
+    setup_monitoring_application(server)
+    
+    print("Applications configured:")
+    for app_id, app_info in server.list_applications().items():
+        print(f"  - {app_id} ({app_info['name']}): {len(app_info['channels'])} channels")
+        for channel in app_info['channels']:
+            print(f"    * {channel}")
+    
+    # Start the server
+    server.start()
+    
+    try:
+        print("\nServer is running. Press Ctrl+C to stop.")
+        print("You can now run client examples to interact with the server.")
+        print("\nServer Statistics:")
+        
+        while True:
+            time.sleep(10)
+            stats = server.get_stats()
+            apps = server.list_applications()
+            
+            print(f"\n--- Server Stats ---")
+            print(f"Active connections: {stats['total_connections']}")
+            print(f"Active applications: {stats['total_applications']}")
+            
+            for app_id, app_info in apps.items():
+                channels_info = server.list_channels(app_id)
+                print(f"  {app_id}: {app_info['connections']} connections")
+                for channel_id, channel_info in channels_info.items():
+                    print(f"    {channel_id}: {channel_info['subscribers']} subscribers")
+            
+    except KeyboardInterrupt:
+        print("\nShutting down server...")
+        server.stop()
+        print("Server stopped.")
+
+
+if __name__ == "__main__":
+    main() 

ipc_framework/examples/chat_client.py

@@ -0,0 +1,168 @@
+#!/usr/bin/env python3
+"""
+Chat Client Example
+
+This example demonstrates how to create a chat client using the IPC framework.
+It connects to the chat_app application and can send/receive messages in different channels.
+"""
+
+import time
+import threading
+import sys
+from .. import FrameworkClient, Message, MessageType
+
+
+class ChatClient:
+    def __init__(self, username: str, host: str = "localhost", port: int = 8888):
+        self.username = username
+        self.client = FrameworkClient("chat_app", host, port)
+        self.current_channel = "general"
+        self.running = False
+    
+    def connect(self):
+        """Connect to the chat server"""
+        if self.client.connect():
+            print(f"Connected as {self.username}")
+            
+            # Subscribe to all chat channels
+            self.subscribe_to_channel("general")
+            self.subscribe_to_channel("tech_talk")
+            self.subscribe_to_channel("random")
+            
+            # Set current channel
+            self.switch_channel("general")
+            return True
+        else:
+            print("Failed to connect to server")
+            return False
+    
+    def subscribe_to_channel(self, channel_id: str):
+        """Subscribe to a chat channel"""
+        def message_handler(message: Message):
+            payload = message.payload
+            msg_type = payload.get('type', 'unknown')
+            
+            if msg_type == 'chat_message':
+                username = payload.get('username', 'Unknown')
+                text = payload.get('text', '')
+                if username != self.username:  # Don't show our own messages
+                    print(f"\n[{channel_id}] {username}: {text}")
+                    self.show_prompt()
+            
+            elif msg_type == 'user_joined':
+                username = payload.get('username', 'Unknown')
+                if username != self.username:
+                    print(f"\n[{channel_id}] *** {username} joined the channel ***")
+                    self.show_prompt()
+        
+        self.client.subscribe(channel_id, message_handler)
+        
+        # Send join notification
+        self.client.notify(channel_id, {
+            'type': 'user_join',
+            'username': self.username
+        })
+    
+    def switch_channel(self, channel_id: str):
+        """Switch to a different channel"""
+        self.current_channel = channel_id
+        print(f"Switched to #{channel_id}")
+        
+        # Send join notification to new channel
+        self.client.notify(channel_id, {
+            'type': 'user_join',
+            'username': self.username
+        })
+    
+    def send_message(self, text: str):
+        """Send a chat message to current channel"""
+        self.client.request(self.current_channel, {
+            'username': self.username,
+            'text': text,
+            'connection_id': self.client.connection_id
+        })
+    
+    def show_prompt(self):
+        """Show the chat prompt"""
+        if self.running:
+            print(f"[{self.current_channel}] {self.username}: ", end="", flush=True)
+    
+    def start_chat(self):
+        """Start the chat interface"""
+        self.running = True
+        
+        print("\n=== Chat Client ===")
+        print("Commands:")
+        print("  /join <channel>  - Switch to a channel (general, tech_talk, random)")
+        print("  /quit            - Exit the chat")
+        print("  <message>        - Send a message to current channel")
+        print(f"\nYou are in #{self.current_channel}")
+        
+        try:
+            while self.running:
+                self.show_prompt()
+                user_input = input().strip()
+                
+                if not user_input:
+                    continue
+                
+                if user_input.startswith('/'):
+                    self.handle_command(user_input)
+                else:
+                    self.send_message(user_input)
+                    print(f"[{self.current_channel}] {self.username}: {user_input}")
+        
+        except KeyboardInterrupt:
+            pass
+        finally:
+            self.disconnect()
+    
+    def handle_command(self, command: str):
+        """Handle chat commands"""
+        parts = command.split()
+        cmd = parts[0].lower()
+        
+        if cmd == '/quit':
+            self.running = False
+            
+        elif cmd == '/join' and len(parts) > 1:
+            channel = parts[1]
+            if channel in ['general', 'tech_talk', 'random']:
+                self.switch_channel(channel)
+            else:
+                print("Available channels: general, tech_talk, random")
+                
+        elif cmd == '/channels':
+            print("Available channels: general, tech_talk, random")
+            print(f"Current channel: {self.current_channel}")
+            
+        elif cmd == '/who':
+            print(f"You are {self.username} in #{self.current_channel}")
+            
+        else:
+            print("Unknown command. Available commands: /join, /channels, /who, /quit")
+    
+    def disconnect(self):
+        """Disconnect from the server"""
+        self.running = False
+        self.client.disconnect()
+        print("\nDisconnected from chat server.")
+
+
+def main():
+    if len(sys.argv) != 2:
+        print("Usage: python chat_client.py <username>")
+        sys.exit(1)
+    
+    username = sys.argv[1]
+    client = ChatClient(username)
+    
+    if client.connect():
+        client.start_chat()
+    else:
+        print("Failed to connect to server. Make sure the server is running.")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()