Class: Daytona::Sandbox

Inherits:
Object
  • Object
show all
Includes:
Instrumentation
Defined in:
lib/daytona/sandbox.rb

Overview

rubocop:disable Metrics/ClassLength

Constant Summary collapse

DEFAULT_TIMEOUT = 
60

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Instrumentation

included

Constructor Details

#initialize(sandbox_dto:, config:, sandbox_api:, otel_state: nil) ⇒ Sandbox

Returns a new instance of Sandbox.



135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
 
# File 'lib/daytona/sandbox.rb', line 135

def initialize(sandbox_dto:, config:, sandbox_api:, otel_state: nil) # rubocop:disable Metrics/MethodLength
  process_response(sandbox_dto)
  @config = config
  @sandbox_api = sandbox_api
  @otel_state = otel_state

  # Create toolbox API clients with dynamic configuration
  toolbox_api_config = build_toolbox_api_config

  # Helper to create API client with authentication header
  create_authenticated_client = lambda do
    client = DaytonaToolboxApiClient::ApiClient.new(toolbox_api_config)
    client.default_headers['Authorization'] = "Bearer #{config.api_key || config.jwt_token}"
    client.default_headers['X-Daytona-Source'] = 'sdk-ruby'
    client.default_headers['X-Daytona-SDK-Version'] = Sdk::VERSION
    client.default_headers['X-Daytona-Organization-ID'] = config.organization_id if config.jwt_token
    client.user_agent = "sdk-ruby/#{Sdk::VERSION}"
    client
  end

  process_api = DaytonaToolboxApiClient::ProcessApi.new(create_authenticated_client.call)
  fs_api = DaytonaToolboxApiClient::FileSystemApi.new(create_authenticated_client.call)
  git_api = DaytonaToolboxApiClient::GitApi.new(create_authenticated_client.call)
  lsp_api = DaytonaToolboxApiClient::LspApi.new(create_authenticated_client.call)
  computer_use_api = DaytonaToolboxApiClient::ComputerUseApi.new(create_authenticated_client.call)
  interpreter_api = DaytonaToolboxApiClient::InterpreterApi.new(create_authenticated_client.call)
  info_api = DaytonaToolboxApiClient::InfoApi.new(create_authenticated_client.call)

  @process = Process.new(
    sandbox_id: id,
    toolbox_api: process_api,
    get_preview_link: proc { |port| preview_url(port) },
    language: (labels || {}).fetch(CODE_TOOLBOX_LANGUAGE_LABEL, 'python'),
    otel_state:
  )
  @fs = FileSystem.new(sandbox_id: id, toolbox_api: fs_api, otel_state:)
  @git = Git.new(sandbox_id: id, toolbox_api: git_api, otel_state:)
  @computer_use = ComputerUse.new(sandbox_id: id, toolbox_api: computer_use_api, otel_state:)
  @code_interpreter = CodeInterpreter.new(
    sandbox_id: id,
    toolbox_api: interpreter_api,
    get_preview_link: proc { |port| preview_url(port) },
    otel_state:
  )
  @lsp_api = lsp_api
  @info_api = info_api
end

Instance Attribute Details

#auto_archive_interval ⇒ Float

Returns Auto-archive interval in minutes.

Returns:

  • (Float) —

    Auto-archive interval in minutes



83
84
85
 
# File 'lib/daytona/sandbox.rb', line 83

def auto_archive_interval
  @auto_archive_interval
end

#auto_delete_interval ⇒ Float

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

Returns:

  • (Float) —

    Auto-delete interval in minutes



87
88
89
 
# File 'lib/daytona/sandbox.rb', line 87

def auto_delete_interval
  @auto_delete_interval
end

#auto_stop_interval ⇒ Float

Returns Auto-stop interval in minutes (0 means disabled).

Returns:

  • (Float) —

    Auto-stop interval in minutes (0 means disabled)



80
81
82
 
# File 'lib/daytona/sandbox.rb', line 80

def auto_stop_interval
  @auto_stop_interval
end

#backup_created_at ⇒ String? (readonly)

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

Returns:

  • (String, nil) —

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



77
78
79
 
# File 'lib/daytona/sandbox.rb', line 77

def backup_created_at
  @backup_created_at
end

#backup_state ⇒ String (readonly)

Returns The state of the backup.

Returns:

  • (String) —

    The state of the backup



73
74
75
 
# File 'lib/daytona/sandbox.rb', line 73

def backup_state
  @backup_state
end

