RPyC (Remote Python Call)

Warnings

• breaking RPyC 6.0.0 introduced a security fix for a Remote Code Execution (RCE) vulnerability related to the `__array__` attribute, which breaks backward compatibility for code relying on `numpy`'s usage of this attribute. The RCE was exploitable if the server-side explicitly called `np.array(x)` on a remote object.
  Fix: Upgrade to RPyC 6.0.0 or later. If relying on `__array__` for NumPy integration, review usage patterns and potentially adapt to new serialization or exposure methods.
• breaking RPyC 5.0.0 officially dropped support for Python 2, coinciding with its end-of-life. Attempting to connect Python 2 clients to Python 3 servers (or vice-versa) or using RPyC 5+ on Python 2 will lead to incompatibility issues due to fundamental differences in Python's object model and bytecode.
  Fix: Migrate all RPyC clients and servers to Python 3.8+ and RPyC 5.0.0 or later.
• gotcha Teleporting functions (e.g., using `rpyc.utils.classic.teleport_function`) between different Python major versions or even different RPyC versions is not officially supported and can lead to errors due to Python bytecode differences. It is recommended to ensure both client and server run the same Python and RPyC versions when using this feature.
  Fix: Ensure client and server use the same Python version and RPyC library version when teleporting functions. For complex objects or closures, consider alternatives like external serialization libraries (e.g., `dill`) or refactoring.
• gotcha Running a classic RPyC server with `--host 0.0.0.0` (which was the default in older versions) exposes it to arbitrary code execution from any connecting client. This can be a significant security risk.
  Fix: Bind the RPyC server to a specific IP address (e.g., `127.0.0.1` for local connections or a specific network interface) or use proper authentication and encryption (SSL/TLS, SSH) for production environments. Always review the exposed services and methods carefully.
• breaking RPyC 5.3.1 included a fix for an experimental thread binding struct that, while fixing issues on some platforms, was not backward compatible. This primarily affects users experimenting with the thread binding feature.
  Fix: Upgrade to RPyC 5.3.1 or later. If you were using the experimental thread binding feature on older versions, be aware of potential changes in behavior.

Install

• pip install rpyc Install RPyC

Imports

• rpyc

  import rpyc

• rpyc.utils.server.ThreadedServer

  from rpyc.utils.server import ThreadedServer

• rpyc.Service

  import rpyc
  
  class MyService(rpyc.Service):
      # ...
  

  Custom services typically inherit from `rpyc.Service`.
• rpyc.classic.connect

  import rpyc
  
  conn = rpyc.classic.connect('localhost', 18812)

  Used for 'classic' RPyC connections to directly access remote modules and built-ins.

Quickstart

This quickstart demonstrates a simple RPyC client-server interaction. First, save the server code as `server.py` and run it in a terminal. Then, save the client code as `client.py` and run it in another terminal to connect to the server, call a remote method, and access a remote module.

# server.py
import rpyc
from rpyc.utils.server import ThreadedServer

class MathService(rpyc.Service):
    def on_connect(self, conn):
        print("Client connected!")

    def on_disconnect(self, conn):
        print("Client disconnected!")

    def exposed_fib(self, n):
        """Calculates the Fibonacci sequence up to n."""
        seq = []
        a, b = 0, 1
        while a < n:
            seq.append(a)
            a, b = b, a + b
        return seq

if __name__ == '__main__':
    # Using a fixed port for demonstration
    port = 18812
    print(f"Starting MathService on port {port}...")
    ts = ThreadedServer(MathService, port=port)
    ts.start()

# --- Save the above as server.py and run: python server.py ---

# client.py
import rpyc
import time

def run_client():
    host = "localhost" # Replace with your server's address if remote
    port = 18812
    try:
        conn = rpyc.connect(host, port)
        print(f"Connected to RPyC server at {host}:{port}")

        # Access an exposed method on the root object
        result = conn.root.fib(1000)
        print(f"Fibonacci sequence up to 1000: {result}")

        # Example of accessing a remote module (classic RPyC behavior)
        remote_sys_version = conn.modules.sys.version
        print(f"Remote Python version: {remote_sys_version.splitlines()[0]}")

        conn.close()
        print("Connection closed.")
    except ConnectionRefusedError:
        print(f"Error: Connection refused. Is the server running on {host}:{port}?")
    except Exception as e:
        print(f"An error occurred: {e}")

if __name__ == '__main__':
    # Optional: Give the server a moment to start if run immediately after
    # time.sleep(1)
    run_client()