siding 0.0.1

data/lib/siding/cli.rb

@@ -0,0 +1,459 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+require_relative "error"
+require_relative "version"
+require_relative "platform"
+require_relative "runtime"
+require_relative "protocol"
+require_relative "staleness"
+
+module Siding
+  class CLI
+    MANAGEMENT_COMMANDS = %w[start status stop restart doctor init version help --help -h].freeze
+    ACCELERATED_EXECUTABLES = %w[rails rake rspec test].freeze
+    OUT_OF_SCOPE_RAILS_COMMANDS = %w[dev:cache].freeze
+    SERVER_COMMANDS = %w[server s].freeze
+    DAEMON_FLAGS = %w[-d --daemon].freeze
+
+    REQUEST_TIMEOUT = 5
+    BOOT_LOG_LINES = 20
+
+    BINSTUBS = %w[rails rake rspec].freeze
+    BINSTUB_MARKER = "generated by siding"
+
+    class << self
+      def management?(name) = MANAGEMENT_COMMANDS.include?(name)
+
+      def accelerated?(argv)
+        executable = argv.first
+        return false unless ACCELERATED_EXECUTABLES.include?(executable)
+        return rails_accelerated?(argv) if executable == "rails"
+
+        true
+      end
+
+      def rails_accelerated?(argv)
+        command = argv[1]
+        return false if OUT_OF_SCOPE_RAILS_COMMANDS.include?(command)
+        return false if SERVER_COMMANDS.include?(command) && argv.any? { DAEMON_FLAGS.include?(_1) }
+
+        true
+      end
+    end
+
+    attr_reader :argv, :client
+
+    def initialize(argv, client)
+      @argv = argv
+      @client = client
+    end
+
+    def run
+      command = argv.first
+      ret = if ["help", "--help", "-h", nil].include?(command)
+        help
+      elsif MANAGEMENT_COMMANDS.include?(command)
+        send(command)
+      else
+        unimplemented(command)
+      end
+      ret.is_a?(Integer) ? ret : 0
+    end
+
+    private
+
+    def logger = client.logger
+
+    def status
+      runtime = client.runtime
+      return report("no Rails application found here", warm: false) if runtime.nil?
+
+      info = runtime.live_server_info
+      if info.nil?
+        runtime.discard_records if runtime.server_info
+        return report("no warm application for #{project_label}", warm: false)
+      end
+
+      report_status(info, request_status(runtime))
+    end
+
+    def stop
+      runtime = client.runtime
+      return unless runtime && File.directory?(runtime.dir)
+
+      pid = runtime.server_pid
+      if pid.nil?
+        runtime.discard_records
+        return
+      end
+
+      request_stop(runtime)
+      terminate(pid)
+      runtime.discard_records
+      logger.debug("stopped server pid #{pid}")
+    end
+
+    def start
+      outcome = client.warm_up
+      return report_start_failure unless outcome
+
+      state = outcome == :already_warm ? "is already warm" : "is warm"
+      logger.notice("#{project_label} #{state}#{server_suffix}")
+    end
+
+    def server_suffix
+      pid = client.runtime&.server_pid
+      pid ? " -- pid #{pid}" : ""
+    end
+
+    def report_start_failure
+      reason = client.unusable_reason
+      if reason
+        logger.notice("cannot boot a warm application for #{project_label}: #{reason}")
+      else
+        logger.notice("#{project_label} did not boot within its bound; its output is in #{client.runtime.boot_log_path}")
+      end
+      1
+    end
+
+    def restart
+      stop
+      return if client.warm_up
+
+      logger.notice("stopped, but nothing was booted -- the next command will boot one")
+      1
+    end
+
+    def version
+      logger.notice("siding #{Siding::VERSION}")
+    end
+
+    def help
+      logger.notice(<<~TEXT.chomp)
+        siding #{Siding::VERSION} -- a Rails application preloader that never serves stale code
+
+        Usage:
+          siding <command> [args...]   run a command against the warm application
+          siding start                 boot a warm application without running a command
+          siding status                report whether a warm application exists
+          siding stop                  stop everything belonging to this project
+          siding restart               stop, then boot fresh
+          siding doctor                explain why an invocation was or was not accelerated
+          siding init                  generate opt-in binstubs
+      TEXT
+      0
+    end
+
+    def doctor
+      lines = ["siding #{Siding::VERSION} -- #{project_label}"]
+      lines.concat(platform_lines)
+      lines.concat(project_lines)
+      lines.concat(runtime_lines)
+      lines.concat(acceleration_lines)
+      lines.concat(server_lines)
+      lines.concat(boot_log_lines)
+      logger.notice(lines.join("\n"))
+      acceleration_available? ? 0 : 1
+    end
+
+    def platform_lines
+      supported = Platform.supported?
+      lines = ["  platform   #{Platform.description}#{supported ? '' : ' -- unsupported'}"]
+      lines << "             #{Platform.unsupported_reason}" unless supported
+      lines
+    end
+
+    def project_lines
+      root = client.app_root
+      return ["  project    no Rails application found above #{client.cwd}"] if root.nil?
+
+      ["  project    #{root}",
+       "  framework  #{resolved_framework_version(root)}",
+       "  ruby       #{RUBY_VERSION} (#{RUBY_PLATFORM})"]
+    end
+
+    def resolved_framework_version(root)
+      lock = File.join(root, "Gemfile.lock")
+      return "unknown (no Gemfile.lock; run `bundle install`)" unless File.file?(lock)
+
+      match = File.read(lock).match(/^\s{4}railties \(([^)]+)\)$/)
+      match ? "Rails #{match[1]} (from Gemfile.lock)" : "unknown (railties not in Gemfile.lock)"
+    rescue SystemCallError => e
+      "unknown (#{e.message})"
+    end
+
+    def runtime_lines
+      runtime = client.runtime
+      return [] if runtime.nil?
+
+      reason = runtime.unavailable_reason
+      lines = ["  runtime    #{runtime.dir}"]
+      lines << if reason
+                 "             unusable: #{reason}"
+               else
+                 "             #{directory_mode(runtime.dir)}, writable"
+               end
+      lines.concat(leftover_lines(runtime))
+    end
+
+    def directory_mode(path)
+      "mode #{format('%04o', File.stat(path).mode & 0o7777)}"
+    rescue SystemCallError
+      "mode unknown"
+    end
+
+    def leftover_lines(runtime)
+      return [] unless File.directory?(runtime.dir)
+
+      info = runtime.server_info
+      return [] if info.nil?
+      return [] unless runtime.live_server_info.nil?
+
+      ["             leftover record naming pid #{info['pid']} (not running; the next " \
+       "invocation clears it)"]
+    end
+
+    def acceleration_lines
+      reason = client.unusable_reason
+      lines = [reason ? "  active     no -- #{reason}" : "  active     yes"]
+      lines << "  commands   accelerated: #{ACCELERATED_EXECUTABLES.join(', ')}"
+      lines << "             passed through: rails #{OUT_OF_SCOPE_RAILS_COMMANDS.join(', rails ')}, " \
+               "rails server -d, and everything else"
+      lines
+    end
+
+    def acceleration_available? = client.unusable_reason.nil?
+
+    def server_lines
+      runtime = client.runtime
+      return [] if runtime.nil?
+
+      info = runtime.live_server_info
+      return ["  warm       nothing running"] + recorded_event_lines(runtime) if info.nil?
+
+      report = request_status(runtime)
+      if report.nil?
+        return ["  warm       pid #{info['pid']}, not answering yet"] + recorded_event_lines(runtime)
+      end
+
+      ["  warm       pid #{info['pid']}, booted #{format_time(info['booted_at'])}" \
+       "#{format_boot_duration(report['boot_seconds'] || info['boot_seconds'])}",
+       "  revision   #{report['revision_label'] || info['revision_label']}",
+       "  served     #{format_served(report)}",
+       "  watch      #{report['watch'] || 'unknown'}"] + event_lines(Array(report["events"]))
+    end
+
+    def recorded_event_lines(runtime)
+      events = Staleness::Events.new(path: runtime.events_path).to_a
+                                .reject { |event| event.resolution == "fresh" }
+                                .last(10).map(&:to_h)
+      events.empty? ? [] : event_lines(events)
+    end
+
+    def boot_log_lines
+      runtime = client.runtime
+      return [] if runtime.nil? || !runtime.live_server_info.nil?
+
+      path = runtime.boot_log_path
+      tail = File.file?(path) ? File.read(path).lines.last(BOOT_LOG_LINES) : []
+      return [] if tail.empty?
+
+      ["  last boot  left this behind in #{path}:"] +
+        tail.map { |line| "             #{line.chomp}" }
+    end
+
+    def init
+      root = client.app_root
+      return report("no Rails application found above #{client.cwd}", warm: false) if root.nil?
+
+      written, skipped = write_binstubs(root)
+      logger.notice(init_report(root, written, skipped).join("\n"))
+      0
+    end
+
+    def write_binstubs(root)
+      directory = File.join(root, "bin")
+      FileUtils.mkdir_p(directory)
+      written = []
+      skipped = []
+
+      BINSTUBS.each do |name|
+        path = File.join(directory, name)
+        # Never overwritten. `bin/rails` in a Rails application is generated, sometimes edited, and
+        # always committed -- replacing one without asking is precisely the "what did this put in my
+        # repository?" problem this command exists to avoid.
+        next skipped << path if File.exist?(path) && !siding_binstub?(path)
+
+        File.write(path, binstub_source(name))
+        File.chmod(0o755, path)
+        written << path
+      end
+
+      [written, skipped]
+    end
+
+    def siding_binstub?(path)
+      File.read(path).include?(BINSTUB_MARKER)
+    rescue SystemCallError
+      false
+    end
+
+    def binstub_source(name)
+      <<~RUBY
+        #!/usr/bin/env ruby
+        # frozen_string_literal: true
+        # #{BINSTUB_MARKER}
+        #
+        # Runs `#{name}` against the warm application when siding can accelerate it, and exactly as
+        # it would have run otherwise. Delete this file to remove it; nothing else refers to it.
+        exec("siding", "#{name}", *ARGV)
+      RUBY
+    end
+
+    def init_report(root, written, skipped)
+      lines = ["siding #{Siding::VERSION} -- #{File.basename(root)}"]
+      lines << (written.empty? ? "  wrote nothing" : "  wrote:")
+      lines.concat(written.map { |path| "    #{relative_to(path, root)}" })
+      unless skipped.empty?
+        lines << "  left alone (not written by siding -- remove them yourself to replace):"
+        lines.concat(skipped.map { |path| "    #{relative_to(path, root)}" })
+      end
+      lines << "  siding <command> keeps working with or without these."
+      lines
+    end
+
+    def relative_to(path, root)
+      path.start_with?("#{root}/") ? path.sub("#{root}/", "") : path
+    end
+
+    def project_label
+      key = client.project_key
+      key ? "#{File.basename(key.app_root)} (#{key.app_env})" : "this directory"
+    end
+
+    def report(message, warm:)
+      logger.notice(message)
+      warm ? 0 : 1
+    end
+
+    def report_status(info, report)
+      return report("a server for #{project_label} is running (pid #{info['pid']}) but not " \
+                    "answering yet", warm: false) if report.nil?
+
+      logger.notice(status_lines(info, report).join("\n"))
+      0
+    end
+
+    def status_lines(info, report)
+      lines = ["#{project_label} is warm -- siding #{report['tool_version'] || Siding::VERSION}"]
+      lines << "  server     pid #{info['pid']}, booted #{format_time(info['booted_at'])}" \
+               "#{format_boot_duration(report['boot_seconds'] || info['boot_seconds'])}"
+      lines << "  revision   #{report['revision_label'] || info['revision_label']}"
+      lines << "  served     #{format_served(report)}"
+      lines << "  watch      #{report['watch'] || 'unknown'}"
+      lines << "  running    #{format_workers(report['workers'])}"
+      lines << "  idle exit  #{format_idle_exit(report)}"
+      lines.concat(event_lines(Array(report["events"])))
+      lines
+    end
+
+    def event_lines(events)
+      return ["  recent     no changes have cost anything yet"] if events.empty?
+
+      ["  recent"] + events.reverse.map do |event|
+        paths = Array(event["trigger_paths"]).first(2).join(", ")
+        detail = [event["reason"], paths].reject { |part| part.to_s.empty? }.join(": ")
+        "    #{format_time(event['at'])}  #{event['resolution']}  #{detail}"
+      end
+    end
+
+    def format_served(report)
+      served = report["served"].to_i
+      last = report["last_activity_at"]
+      "#{served} invocation#{'s' unless served == 1}" \
+        "#{last ? ", last #{format_ago(Time.now.to_f - last.to_f)} ago" : ''}"
+    end
+
+    def format_workers(workers)
+      workers = Array(workers)
+      workers.empty? ? "nothing" : "#{workers.size} worker(s): #{workers.join(', ')}"
+    end
+
+    def format_idle_exit(report)
+      timeout = report["idle_timeout"].to_f
+      return "not scheduled" unless timeout.positive?
+
+      last = report["last_activity_at"].to_f
+      remaining = last.positive? ? timeout - (Time.now.to_f - last) : timeout
+      remaining.positive? ? "in #{format_ago(remaining)}" : "due now"
+    end
+
+    def format_boot_duration(seconds)
+      seconds.to_f.positive? ? " in #{format('%.1f', seconds)}s" : ""
+    end
+
+    def format_time(value)
+      return "unknown" if value.nil?
+      return value if value.is_a?(String)
+
+      Time.at(value.to_f).strftime("%Y-%m-%d %H:%M:%S")
+    rescue StandardError
+      "unknown"
+    end
+
+    def format_ago(seconds)
+      seconds = seconds.to_f
+      return "#{seconds.round}s" if seconds < 90
+
+      minutes = seconds / 60
+      minutes < 90 ? "#{minutes.round}m" : "#{(minutes / 60).round}h"
+    end
+
+    def request_status(runtime)
+      request(runtime, Protocol::STATUS) do |socket|
+        message = Protocol.read_message(socket)
+        message && message.type == Protocol::STATUS_REPORT ? message.payload : nil
+      end
+    end
+
+    def request_stop(runtime)
+      request(runtime, Protocol::STOP) { |socket| Protocol.read_message(socket) }
+    end
+
+    def request(runtime, type)
+      socket = UNIXSocket.new(runtime.socket_path)
+      socket.timeout = REQUEST_TIMEOUT if socket.respond_to?(:timeout=)
+      begin
+        Protocol.client_handshake(socket)
+        Protocol.write_message(socket, type)
+        yield socket
+      ensure
+        socket.close unless socket.closed?
+      end
+    rescue StandardError => e
+      logger.debug("#{type} request failed: #{e.class}: #{e.message}")
+      nil
+    end
+
+    def unimplemented(name)
+      logger.notice("`siding #{name}` is not implemented yet")
+      1
+    end
+
+    def terminate(pid, grace: 5.0)
+      Process.kill("TERM", pid)
+      deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + grace
+      sleep 0.02 while alive?(pid) && Process.clock_gettime(Process::CLOCK_MONOTONIC) < deadline
+      return unless alive?(pid)
+
+      logger.debug("server #{pid} did not leave within #{grace}s; killing it")
+      Process.kill("KILL", pid)
+    rescue Errno::ESRCH
+      nil
+    end
+
+    def alive?(pid) = Runtime.process_alive?(pid)
+  end
+end