expedite 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 492f096e30142c23ad6849f79864355a96fdb042990d43aaaaa85516643a6338
+  data.tar.gz: 29d32100e9df804748a684fdce1636907fe844996adb702e193369c434ffcd8a
+SHA512:
+  metadata.gz: d5f5fce18a565bbc3ea616bf1a5db621a1708eae3f6d1ce6ae6bb5c32d266859983ed35fefc8905184241602bc1554128627adf4ff3281f256056147351c9d2e
+  data.tar.gz: f85be9f1dfe698b1875fd0008d9a0c4ed324f5ddeb1b9562b83431864c4eaa664e1c83e748b680fb6877ecdd00c71a8160226613d52ae6f5338e7ec2195d7809

data/README.md

@@ -0,0 +1,43 @@
+# Expedite
+
+![main](https://github.com/johnny-lai/expedite/actions/workflows/ruby.yml/badge.svg)
+
+Expedite is a Ruby preloader manager that allows commands to be executed against 
+preloaded Ruby applications. Preloader applications can derive from other preloaders, allowing
+derivatives to start faster.
+
+## Usage
+
+Register variants and commands in `expedite_helper.rb`. For example:
+
+```
+Expedite::Variants.register('base' do |name|
+  puts "Base started"
+end
+```
+
+You can register variants that are based on other variants, and you can also have wildcard
+matchers.
+```
+Expedite::Variants.register('development/*', parent: 'base') do |name|
+  customer = File.basename(name)
+  puts "Starting development for #{customer}"
+end
+```
+
+You register commands by creating classes in the `Expedite::Command` module. For example,
+this defines a `custom` command.
+
+```
+Expedite::Commands.register("custom") do
+  puts "[#{Expedite.variant}] sleeping for 5"
+  puts "$sleep_parent = #{$sleep_parent}"
+  puts "$sleep_child = #{$sleep_child}"
+  puts "[#{Expedite.variant}] done"
+end
+```
+
+Then you can execute a command in the variant using:
+```
+Expedite.v("development/abc").call("custom")
+```

data/bin/expedite

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path("../../lib", __FILE__)
+$LOAD_PATH.unshift lib
+
+require 'expedite/cli'
+Expedite::Cli.run(ARGV)

data/lib/expedite.rb

@@ -0,0 +1,19 @@
+require "expedite/client"
+
+module Expedite
+  ##
+  # Returns a client to dispatch actions to the specified variant
+  def self.variant(variant)
+    @clients ||= Hash.new do |h, k|
+      Client.new(env: Env.new, variant: variant)
+    end
+    @clients[variant]
+  end
+
+  ##
+  # Alias for self.variant
+  def self.v(variant)
+    self.variant(variant)
+  end
+end
+

data/lib/expedite/application.rb

@@ -0,0 +1,316 @@
+# Based on https://github.com/rails/spring/blob/master/lib/spring/application.rb
+require 'json'
+require 'pty'
+require 'set'
+require 'socket'
+require 'expedite/commands'
+require 'expedite/env'
+require 'expedite/failsafe_thread'
+require 'expedite/load_helper'
+require 'expedite/signals'
+
+module Expedite
+  def self.variant
+    app.variant
+  end
+
+  def self.app=(app)
+    @app = app
+  end
+  def self.app
+    @app
+  end
+
+  class Application
+    include LoadHelper
+    include Signals
+
+    attr_reader :variant
+    attr_reader :manager, :env, :original_env
+
+    def initialize(variant, manager, original_env, env = Env.new)
+      @variant      = variant
+      @manager      = manager
+      @original_env = original_env
+      @env          = env
+      @mutex        = Mutex.new
+      @waiting      = Set.new
+      @preloaded    = false
+      @state        = :initialized
+      @interrupt    = IO.pipe
+    end
+
+    def boot
+      # This is necessary for the terminal to work correctly when we reopen stdin.
+      Process.setsid rescue Errno::EPERM
+
+      Expedite.app = self
+
+      Signal.trap("TERM") { terminate }
+
+      load_helper
+      eager_preload if false #if ENV.delete("SPRING_PRELOAD") == "1"
+      run
+    end
+
+    def state(val)
+      return if exiting?
+      log "#{@state} -> #{val}"
+      @state = val
+    end
+
+    def state!(val)
+      state val
+      @interrupt.last.write "."
+    end
+
+    def app_name
+      env.app_name
+    end
+
+    def log(message)
+      env.log "[application:#{variant}] #{message}"
+    end
+
+    def preloaded?
+      @preloaded
+    end
+
+    def preload_failed?
+      @preloaded == :failure
+    end
+
+    def exiting?
+      @state == :exiting
+    end
+
+    def terminating?
+      @state == :terminating
+    end
+
+    def initialized?
+      @state == :initialized
+    end
+
+    def preload
+      log "preloading app"
+
+      @preloaded = :success
+    rescue Exception => e
+      @preloaded = :failure
+      raise e unless initialized?
+    end
+
+    def eager_preload
+      with_pty { preload }
+    end
+
+    def run
+      $0 = "expedite variant | #{app_name} | #{variant}"
+
+      Expedite::Variants.lookup(variant).after_fork(variant)
+
+      state :running
+      manager.puts
+
+      loop do
+        IO.select [manager, @interrupt.first]
+
+        if terminating? || preload_failed?
+          exit
+        else
+          serve manager.recv_io(UNIXSocket)
+        end
+      end
+    end
+
+    def serve(client)
+      log "got client"
+      manager.puts
+
+      _stdout, stderr, _stdin = streams = 3.times.map { client.recv_io }
+      [STDOUT, STDERR, STDIN].zip(streams).each { |a, b| a.reopen(b) }
+
+      preload unless preloaded?
+
+      args, env = JSON.load(client.read(client.gets.to_i)).values_at("args", "env")
+
+      exec_name = args.shift
+      command   = Expedite::Commands.lookup(exec_name)
+      command.setup(client)
+
+      connect_database
+
+      pid = fork {
+        Process.setsid
+        IGNORE_SIGNALS.each { |sig| trap(sig, "DEFAULT") }
+        trap("TERM", "DEFAULT")
+
+        ARGV.replace(args)
+        $0 = exec_name
+
+        # Delete all env vars which are unchanged from before Spring started
+        original_env.each { |k, v| ENV.delete k if ENV[k] == v }
+
+        # Load in the current env vars, except those which *were* changed when Spring started
+        env.each { |k, v| ENV[k] = v }
+
+        # requiring is faster, so if config.cache_classes was true in
+        # the environment's config file, then we can respect that from
+        # here on as we no longer need constant reloading.
+        if @original_cache_classes
+          ActiveSupport::Dependencies.mechanism = :require
+          Rails.application.config.cache_classes = true
+        end
+
+        connect_database
+        srand
+
+        invoke_after_fork_callbacks
+        shush_backtraces
+
+        command.call
+      }
+
+      disconnect_database
+
+      log "forked #{pid}"
+      manager.puts pid
+
+      wait pid, streams, client
+    rescue Exception => e
+      log "exception: #{e} at #{e.backtrace.join("\n")}"
+      manager.puts unless pid
+
+      if streams && !e.is_a?(SystemExit)
+        print_exception(stderr, e)
+        streams.each(&:close)
+      end
+
+      client.puts(1) if pid
+      client.close
+    ensure
+      # Redirect STDOUT and STDERR to prevent from keeping the original FDs
+      # (i.e. to prevent `spring rake -T | grep db` from hanging forever),
+      # even when exception is raised before forking (i.e. preloading).
+      reset_streams
+    end
+
+    def terminate
+      if exiting?
+        # Ensure that we do not ignore subsequent termination attempts
+        log "forced exit"
+        @waiting.each { |pid| Process.kill("TERM", pid) }
+        Kernel.exit
+      else
+        state! :terminating
+      end
+    end
+
+    def exit
+      state :exiting
+      manager.shutdown(:RDWR)
+      exit_if_finished
+      sleep
+    end
+
+    def exit_if_finished
+      @mutex.synchronize {
+        Kernel.exit if exiting? && @waiting.empty?
+      }
+    end
+
+    def invoke_after_fork_callbacks
+      # TODO:
+    end
+
+    def disconnect_database
+      ActiveRecord::Base.remove_connection if active_record_configured?
+    end
+
+    def connect_database
+      ActiveRecord::Base.establish_connection if active_record_configured?
+    end
+
+    # This feels very naughty
+    def shush_backtraces
+      Kernel.module_eval do
+        old_raise = Kernel.method(:raise)
+        remove_method :raise
+        define_method :raise do |*args|
+          begin
+            old_raise.call(*args)
+          ensure
+            if $!
+              lib = File.expand_path("..", __FILE__)
+              $!.backtrace.reject! { |line| line.start_with?(lib) }
+            end
+          end
+        end
+        private :raise
+      end
+    end
+
+    def print_exception(stream, error)
+      first, rest = error.backtrace.first, error.backtrace.drop(1)
+      stream.puts("#{first}: #{error} (#{error.class})")
+      rest.each { |line| stream.puts("\tfrom #{line}") }
+    end
+
+    def with_pty
+      PTY.open do |master, slave|
+        [STDOUT, STDERR, STDIN].each { |s| s.reopen slave }
+        reader_thread = Expedite.failsafe_thread { master.read }
+        begin
+          yield
+        ensure
+          reader_thread.kill
+          reset_streams
+        end
+      end
+    end
+
+    def reset_streams
+      [STDOUT, STDERR].each do |stream|
+        stream.reopen(env.log_file)
+      end
+      STDIN.reopen("/dev/null")
+    end
+
+    def wait(pid, streams, client)
+      @mutex.synchronize { @waiting << pid }
+
+      # Wait in a separate thread so we can run multiple commands at once
+      Expedite.failsafe_thread {
+        begin
+          _, status = Process.wait2 pid
+          log "#{pid} exited with #{status.exitstatus}"
+
+          streams.each(&:close)
+          client.puts(status.exitstatus)
+          client.close
+        ensure
+          @mutex.synchronize { @waiting.delete pid }
+          exit_if_finished
+        end
+      }
+
+      Expedite.failsafe_thread {
+        while signal = client.gets.chomp
+          begin
+            Process.kill(signal, -Process.getpgid(pid))
+            client.puts(0)
+          rescue Errno::ESRCH
+            client.puts(1)
+          end
+        end
+      }
+    end
+
+    private
+
+    def active_record_configured?
+      defined?(ActiveRecord::Base) && ActiveRecord::Base.configurations.any?
+    end
+  end
+end

data/lib/expedite/application/boot.rb

@@ -0,0 +1,9 @@
+require "expedite/application"
+
+app = Expedite::Application.new(
+  ENV['EXPEDITE_VARIANT'],
+  UNIXSocket.for_fd(3),
+  {},
+  Expedite::Env.new(log_file: IO.for_fd(4))
+)
+app.boot

data/lib/expedite/application_manager.rb

@@ -0,0 +1,180 @@
+# Based on https://github.com/rails/spring/blob/master/lib/spring/application_manager.rb
+
+require 'bundler'
+require 'expedite/failsafe_thread'
+require 'expedite/send_json'
+require 'expedite/variants'
+
+module Expedite
+  class ApplicationManager
+    include SendJson
+
+    attr_reader :pid, :child, :variant, :env, :status
+
+    def initialize(variant, env)
+      @variant    = variant
+      @env        = env
+      @mutex      = Mutex.new
+      @state      = :running
+      @pid        = nil
+    end
+
+    def log(message)
+      env.log "[application_manager:#{variant}] #{message}"
+    end
+
+    # We're not using @mutex.synchronize to avoid the weird "<internal:prelude>:10"
+    # line which messes with backtraces in e.g. rspec
+    def synchronize
+      @mutex.lock
+      yield
+    ensure
+      @mutex.unlock
+    end
+
+    def start
+      start_child
+    end
+
+    def restart
+      return if @state == :stopping
+      start_child(true)
+    end
+
+    def alive?
+      @pid
+    end
+
+    def with_child
+      synchronize do
+        if alive?
+          begin
+            yield child
+          rescue Errno::ECONNRESET, Errno::EPIPE
+            # The child has died but has not been collected by the wait thread yet,
+            # so start a new child and try again.
+            log "child dead; starting"
+            start
+            yield child
+          end
+        else
+          log "child not running; starting"
+          start
+          yield child
+        end
+      end
+    end
+
+    # Returns the pid of the process running the command, or nil if the application process died.
+    def run(client)
+      @client = client
+      with_child do |child|
+        child.send_io client
+        child.gets or raise Errno::EPIPE
+      end
+
+      pid = child.gets.to_i
+
+      unless pid.zero?
+        log "got worker pid #{pid}"
+        pid
+      end
+    rescue Errno::ECONNRESET, Errno::EPIPE => e
+      log "#{e} while reading from child; returning no pid"
+      nil
+    ensure
+      client.close
+    end
+
+    def stop
+      log "stopping"
+      @state = :stopping
+
+      if pid
+        Process.kill('TERM', pid)
+        Process.wait(pid)
+      end
+    rescue Errno::ESRCH, Errno::ECHILD
+      # Don't care
+    end
+
+    def parent
+      Expedite::Variants.lookup(variant).parent
+    end
+
+    private
+
+    def start_child(preload = false)
+      if parent
+        fork_child(preload)
+      else
+        spawn_child(preload)
+      end
+    end
+
+    def fork_child(preload = false)
+      @child, child_socket = UNIXSocket.pair
+
+      # Compose command
+      wr, rd = UNIXSocket.pair
+      wr.send_io STDOUT
+      wr.send_io STDERR
+      wr.send_io STDIN
+
+      send_json wr, 'args' => ['expedite/boot', variant], 'env' => {}
+      wr.send_io child_socket
+      wr.send_io env.log_file
+      wr.close
+
+      @pid = env.applications[parent].run(rd)
+
+      start_wait_thread(pid, child) if child.gets
+      child_socket.close
+    end
+
+    def spawn_child(preload = false)
+      @child, child_socket = UNIXSocket.pair
+
+      Bundler.with_original_env do
+        bundler_dir = File.expand_path("../..", $LOADED_FEATURES.grep(/bundler\/setup\.rb$/).first)
+        @pid = Process.spawn(
+          {
+            "EXPEDITE_VARIANT" => variant,
+          },
+          "ruby",
+          *(bundler_dir != RbConfig::CONFIG["rubylibdir"] ? ["-I", bundler_dir] : []),
+          "-I", File.expand_path("../..", __FILE__),
+          "-e", "require 'expedite/application/boot'",
+          3 => child_socket,
+          4 => env.log_file,
+        )
+      end
+
+      start_wait_thread(pid, child) if child.gets
+      child_socket.close
+    end
+
+    def start_wait_thread(pid, child)
+      Process.detach(pid)
+
+      Expedite.failsafe_thread do
+        # The recv can raise an ECONNRESET, killing the thread, but that's ok
+        # as if it does we're no longer interested in the child
+        loop do
+          IO.select([child])
+          break if child.recv(1, Socket::MSG_PEEK).empty?
+          sleep 0.01
+        end
+
+        log "child #{pid} shutdown"
+
+        synchronize {
+          if @pid == pid
+            @pid = nil
+            restart
+          end
+        }
+      end
+    end
+  end
+end