Mirko Džaja 0781f83921
feat(docs,sdk-ruby): initial ruby sdk support (#2832)
Signed-off-by: Toma Puljak <toma.puljak@hotmail.com>
Signed-off-by: Vedran Hrncic <vedran.hrncic@gmail.com>
Signed-off-by: Vedran Jukic <vedran.jukic@gmail.com>
Signed-off-by: MDzaja <mirkodzaja0@gmail.com>
Co-authored-by: Toma Puljak <toma.puljak@hotmail.com>
Co-authored-by: Vedran Hrncic <vedran.hrncic@gmail.com>
Co-authored-by: Vedran Jukic <vedran.jukic@gmail.com>
2026-01-27 12:06:03 +01:00

201 lines
5.7 KiB
Ruby

#!/usr/bin/env ruby
# frozen_string_literal: true
require 'daytona'
def basic_exec(sandbox)
# Run some Python code directly (sandbox is configured for Python)
code_result = sandbox.process.code_run(code: 'print("Hello World from code!")')
if code_result.exit_code == 0
puts code_result.result
else
puts "Error running code: #{code_result.exit_code}"
end
# Run OS command
cmd_result = sandbox.process.exec(command: 'echo "Hello World from CMD!"')
if cmd_result.exit_code == 0
puts cmd_result.result
else
puts "Error running command: #{cmd_result.exit_code}"
end
end
def session_exec(sandbox)
# Exec session
# Session allows for multiple commands to be executed in the same context
sandbox.process.create_session('exec-session-1')
# Get the session details any time
session = sandbox.process.get_session('exec-session-1')
puts "session: #{session.inspect}"
# Execute a first command in the session
command = sandbox.process.execute_session_command(
session_id: 'exec-session-1',
req: Daytona::SessionExecuteRequest.new(command: 'export FOO=BAR')
)
# Get the session details again to see the command has been executed
session_updated = sandbox.process.get_session('exec-session-1')
puts "sessionUpdated: #{session_updated.inspect}"
# Get the command details
session_command = sandbox.process.get_session_command(
session_id: 'exec-session-1',
command_id: command.cmd_id
)
puts "sessionCommand: #{session_command.inspect}"
# Execute a second command in the session and see that the environment variable is set
response = sandbox.process.execute_session_command(
session_id: 'exec-session-1',
req: Daytona::SessionExecuteRequest.new(command: 'echo $FOO')
)
puts "FOO=#{response.stdout}"
# We can also get the logs for the command any time after it is executed
logs = sandbox.process.get_session_command_logs(
session_id: 'exec-session-1',
command_id: response.cmd_id
)
puts "[STDOUT]: #{logs.stdout}"
puts "[STDERR]: #{logs.stderr}"
# We can also delete the session
sandbox.process.delete_session('exec-session-1')
end
def session_exec_logs_async(sandbox)
puts 'Executing long running command in a session and streaming logs asynchronously...'
session_id = 'exec-session-async-logs'
sandbox.process.create_session(session_id)
command = sandbox.process.execute_session_command(
session_id: session_id,
req: Daytona::SessionExecuteRequest.new(
command: 'counter=1; while (( counter <= 3 )); do echo "Count: $counter"; ((counter++)); sleep 2; done; non-existent-command',
run_async: true
)
)
sandbox.process.get_session_command_logs_async(
session_id: session_id,
command_id: command.cmd_id,
on_stdout: ->(stdout) { puts "[STDOUT]: #{stdout}" },
on_stderr: ->(stderr) { puts "[STDERR]: #{stderr}" }
)
end
def stateful_code_interpreter(sandbox)
log_stdout = ->(msg) { print "[STDOUT] #{msg.output}" }
log_stderr = ->(msg) { print "[STDERR] #{msg.output}" }
log_error = lambda do |err|
print "[ERROR] #{err.name}: #{err.value}\n"
print "#{err.traceback}\n" unless err.traceback.empty?
end
puts "\n#{'=' * 60}"
puts 'Stateful Code Interpreter'
puts '=' * 60
puts ('=' * 10) + ' Statefulness in the default context ' + ('=' * 10)
result = sandbox.code_interpreter.run_code(
"counter = 1\nprint(f'Initialized counter = {counter}')"
)
print "[STDOUT] #{result.stdout}"
sandbox.code_interpreter.run_code(
"counter += 1\nprint(f'Counter after second call = {counter}')",
on_stdout: log_stdout,
on_stderr: log_stderr,
on_error: log_error
)
puts ('=' * 10) + ' Context isolation ' + ('=' * 10)
ctx = sandbox.code_interpreter.create_context
begin
sandbox.code_interpreter.run_code(
"value = 'stored in isolated context'\nprint(f'Isolated context value: {value}')",
context: ctx,
on_stdout: log_stdout,
on_stderr: log_stderr,
on_error: log_error
)
puts ('-' * 3) + ' Print value from same context ' + ('-' * 3)
ctx_result = sandbox.code_interpreter.run_code(
"print(f'Value still available: {value}')",
context: ctx
)
print "[STDOUT] #{ctx_result.stdout}"
puts ('-' * 3) + ' Print value from different context ' + ('-' * 3)
sandbox.code_interpreter.run_code(
'print(value)',
on_stdout: log_stdout,
on_stderr: log_stderr,
on_error: log_error
)
ensure
sandbox.code_interpreter.delete_context(ctx)
end
puts ('=' * 10) + ' Timeout handling ' + ('=' * 10)
begin
code = <<~PYTHON
import time
print('Starting long running task...')
time.sleep(5)
print('Finished!')
PYTHON
sandbox.code_interpreter.run_code(
code,
timeout: 1,
on_stdout: log_stdout,
on_stderr: log_stderr,
on_error: log_error
)
rescue Daytona::Sdk::TimeoutError => e
puts "Timed out as expected: #{e.message}"
end
end
def main
daytona = Daytona::Daytona.new
# First, create a sandbox
image = Daytona::Image.base('python:3.9.23-slim')
params = Daytona::CreateSandboxFromImageParams.new(
image: image,
language: 'python',
auto_stop_interval: 60,
auto_archive_interval: 60,
auto_delete_interval: 120,
resources: Daytona::Resources.new(cpu: 2, memory: 2, disk: 10)
)
sandbox = daytona.create(
params,
on_snapshot_create_logs: ->(chunk) { print chunk }
)
begin
basic_exec(sandbox)
session_exec(sandbox)
session_exec_logs_async(sandbox)
stateful_code_interpreter(sandbox)
rescue StandardError => e
puts "Error executing commands: #{e.message}"
puts e.backtrace
ensure
# Cleanup
daytona.delete(sandbox)
end
end
main if __FILE__ == $PROGRAM_NAME