ruby_everywhere 0.7.0 → 0.8.0

data/lib/everywhere/child_supervision.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require "socket"
+require_relative "clock"
+require_relative "child_processes"
+require_relative "relay"
+require_relative "shellout"
+require_relative "ui"
+
+module Everywhere
+  # The long-lived children a session keeps on a leash, one per key: `every
+  # dev`'s dev server, desktop shell and log stream; `every preview`'s server
+  # and tunnel.
+  #
+  # It sits above ChildProcesses — which knows how to signal one pid's process
+  # group but nothing about names — and beside Shellout, which knows how to
+  # spawn one child but never remembers it. What lives here is the
+  # session-scoped {key => pid} registry, and the teardown that must not let a
+  # child outlive the CLI that opened it.
+  #
+  # A mixin rather than a collaborator object: the registry has exactly one
+  # owner (the command), and these read as the command's own vocabulary —
+  # stop_child(:web), child_pid(:desktop).
+  module ChildSupervision
+    private
+
+    # Children are spawned from pool threads as well as the main one.
+    def init_children!
+      @pids = {}
+      @relays = {}
+      @children = Mutex.new
+    end
+
+    # Spawn a long-lived child on a pty and relay its output, one tagged line
+    # at a time. A pty rather than a pipe so foreman, cargo and friends still
+    # believe they're on a terminal and keep their colors; PTY.spawn also
+    # setsids, so a Ctrl-C at our terminal can't reach them and teardown
+    # decides when they die.
+    def supervise(key, env, cmd, chdir:, filter: nil, log: nil, on_line: nil)
+      io, pid = spawn_child(env, cmd, chdir: chdir)
+      thread = relay_thread(key, io, pid, filter: filter, log: log, on_line: on_line) if io
+      Process.detach(pid)
+      @children.synchronize do
+        @pids[key] = pid
+        @relays[key] = thread if thread
+      end
+      pid
+    end
+
+    # How this command puts a child into the world: [io, pid], where io is the
+    # side we read its output from — or nil for a child that was handed our own
+    # fds and prints for itself, which gets no relay. Overridden per command,
+    # because only the pty path is shared: what to do when there is no pty is
+    # exactly where dev and preview differ.
+    def spawn_child(env, cmd, chdir:)
+      Shellout.spawn_pty(env, cmd, chdir: chdir)
+    end
+
+    def relay_thread(key, io, pid, filter:, log:, on_line:)
+      Thread.new do
+        Thread.current.name = "relay-#{key}"
+        Thread.current.report_on_exception = false
+        begin
+          Relay.new(io, source: key, log: log, filter: filter, on_line: on_line).run
+        rescue StandardError => e
+          # Losing a relay costs us that child's output, nothing more. It must
+          # not surface later out of the join in teardown.
+          Kernel.warn("#{key} output relay stopped: #{e.class}: #{e.message}")
+        end
+        on_child_exit(key, pid)
+      end
+    end
+
+    # The child's output ended, which for a supervised child means it died.
+    # Nothing to do by default — the pid is still in the registry either way,
+    # and teardown reaps it.
+    def on_child_exit(key, pid); end
+
+    # TERM the child's whole process group, escalate to KILL, and wait for the
+    # relay to drain so its last lines aren't lost. The pid is dropped from the
+    # registry FIRST, so the relay knows this death was asked for.
+    def stop_child(key, grace: 5)
+      pid, thread = @children.synchronize { [@pids.delete(key), @relays.delete(key)] }
+      return unless pid
+
+      reap([pid], grace: grace)
+      thread&.join(1)
+    end
+
+    # TERM each process group, wait for them together rather than serially,
+    # then KILL the stragglers.
+    def reap(pids, grace: 5)
+      live = pids.compact.select { |pid| ChildProcesses.alive?(pid) }
+      return if live.empty?
+
+      live.each { |pid| ChildProcesses.signal(pid, "TERM") }
+      deadline = Clock.monotonic + grace
+      sleep(0.1) while live.any? { |pid| ChildProcesses.alive?(pid) } && Clock.monotonic < deadline
+      live.select { |pid| ChildProcesses.alive?(pid) }.each { |pid| ChildProcesses.signal(pid, "KILL") }
+    end
+
+    def child_pid(key) = @children.synchronize { @pids[key] }
+
+    # Teardown must never raise — it runs from an ensure, where an exception
+    # would mask whatever actually ended the session — and one failed step
+    # must not skip the rest, or a child survives the CLI that spawned it.
+    # That ensure can also run before init_children! ever did, which is why the
+    # registry is read through a nil guard.
+    #
+    # `before` is whatever the host has to shut down ahead of its children —
+    # for `every dev`, the dock's hold on the terminal and the build pool.
+    def teardown_children(grace: 2, before: [])
+      @stopping = true
+      pids, relays = @children ? @children.synchronize { [@pids.values, @relays.values] } : [[], []]
+      (before + [
+        # TERM everything, then give it a moment and KILL whatever is left.
+        # The CLI exits the instant this returns, so anything still alive is
+        # orphaned — and a windowed shell is exactly the kind of child that
+        # doesn't drop dead on the first signal.
+        -> { reap(pids, grace: grace) },
+        -> { relays.each { |thread| thread.join(1) } }
+      ]).each do |step|
+        step.call
+      rescue StandardError => e
+        Kernel.warn("teardown: #{e.class}: #{e.message}")
+      end
+    end
+
+    # Checked once, up front: Integer() would otherwise raise from inside
+    # port_open? — an ArgumentError backtrace after the dock has already
+    # taken over the terminal.
+    def validate_port!(port)
+      number = begin
+        Integer(port.to_s, 10)
+      rescue ArgumentError, TypeError
+        UI.die!("--port must be a number (got #{port.inspect})")
+      end
+      UI.die!("--port must be between 1 and 65535 (got #{number})") unless (1..65_535).cover?(number)
+      number.to_s
+    end
+
+    # Any connect error means "nothing listening yet" for our purposes —
+    # ECONNREFUSED is the common one, but a firewall or an exhausted fd table
+    # answers differently and must not abort the session.
+    def port_open?(port)
+      TCPSocket.new("127.0.0.1", Integer(port)).close
+      true
+    rescue SystemCallError
+      false
+    end
+
+    # Watches the child as well as the port: a dev server that dies on
+    # startup (no `bundle install`, a bin/dev whose foreman isn't installed)
+    # never opens the port, and waiting out the full timeout for it buries
+    # the error it already printed under a minute of silence.
+    #
+    # The hints are appended to the message as-is, for a caller that can say
+    # something more specific about why its server never came up.
+    def wait_for_port(port, pid: nil, timeout: 60, dead_hint: nil, slow_hint: nil)
+      deadline = Clock.monotonic + timeout
+      until port_open?(port)
+        if pid && !ChildProcesses.alive?(pid)
+          UI.die!("the dev server exited before it finished booting — scroll up for its output#{dead_hint}")
+        end
+        if Clock.monotonic > deadline
+          UI.die!("dev server never came up on port #{port} after #{timeout}s#{slow_hint}")
+        end
+        sleep 0.25
+      end
+    end
+  end
+end

