samagotchi 0.138.0 → 0.139.0

data/lib/samagotchi/web/update_check.rb

@@ -17,13 +17,22 @@ module Samagotchi
   module Web
     # Checks RubyGems away from the session hub's Monitor and publishes the
     # result as chi web's version state. The state file preserves cooldowns
-    # and version-level notice deduplication across chi web restarts.
+    # and version-level notice deduplication across chi web restarts, and
+    # keeps AutoUpdate's record (the run in progress, the versions it gave
+    # up on) beside them.
+    #
+    # It runs when update.notify is on, or when update.auto is install
+    # (AutoUpdate needs the answer): with notify off the page and the phone
+    # are told nothing, the hub's `available` stays nil.
     class UpdateCheck
       FIRST_CHECK = 30
       # A failed check (offline at start) tries again this soon, not a whole check_hours later.
       RETRY = 3600
 
+      # @param enabled [Boolean] update.notify: the answer goes to the page
+      # @param auto [Boolean] update.auto is install: check even when +enabled+ is not
       def initialize(hub:, enabled: Config.get("update.notify") == "on",
+                     auto: Config.get("update.auto") == "install",
                      check_hours: Config.get("update.check_hours"),
                      min_age_hours: Config.get("update.min_age_hours"),
                      fetcher: -> { GemUpdate.new.releases }, clock: -> { Time.now },
@@ -31,7 +40,8 @@ module Samagotchi
                      gem_spec: InstalledGem.spec, bundler: nil, gem_dir: ChiHome.gem_dir(gem_spec: gem_spec),
                      installed_versions: InstalledVersions.new)
         @hub = hub
-        @enabled = enabled
+        @notify = enabled
+        @enabled = enabled || auto
         @check_seconds = [check_hours.to_i, 1].max * 3600
         @min_age_seconds = [min_age_hours.to_i, 0].max * 3600
         @fetcher = fetcher
@@ -55,7 +65,7 @@ module Samagotchi
         return self if @thread&.alive?
 
         @stopped = false
-        @hub.update_available(available: still_newer(@state[:available]), blocked: @blocked)
+        @hub.update_available(available: @notify ? still_newer(@state[:available]) : nil, blocked: @blocked)
         @thread = Thread.new { run_loop }
         self
       end
@@ -80,11 +90,11 @@ module Samagotchi
           releases = @fetcher.call
           available = available_release(releases, now)&.version
           notified = @state[:notified]
-          notify = available && !notified.include?(available)
-          next_state = { checked_at: now.iso8601, available: available,
-                         notified: notify ? (notified + [available]) : notified }
+          notify = @notify && available && !notified.include?(available)
+          next_state = @state.merge(checked_at: now.iso8601, available: available,
+                                    notified: notify ? (notified + [available]) : notified)
           persist(next_state)
-          @hub.update_available(available: available, blocked: @blocked, notify: !!notify)
+          @hub.update_available(available: @notify ? available : nil, blocked: @blocked, notify: !!notify)
           @failed = false
           true
         rescue StandardError => e
@@ -94,6 +104,36 @@ module Samagotchi
         end
       end
 
+      # The release the last check found and this chi (and the installed
+      # ones) are still behind, whether or not the page was told.
+      # @return [String, nil]
+      def available
+        still_newer(@state[:available])
+      end
+
+      # AutoUpdate's record of the run it started: {version:, from:, phase:,
+      # kept:, workers:, pushed:, detail:} (symbol keys), nil when none.
+      # @return [Hash, nil]
+      def auto_state
+        @checking.synchronize { @state[:auto]&.dup }
+      end
+
+      # Whether AutoUpdate already tried +version+ and failed (one automatic
+      # try per version).
+      def auto_failed?(version)
+        @checking.synchronize { @state[:auto_failed].include?(version) }
+      end
+
+      # Saves AutoUpdate's record (nil clears it); +failed+ adds a version to
+      # the ones it gave up on.
+      def save_auto(auto, failed: nil)
+        @checking.synchronize do
+          failed_list = failed && !@state[:auto_failed].include?(failed) ? @state[:auto_failed] + [failed] : @state[:auto_failed]
+          persist(@state.merge(auto: auto, auto_failed: failed_list))
+        end
+        nil
+      end
+
       # Why chi web can't install a gem here (the notice's and POST /api/update's
       # one answer), or nil: a source checkout, a Bundler run, a gem dir it
       # can't write.
