Sandbox

Sandbox class for Daytona SDK.

Constructors

new Sandbox()

ruby

def initialize(sandbox_dto:, config:, sandbox_api:, otel_state:)

Returns:

Sandbox - a new instance of Sandbox

Methods

id()

ruby

def id()

Returns:

String - The ID of the sandbox

organization_id()

ruby

def organization_id()

Returns:

String - The organization ID of the sandbox

snapshot()

ruby

def snapshot()

Returns:

String - The snapshot used for the sandbox

user()

ruby

def user()

Returns:

String - The user associated with the project

env()

ruby

def env()

Returns:

Hash\<String, String\>, nil - Environment variables for the sandbox. Not returned by list results; call #refresh on each item to populate.

labels()

ruby

def labels()

Returns:

Hash\<String, String\> - Labels for the sandbox

public()

ruby

def public()

Returns:

Boolean - Whether the sandbox http preview is public

network_block_all()

ruby

def network_block_all()

Returns:

Boolean, nil - Whether to block all network access for the sandbox. Not returned by list results; call #refresh on each item to populate.

network_allow_list()

ruby

def network_allow_list()

Returns:

String, nil - Comma-separated list of allowed CIDR network addresses for the sandbox. Not returned by list results; call #refresh on each item to populate.

target()

ruby

def target()

Returns:

String - The target environment for the sandbox

cpu()

ruby

def cpu()

Returns:

Float - The CPU quota for the sandbox

gpu()

ruby

def gpu()

Returns:

Float - The GPU quota for the sandbox

memory()

ruby

def memory()

Returns:

Float - The memory quota for the sandbox

disk()

ruby

def disk()

Returns:

Float - The disk quota for the sandbox

state()

ruby

def state()

Returns:

DaytonaApiClient:SandboxState - The state of the sandbox

desired_state()

ruby

def desired_state()

Returns:

DaytonaApiClient:SandboxDesiredState - The desired state of the sandbox

error_reason()

ruby

def error_reason()

Returns:

String - The error reason of the sandbox

backup_state()

ruby

def backup_state()

Returns:

String - The state of the backup

backup_created_at()

ruby

def backup_created_at()

Returns:

String, nil - The creation timestamp of the last backup. Not returned by list results; call #refresh on each item to populate.

auto_stop_interval()

ruby

def auto_stop_interval()

Returns:

Float - Auto-stop interval in minutes (0 means disabled)

auto_archive_interval()

ruby

def auto_archive_interval()

Returns:

Float - Auto-archive interval in minutes

auto_delete_interval()

ruby

def auto_delete_interval()

(negative value means disabled, 0 means delete immediately upon stopping)

Returns:

Float - Auto-delete interval in minutes

volumes()

ruby

def volumes()

Returns:

Array\<DaytonaApiClient:SandboxVolume\>, nil - Volumes attached to the sandbox. Not returned by list results; call #refresh on each item to populate.

build_info()

ruby

def build_info()

Returns:

DaytonaApiClient:BuildInfo, nil - Build information for the sandbox if it was created from a dynamic build. Not returned by list results; call #refresh on each item to populate.

created_at()

ruby

def created_at()

Returns:

String - The creation timestamp of the sandbox

updated_at()

ruby

def updated_at()

Returns:

String - The last update timestamp of the sandbox

last_activity_at()

ruby

def last_activity_at()

Returns:

String - The last activity timestamp of the sandbox

daemon_version()

ruby

def daemon_version()

Returns:

String - The version of the daemon running in the sandbox

config()

ruby

def config()

Returns:

Daytona:Config

sandbox_api()

ruby

def sandbox_api()

Returns:

DaytonaApiClient:SandboxApi

process()

ruby

def process()

Returns:

Daytona:Process

fs()

ruby

def fs()

Returns:

Daytona:FileSystem

git()

ruby

def git()

Returns:

Daytona:Git

computer_use()

ruby

def computer_use()

Returns:

Daytona:ComputerUse

code_interpreter()

ruby

def code_interpreter()

Returns:

Daytona:CodeInterpreter

archive()

ruby

def archive()

Archives the sandbox, making it inactive and preserving its state. When sandboxes are archived, the entire filesystem state is moved to cost-effective object storage, making it possible to keep sandboxes available for an extended period. The tradeoff between archived and stopped states is that starting an archived sandbox takes more time, depending on its size. Sandbox must be stopped before archiving.

