Experiment with callr session

Author: renkun-ken

R/notebook2.R

@@ -0,0 +1,142 @@
+requireNamespace("jsonlite")
+requireNamespace("callr")
+
+args <- commandArgs(trailingOnly = TRUE)
+exprs <- parse(text = args, keep.source = FALSE)
+env <- new.env()
+for (expr in exprs) {
+  eval(expr, env)
+}
+
+# r <- callr::r_session$new(
+#   callr::r_session_options(
+#     system_profile = TRUE, user_profile = TRUE, supervise = TRUE),
+#   wait = TRUE
+# )
+
+# r$run(function() {
+#   requireNamespace("jsonlite")
+#   requireNamespace("svglite")
+
+#   .vscNotebook <- local({
+#     null_dev_id <- c(pdf = 2L)
+#     null_dev_size <- c(7 + pi, 7 + pi)
+#     viewer_file <- NULL
+#     browser_url <- NULL
+
+#     options(
+#       device = function(...) {
+#         pdf(NULL,
+#           width = null_dev_size[[1L]],
+#           height = null_dev_size[[2L]],
+#           bg = "white")
+#         dev.control(displaylist = "enable")
+#       },
+#       viewer = function(url, ...) {
+#         write_log("viewer: ", url)
+#         viewer_file <<- url
+#       },
+#       page_viewer = function(url, ...) {
+#         write_log("page_viewer: ", url)
+#         viewer_file <<- url
+#       },
+#       browser = function(url, ...) {
+#         write_log("browser: ", url)
+#         browser_url <<- url
+#       }
+#     )
+
+#     check_null_dev <- function() {
+#       identical(dev.cur(), null_dev_id) &&
+#         identical(dev.size(), null_dev_size)
+#     }
+
+#     evaluate <- function(expr) {
+#       tryCatch({
+#         out <- withVisible(eval(expr, globalenv()))
+#         text <- utils::capture.output(print(out$value, view = TRUE))
+#         if (check_null_dev()) {
+#           record <- recordPlot()
+#           plot_file <- tempfile(fileext = ".svg")
+#           svglite::svglite(plot_file, width = 12, height = 8)
+#           replayPlot(record)
+#           graphics.off()
+#           res <- list(
+#             type = "plot",
+#             result = plot_file
+#           )
+#         } else if (!is.null(viewer_file)) {
+#           res <- list(
+#             type = "viewer",
+#             result = viewer_file
+#           )
+#         } else if (!is.null(browser_url)) {
+#           res <- list(
+#             type = "browser",
+#             result = browser_url
+#           )
+#         } else if (out$visible) {
+#           res <- list(
+#             type = "text",
+#             result = paste0(text, collapse = "\n")
+#           )
+#         } else {
+#           res <- list(
+#             type = "text",
+#             result = ""
+#           )
+#         }
+#       })
+
+#       res
+#     }
+
+#     environment()
+#   })
+
+#   attach(environment(), name = "tools:vscNotebook")
+#   NULL
+# })
+
+con <- socketConnection(host = "127.0.0.1", port = env$port, open = "r+b")
+
+while (TRUE) {
+  if (socketSelect(list(con), timeout = 0)) {
+    header <- readLines(con, 1, encoding = "UTF-8")
+    n <- as.integer(gsub("^Content-Length: (\\d+)$", "\\1", header))
+    content <- readChar(con, n, useBytes = TRUE)
+    Encoding(content) <- "UTF-8"
+    print(content)
+  }
+  Sys.sleep(0.1)
+}
+
+# while (TRUE) {
+#   write_log("Listening on port: ", env$port)
+#   con <- try(socketConnection(host = "127.0.0.1", port = env$port,
+#     blocking = TRUE, server = TRUE,
+#     open = "r+"), silent = TRUE)
+#   if (inherits(con, "try-error")) {
+#     message(con)
+#   } else {
+#     tryCatch({
+#       line <- readLines(con, n = 1)
+#       write_log(line)
+#       request <- jsonlite::fromJSON(line)
+
+#       str <- tryCatch({
+#         expr <- parse(text = request$expr)
+#       }, error = function(e) {
+#         list(
+#           type = "error",
+#           result = conditionMessage(e)
+#         )
+#       }
+#       )
+#       response <- jsonlite::toJSON(str, auto_unbox = TRUE, force = TRUE)
+#       writeLines(response, con)
+#     }, error = function(e) {
+#       message(e)
+#     }, finally = close(con))
+#   }
+# }

