RStudio jobs support

[gaborcsardi]

From callr:

fun <- function() {
  for (i in 1:10) {
    cat(paste(i, "\n"))
    prog <- paste0("# ---- ", Sys.getenv("RSTUDIO_API_JOB_ID"),
                   " progress ", i*10, "%\n")
    cat(prog)
    Sys.sleep(1)
  }
}

r <- callr::r_bg(fun, stdout = "|rstudio", stderr = "|rstudio",
                 rstudio_job = TRUE, 
                 rstudio_job_options = list(name = "bgr", progress = TRUE))

Running a shell script from processx, save this as test.sh first, then run the R code:

#! /bin/bash

for i in `seq 1 10`
do
  sleep 1
  echo $i
  echo "# ---- $RSTUDIO_API_JOB_ID progress ${i}0%"
done

p <- process$new(
  "./test.sh", 
  rstudio_job = TRUE, 
  rstudio_job_options = list(nam = "myjob", progress = TRUE)
)

Glitches that could be improved with some changes in RStudio and rstudioapi:

• Switches to the job pane, and then to the console.
• Needs to create another RStudio job to show the progress.

This is Unix only, for now. Windows is coming soon as well.

[gaborcsardi]

This is quite difficult to implement on Windows, unfortunately. The closest I got is this, maybe this is doable with some more effort:

1. Create a pipe server in the main process.
2. Start RStudio job process, then wait.
3. The job process connects to the pipe server.
4. The job process tells the main process that it has connected to the pipe, and the main process can continue.
5. The main process starts the subprocess, and passes the server end of the pipe to it.

The difficult step is 4, because reading from or writing to a pipe that does not have both ends connected is an error. So the main process cannot simply poll the read end of the pipe.

There is ConnectNamedPipe(), but this is a non-interruptible call, unless we use overlapped IO. But if we use overlapped IO and pass the overlapped pipe to the child process, then (in theory) the child process must also use overlapped IO when writing to the stdout. Which is quite a strong assumption. Luckily, doing a synchronous write on an overlapped handle seems to work and block internally. (It is potentially problematic if one mixes it with asynchronous calls, but the child process will probably not do that.) (https://community.osr.com/discussion/comment/225712/#Comment_225712)

In addition to the Windows difficulties, the other downside of the FIFO (or named pipe) approach is that the background process will die when trying to write to a terminated RStudio job process. So maybe it is better to use a temp file for this, and we can poll() the file on Unix and open the file with overlapped IO on Windows. If this works at all.