#build_info ⇒ DaytonaApiClient::BuildInfo? (readonly)

Returns 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.

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.



96
97
98
 
# File 'lib/daytona/sandbox.rb', line 96

def build_info
  @build_info
end

#code_interpreter ⇒ Daytona::CodeInterpreter (readonly)

Returns:



129
130
131
 
# File 'lib/daytona/sandbox.rb', line 129

def code_interpreter
  @code_interpreter
end

#computer_use ⇒ Daytona::ComputerUse (readonly)

Returns:



126
127
128
 
# File 'lib/daytona/sandbox.rb', line 126

def computer_use
  @computer_use
end

#config ⇒ Daytona::Config (readonly)

Returns:



111
112
113
 
# File 'lib/daytona/sandbox.rb', line 111

def config
  @config
end

#cpu ⇒ Float (readonly)

Returns The CPU quota for the sandbox.

Returns:

  • (Float) —

    The CPU quota for the sandbox



52
53
54
 
# File 'lib/daytona/sandbox.rb', line 52

def cpu
  @cpu
end

#created_at ⇒ String (readonly)

Returns The creation timestamp of the sandbox.

Returns:

  • (String) —

    The creation timestamp of the sandbox



99
100
101
 
# File 'lib/daytona/sandbox.rb', line 99

def created_at
  @created_at
end

#daemon_version ⇒ String (readonly)

Returns The version of the daemon running in the sandbox.

Returns:

  • (String) —

    The version of the daemon running in the sandbox



108
109
110
 
# File 'lib/daytona/sandbox.rb', line 108

def daemon_version
  @daemon_version
end

#desired_state ⇒ DaytonaApiClient::SandboxDesiredState (readonly)

Returns The desired state of the sandbox.

Returns:

  • (DaytonaApiClient::SandboxDesiredState) —

    The desired state of the sandbox



67
68
69
 
# File 'lib/daytona/sandbox.rb', line 67

def desired_state
  @desired_state
end

#disk ⇒ Float (readonly)

Returns The disk quota for the sandbox.

Returns:

  • (Float) —

    The disk quota for the sandbox



61
62
63
 
# File 'lib/daytona/sandbox.rb', line 61

def disk
  @disk
end

#domain_allow_list ⇒ String? (readonly)

Returns Comma-separated list of allowed domains for the sandbox. Not returned by list results; call #refresh on each item to populate.

Returns:

  • (String, nil) —

    Comma-separated list of allowed domains for the sandbox. Not returned by list results; call #refresh on each item to populate.



46
47
48
 
# File 'lib/daytona/sandbox.rb', line 46

def domain_allow_list
  @domain_allow_list
end

#env ⇒ Hash<String, String>? (readonly)

Returns Environment variables for the sandbox. Not returned by list results; call #refresh on each item to populate.

Returns:

  • (Hash<String, String>, nil) —

    Environment variables for the sandbox. Not returned by list results; call #refresh on each item to populate.



28
29
30
 
# File 'lib/daytona/sandbox.rb', line 28

def env
  @env
end

#error_reason ⇒ String (readonly)

Returns The error reason of the sandbox.

Returns:

  • (String) —

    The error reason of the sandbox



70
71
72
 
# File 'lib/daytona/sandbox.rb', line 70

def error_reason
  @error_reason
end

#fs ⇒ Daytona::FileSystem (readonly)

Returns:



120
121
122
 
# File 'lib/daytona/sandbox.rb', line 120

def fs
  @fs
end

#git ⇒ Daytona::Git (readonly)

Returns:



123
124
125
 
# File 'lib/daytona/sandbox.rb', line 123

def git
  @git
end

#gpu ⇒ Float (readonly)

Returns The GPU quota for the sandbox.

Returns:

  • (Float) —

    The GPU quota for the sandbox



55
56
57
 
# File 'lib/daytona/sandbox.rb', line 55

def gpu
  @gpu
end

#id ⇒ String (readonly)

Returns The ID of the sandbox.

Returns:

  • (String) —

    The ID of the sandbox



15
16
17
 
# File 'lib/daytona/sandbox.rb', line 15

def id
  @id
end

#labels ⇒ Hash<String, String>

Returns Labels for the sandbox.

Returns:

  • (Hash<String, String>) —

    Labels for the sandbox



31
32
33
 
# File 'lib/daytona/sandbox.rb', line 31

def labels
  @labels
end

#last_activity_at ⇒ String (readonly)

Returns The last activity timestamp of the sandbox.