src/notebook.ts

@@ -2,7 +2,6 @@ import * as vscode from 'vscode';
 import net = require('net');
 import { spawn, ChildProcess } from 'child_process';
 import { dirname } from 'path';
-import getPort = require('get-port');
 import * as fs from 'fs';
 
 interface REvalOutput {
@@ -12,13 +11,23 @@ interface REvalOutput {
 
 class RKernel {
   private kernelScript: string;
+  private doc: vscode.NotebookDocument;
   private cwd: string;
   private process: ChildProcess;
   private port: number;
+  private socket: net.Socket;
 
   constructor(kernelScript: string, doc: vscode.NotebookDocument) {
     this.kernelScript = kernelScript;
     this.cwd = dirname(doc.uri.fsPath);
+    this.doc = doc;
+  }
+
+  private request(obj: any) {
+    if (this.socket) {
+      const json = JSON.stringify(obj);
+      this.socket.write(`Content-Length: ${json.length}\n${json}\n`);
+    }
   }
 
   public async start() {
@@ -29,21 +38,38 @@ class RKernel {
     const env = Object.create(process.env);
     env.LANG = 'en_US.UTF-8';
 
-    this.port = await getPort();
-    const childProcess = spawn('R', ['--quiet', '--slave', '-f', this.kernelScript, '--args', `port=${this.port}`],
-      { cwd: this.cwd, env: env });
-    childProcess.stderr.on('data', (chunk: Buffer) => {
-      const str = chunk.toString();
-      console.log(`R stderr (${childProcess.pid}): ${str}`);
-    });
-    childProcess.stdout.on('data', (chunk: Buffer) => {
-      const str = chunk.toString();
-      console.log(`R stdout (${childProcess.pid}): ${str}`);
+    const server = net.createServer(socket => {
+      console.log('socket started');
+      this.socket = socket;
+      socket.on('data', (chunk: Buffer) => {
+        const str = chunk.toString();
+        console.log(`socket (${socket.localAddress}:${socket.localPort}): ${str}`);
+      });
+      socket.on('end', () => {
+        console.log('socket disconnected');
+        this.socket = undefined;
+      });
+      server.close();
     });
-    childProcess.on('exit', (code, signal) => {
-      console.log(`R exited with code ${code}`);
+
+    server.listen(0, '127.0.0.1', () => {
+      this.port = (server.address() as net.AddressInfo).port;
+      const childProcess = spawn('R', ['--quiet', '--slave', '-f', this.kernelScript, '--args', `port=${this.port}`],
+        { cwd: this.cwd, env: env });
+      childProcess.stderr.on('data', (chunk: Buffer) => {
+        const str = chunk.toString();
+        console.log(`R stderr (${childProcess.pid}): ${str}`);
+      });
+      childProcess.stdout.on('data', (chunk: Buffer) => {
+        const str = chunk.toString();
+        console.log(`R stdout (${childProcess.pid}): ${str}`);
+      });
+      childProcess.on('exit', (code, signal) => {
+        console.log(`R exited with code ${code}`);
+      });
+      this.process = childProcess;
+      return childProcess;
     });
-    this.process = childProcess;
 
     return new Promise((resolve) => setTimeout(resolve, 500));
   }
@@ -61,6 +87,13 @@ class RKernel {
   }
 
   public async eval(cell: vscode.NotebookCell): Promise<REvalOutput> {
+    if (this.socket) {
+      this.request({
+        uri: cell.uri,
+        time: Date.now(),
+        expr: cell.document.getText(),
+      });
+    }
     if (this.process) {
       const client = net.createConnection({ host: '127.0.0.1', port: this.port }, () => {
         console.log(`uri: ${cell.uri}, connect`);