@@ -158,19 +198,25 @@ module Samagotchi
       def blocked_reason = self.class.blocked_reason(gem_spec: @gem_spec, bundler: @bundler, gem_dir: @gem_dir)
 
       def load_state
-        return { checked_at: nil, available: nil, notified: [] } unless File.file?(@state_file)
+        return empty_state unless File.file?(@state_file)
 
         data = JSON.parse(File.read(@state_file))
         {
           checked_at: data["checked_at"],
           available: data["available"],
-          notified: Array(data["notified"]).select { |version| version.is_a?(String) }
+          notified: strings(data["notified"]),
+          auto: data["auto"].is_a?(Hash) ? data["auto"].transform_keys(&:to_sym) : nil,
+          auto_failed: strings(data["auto_failed"])
         }
       rescue JSON::ParserError, SystemCallError => e
         Log.warn(:web, "update_check_failed", error: e.class.name, msg: e.message)
-        { checked_at: nil, available: nil, notified: [] }
+        empty_state
       end
 
+      def empty_state = { checked_at: nil, available: nil, notified: [], auto: nil, auto_failed: [] }
+
+      def strings(list) = Array(list).select { |version| version.is_a?(String) }
+
       def persist(state)
         FileUtils.mkdir_p(File.dirname(@state_file))
         AtomicFile.write(@state_file, JSON.generate(state), perm: 0o600)

