From de6ff1216c2f9bdb88c35fe9a29d9304a98c1066 Mon Sep 17 00:00:00 2001
From: Tomas Stupka <tomas.stupka@oracle.com>
Date: Fri, 13 Apr 2018 12:09:22 +0200
Subject: [PATCH] adjusted graalvm package to changes in interop
---
com.oracle.truffle.r.pkgs/graalvm/R/g.R | 94 +++++++++----------
.../graalvm/data/handler.rb | 4 +-
.../graalvm/data/server.js | 32 +++----
3 files changed, 65 insertions(+), 65 deletions(-)
diff --git a/com.oracle.truffle.r.pkgs/graalvm/R/g.R b/com.oracle.truffle.r.pkgs/graalvm/R/g.R
index 5d1b5cdf53..e9d480d2dd 100644
--- a/com.oracle.truffle.r.pkgs/graalvm/R/g.R
+++ b/com.oracle.truffle.r.pkgs/graalvm/R/g.R
@@ -59,7 +59,7 @@ ping <- function() {
}
#' Start the GraalVM agent. The agent is normally started automatically upon the first
-#' code ecxecution.
+#' code execution.
#' @export
graalvm.start <- function() {
if (!ping()) {
@@ -70,14 +70,14 @@ graalvm.start <- function() {
serverScriptPath <- attr(packageDescription("graalvm"), "file")
serverScriptPath <- substr(serverScriptPath, 1, nchar(serverScriptPath)-16)
serverScriptPath <- paste0(serverScriptPath, "data/server.js")
-
- libEnvVar <- paste0("R_LIBS=", getOption("graalvm.rlibs"))
-
+
+ envVars <- paste0("R_LIBS=", getOption("graalvm.rlibs"), "; R_HOME=", gHome, "/jre/languages/R")
+
gHost <- getOption("graalvm.host");
gPort <- getOption("graalvm.port");
javaOpts <- getOption("graalvm.javaOpts");
- nodeLaunchCmd <- paste0(libEnvVar, " ", gHome, "/bin/node ", javaOpts, " ", serverScriptPath, " ", gHost, " ", gPort, " &")
+ nodeLaunchCmd <- paste0(envVars, " ", gHome, "/bin/node --jvm --polyglot", javaOpts, " ", serverScriptPath, " ", gHost, " ", gPort, " &")
system(nodeLaunchCmd, ignore.stdout = TRUE, ignore.stderr = TRUE)
attempts <- 0L
@@ -114,27 +114,27 @@ graalvm.stop <- function() {
}
#' Execute code by GraalVM using the language interpreter that corresponds
-#' to the language mimetype.
+#' to the language languageId.
#'
#' @param code the code to be executed. It must be a language element as long as the target
#' language is R, otherwise it must be a string.
#' @param echo controls whether this function returns the result of the interpreted code.
#' The default value is TRUE.
-#' @param mimetype The mimetype of the target language. Currently supported values are
-#' "application/x-r", "text/javascript" and "application/x-ruby".
+#' @param languageId The languageId of the target language. Currently supported values are
+#' "R", "js" and "ruby".
#' @family execution functions
#' @examples
#' g(runif(10^3))
#' g(runif(10^8), echo = FALSE) # We do not want that the result is returned due to its size
-#' g("1 < 2", mimetype = "text/javascript")
+#' g("1 < 2", languageId = "js")
#' @export
-g <- function(code, echo = TRUE, mimetype = "application/x-r") {
- if (mimetype == "application/x-r") {
+g <- function(code, echo = TRUE, languageId = "R") {
+ if (languageId == "R") {
code <- deparse(substitute(code))
} else {
if (!is.character(code)) stop("The code argument must a character vector")
}
- send(code, echo, mimetype)
+ send(code, echo, languageId)
}
#' Execute R code.
@@ -144,7 +144,7 @@ g <- function(code, echo = TRUE, mimetype = "application/x-r") {
#' @export
g.r <- function(code, echo = TRUE) {
if (!is.character(code)) stop("The code argument must a character vector")
- send(code, echo, "application/x-r")
+ send(code, echo, "R")
}
#' Execute JavaScript code.
@@ -154,7 +154,7 @@ g.r <- function(code, echo = TRUE) {
#' @export
g.js <- function(code, echo = TRUE) {
if (!is.character(code)) stop("The code argument must a character vector")
- send(code, echo, "text/javascript")
+ send(code, echo, "js")
}
#' Execute Ruby code.
@@ -164,7 +164,7 @@ g.js <- function(code, echo = TRUE) {
#' @export
g.rb <- function(code, echo = TRUE) {
if (!is.character(code)) stop("The code argument must a character vector")
- send(code, echo, "application/x-ruby")
+ send(code, echo, "ruby")
}
#' Assign a value to a paired variable. The value is assigned both locally and remotely.
@@ -194,10 +194,10 @@ gset <- function(var, value = var) {
stop(paste("Unpaired variable ", varName))
}
deparsedValue = NULL
- if (meta$mimetype == "application/x-r") {
+ if (meta$languageId == "R") {
deparsedValue <- paste(deparse(substitute(value)), collapse="\n")
}
- setVar(varName, value, deparsedValue, meta$mimetype)
+ setVar(varName, value, deparsedValue, meta$languageId)
} else {
stop(paste("Undefined variable ", varName))
}
@@ -207,19 +207,19 @@ gset <- function(var, value = var) {
#'
#' @family paired variables
#' @export
-gset.r <- function(var, value) setVar(deparse(substitute(var)), value, paste(deparse(substitute(value)), collapse="\n"), "application/x-r")
+gset.r <- function(var, value) setVar(deparse(substitute(var)), value, paste(deparse(substitute(value)), collapse="\n"), "R")
#' Assign the value to the paired variable in Graal JS and locally.
#'
#' @family paired variables
#' @export
-gset.js <- function(var, value) setVar(deparse(substitute(var)), value, NULL, "text/javascript")
+gset.js <- function(var, value) setVar(deparse(substitute(var)), value, NULL, "js")
#' Assign the value to the paired variable in Graal Ruby and locally.
#'
#' @family paired variables
#' @export
-gset.rb <- function(var, value) setVar(deparse(substitute(var)), value, NULL, "application/x-ruby")
+gset.rb <- function(var, value) setVar(deparse(substitute(var)), value, NULL, "ruby")
#' Retrieve the variable defined in a GraalVM language. The local variable must have been
#' initialized by one of the language specific gget.* or ggset.* functions.
@@ -233,7 +233,7 @@ gget <- function(var) {
if (is.null(meta)) {
stop(paste("Unpaired variable ", varName))
}
- getVar(varName, meta$mimetype)
+ getVar(varName, meta$languageId)
} else {
stop(paste("Undefined variable ", varName))
}
@@ -243,95 +243,95 @@ gget <- function(var) {
#'
#' @family paired variables
#' @export
-gget.r <- function(var) getVar(deparse(substitute(var)), "application/x-r")
+gget.r <- function(var) getVar(deparse(substitute(var)), "R")
#' Retrieve the variable defined in GraalVM JS.
#'
#' @family paired variables
#' @export
-gget.js <- function(var) getVar(deparse(substitute(var)), "text/javascript")
+gget.js <- function(var) getVar(deparse(substitute(var)), "js")
#' Retrieve the variable defined in GraalVM Ruby.
#'
#' @family paired variables
#' @export
-gget.rb <- function(var) getVar(deparse(substitute(var)), "application/x-ruby")
+gget.rb <- function(var) getVar(deparse(substitute(var)), "ruby")
-setVar <- function(varName, value, deparsedValue, mimetype="application/x-r") {
+setVar <- function(varName, value, deparsedValue, languageId="R") {
localValue <- value
meta <- NULL
if (exists(varName)) {
meta <- attr(var, "graalvm")
}
if (is.null(meta)) {
- meta <- list(varName = varName, mimetype = mimetype)
+ meta <- list(varName = varName, languageId = languageId)
attr(localValue, "graalvm") <- meta
}
- if (meta$mimetype == "application/x-r") {
+ if (meta$languageId == "R") {
code <- paste0(meta$varName, "<-", deparsedValue)
- } else if (meta$mimetype == "text/javascript") {
+ } else if (meta$languageId == "js") {
code <- paste0(meta$varName, "=", toJSON(value))
- } else if (meta$mimetype == "application/x-ruby") {
+ } else if (meta$languageId == "ruby") {
code <- paste0("$", meta$varName, "=", toJSON(value))
} else {
- stop(paste("Unsupported language mimetype:", mimetype))
+ stop(paste("Unsupported language languageId:", languageId))
}
- send(code, FALSE, meta$mimetype)
+ send(code, FALSE, meta$languageId)
assign(varName, localValue, inherits = TRUE)
}
-getVar <- function(varName, mimetype="application/x-r") {
+getVar <- function(varName, languageId="R") {
meta <- NULL
if (exists(varName)) {
meta <- attr(var, "graalvm")
}
if (is.null(meta)) {
- meta <- list(varName = varName, mimetype = mimetype)
+ meta <- list(varName = varName, languageId = languageId)
}
- if (meta$mimetype == "application/x-r") {
+ if (meta$languageId == "R") {
code <- meta$varName
- } else if (meta$mimetype == "text/javascript") {
+ } else if (meta$languageId == "js") {
code <- meta$varName
- } else if (meta$mimetype == "application/x-ruby") {
+ } else if (meta$languageId == "ruby") {
code <- paste0("$", meta$varName)
} else {
- stop(paste("Unsupported language mimetype:", mimetype))
+ stop(paste("Unsupported language languageId:", languageId))
}
- value <- send(code, TRUE, meta$mimetype)
+ value <- send(code, TRUE, meta$languageId)
if (!is.null(value)) {
- meta <- list("varName" = varName, "mimetype" = mimetype)
+ meta <- list("varName" = varName, "languageId" = languageId)
attr(value, "graalvm") <- meta
}
assign(varName, value, inherits = TRUE)
}
-send <- function(code, echo, mimetype) {
- tryCatch(sendAttempt(code, echo, mimetype), error = function(e) {
+send <- function(code, echo, languageId) {
+ tryCatch(sendAttempt(code, echo, languageId), error = function(e) {
# try to restart the agent and invoke it agains
graalvm.start()
- sendAttempt(code, echo, mimetype)
+ sendAttempt(code, echo, languageId)
})
}
-sendAttempt <- function(code, echo, mimetype) {
+sendAttempt <- function(code, echo, languageId) {
code <- paste(code, collapse="\n")
if (!graalvmEnv$status) {
graalvm.start()
}
h <- new_handle(failonerror = FALSE)
- handle_setform(h, code=code, echo=as.character(echo), mimetype=mimetype)
+ handle_setform(h, code=code, echo=as.character(echo), languageId=languageId)
url <- commandURL("")
resp <- curl_fetch_memory(url, handle = h)
respData <- rawToChar(resp$content)
respData <- strsplit(respData, "\r\n")[[1]]
- if (mimetype == "application/x-r") {
+ if (languageId == "R") {
respObj <- eval(parse(text=respData))
- } else if (mimetype == "text/javascript") {
+ } else if (languageId == "js") {
respObj <- fromJSON(respData)
- } else if (mimetype == "application/x-ruby") {
+ } else if (languageId == "ruby") {
respObj <- fromJSON(respData)
}
diff --git a/com.oracle.truffle.r.pkgs/graalvm/data/handler.rb b/com.oracle.truffle.r.pkgs/graalvm/data/handler.rb
index 69d9a54345..4ceac9bcc7 100644
--- a/com.oracle.truffle.r.pkgs/graalvm/data/handler.rb
+++ b/com.oracle.truffle.r.pkgs/graalvm/data/handler.rb
@@ -33,5 +33,5 @@ def toJSON(res)
Truffle::Interop.to_java_string(res.to_json)
end
-Truffle::Interop.export('storeExpr', method(:storeExpr))
-Truffle::Interop.export('rubyToJSON', method(:toJSON))
\ No newline at end of file
+Polyglot.export('storeExpr', method(:storeExpr))
+Polyglot.export('rubyToJSON', method(:toJSON))
\ No newline at end of file
diff --git a/com.oracle.truffle.r.pkgs/graalvm/data/server.js b/com.oracle.truffle.r.pkgs/graalvm/data/server.js
index 6355d01a17..2896ef911d 100644
--- a/com.oracle.truffle.r.pkgs/graalvm/data/server.js
+++ b/com.oracle.truffle.r.pkgs/graalvm/data/server.js
@@ -73,19 +73,19 @@ function evalJS(code, echo) {
}
var rHandlerScript = fs.readFileSync( __dirname + "/handler.fr", "utf8");
-Interop.eval("application/x-r", rHandlerScript);
+Polyglot.eval("R", rHandlerScript);
-rParser = Interop.import('parser');
-rResult = Interop.import('result');
-rIsError = Interop.import('isError');
-deparseObject = Interop.import('deparseObject');
+rParser = Polyglot.import('parser');
+rResult = Polyglot.import('result');
+rIsError = Polyglot.import('isError');
+deparseObject = Polyglot.import('deparseObject');
function evalR(code, echo) {
rParser(code);
if (echo) {
- Interop.eval("application/x-r", "err <- TRUE; out <- tryCatch({ err <- TRUE; r <- eval(exp); err <- FALSE; r }, error = function(e) e$message)");
+ Polyglot.eval("R", "err <- TRUE; out <- tryCatch({ err <- TRUE; r <- eval(exp); err <- FALSE; r }, error = function(e) e$message)");
} else {
- Interop.eval("application/x-r", "err <- TRUE; out <- tryCatch({ err <- TRUE; eval(exp); err <- FALSE; NULL }, error = function(e) e$message)");
+ Polyglot.eval("R", "err <- TRUE; out <- tryCatch({ err <- TRUE; eval(exp); err <- FALSE; NULL }, error = function(e) e$message)");
}
var res = {}
res.data = rResult();
@@ -94,9 +94,9 @@ function evalR(code, echo) {
}
var rubyHandlerScript = fs.readFileSync( __dirname + "/handler.rb", "utf8");
-Interop.eval("application/x-ruby", rubyHandlerScript);
-rubyStoreExpr = Interop.import('storeExpr');
-rubyToJSON = Interop.import('rubyToJSON');
+Polyglot.eval("ruby", rubyHandlerScript);
+rubyStoreExpr = Polyglot.import('storeExpr');
+rubyToJSON = Polyglot.import('rubyToJSON');
function evalRuby(code, echo) {
rubyStoreExpr(code);
@@ -107,9 +107,9 @@ function evalRuby(code, echo) {
-1
end`;
if (echo) {
- r = Interop.eval("application/x-ruby", code);
+ r = Polyglot.eval("ruby", code);
} else {
- r = Interop.eval("application/x-ruby", code);
+ r = Polyglot.eval("ruby", code);
}
var res = {}
rJSON = rubyToJSON(r);
@@ -137,16 +137,16 @@ function processPost(request, response) {
//console.log("Params: " + JSON.stringify(params));
var echo = params.echo === "TRUE";
var res;
- if (params.mimetype == "application/x-r") {
+ if (params.languageId == "R") {
res = evalR(params.code, echo);
- } else if (params.mimetype == "text/javascript") {
+ } else if (params.languageId == "js") {
res = evalJS(params.code, echo);
- } else if (params.mimetype == "application/x-ruby") {
+ } else if (params.languageId == "ruby") {
res = evalRuby(params.code, echo);
} else {
res = {
isError : true,
- data : deparseObject("Unsupported language: " + params.mimetype)
+ data : deparseObject("Unsupported language: " + params.languageId)
}
}
if (res.isError) {
--
GitLab