data/lib/everywhere/clock.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Everywhere
+  # The one clock every deadline in the CLI measures against. Monotonic, so a
+  # timeout can't be lengthened or skipped by an NTP step or a DST change
+  # mid-build.
+  module Clock
+    module_function
+
+    def monotonic = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  end
+end

data/lib/everywhere/commands/build.rb

@@ -5,10 +5,12 @@ require "fileutils"
 require "tmpdir"
 require "shellwords"
 require_relative "../shellout"
+require_relative "../host"
 require_relative "../log_filter"
 require_relative "../png"
 require_relative "../icon"
 require_relative "../paths"
+require_relative "../plist"
 require_relative "../desktop_assets"
 require_relative "../builders/ios"
 require_relative "../builders/android"
@@ -63,6 +65,17 @@ module Everywhere
         root_path = File.expand_path(root)
         config = Everywhere::Config.load(root_path)
 
+        # Before any builder runs: the bundle id names the work dirs they wipe
+        # and recreate, so a malformed one is a wrong path, not a wrong label.
+        identity_errors = config.identity_errors
+        UI.die!("app: in config/everywhere.yml:\n#{identity_errors.join("\n")}") unless identity_errors.empty?
+
+        # Baked into the shell here, so this is the last moment an unusable
+        # feed URL can still be a message instead of a shipped app that never
+        # updates.
+        updates_errors = config.updates_errors
+        UI.die!("updates: in config/everywhere.yml:\n#{updates_errors.join("\n")}") unless updates_errors.empty?
+
         # Builder dispatch on the target's os (build-engine.md §5): macOS is
         # the tebako+tauri path below; the mobile targets are Hotwire Native
         # shells, each built by its own builder. Anything else has no builder yet.