data/lib/samagotchi/web/update_ops.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+require "json"
+require "open3"
+require "rbconfig"
+require_relative "../child_env"
+require_relative "../chi_home"
+require_relative "../client_id"
+require_relative "../installed_gem"
+require_relative "../live_versions"
+require_relative "../log"
+require_relative "../session"
+require_relative "../session_manager"
+require_relative "../version"
+require_relative "update_check"
+
+module Samagotchi
+  module Web
+    # The three update operations chi web runs for its owner, one at a time
+    # (App's routes ask for them, and so does AutoUpdate): an install
+    # (`chi update --to V` in a child), a pass restarting the stale workers,
+    # and chi web's own restart. Each answers at once, :started (it runs on
+    # its own thread, its progress and result going out as `chi_update`
+    # frames) or a refusal; the caller decides what a refusal says.
+    class UpdateOps
+      # chi update's own words when it printed no rows.
+      class UpdateFailed < StandardError; end
+
+      # @param hub [SessionHub, nil] the frames' publisher
+      # @param manager [#restart_session] SessionManager
+      # @param state_dir [String, nil] the sessions dir (nil: the default)
+      # @param runner [#call] `(argv, env:, progress:) → [stdout, success]`
+      #   runs the chi update child
+      # @param blocked [#call] why this install can't take a gem, or nil
+      def initialize(hub:, manager: SessionManager, state_dir: nil, runner: nil, blocked: nil)
+        @hub = hub
+        @manager = manager
+        @state_dir = state_dir
+        @runner = runner || method(:run_update_command)
+        @blocked = blocked || -> { UpdateCheck.blocked_reason }
+        @mutex = Mutex.new
+        @running = false
+        @restart_web = nil
+      end
+
+      # Set by Server.start: the lambda that has chi web restart itself
+      # (true; :no_wrapper when there is nothing to exec; false when one was
+      # already asked for).
+      attr_writer :restart_web
+
+      # Whether the restart lambda is there (a stand-in server has none).
+      def restart_web? = !@restart_web.nil?
+
+      # Why a gem can't be installed here (UpdateCheck.blocked_reason), or nil.
+      def blocked_reason = @blocked.call
+
+      # Whether an operation runs (or chi web is restarting).
+      def running? = @mutex.synchronize { @running }
+
+      # Runs `chi update --to +version+` on a thread.
+      # @param wait [Boolean] block until it ends and answer its final
+      #   `{state:, rows:}` instead of :started
+      # @return [Symbol, Hash] :started, :busy (another operation runs) or
+      #   :start_failed (no thread); with wait: the result
+      def install(version, wait: false, auto: false)
+        return :busy unless claim
+
+        @hub.publish_update(state: "running", rows: [], operation: "install", version: version, auto: auto)
+        thread = Thread.new { perform_install(version, auto) }
+        wait ? thread.value : :started
+      rescue ThreadError => e
+        release
+        Log.warn(:web, "update_start_failed", error: e.class.name, msg: e.message)
+        @hub&.publish_update(state: "failed", rows: [
+          { "component" => "chi update", "status" => "failed (couldn't start update)", "failed" => true, "kept" => [] }
+        ], operation: "install", auto: auto)
+        :start_failed
+      end
+
+      # Restarts every stale worker (the worker refuses atomically when busy).
+      # @param select [#call, nil] asked of each stale worker (a
+      #   LiveVersions::Worker): false leaves it, as a `skipped` row
+      # @return [Symbol, Hash] as #install
+      def restart_workers(wait: false, auto: false, select: nil)
+        return :busy unless claim
+
+        @hub.publish_update(state: "running", rows: [], operation: "workers", auto: auto)
+        thread = Thread.new { perform_worker_restarts(auto, select) }
+        wait ? thread.value : :started
+      rescue ThreadError => e
+        release
+        Log.warn(:web, "worker_restart_start_failed", error: e.class.name, msg: e.message)
+        @hub&.publish_update(state: "failed", rows: [
+          { "state" => "failed", "reason" => "couldn't start worker restarts" }
+        ], operation: "workers", auto: auto)
+        :start_failed
+      end
+
+      # The exec replaces this process: an update's chi update child (its
+      # pipes read here) or a worker restart pass would die mid-way, so
+      # neither may run, and none starts once the restart is asked for.
+      # @return [Symbol] :unavailable (no restart lambda), :busy, :started,
+      #   :no_wrapper or :requested (already restarting)
+      def restart_web
+        return :unavailable unless @restart_web
+
+        busy = @mutex.synchronize do
+          next true if @running
+
+          @running = true # held for good once restarting: the exec ends this process
+          false
+        end
+        return :busy if busy
+
+        case @restart_web.call
+        when true then return :started
+        when :no_wrapper then answer = :no_wrapper
+        else answer = :requested
+        end
+        release
+        answer
+      end
+
+      # The chi update child: with a chi home, the home's chi (its gem dirs
+      # are what new workers activate); else this Ruby and the wrapper.
+      def update_argv(version, home: ChiHome.current)
+        args = ["update", "--to", version, "--no-desktop", "--json"]
+        return home.boot_argv(run: ChiHome::CHI_BOOT) + ["--", *args] if home
+
+        [RbConfig.ruby, InstalledGem.wrapper, *args]
+      end
+
+      private
+
+      def claim
+        @mutex.synchronize do
+          next false if @running
+
+          @running = true
+        end
+      end
+
+      def release
+        @mutex.synchronize { @running = false }
+      end
+
+      def perform_install(version, auto)
+        argv = update_argv(version)
+        said = nil
+        output, success = @runner.call(argv, env: ChildEnv.unbundled,
+                                             progress: lambda { |line|
+                                               said = line unless line.strip.empty?
+                                               @hub.publish_update(state: "running", rows: [], progress: line,
+                                                                   operation: "install", version: version, auto: auto)
+                                             })
+        rows = update_rows(output)
+        # No rows (a usage error, a refusal): what the child said is the reason.
+        raise UpdateFailed, said || output.lines.map(&:strip).find { |line| !line.empty? } || "chi update printed no rows" unless rows
+
+        # The installed version as of now (the hub's own look is up to a probe interval old), before "done".
+        @hub.refresh_installed if success
+        state = success ? "done" : "failed"
+        @hub.publish_update(state: state, rows: rows, operation: "install", version: version, auto: auto)
+        { state: state, rows: rows }
+      rescue StandardError => e
+        Log.exception(:web, "update_failed", e)
+        rows = [{ "component" => "chi update", "status" => "failed (#{e.message.lines.first.to_s.strip})",
+                  "failed" => true, "kept" => [] }]
+        @hub.publish_update(state: "failed", rows: rows, operation: "install", version: version, auto: auto)
+        { state: "failed", rows: rows }
+      ensure
+        release
+      end
+
+      # chi update --json's rows, or nil when it printed none.
+      def update_rows(output)
+        rows = JSON.parse(output)
+        rows if rows.is_a?(Array) && rows.all?(Hash)
+      rescue JSON::ParserError
+        nil
+      end
+
+      def run_update_command(argv, env:, progress:)
+        Open3.popen3(env, *argv) do |stdin, stdout, stderr, wait_thread|
+          stdin.close
+          stderr_thread = Thread.new { stderr.each_line { |line| progress.call(line.chomp) } }
+          output = stdout.read
+          stderr_thread.value
+          [output, wait_thread.value.success?]
+        end
+      end
+
+      # One worker's restart as its row.
+      def restart_one(worker)
+        restarted = @manager.restart_session(worker.session_id, state_dir: @state_dir, client_id: ClientId::WEB_RESTART)
+        @hub.touch(worker.session_id)
+        { "session_id" => restarted.session_id, "state" => "restarted", "from_version" => restarted.from_version,
+          "version" => restarted.version }
+      rescue SessionManager::RestartRefused => e
+        # detail: the refusal's own words (RestartRefused.words), the reason code for clients.
+        { "session_id" => worker.session_id, "state" => "refused", "reason" => e.reason.to_s,
+          "detail" => e.message, "holds" => e.holds.map(&:to_s) }
+      rescue SessionManager::OwnedByTUI => e
+        { "session_id" => worker.session_id, "state" => "owned_by_tui", "detail" => e.message }
+      rescue StandardError => e
+        Log.exception(:web, "worker_restart_failed", e, sid: worker.session_id)
+        { "session_id" => worker.session_id, "state" => "failed", "reason" => e.class.name, "detail" => e.message }
+      end
+
+      # A worker the caller's +select+ left: still on the old chi, to restart when it is idle.
+      def skipped(worker)
+        { "session_id" => worker.session_id, "state" => "skipped", "reason" => "not_idle",
+          "detail" => "not idle for long enough: it restarts when it is idle" }
+      end
+
+      def default_state_dir = @state_dir || Session.default_state_dir
+
+      def perform_worker_restarts(auto, select)
+        # Installed now: the hub's own look is up to a full probe old (nil right after chi web started).
+        target = @hub.refresh_installed || VERSION
+        rows = []
+        LiveVersions.stale_workers(target, state_dir: default_state_dir).each do |worker|
+          row = select && !select.call(worker) ? skipped(worker) : restart_one(worker)
+          rows << row
+          @hub.publish_update(state: "running", rows: rows.dup, operation: "workers", auto: auto)
+        end
+        state = rows.any? { |row| row["state"] == "failed" } ? "failed" : "done"
+        @hub.publish_update(state: state, rows: rows, operation: "workers", auto: auto)
+        { state: state, rows: rows }
+      rescue StandardError => e
+        Log.exception(:web, "worker_restart_failed", e)
+        rows = [{ "state" => "failed", "reason" => e.class.name, "detail" => e.message }]
+        @hub.publish_update(state: "failed", rows: rows, operation: "workers", auto: auto)
+        { state: "failed", rows: rows }
+      ensure
+        release
+      end
+    end
+  end
+end