Returns:

  • (String) —

    The last activity timestamp of the sandbox



105
106
107
 
# File 'lib/daytona/sandbox.rb', line 105

def last_activity_at
  @last_activity_at
end

#memory ⇒ Float (readonly)

Returns The memory quota for the sandbox.

Returns:

  • (Float) —

    The memory quota for the sandbox



58
59
60
 
# File 'lib/daytona/sandbox.rb', line 58

def memory
  @memory
end

#network_allow_list ⇒ String? (readonly)

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

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.



42
43
44
 
# File 'lib/daytona/sandbox.rb', line 42

def network_allow_list
  @network_allow_list
end

#network_block_all ⇒ Boolean? (readonly)

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

Returns:

  • (Boolean, nil) —

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



38
39
40
 
# File 'lib/daytona/sandbox.rb', line 38

def network_block_all
  @network_block_all
end

#organization_id ⇒ String (readonly)

Returns The organization ID of the sandbox.

Returns:

  • (String) —

    The organization ID of the sandbox



18
19
20
 
# File 'lib/daytona/sandbox.rb', line 18

def organization_id
  @organization_id
end

#process ⇒ Daytona::Process (readonly)

Returns:



117
118
119
 
# File 'lib/daytona/sandbox.rb', line 117

def process
  @process
end

#public ⇒ Boolean (readonly)

Returns Whether the sandbox http preview is public.

Returns:

  • (Boolean) —

    Whether the sandbox http preview is public



34
35
36
 
# File 'lib/daytona/sandbox.rb', line 34

def public
  @public
end

#sandbox_api ⇒ DaytonaApiClient::SandboxApi (readonly)

Returns:

  • (DaytonaApiClient::SandboxApi) 


114
115
116
 
# File 'lib/daytona/sandbox.rb', line 114

def sandbox_api
  @sandbox_api
end

#snapshot ⇒ String (readonly)

Returns The snapshot used for the sandbox.

Returns:

  • (String) —

    The snapshot used for the sandbox



21
22
23
 
# File 'lib/daytona/sandbox.rb', line 21

def snapshot
  @snapshot
end

#state ⇒ DaytonaApiClient::SandboxState (readonly)

Returns The state of the sandbox.

Returns:

  • (DaytonaApiClient::SandboxState) —

    The state of the sandbox



64
65
66
 
# File 'lib/daytona/sandbox.rb', line 64

def state
  @state
end

#target ⇒ String (readonly)

Returns The target environment for the sandbox.

Returns:

  • (String) —

    The target environment for the sandbox



49
50
51
 
# File 'lib/daytona/sandbox.rb', line 49

def target
  @target
end

#updated_at ⇒ String (readonly)

Returns The last update timestamp of the sandbox.

Returns:

  • (String) —

    The last update timestamp of the sandbox



102
103
104
 
# File 'lib/daytona/sandbox.rb', line 102

def updated_at
  @updated_at
end

#user ⇒ String (readonly)

Returns The user associated with the project.

Returns:

  • (String) —

    The user associated with the project



24
25
26
 
# File 'lib/daytona/sandbox.rb', line 24

def user
  @user
end

#volumes ⇒ Array<DaytonaApiClient::SandboxVolume>? (readonly)

Returns Volumes attached to the sandbox. Not returned by list results; call #refresh on each item to populate.

Returns:

  • (Array<DaytonaApiClient::SandboxVolume>, nil) —

    Volumes attached to the sandbox. Not returned by list results; call #refresh on each item to populate.



91
92
93
 
# File 'lib/daytona/sandbox.rb', line 91

def volumes
  @volumes
end

Instance Method Details

#archive ⇒ void

This method returns an undefined value.

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.



190
191
192
193
 
# File 'lib/daytona/sandbox.rb', line 190

def archive
  sandbox_api.archive_sandbox(id)
  refresh
end

#create_lsp_server(language_id:, path_to_project:) ⇒ Daytona::LspServer

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:



480
481
482
 
# File 'lib/daytona/sandbox.rb', line 480

def create_lsp_server(language_id:, path_to_project:)
  LspServer.new(language_id:, path_to_project:, toolbox_api: @lsp_api, sandbox_id: id, otel_state:)
end

#create_signed_preview_url(port, expires_in_seconds = nil) ⇒ DaytonaApiClient::SignedPortPreviewUrl

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

Examples:

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

