Function spawn_vm_thread

components/vm/src/vmthread.rs:13–67

(
    create: CreateRt,
    make_span: F,
)

use crate::vm::{CreateRt, ShutdownReason, Vm, VmShutdownHandle};

pub async fn spawn_vm_thread<F: FnOnce() -> tracing::Span + Send + Sync + 'static>(
    create: CreateRt,
    make_span: F,
) -> VmShutdownHandle {
    let (vm_created_send, vm_created_recv) = oneshot::channel();
    let (ping_send, mut ping_recv) = mpsc::channel::<oneshot::Sender<()>>(1);

    std::thread::spawn(move || {
        let rt = tokio::runtime::Builder::new_current_thread()
            .enable_all()
            .build()
            .unwrap();

        let cpu_counter = counter!("bl.vm.cpu_microseconds_total");
        let result = Vm::create_with_handles(create, cpu_counter);
        vm_created_send
            .send(result.shutdown_handle.clone())
            .unwrap();

        // tokio_current.block_on(t);
        let span = make_span();
        rt.block_on(
            async move {
                let set = LocalSet::new();

                // A simple task that sends echo responses on a channel
                //
                // if the js runtime encounters a runaway situation with something like
                // an infinite "for" loop, then the thread will be blocked and this task
                // will not send echo responses anymore, leading to an outside thread
                // being able to detect the runaway and being able to shut down the runaway runtime
                set.spawn_local(async move {
                    loop {
                        match ping_recv.recv().await {
                            Some(r) => {
                                let _ = r.send(());
                            }
                            None => return,
                        }
                    }
                });
                set.run_until(result.future).await
            }
            .instrument(span),
        );

        rt.shutdown_timeout(tokio::time::Duration::from_secs(60));
    });

    let shutdown_handle = vm_created_recv.await.unwrap();

    tokio::spawn(monitor_vm_runaway(shutdown_handle.clone(), ping_send));

    shutdown_handle
}

// runaway script detection ensures that no single vm can
// block the thread for more than the allowed interval