data/lib/samagotchi/worker_task_wakes.rb

@@ -129,7 +129,7 @@ module Samagotchi
     end
 
     def note(entry, record, wake:, turn_id: nil)
-      TaskFinishNote.note(record, limit_sec: entry.limit_sec, wake: wake, turn_id: turn_id,
+      TaskFinishNote.note(record, limit_sec: entry.limit_sec, early_sec: entry.early_sec, wake: wake, turn_id: turn_id,
                                   cap: KernelLoop.resolve_output_char_cap(nil))
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.138.0
+  version: 0.139.0
 platform: ruby
 authors:
 - Dmitry Dedov
@@ -752,6 +752,7 @@ files:
 - lib/samagotchi/vision_support.rb
 - lib/samagotchi/waiting_steer.rb
 - lib/samagotchi/web/app.rb
+- lib/samagotchi/web/auto_update.rb
 - lib/samagotchi/web/capabilities.rb
 - lib/samagotchi/web/editor.rb
 - lib/samagotchi/web/grants.rb
@@ -951,6 +952,7 @@ files:
 - lib/samagotchi/web/tunnel.rb
 - lib/samagotchi/web/tunnel/tailscale.rb
 - lib/samagotchi/web/update_check.rb
+- lib/samagotchi/web/update_ops.rb
 - lib/samagotchi/web/verify_fresh_routes.rb
 - lib/samagotchi/worker.rb
 - lib/samagotchi/worker_idle_exit.rb