Parameters:

  • port (Integer) —

    The port to open the preview link on

  • expires_in_seconds (Integer, nil) (defaults to: 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



328
329
330
 
# File 'lib/daytona/sandbox.rb', line 328

def create_signed_preview_url(port, expires_in_seconds = nil)
  sandbox_api.get_signed_port_preview_url(id, port, { expires_in_seconds: })
end

#create_ssh_access(expires_in_minutes) ⇒ DaytonaApiClient::SshAccessDto

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) 


262
 
# File 'lib/daytona/sandbox.rb', line 262

def create_ssh_access(expires_in_minutes) = sandbox_api.create_ssh_access(id, { expires_in_minutes: })

#delete ⇒ void

This method returns an undefined value.



265
266
267
268
269
270
271
272
 
# File 'lib/daytona/sandbox.rb', line 265

def delete
  sandbox_api.delete_sandbox(id)
  refresh
rescue DaytonaApiClient::ApiError => e
  raise unless e.code == 404

  @state = 'destroyed'
end

#experimental_create_snapshot(name:, timeout: DEFAULT_TIMEOUT) ⇒ void

This method returns an undefined value.

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) (defaults to: DEFAULT_TIMEOUT) —

    Maximum wait time in seconds (defaults to 60 s)



545
546
547
548
549
550
551
552
553
554
 
# File 'lib/daytona/sandbox.rb', line 545

def experimental_create_snapshot(name:, timeout: DEFAULT_TIMEOUT)
  with_timeout(
    timeout:,
    message: "Sandbox #{id} snapshot failed within the #{timeout} seconds timeout period",
    setup: proc {
      sandbox_api.create_sandbox_snapshot(id, DaytonaApiClient::CreateSandboxSnapshot.new(name:))
      refresh
    }
  ) { wait_for_snapshot_complete }
end

#experimental_fork(name: nil, timeout: DEFAULT_TIMEOUT) ⇒ Daytona::Sandbox

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) (defaults to: nil) —

    Optional name for the forked Sandbox

  • timeout (Numeric) (defaults to: DEFAULT_TIMEOUT) —

    Maximum wait time in seconds (defaults to 60 s)

Returns:



517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
 
# File 'lib/daytona/sandbox.rb', line 517

def experimental_fork(name: nil, timeout: DEFAULT_TIMEOUT) # rubocop:disable Metrics/MethodLength
  forked_dto = nil
  with_timeout(
    timeout:,
    message: "Sandbox #{id} fork failed to become ready within the #{timeout} seconds timeout period",
    setup: proc {
      forked_dto = sandbox_api.fork_sandbox(id, DaytonaApiClient::ForkSandbox.new(name:))
    }
  ) do
    forked = Sandbox.new(
      sandbox_dto: forked_dto,
      config:,
      sandbox_api:,
      code_toolbox:,
      otel_state:
    )
    forked.send(:wait_for_states, operation: OPERATION_START,
                                  target_states: [DaytonaApiClient::SandboxState::STARTED])
    return forked
  end
end

#expire_signed_preview_url(port, token) ⇒ void

This method returns an undefined value.

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

Examples:

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

Parameters:

  • port (Integer) —

    The port to expire the signed preview URL on

  • token (String) —

    The token to expire



340
341
342
 
# File 'lib/daytona/sandbox.rb', line 340

def expire_signed_preview_url(port, token)
  sandbox_api.expire_signed_port_preview_url(id, port, token)
end

#get_user_home_dir ⇒ String

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

Examples:

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

Returns:

  • (String) —

    The absolute path to the Sandbox user’s home directory for the logged in user



281
282
283
284
285
 
# File 'lib/daytona/sandbox.rb', line 281

def get_user_home_dir
  @info_api.get_user_home_dir.dir
rescue StandardError => e
  raise Sdk::Error, "Failed to get user home directory: #{e.message}"
end

#get_work_dir ⇒ String

Gets the working directory path inside the Sandbox.

Examples:

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

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.



295
296
297
298
299
 
# File 'lib/daytona/sandbox.rb', line 295

def get_work_dir
  @info_api.get_work_dir.dir
rescue StandardError => e
  raise Sdk::Error, "Failed to get working directory path: #{e.message}"
end

#pause(timeout: DEFAULT_TIMEOUT) ⇒ void

This method returns an undefined value.

Pauses the Sandbox, freezing all running processes. The Sandbox will enter a ‘pausing’ state and transition to ‘paused’ when complete.

Parameters:

  • timeout (Numeric) (defaults to: DEFAULT_TIMEOUT) —

    Maximum wait time in seconds (defaults to 60 s)



