Class: Daytona::Daytona

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

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Instrumentation

included

Constructor Details

#initialize(config = Config.new) ⇒ Daytona

Returns a new instance of Daytona.

Parameters:

  • config (Daytona::Config) (defaults to: Config.new) —

    Configuration options. Defaults to Daytona::Config.new



38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
 
# File 'lib/daytona/daytona.rb', line 38

def initialize(config = Config.new)
  @config = config
  ensure_access_token_defined

  otel_enabled = config.otel_enabled ||
                 config._experimental&.dig('otel_enabled') ||
                 config.read_env('DAYTONA_OTEL_ENABLED') == 'true' ||
                 config.read_env('DAYTONA_EXPERIMENTAL_OTEL_ENABLED') == 'true'
  @otel_state = (::Daytona.init_otel(Sdk::VERSION) if otel_enabled)

  @api_client = build_api_client
  @sandbox_api = DaytonaApiClient::SandboxApi.new(api_client)
  @config_api = DaytonaApiClient::ConfigApi.new(api_client)
  @analytics_api_url = nil
  @analytics_api_url_fetched = false
  @analytics_api_url_mutex = Mutex.new
  @volume = VolumeService.new(DaytonaApiClient::VolumesApi.new(api_client), otel_state:)
  @secret = SecretService.new(DaytonaApiClient::SecretApi.new(api_client), otel_state:)
  @object_storage_api = DaytonaApiClient::ObjectStorageApi.new(api_client)
  @snapshots_api = DaytonaApiClient::SnapshotsApi.new(api_client)
  @snapshot = SnapshotService.new(
    snapshots_api:,
    object_storage_api:,
    default_region_id: config.target,
    otel_state:
  )
  token = config.api_key || config.jwt_token

  if config.use_deprecated_polling
    warn(
      '[DEPRECATION] Polling-only mode (use_deprecated_polling / DAYTONA_USE_DEPRECATED_POLLING) ' \
      'is deprecated and will be removed in a future release.',
      uplevel: 1
    )
  else
    @event_dispatcher = EventDispatcher.new(
      api_url: config.api_url,
      token: token,
      organization_id: config.organization_id,
      source: SOURCE_RUBY,
      sdk_version: Sdk::VERSION
    )
    @event_dispatcher.ensure_connected
  end

  @subscription_manager = EventSubscriptionManager.new(@event_dispatcher)
end

Instance Attribute Details

#api_client ⇒ DaytonaApiClient (readonly)

Returns:

  • (DaytonaApiClient) 


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

def api_client
  @api_client
end

#config ⇒ Daytona::Config (readonly)

Returns:



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

def config
  @config
end

#object_storage_api ⇒ DaytonaApiClient::ObjectStorageApi (readonly)

Returns:

  • (DaytonaApiClient::ObjectStorageApi) 


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

def object_storage_api
  @object_storage_api
end

#sandbox_api ⇒ DaytonaApiClient::SandboxApi (readonly)

Returns:

  • (DaytonaApiClient::SandboxApi) 


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

def sandbox_api
  @sandbox_api
end

#secret ⇒ Daytona::SecretService (readonly)

Returns:



26
27
28
 
# File 'lib/daytona/daytona.rb', line 26

def secret
  @secret
end

#snapshot ⇒ Daytona::SnapshotService (readonly)

Returns:



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

def snapshot
  @snapshot
end

#snapshots_api ⇒ DaytonaApiClient::SnapshotsApi (readonly)

Returns:

  • (DaytonaApiClient::SnapshotsApi) 


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

def snapshots_api
  @snapshots_api
end

#volume ⇒ Daytona::VolumeService (readonly)

Returns:



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

def volume
  @volume
end

Instance Method Details

#close ⇒ void

This method returns an undefined value.

Shuts down OTel providers, flushing any pending telemetry data.



89
90
91
92
93
94
95
96
 
# File 'lib/daytona/daytona.rb', line 89

