File size: 4,554 Bytes
e500fa4
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
8120925
e500fa4
 
8120925
e500fa4
 
 
8120925
 
 
 
 
e500fa4
8120925
 
e500fa4
 
 
 
8120925
e500fa4
 
 
8120925
e500fa4
 
 
8120925
e500fa4
 
 
 
8120925
e500fa4
 
 
 
 
8120925
e500fa4
 
 
 
8120925
 
e500fa4
8120925
e500fa4
 
8120925
e500fa4
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
import sys
import asyncio
import websockets
from urllib.parse import urlparse, parse_qs
from utils import setup_logging, parse_message, create_response, validate_token
from config import WS_HOST, WS_PORT, LOG_LEVEL, LOG_FILE
from connection_manager import ConnectionManager  # Add this import

class WebSocketServer:
    def __init__(self):
        self.logger = setup_logging(LOG_LEVEL, LOG_FILE)
        self.conn_manager = ConnectionManager()  # Add connection manager
    
    async def handle_websocket(self, websocket: websockets.WebSocketServerProtocol, path: str):
        """Main WebSocket connection handler."""
        session = None
        client_info = f"{websocket.remote_address[0]}:{websocket.remote_address[1]}"
        
        try:
            self.logger.info(f"New connection attempt from {client_info}")
            query_params = parse_qs(urlparse(path).query)
            token = query_params.get("token", [None])[0]
            
            if not token:
                self.logger.warning(f"Connection attempt from {client_info} rejected: No token provided")
                await websocket.send(create_response('error', 'Missing token'))
                return
                
            if not validate_token(token):
                self.logger.warning(f"Connection attempt from {client_info} rejected: Invalid token")
                await websocket.send(create_response('error', 'Invalid token'))
                return
                
            session = self.conn_manager.create_session(token, websocket)
            if not session:
                self.logger.warning(f"Connection attempt from {client_info} rejected: Session creation failed")
                await websocket.send(create_response('error', 'Invalid token'))
                return
                
            self.logger.info(f"Client {client_info} successfully connected with token: {token}")
            await websocket.send(create_response('connect', 'Connected', {'token': session.token}))
            
            async for message in websocket:
                self.logger.debug(f"Received message from {client_info}: {message}")
                session.update_activity()
                parsed_msg = parse_message(message)
                
                if not parsed_msg:
                    self.logger.warning(f"Invalid message format from {client_info}: {message}")
                    await websocket.send(create_response('error', 'Invalid message format'))
                    continue
                    
                msg_type = parsed_msg.get('type')
                if msg_type == 'ping':
                    self.logger.debug(f"Ping received from {client_info}")
                    await websocket.send(create_response('pong', 'Pong'))
                else:
                    await self.handle_message(session, parsed_msg)
        
        except websockets.ConnectionClosed as e:
            self.logger.info(f"WebSocket connection closed for {client_info}. Code: {e.code}, Reason: {e.reason}")
        except Exception as e:
            self.logger.error(f"Error handling connection from {client_info}: {str(e)}", exc_info=True)
        finally:
            if session:
                self.logger.info(f"Cleaning up session for {client_info}")
                self.conn_manager.remove_connection(session.token)
    
    async def session_cleanup_task(self):
        """Periodic task to clean up expired sessions."""
        while True:
            await asyncio.sleep(300)
            self.conn_manager.cleanup_expired_sessions()
    
    def stop_server(self, signal):
        """Handle server shutdown gracefully."""
        self.logger.info(f"Received {signal.name}, shutting down...")
        sys.exit(0)
    
    async def run_server(self):
        """Start the WebSocket server."""
        server = await websockets.serve(
            self.handle_websocket, 
            WS_HOST, 
            WS_PORT,
            ping_interval=20,
            ping_timeout=20
        )
        
        # Start session cleanup task
        cleanup_task = asyncio.create_task(self.session_cleanup_task())
        
        self.logger.info(f"WebSocket Server started on {WS_HOST}:{WS_PORT}")
        
        await server.wait_closed()
        cleanup_task.cancel()

def main():
    server = WebSocketServer()
    asyncio.run(server.run_server())

if __name__ == "__main__":
    print("Starting WebSocket server...")
    main()