Commit b8154208 authored by Andreas Tille's avatar Andreas Tille

New upstream version 2.0.4

parents
Package: callr
Title: Call R from R
Version: 2.0.4
Authors@R: c(
person("Gábor", "Csárdi", role = c("aut", "cre", "cph"),
email = "csardi.gabor@gmail.com",
comment = c(ORCID = "0000-0001-7098-9676")),
person("Winston", "Chang", role = "aut"),
person("RStudio", role = c("cph", "fnd")),
person("Mango Solutions", role = c("cph", "fnd")))
Description: It is sometimes useful to perform a computation in a
separate R process, without affecting the current R process at all.
This packages does exactly that.
License: MIT + file LICENSE
LazyData: true
URL: https://github.com/r-lib/callr#readme
BugReports: https://github.com/r-lib/callr/issues
RoxygenNote: 6.0.1.9000
Imports: processx (>= 3.1.0), R6, utils
Suggests: covr, testthat, withr
Encoding: UTF-8
NeedsCompilation: no
Packaged: 2018-05-15 15:56:01 UTC; gaborcsardi
Author: Gábor Csárdi [aut, cre, cph] (<https://orcid.org/0000-0001-7098-9676>),
Winston Chang [aut],
RStudio [cph, fnd],
Mango Solutions [cph, fnd]
Maintainer: Gábor Csárdi <csardi.gabor@gmail.com>
Repository: CRAN
Date/Publication: 2018-05-15 16:36:39 UTC
YEAR: 2016
COPYRIGHT HOLDER: Mango Solutions, RStudio
58a8fa85ca12dcde6793e6f45f3c990c *DESCRIPTION
09079911e7389192b5cd3b99be725742 *LICENSE
24b36b522867eb628d55fda8da214785 *NAMESPACE
15ff52205b476040352bb20c97397545 *NEWS.md
41bbee670560ed8e430961df42c0844f *R/check.R
1af981d73baf2d14f3ef0f2137c94fa1 *R/error.R
741e12f2fa0b6e798b04b3b37614ca17 *R/eval-bg.R
f2d740e63c066a8369e87021606a47e1 *R/eval.R
29837d0f822068437c0b11c4ad3dbbb3 *R/options.R
b111ef0528b92dd46f9b87d181ad821b *R/package.R
1960cf0a2248f1ba89d39d00121a5438 *R/presets.R
57e46eb271bbc3020eb4c7bf45fa5625 *R/processx-forward.R
dcbe9c7ea85c48c2e034822bc1019cc7 *R/r-process.R
adcda965cb8f0ff2dd9d37747ca73a27 *R/rcmd-bg.R
b7e89d9aab986720bc932cd55c5dda93 *R/rcmd-process.R
5dfb418a748197e3ff73ebeea2f9ff3c *R/rcmd.R
d43ff73966f3118d574afb2668cb4d11 *R/result.R
20eea965decb7c203f12e905cd7090c4 *R/run.R
f6c29abb1a65f976c8cc67061f13dc50 *R/script.R
73e162fd02afbee7e8abe64d3aa1e433 *R/setup.R
54e7b11527174318cc822a29ef20c5ce *R/utils.R
66254ea46a2c6de87c96fb473abc7fa7 *README.md
5d976bfc318cf5c59663c744e47d88fc *inst/_pkgdown.yml
f016ae44474fd10d44cef6ccaf294913 *inst/developer-notes.md
b09aaab293cfd614e879088f0dc1dc7a *man/callr.Rd
66b8df108030a8f7d6857033105fc6ed *man/convert_and_check_my_args.Rd
e1d2ff482272edf64625401172e8cc55 *man/get_result.Rd
0f9ded268d665d0d91b2cf0fd8e9b0e1 *man/make_error.Rd
ef5d0a6f048c3860c26130e9f01d31ae *man/r.Rd
249868199e6013e23d86e3d8e739f47c *man/r_bg.Rd
2df0daaa35b88e00a49710e043e9b67d *man/r_copycat.Rd
e3f1682a7bf45272a863ded92c3f0978 *man/r_process.Rd
0ba68b24099710b8a7257b172cfb8d26 *man/r_process_options.Rd
675e10b33de2b5e39a6f3fc46083525f *man/r_vanilla.Rd
785da32d0d2bc66532f236c7f0288735 *man/rcmd.Rd
0598263f77fc98041b0fc1dc453bea79 *man/rcmd_bg.Rd
f73c95c5caa25cf24c8fabdd44ae26de *man/rcmd_copycat.Rd
51243d0c51a79e41fb24174e775be88d *man/rcmd_process.Rd
650bef3bdd486a28306d18e16fd7072c *man/rcmd_process_options.Rd
53f063f573f3fedb126751f74435d85a *man/rcmd_safe.Rd
d8ee9a320966872e15fd7ff31c2db7f5 *man/reexports.Rd
abfb3bf2c109189261fc8fe182c7918e *tests/testthat.R
b4e448e8600fa63f41cc30e5e784f75c *tests/testthat/fixtures/simple.txt
8c2590aa8056f95331b07efb3933b3ab *tests/testthat/helper.R
0ea03f705e8d0f2826aa552d001085b5 *tests/testthat/test-callback.R
c78455c5534676485d31a64fcf5f81ca *tests/testthat/test-error.R
cdd2fe2ed677ac9987cf0d56d9c36445 *tests/testthat/test-eval.R
58a377f45992b97bf840211f69989528 *tests/testthat/test-options.R
277161b9757cf4404ec6c5ed10ddb73b *tests/testthat/test-presets.R
7637bd4900c85334e8d62edfca85f8b0 *tests/testthat/test-quit.R
d4eda2bb5864fc1067677faa55184b30 *tests/testthat/test-r-bg.R
daee50f1abc1080cc5cec17ace7a23ce *tests/testthat/test-r-process.R
e70bf1ae5b2f724a2969bc39f9f162b3 *tests/testthat/test-rcmd-bg.R
6d90b63cb2be6d64eb85efc980ba96d4 *tests/testthat/test-rcmd-process.R
1a64111701a529636ce5fe4d2d3ebd89 *tests/testthat/test-rcmd.R
80fb13a15e78ee8c43d039a82101e7b4 *tests/testthat/test-timeout.R
# Generated by roxygen2: do not edit by hand
export(poll)
export(process)
export(r)
export(r_bg)
export(r_copycat)
export(r_process)
export(r_process_options)
export(r_safe)
export(r_vanilla)
export(rcmd)
export(rcmd_bg)
export(rcmd_copycat)
export(rcmd_process)
export(rcmd_process_options)
export(rcmd_safe)
export(rcmd_safe_env)
export(run)
importFrom(R6,R6Class)
importFrom(processx,poll)
importFrom(processx,process)
importFrom(processx,run)
importFrom(utils,debugger)
importFrom(utils,head)
importFrom(utils,modifyList)
importFrom(utils,tail)
# callr 2.0.4
* pkgdown web site at https://callr.r-lib.org (#52, #53).
* callr users `.Renviron` files now (and `R_ENVIRON_USER` as well),
but overrides the library path, as requested in `r()`, etc. (#30).
* callr now handles the case when the subprocess calls `quit()`.
* callr now uses the processx package, instead of embedded code,
to create and control processes.
# callr 2.0.3
* The default behavior on error can be set now with the `callr.error`
option.
* Better error message if the child R process crashes or gets killed. (#41)
* `r_bg` and `rcmd_bg` now have the `supervise` option (#45).
# callr 2.0.2
* Fix a bug with R-devel, caused by the change on 2018-02-08:
https://github.com/wch/r-source/commit/924582943706100e88a11d6bb0585d25779c91f5
#37, #38
* Fix a race condition on Windows, when creating named pipes for stdout
or stderr. The client sometimes didn't wait for the server, and callr
failed with ERROR_PIPE_BUSY (231, All pipe instances are busy).
# callr 2.0.1
* Fix compilation issues on CRAN's Solaris machine
* Fix a test failure on CRAN's macOS machine
# callr 2.0.0
* Run R or R CMD * in the background, see `r_bg()`, `rcmd_bg()`,
and also `r_process` and `rcmd_process`
* The defaults for `r()` are safer now, the match the defaults of
`r_safe()`. `r_safe()` is kept for compatibility. `r_copycat()` has the
old `r()` defaults.
* The defaults for `rcmd()` are safer now, the match the defaults of
`rcmd_safe()`. `rcmd_safe()` is kept for compatibility. `rcmd_copycat()`
has the old `rcmd()` defaults.
* Support block callbacks, in addition to line callbacks. Block callbacks
are called for arbitrary chunks of output, even without a newline
* Add `spinner` argument to show a spinner in `r()` or `rcmd()`
* Support timeouts, via the `timeout` argument
* Fix bug when stdout and stderr are redirected to the same file
* `rcmd_safe_env()` to allow extending the environment variables set in
safe mode
* `rcmd()` gets a `fail_on_status` argument
* `rcmd()` gets an `echo` argument to potentially show the command to be
run on the screen (#15)
* `rcmd()` gets a `wd` argument to set the working directory
# callr 1.0.0
First public release.
#' Convert and check function arguments
#'
#' This function is used for all variants of `r` and `rcmd`. An argument
#' name is only used to refer to one kind of object, to make this possible.
#'
#' The benefit of having a single `options` object is to avoid passing
#' around a lot of arguments all the time.
#'
#' The benefit of making this object internal (i.e. that the `r`, etc.
#' functions have multiple arguments instead of a single `options` list),
#' is that documentation and usage is more user friendly (e.g. command-
#' completion works in the editor.
#'
#' @param options List of options.
#'
#' @keywords internal
convert_and_check_my_args <- function(options) {
has <- function(x) x %in% names(options)
no <- function(x) ! has(x)
## Conversions
options <- within(options, {
if (has("libpath")) libpath <- as.character(libpath)
if (has("repos")) repos <- as.character(repos)
if (has("stdout") && !is.null(stdout)) {
stdout <- as.character(stdout)
}
if (has("stderr") && !is.null(stderr)) {
stderr <- as.character(stderr)
}
if (has("error")) error <- error[1]
if (has("cmdargs")) cmdargs <- as.character(cmdargs)
if (has("timeout") && !inherits(timeout, "difftime")) {
timeout <- as.difftime(
as.double(timeout),
units = "secs"
)
}
if (no("wd")) wd <- "."
if (no("echo")) echo <- FALSE
if (no("fail_on_status")) fail_on_status <- FALSE
if (no("tmp_files")) tmp_files <- character()
})
## Checks
with(options, stopifnot(
no("func") || is.function(func),
no("func") || is.list(args),
is.character(libpath),
is.character(repos),
no("stdout") || is.null(stdout) || is_string(stdout),
no("stderr") || is.null(stderr) || is_string(stderr),
no("error") || is_string(error),
is.character(cmdargs),
no("echo") || is_flag(echo),
no("show") || is_flag(show),
no("callback") || is.null(callback) || is.function(callback),
no("block_callback") || is.null(block_callback) ||
is.function(block_callback),
no("spinner") || is_flag(spinner),
is_flag(system_profile),
is_flag(user_profile),
is.character(env),
no("timeout") || (length(timeout) == 1 && !is.na(timeout)),
no("wd") || is_string(wd),
no("fail_on_status") || is_flag(fail_on_status)
))
options
}
#' Create an error object
#'
#' There are two kinds of errors, both have class `callr_error`:
#' 1. the first one is thrown after a timeout: `callr_timeout_error`.
#' 2. the second one is thrown after an R error (in the other session):
#' `callr_status_error`.
#'
#' @param out The object returned by [run()].
#' @param msg An extra message to add to the error message.
#' @keywords internal
make_error <- function(out, msg = NULL) {
error_class <- c(
if (out$timeout) "callr_timeout_error" else "callr_status_error",
"callr_error", "error", "condition"
)
error_msg <- paste0(
if (out$timeout) "callr timed out" else "callr failed",
if (!is.null(msg)) paste0(", ", msg) else if (!out$timeout) ":"
)
structure(
list(
message = paste(error_msg, out$stderr),
status = out$status,
stdout = out$stdout,
stderr = out$stderr
),
class = error_class
)
}
#' Evaluate an expression in another R session, in the background
#'
#' Starts evaluating an R function call in a background R process, and
#' returns immediately.
#'
#' @inheritParams r
#' @param supervise Whether to register the process with a supervisor. If \code{TRUE},
#' the supervisor will ensure that the process is killed when the R process
#' exits.
#' @return An `r_process` object, which inherits from [process],
#' so all `process` methods can be called on it, and in addition it also
#' has a `get_result()` method to collect the result.
#'
#' @export
#' @examples
#' \dontrun{
#' rx <- r_bg(function() 1 + 2)
#'
#' # wait until it is done
#' rx$wait()
#' rx$is_alive()
#' rx$get_result()
#' }
r_bg <- function(func, args = list(), libpath = .libPaths(),
repos = c(getOption("repos"),
c(CRAN = "https://cloud.r-project.org")),
stdout = "|", stderr = "|",
error = getOption("callr.error", "error"),
cmdargs = c("--no-site-file", "--slave",
"--no-save", "--no-restore"),
system_profile = FALSE, user_profile = FALSE,
env = rcmd_safe_env(), supervise = FALSE) {
r_process$new(options = as.list(environment()))
}
#' Evaluate an expression in another R session
#'
#' From `callr` version 2.0.0, `r()` is equivalent to `r_safe()`, and
#' tries to set up a less error prone execution environment. In particular:
#' * It makes sure that at least one reasonable CRAN mirror is set up.
#' * Adds some command line arguments are added to avoid saving
#' `.RData` files, etc.
#' * Ignores the system and user profiles.
#' * Various environment variables are set: `CYGWIN` to avoid
#' warnings about DOS-style paths, `R_TESTS` to avoid issues
#' when `callr` is invoked from unit tests, `R_BROWSER`
#' and `R_PDFVIEWER` to avoid starting a browser or a PDF viewer.
#' See [rcmd_safe_env()].
#'
#' The pre-2.0.0 `r()` function is called [r_copycat()] now.
#'
#' @param func Function object to call in the new R process.
#' The function should be self-contained and only refer to
#' other functions and use variables explicitly from other packages
#' using the `::` notation. The environment of the function
#' is set to `.GlobalEnv` before passing it to the child process.
#' Because of this, it is good practice to create an anonymous
#' function and pass that to `callr`, instead of passing
#' a function object from a (base or other) package. In particular
#' ```
#' r(.libPaths)
#' ```
#' does not work, because `.libPaths` is defined in a special
#' environment, but
#' ```
#' r(function() .libPaths())
#' ```
#' works just fine.
#' @param args Arguments to pass to the function. Must be a list.
#' @param libpath The library path.
#' @param repos The *repos* option. If `NULL`, then no
#' *repos* option is set. This options is only used if
#' `user_profile` or `system_profile` is set `FALSE`,
#' as it is set using the system or the user profile.
#' @param stdout The name of the file the standard output of
#' the child R process will be written to.
#' If the child process runs with the `--slave` option (the default),
#' then the commands are not echoed and will not be shown
#' in the standard output. Also note that you need to call `print()`
#' explicitly to show the output of the command(s).
#' @param stderr The name of the file the standard error of
#' the child R process will be written to.
#' In particular `message()` sends output to the standard
#' error. If nothing was sent to the standard error, then this file
#' will be empty. This can be the same file as `stderr`, although there
#' is no guarantee that the lines will be in the correct chronological
#' order.
#' @param error What to do if the remote process throws an error.
#' See details below.
#' @param cmdargs Command line arguments to pass to the R process.
#' Note that `c("-f", rscript)` is appended to this, `rscript`
#' is the name of the script file to run. This contains a call to the
#' supplied function and some error handling code.
#' @param show Logical, whether to show the standard output on the screen
#' while the child process is running. Note that this is independent
#' of the `stdout` and `stderr` arguments. The standard
#' error is not shown currently.
#' @param callback A function to call for each line of the standard
#' output and standard error from the child process. It works together
#' with the `show` option; i.e. if `show = TRUE`, and a
#' callback is provided, then the output is shown of the screen, and the
#' callback is also called.
#' @param block_callback A function to call for each block of the standard
#' output and standard error. This callback is not line oriented, i.e.
#' multiple lines or half a line can be passed to the callback.
#' @param spinner Whether to show a calming spinner on the screen while
#' the child R session is running. By default it is shown if
#' `show = TRUE` and the R session is interactive.
#' @param system_profile Whether to use the system profile file.
#' @param user_profile Whether to use the user's profile file.
#' @param env Environment variables to set for the child process.
#' @param timeout Timeout for the function call to finish. It can be a
#' [base::difftime] object, or a real number, meaning seconds.
#' If the process does not finish before the timeout period expires,
#' then a `system_command_timeout_error` error is thrown. `Inf`
#' means no timeout.
#' @return Value of the evaluated expression.
#'
#' @section Error handling:
#'
#' `callr` handles errors properly. If the child process throws an
#' error, then `callr` throws an error with the same error message
#' in the parent process.
#'
#' The `error` expert argument may be used to specify a different
#' behavior on error. The following values are possible:
#' * `error` is the default behavior: throw an error in the parent, with
#' the same error message. In fact the same error object is thrown again.
#' * `stack` also throws an error in the parent, but the error
#' is of a special kind, class `callr_error`, and it contains
#' both the original error object, and the call stack of the child,
#' as written out by [utils::dump.frames()].
#' * `debugger` is similar to `stack`, but in addition
#' to returning the complete call stack, it also start up a debugger
#' in the child call stack, via [utils::debugger()].
#'
#' The default error behavior can be also set using the `callr.error`
#' option. This is useful to debug code that uses `callr`.
#'
#' @family callr functions
#' @examples
#' \dontrun{
#' # Workspace is empty
#' r(function() ls())
#'
#' # library path is the same by default
#' r(function() .libPaths())
#' .libPaths()
#' }
#'
#' @export
r <- function(func, args = list(), libpath = .libPaths(),
repos = c(getOption("repos"),
c(CRAN = "https://cloud.r-project.org")),
stdout = NULL, stderr = NULL,
error = getOption("callr.error", "error"),
cmdargs = c("--no-site-file", "--slave",
"--no-save", "--no-restore"),
show = FALSE, callback = NULL,
block_callback = NULL, spinner = show && interactive(),
system_profile = FALSE, user_profile = FALSE,
env = rcmd_safe_env(), timeout = Inf) {
## This contains the context that we set up in steps
options <- convert_and_check_my_args(as.list(environment()))
## This cleans up everything...
on.exit(unlink(options$tmp_files, recursive = TRUE), add = TRUE)
options <- setup_script_files(options)
options <- setup_context(options)
options <- setup_callbacks(options)
options <- setup_r_binary_and_args(options)
out <- run_r(options)
get_result(output = out, options)
}
#' Create options for an [r_process] object
#'
#' @param ... Options to override, named arguments.
#' @return A list of options.
#'
#' `r_process_options()` creates a set of options to initialize a new
#' object from the `r_process` class. Its arguments must be named, the
#' names are used as option names. The options correspond to (some of)
#' the arguments of the [r()] function. At least the `func` option must be
#' specified, this is the R function to run in the background.
#'
#' @export
#' @examples
#' ## List all options and their default values:
#' r_process_options()
r_process_options <- function(...) {
update_options(r_process_options_default(), ...)
}
#' Create options for an [rcmd_process] object
#'
#' @param ... Options to override, named arguments.
#' @return A list of options.
#'
#' `rcmd_process_options()` creates a set of options to initialize a new
#' object from the `rcmd_process` class. Its arguments must be named, the
#' names are used as option names. The options correspond to (some of)
#' the arguments of the [rcmd()] function. At least the `cmd` option must
#' be specified, to select the `R CMD` subcommand to run. Typically
#' `cmdargs` is specified as well, to supply more arguments to `R CMD`.
#'
#' @export
#' @examples
#' ## List all options and their default values:
#' rcmd_process_options()
rcmd_process_options <- function(...) {
update_options(rcmd_process_options_default(), ...)
}
r_process_options_default <- function() {
list(
func = NULL,
args = list(),
libpath = .libPaths(),
repos = c(getOption("repos"), CRAN = "https://cloud.r-project.org"),
stdout = "|",
stderr = "|",
error = getOption("callr.error", "error"),
cmdargs = c("--no-site-file", "--slave",
"--no-save", "--no-restore"),
system_profile = FALSE,
user_profile = FALSE,
env = character(),
supervise = FALSE
)
}
rcmd_process_options_default <- function() {
list(
cmd = NULL,
cmdargs = character(),
libpath = .libPaths(),
stdout = "|",
stderr = "|",
repos = c(getOption("repos"), CRAN = "https://cloud.r-project.org"),
system_profile = FALSE,
user_profile = FALSE,
env = rcmd_safe_env(),
wd = ".",
supervise = FALSE
)
}
#' @importFrom utils modifyList
update_options <- function(old_opts, ...) {
new_opts <- list(...)
stopifnot(is.named(new_opts))
check_for_option_names(old_opts, new_opts)
modifyList(old_opts, new_opts)
}
check_for_option_names <- function(old, new) {
if (length(miss <- setdiff(names(new), names(old)))) {
stop("Unknown option", if (length(miss) > 1) "s", ":",
enumerate(sQuote(miss)))
}
}
#' Call R from R
#'
#' It is sometimes useful to perform a computation in a separate R
#' process, without affecting the current R process at all. This packages
#' does exactly that.
#'
#' @docType package
#' @name callr
NULL
#' Run an R child process, with no configuration
#'
#' It tries to mimic a fresh R installation. In particular:
#' * No library path setting.
#' * No CRAN(-like) repository is set.
#' * The system and user profiles are not run.
#'
#' @param ... Additional arguments are passed to [r()].
#' @inheritParams r
#'
#' @family callr functions
#' @export
#' @examples
#' \dontrun{
#' # Compare to r()
#' r(function() .libPaths())
#' r_vanilla(function() .libPaths())
#'
#' r(function() getOption("repos"))
#' r_vanilla(function() getOption("repos"))
#' }
r_vanilla <- function(func, args = list(), libpath = character(),
repos = c(CRAN = "@CRAN@"), cmdargs = "--slave",
system_profile = FALSE, user_profile = FALSE,
env = character(), ...) {
r(func, args = args, libpath = libpath, repos = repos,
cmdargs = cmdargs, system_profile = system_profile,
user_profile = user_profile, env = env, ...)
}
#' @rdname r
#' @export
r_safe <- r
#' Run an R process that mimics the current R process
#'
#' Differences to [r()]:
#' * No extra repoditories are set up.
#' * The `--no-site-file`, `--no-save`, `--no-restore`
#' command line arguments are not used. (But `--slave` still is.)
#' * The system profile and the user profile are loaded.
#' * No extra environment variables are set up.
#'
#' @inheritParams r
#' @param ... Additional arguments are passed to [r()].
#'
#' @family callr functions
#' @export
r_copycat <- function(func, args = list(), libpath = .libPaths(),
repos = getOption("repos"), cmdargs = "--slave",
system_profile = TRUE, user_profile = TRUE,
env = character(), ...) {
r(func, args = args, libpath = libpath, repos = repos, cmdargs = cmdargs,
system_profile = system_profile, user_profile = user_profile,
env = env, ...)
}
#' @importFrom processx run
#' @export
processx::run
#' @importFrom processx process
#' @export
processx::process
#' @importFrom processx poll
#' @export
processx::poll
#' External R Process
#'
#' An R process that runs in the background. This is an R6 class that
#' extends the [process] class.
#'
#' @section Usage:
#' ```
#' rp <- r_process$new(options)
#' rp$get_result()
#' ```
#'
#' See [process] for the inherited methods.
#'
#' @section Arguments:
#' * `options` A list of options created via [r_process_options()].
#'
#' @section Details:
#' `r_process$new` creates a new instance. Its `options` argument is best
#' created by the [r_process_options()] function.
#'
#' `rp$get_result()` returns the result, an R object, from a finished
#' background R process. If the process has not finished yet, it throws an
#' error. (You can use `rp$wait()` to wait for the process to finish,
#' optionally with a timeout.)
#'
#' @name r_process
#' @examples
#' \dontrun{
#' ## List all options and their default values:
#' r_process_options()
#'
#' ## Start an R process in the background, wait for it, get result
#' opts <- r_process_options(func = function() 1 + 1)
#' rp <- r_process$new(opts)
#' rp$wait()
#' rp$get_result()
#' }
NULL
#' @importFrom R6 R6Class
#' @export
r_process <- R6Class(
"r_process",
inherit = process,
public = list(
initialize = function(options)
rp_init(self, private, super, options),
get_result = function()
rp_get_result(self, private)
),
private = list(
options = NULL
)
)
rp_init <- function(self, private, super, options) {
## This contains the context that we set up in steps
options <- convert_and_check_my_args(options)
options <- setup_script_files(options)
options <- setup_context(options)
options <- setup_r_binary_and_args(options)
private$options <- options
with_envvar(
options$env,
super$initialize(options$bin, options$real_cmdargs,
stdout = options$stdout, stderr = options$stderr,
supervise = options$supervise)
)
invisible(self)
}