Returns:

void

auto_archive_interval=()

ruby

def auto_archive_interval=(interval)

Sets the auto-archive interval for the Sandbox. The Sandbox will automatically archive after being continuously stopped for the specified interval.

Parameters:

interval Integer -

Returns:

Integer

Raises:

Daytona:Sdk:Error -

auto_delete_interval=()

ruby

def auto_delete_interval=(interval)

Sets the auto-delete interval for the Sandbox. The Sandbox will automatically delete after being continuously stopped for the specified interval.

Parameters:

interval Integer -

Returns:

Integer

Raises:

Daytona:Sdk:Error -

update_network_settings()

ruby

def update_network_settings(network_block_all:, network_allow_list:)

Updates outbound network policy on the runner (block all, restore access, or CIDR allow list).

Parameters:

network_block_all Boolean, nil -
network_allow_list String, nil -

Returns:

void

Raises:

Daytona:Sdk:Error -

auto_stop_interval=()

ruby

def auto_stop_interval=(interval)

Sets the auto-stop interval for the Sandbox. The Sandbox will automatically stop after being idle (no new events) for the specified interval. Events include any state changes or interactions with the Sandbox through the SDK. Interactions using Sandbox Previews are not included.

Parameters:

interval Integer -

Returns:

Integer

Raises:

Daytona:Sdk:Error -

create_ssh_access()

ruby

def create_ssh_access(expires_in_minutes)

Creates an SSH access token for the sandbox.

Parameters:

expires_in_minutes Integer - TThe number of minutes the SSH access token will be valid for

Returns:

DaytonaApiClient:SshAccessDto

delete()

ruby

def delete()

Returns:

void

get_user_home_dir()

ruby

def get_user_home_dir()

Gets the user's home directory path for the logged in user inside the Sandbox.

Returns:

String - The absolute path to the Sandbox user's home directory for the logged in user

Examples:

ruby

user_home_dir = sandbox.get_user_home_dir
puts "Sandbox user home: #{user_home_dir}"

get_work_dir()

ruby

def get_work_dir()

Gets the working directory path inside the Sandbox.

Returns:

String - The absolute path to the Sandbox working directory. Uses the WORKDIR specified in the Dockerfile if present, or falling back to the user's home directory if not.

Examples:

ruby

work_dir = sandbox.get_work_dir
puts "Sandbox working directory: #{work_dir}"

labels=()

ruby

def labels=(labels)

Sets labels for the Sandbox.

Parameters:

labels Hash<String, String> -

Returns:

Hash\<String, String\>

preview_url()

ruby

def preview_url(port)

Retrieves the preview link for the sandbox at the specified port. If the port is closed, it will be opened automatically. For private sandboxes, a token is included to grant access to the URL.

Parameters:

port Integer -

Returns:

DaytonaApiClient:PortPreviewUrl

create_signed_preview_url()

ruby

def create_signed_preview_url(port, expires_in_seconds)

Creates a signed preview URL for the sandbox at the specified port.

Parameters:

port Integer - The port to open the preview link on
expires_in_seconds Integer, nil - The number of seconds the signed preview URL will be valid for. Defaults to 60 seconds.

Returns:

DaytonaApiClient:SignedPortPreviewUrl - The signed preview URL response object

Examples:

ruby

signed_url = sandbox.create_signed_preview_url(3000, 120)
puts "Signed URL: #{signed_url.url}"
puts "Token: #{signed_url.token}"

expire_signed_preview_url()

ruby

def expire_signed_preview_url(port, token)

Expires a signed preview URL for the sandbox at the specified port.

Parameters:

port Integer - The port to expire the signed preview URL on
token String - The token to expire

Returns:

void

Examples:

ruby

sandbox.expire_signed_preview_url(3000, "token-value")

refresh()

ruby

def refresh()

Refresh the Sandbox data from the API.

Returns:

void

refresh_activity()

ruby

def refresh_activity()

Refreshes the sandbox activity to reset the timer for automated lifecycle management actions.

This method updates the sandbox's last activity timestamp without changing its state. It is useful for keeping long-running sessions alive while there is still user activity.

Returns:

void

Examples:

ruby

sandbox.refresh_activity

