Method run_connection

packages/server/src/webkit.rs:256–398

(&self, socket: WebKitSocket)

    }

    async fn run_connection(&self, socket: WebKitSocket) -> Result<(), AppError> {
        let mut stream = timeout(WEBKIT_IO_TIMEOUT, UnixStream::connect(&socket.path))
            .await
            .map_err(|_| AppError::native("Timed out connecting to simulator webinspectord."))?
            .map_err(|error| {
                AppError::native(format!(
                    "Unable to connect to simulator webinspectord at {}: {error}",
                    socket.path
                ))
            })?;

        let connection_id = new_remote_inspector_id();
        send_rpc(
            &mut stream,
            "_rpc_reportIdentifier:",
            rpc_args(&connection_id),
        )
        .await?;
        sleep(WEBKIT_SOCKET_ACTIVATION_DELAY).await;
        send_get_connected_applications(&mut stream, &connection_id).await?;

        let mut next_listing_refresh = Instant::now() + WEBKIT_DISCOVERY_REFRESH_INTERVAL;
        let mut applications: BTreeMap<String, WebKitApplication> = BTreeMap::new();
        let mut requested_listings: HashSet<String> = HashSet::new();
        let mut pages: BTreeMap<(String, u64), WebKitPage> = BTreeMap::new();

        loop {
            let read_timeout = Duration::from_millis(500);
            let packet = match timeout(read_timeout, read_packet(&mut stream)).await {
                Ok(Ok(packet)) => packet,
                Ok(Err(error)) => return Err(error),
                Err(_) => {
                    if Instant::now() >= next_listing_refresh {
                        send_get_connected_applications(&mut stream, &connection_id).await?;
                        for app_id in applications.keys() {
                            send_forward_get_listing(&mut stream, &connection_id, app_id).await?;
                        }
                        next_listing_refresh = Instant::now() + WEBKIT_DISCOVERY_REFRESH_INTERVAL;
                    }
                    continue;
                }
            };

            let message = match parse_rpc_message(&packet) {
                Ok(message) => message,
                Err(error) => {
                    debug!("Ignoring malformed WebKit discovery packet: {error}");
                    continue;
                }
            };
            debug!(
                selector = %message.selector,
                "Received WebKit discovery selector"
            );

            match message.selector.as_str() {
                "_rpc_reportConnectedApplicationList:" => {
                    let live_apps = parse_application_list(&message.args);