callr version 2.0.0,
r() is equivalent to
tries to set up a less error prone execution environment. In particular:
Ensures that at least one reasonable CRAN mirror is set up.
Adds some command line arguments to avoid saving
.RData files, etc.
Ignores the system and user profiles (by default).
Sets various environment variables:
CYGWIN to avoid
warnings about DOS-style paths,
R_TESTS to avoid issues
callr is invoked from unit tests,
R_PDFVIEWER to avoid starting a browser or a PDF viewer.
r( func, args = list(), libpath = .libPaths(), repos = default_repos(), stdout = NULL, stderr = NULL, poll_connection = TRUE, error = getOption("callr.error", "error"), cmdargs = c("--slave", "--no-save", "--no-restore"), show = FALSE, callback = NULL, block_callback = NULL, spinner = show && interactive(), system_profile = FALSE, user_profile = "project", env = rcmd_safe_env(), timeout = Inf, package = FALSE, arch = "same", ... ) r_safe( func, args = list(), libpath = .libPaths(), repos = default_repos(), stdout = NULL, stderr = NULL, poll_connection = TRUE, error = getOption("callr.error", "error"), cmdargs = c("--slave", "--no-save", "--no-restore"), show = FALSE, callback = NULL, block_callback = NULL, spinner = show && interactive(), system_profile = FALSE, user_profile = "project", env = rcmd_safe_env(), timeout = Inf, package = FALSE, arch = "same", ... )
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
does not work, because
works just fine.
Arguments to pass to the function. Must be a list.
The library path.
The name of the file the standard output of
the child R process will be written to.
If the child process runs with the
The name of the file the standard error of
the child R process will be written to.
Whether to have a control connection to the process. This is used to transmit messages from the subprocess to the main process.
What to do if the remote process throws an error. See details below.
Command line arguments to pass to the R process.
Logical, whether to show the standard output on the screen
while the child process is running. Note that this is independent
A function to call for each line of the standard
output and standard error from the child process. It works together
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.
Whether to show a calming spinner on the screen while
the child R session is running. By default it is shown if
Whether to use the system profile file.
Whether to use the user's profile file.
If this is
Environment variables to set for the child process.
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,
Whether to keep the environment of
Architecture to use in the child process, for multi-arch
builds of R. By default the same as the main process. See
Extra arguments are passed to
Value of the evaluated expression.
r() function from before 2.0.0 is called
callr handles errors properly. If the child process throws an
callr throws an error with the same error message
in the main process.
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 main process,
with a prefix and the same error message as in the subprocess.
stack also throws an error in the main process, 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(). This is now deprecated,
because the error thrown for
"error" has the same information.
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
The default error behavior can be also set using the
option. This is useful to debug code that uses
callr uses parent errors, to keep the stacks of the main process and the subprocess(es) in the same error object.
callr makes a copy of the user's
.Renviron file and potentially of
the local or user
.Rprofile, in the session temporary
directory. Avoid storing sensitive information such as passwords, in
your environment file or your profile, otherwise this information will
get scattered in various files, at least temporarily, until the
subprocess finishes. You can use the keyring package to avoid passwords
in plain files.