sandbox-provider 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 012300e69a3b0389101f1d843340008aab5e7cc0ef0173227187e7a0f889ec52
-  data.tar.gz: 10e39f638d1aec981f651a0ed391a07834fbb0a900944ae8ddcff6996a726cea
+  metadata.gz: 9e0e09727229563480ccb1c17fa80d6006fc308373d485a5e74e6b5dbfeeaa95
+  data.tar.gz: eb2b8ab9b4e9c83dd2b1def46e15efbee8c3e659497e52b2a6b3b37d38ca35cc
 SHA512:
-  metadata.gz: 12d574beb0f49b05519c9ff95fae5de37d5c54baf0fa034b1d0d64d138e99d6925531ea48d449e02d7ca4adbfe4a7d64597067a750e73b57a358de96388d66e5
-  data.tar.gz: 7370726a28469cf76d5d55d55a20fc226928bea484e9739be9cba51f6e88bc32ab0b75b4787f6ce421f8486bd2ee22d27fcd1c354e78a434885c7c5436286f4d
+  metadata.gz: e9db2ef6f5b3ec73c6a9f81f50a825425a06ff07c9d890ab3675dc01efcd32f07289165be8bb78f1df42406004da737f355396bd6463e263c738d97312a569ef
+  data.tar.gz: d97de7d218e2118880fe0bb578ddaace7d5b58ad498f6f743a6b7c11aff91c30f16d3e54215c47987037a627e9c3d4d46f19fd3d37408c58bc396978e3bd9a0e

data/lib/sandbox/provider/daytona/toolbox.rb