561
562
563
564
565
566
567
568
569
570
 
# File 'lib/daytona/sandbox.rb', line 561

def pause(timeout: DEFAULT_TIMEOUT)
  with_timeout(
    timeout:,
    message: "Sandbox #{id} failed to pause within the #{timeout} seconds timeout period",
    setup: proc {
      sandbox_api.pause_sandbox(id)
      refresh
    }
  ) { wait_for_pause_complete }
end

#preview_url(port) ⇒ DaytonaApiClient::PortPreviewUrl

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) 


315
 
# File 'lib/daytona/sandbox.rb', line 315

def preview_url(port) = sandbox_api.get_port_preview_url(id, port)

#recover(timeout = DEFAULT_TIMEOUT) ⇒ void

This method returns an undefined value.

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

Examples:

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

Parameters:

  • timeout (Numeric) (defaults to: DEFAULT_TIMEOUT) —

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



392
393
394
395
396
397
398
399
400
 
# File 'lib/daytona/sandbox.rb', line 392

def recover(timeout = DEFAULT_TIMEOUT)
  with_timeout(
    timeout:,
    message: "Sandbox #{id} failed to recover within the #{timeout} seconds timeout period",
    setup: proc { process_response(sandbox_api.recover_sandbox(id)) }
  ) { wait_for_states(operation: OPERATION_START, target_states: [DaytonaApiClient::SandboxState::STARTED]) }
rescue StandardError => e
  raise Sdk::Error, "Failed to recover sandbox: #{e.message}"
end

#refresh ⇒ void

This method returns an undefined value.

Refresh the Sandbox data from the API.



347
 
# File 'lib/daytona/sandbox.rb', line 347

def refresh = process_response(sandbox_api.get_sandbox(id))

#refresh_activity ⇒ void

This method returns an undefined value.

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.

Examples:

sandbox.refresh_activity


358
359
360
361
362
363
 
# File 'lib/daytona/sandbox.rb', line 358

def refresh_activity
  sandbox_api.update_last_activity(id)
  nil
rescue StandardError => e
  raise Sdk::Error, "Failed to refresh sandbox activity: #{e.message}"
end

#resize(resources, timeout = DEFAULT_TIMEOUT) ⇒ void

This method returns an undefined value.

Resizes the Sandbox resources.

Changes the CPU, memory, or disk allocation. Resizing a started sandbox accepts only CPU and memory increases. Disk resize requires a stopped sandbox; disk can only grow. GPU is not resizable — to change GPU, create a new sandbox.

Examples:

Resize a started sandbox (CPU and memory can be increased)

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

Resize a stopped sandbox (CPU, memory, and disk can be changed)

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

Parameters:

  • resources (Daytona::Resources) —

    New resource configuration (cpu, memory, disk only)

  • timeout (Numeric) (defaults to: DEFAULT_TIMEOUT) —

    Maximum wait time in seconds (defaults to 60 s)

Raises:

  • (Sdk::Error) —

    If resources.gpu or resources.gpu_type is set



440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
 
# File 'lib/daytona/sandbox.rb', line 440

def resize(resources, timeout = DEFAULT_TIMEOUT)
  raise Sdk::Error, 'Resources must not be nil' if resources.nil?

  if resources.gpu || resources.gpu_type
    raise Sdk::Error,
          'Resize does not support changes to gpu or gpu_type — to change GPU, create a new sandbox'
  end

  with_timeout(
    timeout:,
    message: "Sandbox #{id} failed to resize within the #{timeout} seconds timeout period",
    setup: proc {
      resize_attrs = {}
      resize_attrs[:cpu] = resources.cpu if resources.cpu
      resize_attrs[:memory] = resources.memory if resources.memory
      resize_attrs[:disk] = resources.disk if resources.disk
      resize_request = DaytonaApiClient::ResizeSandbox.new(resize_attrs)
      process_response(sandbox_api.resize_sandbox(id, resize_request))
    }
  ) { wait_for_resize_complete }
end

#revoke_ssh_access(token) ⇒ void

This method returns an undefined value.

Revokes an SSH access token for the sandbox.

Parameters:

  • token (String) 


369
 
# File 'lib/daytona/sandbox.rb', line 369

def revoke_ssh_access(token) = sandbox_api.revoke_ssh_access(id, token:)

#start(timeout = DEFAULT_TIMEOUT) ⇒ void

This method returns an undefined value.

Starts the Sandbox and waits for it to be ready.

Parameters:

  • timeout (Numeric) (defaults to: DEFAULT_TIMEOUT) —

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



