sandbox-provider 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c4be6ee4a326cae728dfa5986e371fb23a3b51a34646c3fc26d0c79e95647a7b
-  data.tar.gz: fd8ec5fda4686750696ea0e7ea14bdc317eeef2a90b6156ccee3c5ee91595e3b
+  metadata.gz: 9e0e09727229563480ccb1c17fa80d6006fc308373d485a5e74e6b5dbfeeaa95
+  data.tar.gz: eb2b8ab9b4e9c83dd2b1def46e15efbee8c3e659497e52b2a6b3b37d38ca35cc
 SHA512:
-  metadata.gz: f874cc33545840d4a68b082858285aa9824f61743db170c38fa82a7b208ed646028be1750069f4a77a38707c306d54ebd52c191fd6b0f9a79d8f7c01beb9bbc5
-  data.tar.gz: 8b6d3e75a0e01167d9a83950b0d481abbf2267e3491283cdb82f84137594d441b971c1dab46c7182addd9c8a1fa87fc2482ddc95749f5c0e90e03e10d460fdde
+  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,29 +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 shares it, across processes when the store is shared. A fork gets its own.
-  # A store answers read(id), write(id, access), delete(id) and synchronize(id) { }.
-  class Tokens
-    def initialize
-      @tokens = {}
-      @lock = Monitor.new
-    end
-
-    def read(id) = @tokens[id]
-    def write(id, access) = @tokens[id] = access
-    def delete(id) = @tokens.delete(id)
-    def synchronize(_id, &) = @lock.synchronize(&)
-  end
-
-  class << self
-    attr_writer :tokens
-
-    def tokens = @tokens ||= Tokens.new
-  end
 
   def initialize(token, client: Client.new(token), **)
     super(token, **)
@@ -166,7 +144,6 @@ to: Time.current.utc.iso8601 })
 
   # A parent with live forks cannot go: the error says so.
   def destroy(m)
-    self.class.tokens.synchronize(m.id) { self.class.tokens.delete(m.id) }
     @client.delete("/sandbox/#{m.id}", force: true)
   rescue Error => e
     raise unless e.status == 404
@@ -180,19 +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)
-    Link.new(-> (stale) { access(m.id, stale:) }, host_key:, on_host_key:)
-  end
-
-  # The sandbox's token from the store, minted when there is none, it nears expiry, or it is `stale`: the
-  # one a refused connection used. Another process may have replaced it already; then that one is kept.
-  def access(id, stale: nil)
-    tokens = self.class.tokens
-    tokens.synchronize(id) do
-      kept = tokens.read(id)
-      kept = nil if kept.nil? || kept.until < Time.current || kept.token == stale
-      kept || mint(id).tap { |minted| tokens.write(id, minted) }
-    end
+    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
@@ -249,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.2"
+    VERSION = "0.1.3"
   end
 end

data/lib/sandbox-provider.rb

@@ -12,7 +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/link"
+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.2
+  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,7 +52,7 @@ files:
 - lib/sandbox/provider/cloud_init.rb
 - lib/sandbox/provider/daytona.rb
 - lib/sandbox/provider/daytona/client.rb
-- lib/sandbox/provider/daytona/link.rb
+- lib/sandbox/provider/daytona/toolbox.rb
 - lib/sandbox/provider/e2b.rb
 - lib/sandbox/provider/e2b/client.rb
 - lib/sandbox/provider/e2b/envd.rb

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

@@ -1,59 +0,0 @@
-# An SSH transport whose token another process can revoke by minting a new one. A command refused before
-# it printed anything is tried once more with the store's current token.
-class Sandbox::Provider::Daytona::Link
-  RETRY = [ *Sandbox::Adapter::Ssh::CONNECTION_ERRORS, Net::SSH::AuthenticationFailed ].freeze
-
-  def initialize(access, host_key: nil, on_host_key: nil)
-    @access = access
-    @host_key = host_key
-    @on_host_key = on_host_key
-    @ssh = build(access.call(nil))
-  end
-
-  def address = @ssh.address
-  def host = @ssh.host
-  def port = @ssh.port
-  def user = @ssh.user
-  def key = @ssh.key
-  def connection_errors = Sandbox::Adapter::Ssh::CONNECTION_ERRORS
-  def reattaches? = true
-
-  def exec(command, &block)
-    printed = false
-    begin
-      @ssh.exec(command) do |line|
-        printed = true
-        block&.call(line)
-      end
-    rescue *RETRY
-      raise if printed
-
-      refresh
-      @ssh.exec(command, &block)
-    end
-  end
-
-  def upload(path, io)
-    @ssh.upload(path, io)
-  rescue *RETRY
-    io.rewind if io.respond_to?(:rewind)
-    refresh
-    @ssh.upload(path, io)
-  end
-
-  def download(path)
-    @ssh.download(path)
-  rescue *RETRY
-    refresh
-    @ssh.download(path)
-  end
-
-  private
-
-    def refresh = @ssh = build(@access.call(@ssh.user))
-
-    def build(access)
-      Sandbox::Adapter::Ssh.new(host: access.host, port: access.port, user: access.token, key: nil,
-                                host_key: @host_key, on_host_key: ->(key) { @host_key = key; @on_host_key&.call(key) })
-    end
-end