@@ -0,0 +1,128 @@
+require "net/http"
+require "securerandom"
+
+# Reaches a Daytona sandbox through its toolbox, the daemon Daytona runs in every sandbox, over HTTP with the
+# organization's API key: nothing to mint, nothing another process can revoke. Answers the verbs Box asks of a
+# transport, as Sandbox::Adapter::Ssh does.
+#
+# A command runs in a process session of its own, as root, started async; its log is read every POLL seconds
+# and only the bytes not yet read are yielded, until the command has an exit code. The session is deleted
+# afterwards, which ends anything the command left running. A command is always a subprocess of the session's
+# shell (Box sends `bash -lc`), so its `exit` ends the command, not the session.
+class Sandbox::Provider::Daytona::Toolbox
+  # The sandbox cannot be reached for now: stopped, restarting, the proxy or the network failing. Box retries
+  # it within its deadline, as it does a dropped SSH link.
+  Unreachable = Class.new(StandardError)
+
+  BASE = "https://proxy.app.daytona.io/toolbox".freeze
+  POLL = 0.5
+  # Seconds a command without `within` may run before it is given up on: a command whose exit never comes
+  # back (a toolbox that lost it) must not hold its caller for good. Longer than anything Box runs plainly.
+  LIMIT = 2 * 3600
+  # Answers that mean the sandbox is not there to answer yet, as opposed to refusing the request.
+  AGAIN = [ 408, 425, 429, 500, 502, 503, 504 ].freeze
+
+  attr_reader :sandbox_id
+
+  def initialize(sandbox_id, token, base: BASE)
+    @sandbox_id = sandbox_id
+    @token = token
+    @base = base.presence || BASE
+  end
+
+  def address = sandbox_id
+  def connection_errors = [ Unreachable ]
+  # A detached command's log can be followed again after a dropped request.
+  def reattaches? = true
+  # Takes `within:` on exec.
+  def bounded? = true
+
+  # Runs a shell command line; each output line is yielded; returns the exit status. With `within`, a command
+  # still running after that many seconds raises Unreachable, which its caller retries.
+  def exec(command, within: nil, &)
+    session = "nvoi-#{SecureRandom.hex(8)}"
+    request(Net::HTTP::Post, "/process/session", json: { sessionId: session })
+    begin
+      started = request(Net::HTTP::Post, "/process/session/#{session}/exec",
+                        json: { command:, runAsync: true })
+      follow(session, JSON.parse(started).fetch("cmdId"), within:, &)
+    ensure
+      close(session)
+    end
+  end
+
+  def upload(path, io)
+    body = io.respond_to?(:read) ? io.read : File.binread(io)
+    boundary = "nvoi-#{SecureRandom.hex(12)}"
+    name = File.basename(path)
+    head = "--#{boundary}\r\n" \
+           "Content-Disposition: form-data; name=\"file\"; filename=\"#{name}\"\r\n" \
+           "Content-Type: application/octet-stream\r\n\r\n"
+    form = head.b + body.to_s.b + "\r\n--#{boundary}--\r\n".b
+    request(Net::HTTP::Post, "/files/upload", params: { path: }, body: form,
+                                              type: "multipart/form-data; boundary=#{boundary}")
+  end
+
+  def download(path) = request(Net::HTTP::Get, "/files/download", params: { path: })
+
+  private
+
+    # New log bytes until the command has an exit code, then whatever it printed last.
+    def follow(session, command, within:)
+      deadline = Time.current + (within || LIMIT)
+      read = 0
+      buffer = "".b
+      path = "/process/session/#{session}/command/#{command}"
+      loop do
+        status = JSON.parse(request(Net::HTTP::Get, path)).fetch("exitCode", nil)
+        log = request(Net::HTTP::Get, "#{path}/logs").b
+        Sandbox::Adapter::Box.each_line(buffer, log.byteslice(read..).to_s) { |line| yield line if block_given? }
+        read = log.bytesize
+        unless status.nil?
+          yield buffer.force_encoding("UTF-8").scrub if buffer.present? && block_given?
+          return status
+        end
+        if Time.current > deadline
+          raise Unreachable, "#{sandbox_id}: command still running after #{within}s" if within
+
+          raise Sandbox::Adapter::Box::Failed, "#{sandbox_id}: no exit status after #{LIMIT}s"
+        end
+        sleep POLL
+      end
+    end
+
+    # A session that cannot be deleted now ends with the sandbox; its command is not ours to wait on.
+    def close(session)
+      request(Net::HTTP::Delete, "/process/session/#{session}")
+    rescue Unreachable, Sandbox::Adapter::Box::Failed
+      nil
+    end
+
+    def request(klass, path, params: {}, json: nil, body: nil, type: nil)
+      uri = URI("#{@base}/#{sandbox_id}#{path}")
+      uri.query = URI.encode_www_form(params) if params.any?
+      req = klass.new(uri)
+      req["Authorization"] = "Bearer #{@token}"
+      if json
+        req["Content-Type"] = "application/json"
+        req.body = json.to_json
+      elsif body
+        req["Content-Type"] = type
+        req.body = body
+      end
+      res = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https", open_timeout: 10,
+                                                read_timeout: 60) { _1.request(req) }
+      answer(res, klass, path)
+    rescue *Sandbox::Adapter::Provider::UNREACHABLE => e
+      raise Unreachable, "#{sandbox_id}: #{e.class}: #{e.message}"
+    end
+
+    def answer(res, klass, path)
+      return res.body.to_s if res.is_a?(Net::HTTPSuccess)
+
+      said = "#{klass::METHOD} #{path} #{res.code}: #{res.body.to_s.strip[0, 200]}"
+      raise Unreachable, "#{sandbox_id}: #{said}" if AGAIN.include?(res.code.to_i)
+
+      raise Sandbox::Adapter::Box::Failed, "daytona toolbox #{said}"
+    end
+end

data/lib/sandbox/provider/daytona.rb

@@ -1,4 +1,5 @@
-# Daytona linux-vm sandboxes: one VM snapshot per shape and region. SSH lands as root behind a short-lived token.
+# Daytona linux-vm sandboxes: one VM snapshot per shape and region. Commands and files go through the
+# sandbox's toolbox with the API key (Daytona::Toolbox), as root; there is no SSH.
 class Sandbox::Provider::Daytona < Sandbox::Adapter::SandboxVm
   IMAGE = "ubuntu:24.04"
   REGION = "uk-south-1"
