Method start

raphtory-graphql/src/python/server/server.rs:211–270

(&self, port: Option<u16>, timeout_ms: u64)

        signature = (port = None, timeout_ms = 5000)
    )]
    pub fn start(&self, port: Option<u16>, timeout_ms: u64) -> PyResult<PyRunningGraphServer> {
        let (sender, receiver) = crossbeam_channel::bounded::<BridgeCommand>(1);
        let (start_sender, start_receiver) = crossbeam_channel::bounded::<ServerStarted>(1);
        let cloned_sender = sender.clone();
        let server = self.0.clone();

        let join_handle = thread::spawn(move || {
            block_on(async move {
                let running_server = match port {
                    None => server.start().await?,
                    Some(port) => server.start_with_port(port).await?,
                };
                if let Err(_) = start_sender.send(ServerStarted {
                    port: running_server.port(),
                }) {
                    // This happens if the other end of the channel doesn't exist
                    running_server.stop().await;
                    return Ok(());
                };

                let tokio_sender = running_server._get_sender().clone();
                tokio::task::spawn_blocking(move || {
                    match receiver.recv().expect("Failed to wait for cancellation") {
                        BridgeCommand::StopServer => tokio_sender
                            .blocking_send(())
                            .expect("Failed to send cancellation signal"),
                        BridgeCommand::StopListening => (),
                    }
                });
                let result = running_server.wait().await;
                _ = cloned_sender.send(BridgeCommand::StopListening);
                result
            })
        });

        let port = match start_receiver.recv_timeout(Duration::from_millis(timeout_ms)) {
            Ok(msg) => msg.port,
            Err(err) => {
                match err {
                    RecvTimeoutError::Timeout => {
                        return Err(PyRuntimeError::new_err(format!(
                            "Failed to start server in {timeout_ms} milliseconds"
                        )))
                    }
                    RecvTimeoutError::Disconnected => {
                        // failure in server start, extract the error
                        let result = join_handle.join().unwrap(); // propagate any panic
                        let err = match result {
                            Ok(_) => PyRuntimeError::new_err("Failed to start server"),
                            Err(err) => adapt_err_value(&err),
                        };
                        return Err(err);
                    }
                }
            }
        };

        let server = PyRunningGraphServer::new(join_handle, sender, port)?;