def close
  @subscription_manager&.shutdown
  @subscription_manager = nil
  @event_dispatcher&.disconnect
  @event_dispatcher = nil
  ::Daytona.shutdown_otel(@otel_state)
  @otel_state = nil
end

#create(params = nil, on_snapshot_create_logs: nil) ⇒ Daytona::Sandbox

Creates a sandbox with the specified parameters

Parameters:

Returns:

Raises:

  • (Daytona::Sdk::Error) —

    If auto_stop_interval, auto_pause_interval, or auto_archive_interval is negative, or if auto_stop_interval and auto_pause_interval are both non-zero



104
105
106
107
108
109
110
111
112
113
114
115
116
117
 
# File 'lib/daytona/daytona.rb', line 104

def create(params = nil, on_snapshot_create_logs: nil)
  if params.nil?
    params = CreateSandboxFromSnapshotParams.new(language: CodeLanguage::PYTHON)
  elsif params.language.nil?
    params.language = CodeLanguage::PYTHON
  end

  unless CodeLanguage::ALL.include?(params.language.to_s.to_sym)
    raise ArgumentError,
          "Invalid #{CODE_TOOLBOX_LANGUAGE_LABEL}: #{params.language}. Supported languages: #{CodeLanguage::ALL.join(', ')}"
  end

  _create(params, on_snapshot_create_logs:)
end

#delete(sandbox, wait: false) ⇒ void

This method returns an undefined value.

Deletes a Sandbox.

Parameters:

  • sandbox (Daytona::Sandbox)
  • wait (Boolean) (defaults to: false) —

    When true, block until the Sandbox is destroyed.



124
 
# File 'lib/daytona/daytona.rb', line 124

def delete(sandbox, wait: false) = sandbox.delete(wait:)

#get(id) ⇒ Daytona::Sandbox

Gets a Sandbox by its ID.

Parameters:

  • id (String)

Returns:



130
131
132
133
 
# File 'lib/daytona/daytona.rb', line 130

def get(id)
  sandbox_dto = sandbox_api.get_sandbox(id)
  to_sandbox(sandbox_dto:)
end

#list(query = nil) ⇒ Enumerator<Daytona::Sandbox>

Iterates over Sandboxes matching the given query.

Examples:

daytona.list(Daytona::ListSandboxesQuery.new(labels: { 'env' => 'dev' })).each do |sandbox|
  puts sandbox.id
end

Parameters:

Returns:

Raises:



145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
 
# File 'lib/daytona/daytona.rb', line 145

def list(query = nil)
  q = query || ListSandboxesQuery.new

  Enumerator.new do |yielder|
    cursor = nil
    first_page = true
    while first_page || cursor
      first_page = false
      response = fetch_sandbox_page(q, cursor)
      response.items.each do |sandbox_dto|
        yielder << to_sandbox(sandbox_dto: sandbox_dto)
      end
      cursor = response.next_cursor
      break if cursor.nil? || (cursor.respond_to?(:empty?) && cursor.empty?)
    end
  end
end

#start(sandbox, timeout = Sandbox::DEFAULT_TIMEOUT) ⇒ void

This method returns an undefined value.

Starts a Sandbox and waits for it to be ready.

Parameters:

  • sandbox (Daytona::Sandbox)
  • timeout (Numeric) (defaults to: Sandbox::DEFAULT_TIMEOUT) —

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



168
 
# File 'lib/daytona/daytona.rb', line 168

def start(sandbox, timeout = Sandbox::DEFAULT_TIMEOUT) = sandbox.start(timeout)

#stop(sandbox, timeout = Sandbox::DEFAULT_TIMEOUT) ⇒ void

This method returns an undefined value.

Stops a Sandbox and waits for it to be stopped.

Parameters:

  • sandbox (Daytona::Sandbox)
  • timeout (Numeric) (defaults to: Sandbox::DEFAULT_TIMEOUT) —

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



175
 
# File 'lib/daytona/daytona.rb', line 175

def stop(sandbox, timeout = Sandbox::DEFAULT_TIMEOUT) = sandbox.stop(timeout)