Reference

connect_repl([host=localhost,] port::Integer=27754;
             tunnel = (host != localhost) ? :ssh : :none,
             ssh_opts = ``, region=nothing, namespace=nothing,
             repl=Base.active_repl, session_id = nothing)

Connect client REPL to a remote host on port. This is then accessible as a remote sub-repl of the current Julia session.

For security, connect_repl() uses an ssh tunnel for remote hosts. This means that host needs to be running an ssh server and you need ssh credentials set up for use on that host. For secure networks this can be disabled by setting tunnel=:none.

To provide extra options to SSH, you may pass a Cmd object in the ssh_opts keyword, for example an identity file may be set with ssh_opts = `-i /path/to/identity.pem`. For a more permanent solution, add a Host section to your ssh config file.

You can also use the following technologies for tunneling in place of SSH:

1. AWS Session Manager: set tunnel=:aws. The optional region keyword argument can be used to specify the AWS Region of your server.
2. kubectl: set tunnel=:k8s. The optional namespace keyword argument can be used to specify the namespace of your Kubernetes resource.

See README.md for more information.

serve_repl([address=Sockets.localhost,] port=27754; [on_client_connect=nothing])
serve_repl(server)

Start a REPL server listening on interface address and port. In normal operation serve_repl() serves REPL clients indefinitely (ie., it does not return), so you will generally want to launch it using @async serve_repl() to do other useful work at the same time.

The hook on_client_connect may be supplied to modify the ServerSideSession for a client after each client connects. This can be used to define the default module in which the client evaluates commands.

If you want to be able to stop the server you can pass an already-listening server object (the result of Sockets.listen()). The server can then be cancelled from another task using close(server) as necessary to control the server lifetime.

Security

serve_repl() uses an unauthenticated, unecrypted protocol so it should not be used on open networks or multi-user machines where other users aren't trusted. For open networks, use the default address=Sockets.localhost and the automatic ssh tunnel support provided by the client-side connect_repl().

connect_remote([host=localhost,] port::Integer=27754;
             tunnel = (host != localhost) ? :ssh : :none,
             ssh_opts = ``, session_id = nothing)

Connect to remote server without any REPL integrations. This will allow you to use @remote, but not the REPL mode. Useful in circumstances where no REPL is available, but interactivity is desired like Jupyter or Pluto notebooks. Otherwise, see connect_repl.

@remote ex

Execute expression ex on the other side of the current RemoteREPL connection and return the value.

This can be used in both directions:

1. From the normal julia> prompt, execute ex on the remote server and return the value to the client.
2. From a remote prompt, execute ex on the client and push the resulting value to the remote server.

Examples

Push a value from the client to the server:

julia> client_val = 1:100;

julia@localhost> server_val = @remote client_val
1:100

Fetch a pair of variables (x,y) from the server, and plot them on the client with a single line:

# In two lines
julia> x,y = @remote (x, y)
       plot(x, y)

# Or as a single expression
julia> plot(@remote((x, y))...)

remote_eval(cmdstr)
remote_eval(host, port, cmdstr)

Parse a string cmdstr, evaluate it in the remote REPL server's Main module or the session with session_id, then close the connection. Returns the result which the REPL would normally pass to show() (likely a Text object).

For example, to cause the remote Julia instance to exit, you could use

using RemoteREPL
RemoteREPL.remote_eval("exit()")

remotecmd(conn::Connection, out_stream::IO, cmdstr::String)

Evaluate cmdstr in the remote session of connection conn and write result into out_stream. Also supports the magic RemoteREPL commands like %module and %include.

remotecmd(cmdstr::String)

Evaluate cmdstr in the last opened RemoteREPL connection and print result to Base.stdout

remotecmd(conn::Connection, cmdstr::String)

Evaluate cmdstr in the connection conn and print result to Base.stdout.

remote_module!(conn::Connection = _repl_client_connection, mod::Module)

Change future remote commands in the session of connection conn to be evaluated into module mod. The default connection _repl_client_connection is the last established RemoteREPL connection. If the module cannot be evaluated locally pass the name as a string. Equivalent to using the %module magic.

remote_module!(conn::Connection = _repl_client_connection, modstr::String)

Change future remote commands in the session of connection conn to be evaluated into module identified by modstr. The default connection _repl_client_connection is the last established RemoteREPL connection. Equivalent to using the %module magic.