start method

Future<void> start()

Start the WebSocket server.

Implementation

Future<void> start() async {
  _server = await HttpServer.bind(
    config.host != null
        ? InternetAddress(config.host!)
        : InternetAddress.anyIPv4,
    config.port,
    shared: config.shared,
  );
  Khadem.logger.info(
    '🟢 WebSocket Server started on ws://${config.host ?? 'localhost'}:${config.port}',
  );

  _server!.listen((HttpRequest request) async {
    final req = Request(request);
    RequestContext.run(req, () async {
      if (WebSocketTransformer.isUpgradeRequest(request)) {
        try {
          final res = Response(request);

          await MiddlewarePipeline.execute(
            _handshakeMiddlewares,
            req,
            res,
            (req, res) async {
              // Handshake passed
            },
          );

          if (res.sent) return;

          final ws = await WebSocketTransformer.upgrade(request);
          if (config.pingInterval != null) {
            ws.pingInterval = config.pingInterval;
          }

          final clientId = _generateClientId();
          final client = SocketClient(
            id: clientId,
            socket: ws,
            manager: _manager,
            request: req,
          );

          final handler = SocketHandler(
            client: client,
            manager: _manager,
            router: _router,
            maxMessageBytes: config.maxMessageBytes,
          );

          _manager.addClient(client);

          if (_onConnectCallback != null) {
            try {
              await _onConnectCallback!(client);
            } catch (e) {
              Khadem.logger.error('Error in onConnect: $e');
            }
          }

          handler.init();

          ws.done.then((_) async {
            _manager.removeClient(client);
            if (_onDisconnectCallback != null) {
              try {
                await _onDisconnectCallback!(client);
              } catch (e) {
                Khadem.logger.error('Error in onDisconnect: $e');
              }
            }
          });
        } catch (e) {
          Khadem.logger.error('WebSocket upgrade error: $e');
          try {
            request.response.statusCode = HttpStatus.internalServerError;
            await request.response.close();
          } catch (_) {}
        }
      } else {
        request.response.statusCode = HttpStatus.badRequest;
        await request.response.close();
      }
    });
  });
}