375
376
377
378
379
380
381
 
# File 'lib/daytona/sandbox.rb', line 375

def start(timeout = DEFAULT_TIMEOUT)
  with_timeout(
    timeout:,
    message: "Sandbox #{id} failed to become ready within the #{timeout} seconds timeout period",
    setup: proc { process_response(sandbox_api.start_sandbox(id)) }
  ) { wait_for_states(operation: OPERATION_START, target_states: [DaytonaApiClient::SandboxState::STARTED]) }
end

#stop(timeout = DEFAULT_TIMEOUT, force: false) ⇒ void

This method returns an undefined value.

Stops the Sandbox and waits for it to be stopped.

Parameters:

  • timeout (Numeric) (defaults to: DEFAULT_TIMEOUT) —

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

  • force (Boolean) (defaults to: false) —

    If true, uses SIGKILL instead of SIGTERM (defaults to false).



407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
 
# File 'lib/daytona/sandbox.rb', line 407

def stop(timeout = DEFAULT_TIMEOUT, force: false) # rubocop:disable Metrics/MethodLength
  with_timeout(
    timeout:,
    message: "Sandbox #{id} failed to become stopped within the #{timeout} seconds timeout period",
    setup: proc {
      sandbox_api.stop_sandbox(id, { force: force })
      refresh
    }
  ) do
    wait_for_states(
      operation: OPERATION_STOP,
      target_states: [DaytonaApiClient::SandboxState::STOPPED, DaytonaApiClient::SandboxState::DESTROYED]
    )
  end
end

#update_network_settings(network_block_all: nil, network_allow_list: nil, domain_allow_list: nil) ⇒ void

This method returns an undefined value.

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

Parameters:

  • network_block_all (Boolean, nil) (defaults to: nil)
  • network_allow_list (String, nil) (defaults to: nil)
  • domain_allow_list (String, nil) (defaults to: nil)

Raises:



226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
 
# File 'lib/daytona/sandbox.rb', line 226

def update_network_settings(network_block_all: nil, network_allow_list: nil, domain_allow_list: nil)
  if network_block_all.nil? && network_allow_list.nil? && domain_allow_list.nil?
    raise Sdk::Error,
          'At least one of network_block_all, network_allow_list or domain_allow_list must be provided'
  end

  body = DaytonaApiClient::UpdateSandboxNetworkSettings.new(
    network_block_all:,
    network_allow_list:,
    domain_allow_list:
  )
  data = sandbox_api.update_network_settings(id, body)
  @network_block_all = data.network_block_all
  @network_allow_list = data.network_allow_list
  @domain_allow_list = data.domain_allow_list
end

#validate_ssh_access(token) ⇒ DaytonaApiClient::SshAccessValidationDto

Validates an SSH access token for the sandbox.

Parameters:

  • token (String)

Returns:

  • (DaytonaApiClient::SshAccessValidationDto) 


488
 
# File 'lib/daytona/sandbox.rb', line 488

def validate_ssh_access(token) = sandbox_api.validate_ssh_access(token)

#wait_for_resize_complete(_timeout = DEFAULT_TIMEOUT) ⇒ void

This method returns an undefined value.

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)



467
468
469
470
 
# File 'lib/daytona/sandbox.rb', line 467

def wait_for_resize_complete(_timeout = DEFAULT_TIMEOUT)
  wait_for_states(operation: OPERATION_RESIZE, target_states: [DaytonaApiClient::SandboxState::STARTED,
                                                               DaytonaApiClient::SandboxState::STOPPED])
end

#wait_for_sandbox_start(_timeout = DEFAULT_TIMEOUT) ⇒ void

This method returns an undefined value.

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).



495
496
497
 
# File 'lib/daytona/sandbox.rb', line 495

def wait_for_sandbox_start(_timeout = DEFAULT_TIMEOUT)
  wait_for_states(operation: OPERATION_START, target_states: [DaytonaApiClient::SandboxState::STARTED])
end

#wait_for_sandbox_stop(_timeout = DEFAULT_TIMEOUT) ⇒ void

This method returns an undefined value.

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).



505
506
507
508
 
# File 'lib/daytona/sandbox.rb', line 505

def wait_for_sandbox_stop(_timeout = DEFAULT_TIMEOUT)
  wait_for_states(operation: OPERATION_STOP, target_states: [DaytonaApiClient::SandboxState::STOPPED,
                                                             DaytonaApiClient::SandboxState::DESTROYED])
end