revoke_ssh_access()

ruby

def revoke_ssh_access(token)

Revokes an SSH access token for the sandbox.

Parameters:

token String -

Returns:

void

start()

ruby

def start(timeout)

Starts the Sandbox and waits for it to be ready.

Parameters:

timeout Numeric - Maximum wait time in seconds (defaults to 60 s).

Returns:

void

recover()

ruby

def recover(timeout)

Recovers the Sandbox from a recoverable error and waits for it to be ready.

Parameters:

timeout Numeric - Maximum wait time in seconds (defaults to 60 s).

Returns:

void

Examples:

ruby

sandbox = daytona.get('my-sandbox-id')
sandbox.recover(timeout: 40)  # Wait up to 40 seconds
puts 'Sandbox recovered successfully'

stop()

ruby

def stop(timeout, force:)

Stops the Sandbox and waits for it to be stopped.

Parameters:

timeout Numeric - Maximum wait time in seconds (defaults to 60 s).
force Boolean - If true, uses SIGKILL instead of SIGTERM (defaults to false).

Returns:

void

resize()

ruby

def resize(resources, timeout)

Resizes the Sandbox resources.

Changes the CPU, memory, or disk allocation for the Sandbox. Resizing a started sandbox allows increasing CPU and memory. To resize disk or decrease resources, the sandbox must be stopped first.

Parameters:

resources Daytona:Resources - New resource configuration
timeout Numeric - Maximum wait time in seconds (defaults to 60 s)

Returns:

void

Raises:

Sdk:Error -

Examples:

ruby

sandbox.resize(Daytona::Resources.new(cpu: 4, memory: 8))

ruby

sandbox.stop
sandbox.resize(Daytona::Resources.new(cpu: 2, memory: 4, disk: 30))

wait_for_resize_complete()

ruby

def wait_for_resize_complete(_timeout)

Waits for the Sandbox resize operation to complete. Polls the Sandbox status until the state is no longer 'resizing'.

Parameters:

timeout Numeric - Maximum wait time in seconds (defaults to 60 s)

Returns:

void

create_lsp_server()

ruby

def create_lsp_server(language_id:, path_to_project:)

Creates a new Language Server Protocol (LSP) server instance. The LSP server provides language-specific features like code completion, diagnostics, and more.

Parameters:

language_id Symbol - The language server type (e.g., Daytona::LspServer::Language::PYTHON)
path_to_project String - Path to the project root directory. Relative paths are resolved based on the sandbox working directory.

Returns:

Daytona:LspServer

validate_ssh_access()

ruby

def validate_ssh_access(token)

Validates an SSH access token for the sandbox.

Parameters:

token String -

Returns:

DaytonaApiClient:SshAccessValidationDto

wait_for_sandbox_start()

ruby

def wait_for_sandbox_start(_timeout)

Waits for the Sandbox to reach the 'started' state. Polls the Sandbox status until it reaches the 'started' state or encounters an error.

Parameters:

timeout Numeric - Maximum wait time in seconds (defaults to 60 s).

Returns:

void

wait_for_sandbox_stop()

ruby

def wait_for_sandbox_stop(_timeout)

Waits for the Sandbox to reach the 'stopped' state. Polls the Sandbox status until it reaches the 'stopped' state or encounters an error. Treats destroyed as stopped to cover ephemeral sandboxes that are automatically deleted after stopping.

Parameters:

timeout Numeric - Maximum wait time in seconds (defaults to 60 s).

Returns:

void

experimental_fork()

ruby

def experimental_fork(name:, timeout:)

Forks the Sandbox, creating a new Sandbox with an identical filesystem. The forked Sandbox is a copy-on-write clone of the original. It starts with the same disk contents but operates independently from that point on.

Parameters:

name String, nil - Optional name for the forked Sandbox
timeout Numeric - Maximum wait time in seconds (defaults to 60 s)

Returns:

Daytona:Sandbox - The forked Sandbox

experimental_create_snapshot()

ruby

def experimental_create_snapshot(name:, timeout:)

Creates a snapshot from the current state of the Sandbox. The Sandbox will temporarily enter a 'snapshotting' state and return to its previous state when complete.

Parameters:

name String - Name for the new snapshot
timeout Numeric - Maximum wait time in seconds (defaults to 60 s)

Returns:

void