@@ -11,13 +12,6 @@ class Sandbox::Provider::Daytona < Sandbox::Adapter::SandboxVm
     "build_failed" => :broken,
     "destroyed" => :broken
   }.freeze
-  TOKEN_MINUTES = 24 * 60
-  # An SSH token and where it lands, good until `until`.
-  Access = Data.define(:host, :port, :token, :until)
-  # One token per sandbox, kept until it nears expiry: minting a new one revokes the previous, so every
-  # transport to the same sandbox (root or the deploy user) shares it. A fork gets its own.
-  TOKENS = {}
-  TOKENS_LOCK = Mutex.new
 
   def initialize(token, client: Client.new(token), **)
     super(token, **)
@@ -150,7 +144,6 @@ to: Time.current.utc.iso8601 })
 
   # A parent with live forks cannot go: the error says so.
   def destroy(m)
-    TOKENS_LOCK.synchronize { TOKENS.delete(m.id) }
     @client.delete("/sandbox/#{m.id}", force: true)
   rescue Error => e
     raise unless e.status == 404
@@ -164,20 +157,10 @@ to: Time.current.utc.iso8601 })
     wake(machine(sandbox))
   end
 
+  # The sandbox's toolbox, reached with the API key: the same in every process, and nothing to revoke. A
+  # key or a host key has no use here.
   def transport(m, key: nil, host_key: nil, on_host_key: nil)
-    access = TOKENS_LOCK.synchronize do
-      kept = TOKENS[m.id]
-      kept = nil if kept.nil? || kept.until < Time.current
-      kept || (TOKENS[m.id] = mint(m.id))
-    end
-    Sandbox::Adapter::Ssh.new(
-      host: access.host,
-      port: access.port,
-      user: access.token,
-      key: nil,
-      host_key:,
-      on_host_key:
-    )
+    Toolbox.new(m.id, @token, base: m.data[:toolboxProxyUrl])
   end
 
   # Their preview link for the port: a host at their edge and a token it wants in a header. The token rotates
@@ -234,21 +217,6 @@ to: Time.current.utc.iso8601 })
       { cpu: 16, memory: 32, disk: 15 }
     end
 
-    def mint(sandbox_id)
-      access = @client.post(
-        "/sandbox/#{sandbox_id}/ssh-access",
-        {},
-        params: { expiresInMinutes: TOKEN_MINUTES }
-      )
-      command = access[:sshCommand].to_s
-      Access.new(
-        host: command[/@(\S+)/, 1],
-        port: (command[/-p (\d+)/, 1] || 22).to_i,
-        token: access[:token],
-        until: Time.current + (TOKEN_MINUTES - 10).minutes
-      )
-    end
-
     def wait(id, timeout: 300)
       deadline = Time.current + timeout
       loop do

data/lib/sandbox/provider/version.rb

@@ -1,5 +1,5 @@
 module Sandbox
   module Provider
-    VERSION = "0.1.1"
+    VERSION = "0.1.3"
   end
 end

data/lib/sandbox-provider.rb

@@ -12,6 +12,7 @@ require_relative "sandbox/provider/hetzner"
 require_relative "sandbox/provider/hetzner/client"
 require_relative "sandbox/provider/daytona"
 require_relative "sandbox/provider/daytona/client"
+require_relative "sandbox/provider/daytona/toolbox"
 require_relative "sandbox/provider/e2b"
 require_relative "sandbox/provider/e2b/client"
 require_relative "sandbox/provider/e2b/envd"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sandbox-provider
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - nvoi
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.1
+        version: 0.1.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.1
+        version: 0.1.2
 - !ruby/object:Gem::Dependency
   name: ed25519
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +52,7 @@ files:
 - lib/sandbox/provider/cloud_init.rb
 - lib/sandbox/provider/daytona.rb
 - lib/sandbox/provider/daytona/client.rb
+- lib/sandbox/provider/daytona/toolbox.rb
 - lib/sandbox/provider/e2b.rb
 - lib/sandbox/provider/e2b/client.rb
 - lib/sandbox/provider/e2b/envd.rb