@@ -75,13 +88,13 @@ module Everywhere
           app = mobile_builder(target).new(config: config, root: root_path, target: target,
                                            template_dir: template_dir, **channel_option(target, channel))
                                       .build!(dist_dir: dist_dir, **mobile_options(target, device: device, format: format))
-          UI.success("built #{rel(app, root_path)}")
+          UI.success("built #{UI.rel_path(app, root_path)}")
           return
         when "macos" # ...which is the rest of this method
           # Every step of it ends in codesign and an .app bundle, so a Linux
           # host can only fail — the question is whether it fails here or
           # thirty minutes in, at the first codesign.
-          UI.die!("desktop builds are macOS-only for now") unless RUBY_PLATFORM.include?("darwin")
+          UI.die!("desktop builds are macOS-only for now") unless Host.darwin?
         else
           UI.die!("no builder for target #{target} — macos-*, ios-* and android-* are supported")
         end
@@ -124,15 +137,15 @@ module Everywhere
         UI.step("#{UI.bold(framework.name)} app at #{framework.root}")
 
         if skip_press
-          UI.die!("--skip-press given but #{rel(output_path, root_path)} doesn't exist") unless File.exist?(output_path)
-          UI.step("reusing pressed binary #{rel(output_path, root_path)}")
+          UI.die!("--skip-press given but #{UI.rel_path(output_path, root_path)} doesn't exist") unless File.exist?(output_path)
+          UI.step("reusing pressed binary #{UI.rel_path(output_path, root_path)}")
         else
           press!(framework, entry, ruby, output_path)
         end
 
         bundle_app(output_path, app_name, shell_dir, config, target: target)
 
-        UI.success("built #{rel(output_path, root_path)} (#{(File.size(output_path) / 1024.0 / 1024.0).round}MB)")
+        UI.success("built #{UI.rel_path(output_path, root_path)} (#{(File.size(output_path) / 1024.0 / 1024.0).round}MB)")
       end
 
       private
@@ -193,8 +206,6 @@ module Everywhere
         target
       end
 
-      def rel(path, root_path) = UI.short_path(path.sub("#{root_path}/", "").sub("#{Dir.pwd}/", ""))
-
       # The precompile step runs against the HOST Ruby — unlike tebako press,
       # which installs the app's gems itself inside the packaged Ruby. A fresh
       # machine (a hosted build runner, a brand-new checkout) has Gemfile.lock
@@ -400,6 +411,8 @@ module Everywhere
       # and CFBundleVersion come from `app.version` in everywhere.yml (via
       # config.version), so the bundle and the release.json receipt agree.
       def info_plist(app_name, exe_name, icon, identifier, version)
+        app_name, exe_name, icon, identifier, version =
+          [app_name, exe_name, icon, identifier, version].map { |v| Everywhere::Plist.escape(v) if v }
         icon_keys = icon ? "  <key>CFBundleIconFile</key><string>#{icon}</string>\n" : ""
         <<~PLIST
           <?xml version="1.0" encoding="UTF-8"?>
@@ -420,8 +433,6 @@ module Everywhere
         PLIST
       end
 
-      private
-
       # Tebako's output is thousands of lines; re-surface the warnings that
       # actually matter to the app developer after the build finishes.
       def surface_warnings(log)