expedite 0.0.1

data/lib/expedite/env.rb

@@ -0,0 +1,60 @@
+require 'digest'
+require 'pathname'
+require 'expedite/version'
+
+module Expedite
+  class Env
+    attr_accessor :root
+    attr_accessor :application_id, :app_name, :log_file
+    attr_reader :applications
+
+    def initialize(root: nil, app_name: nil, log_file: nil)
+      @root = root || Dir.pwd
+      @app_name = app_name || File.basename(@root)
+      @log_file = log_file || File.open(File::NULL, "a")
+      @tmp_path = nil
+
+      @application_id = Digest::SHA1.hexdigest(@root)
+
+      env = self
+      @applications = Hash.new do |h, k|
+        h[k] = ApplicationManager.new(k, env)
+      end
+    end
+
+    def version
+      Expedite::VERSION
+    end
+
+    def tmp_path
+      return @tmp_path unless @tmp_path.nil?
+
+      require "tmpdir"
+      path = Pathname.new(File.join(Dir.tmpdir, "expedite-#{Process.uid}"))
+      require "fileutils"
+      FileUtils.mkdir_p(path) unless path.exist?
+      @tmp_path = path
+    end
+
+    def socket_path
+      tmp_path.join(application_id)
+    end
+
+    def pidfile_path
+      tmp_path.join("#{application_id}.pid")
+    end
+
+    def log(message)
+      log_file.puts "[#{Time.now}] [#{Process.pid}] #{message}"
+      log_file.flush
+    end
+
+    def server_command
+      "#{File.expand_path("../../../bin/expedite", __FILE__)} server --background"
+    end
+
+    def graceful_termination_timeout
+      2
+    end
+  end
+end

data/lib/expedite/errors.rb

@@ -0,0 +1,8 @@
+
+module Expedite
+  class Error < StandardError
+  end
+
+  class CommandNotFound < Error
+  end
+end

data/lib/expedite/failsafe_thread.rb

@@ -0,0 +1,15 @@
+# Based on https://github.com/rails/spring/blob/master/lib/spring/failsafe_thread.rb
+require 'thread'
+
+module Expedite
+  class << self
+    def failsafe_thread
+      Thread.new {
+        begin
+          yield
+        rescue
+        end
+      }
+    end
+  end
+end

data/lib/expedite/load_helper.rb

@@ -0,0 +1,11 @@
+module Expedite
+  module LoadHelper
+    def load_helper
+      helper = "expedite_helper.rb"
+      if File.exist?(helper)
+        log "loading #{helper}"
+        load(helper)
+      end
+    end
+  end
+end

data/lib/expedite/send_json.rb

@@ -0,0 +1,10 @@
+module Expedite
+  module SendJson
+    def send_json(socket, data)
+      data = JSON.dump(data)
+
+      socket.puts  data.bytesize
+      socket.write data
+    end
+  end
+end

data/lib/expedite/server.rb

@@ -0,0 +1,190 @@
+# Based on https://github.com/rails/spring/blob/master/lib/spring/server.rb
+require 'json'
+require 'socket'
+require "expedite/application_manager"
+require "expedite/env"
+require 'expedite/load_helper'
+require "expedite/signals"
+
+module Expedite
+  class Server
+    include LoadHelper
+    include Signals
+
+    def self.boot(options = {})
+      new(options).boot
+    end
+
+    attr_reader :env
+
+    def initialize(foreground: true, env: nil)
+      @foreground   = foreground
+      @env          = env || default_env
+      @pidfile      = @env.pidfile_path.open('a')
+      @mutex        = Mutex.new
+    end
+
+    def foreground?
+      @foreground
+    end
+
+    def log(message)
+      env.log "[server] #{message}"
+    end
+
+    def boot
+      load_helper
+
+      write_pidfile
+      set_pgid unless foreground?
+      ignore_signals unless foreground?
+      set_exit_hook
+      set_process_title
+      start_server
+      exit 0
+    end
+
+    def pid
+      @env.pidfile_path.read.to_i
+    rescue Errno::ENOENT
+      nil
+    end
+
+    def running?
+      pidfile = @env.pidfile_path.open('r+')
+      !pidfile.flock(File::LOCK_EX | File::LOCK_NB)
+    rescue Errno::ENOENT
+      false
+    ensure
+      if pidfile
+        pidfile.flock(File::LOCK_UN)
+        pidfile.close
+      end
+    end
+
+    # timeout: Defaults to 2 seconds
+    def stop
+      if running?
+        timeout = Time.now + @env.graceful_termination_timeout
+        kill 'TERM'
+        sleep 0.1 until !running? || Time.now >= timeout
+
+        if running?
+          kill 'KILL'
+          :killed
+        else
+          :stopped
+        end
+      else
+        :not_running
+      end
+    end
+
+    def kill(sig)
+      pid = self.pid
+      Process.kill(sig, pid) if pid
+    rescue Errno::ESRCH
+      # already dead
+    end
+
+    def start_server
+      server = UNIXServer.open(env.socket_path)
+      log "started on #{env.socket_path}"
+      loop { serve server.accept }
+    rescue Interrupt
+    end
+
+    def serve(client)
+      log "accepted client"
+      client.puts env.version
+
+      app_client = client.recv_io
+      command    = JSON.load(client.read(client.gets.to_i))
+
+      args, variant = command.values_at('args', 'variant')
+      cmd = args.first
+      if true #Expedite.command(cmd)
+        log "running command #{cmd}"
+        client.puts
+
+        target = env.applications[variant]
+        client.puts target.run(app_client)
+      else
+        log "command not found #{cmd}"
+        client.close
+      end
+    rescue SocketError => e
+      raise e unless client.eof?
+    ensure
+      redirect_output
+    end
+
+    # Boot the server into the process group of the current session.
+    # This will cause it to be automatically killed once the session
+    # ends (i.e. when the user closes their terminal).
+    def set_pgid
+      # Process.setpgid(0, SID.pgid)
+    end
+
+    # Ignore SIGINT and SIGQUIT otherwise the user typing ^C or ^\ on the command line
+    # will kill the server/application.
+    def ignore_signals
+      IGNORE_SIGNALS.each { |sig| trap(sig, "IGNORE") }
+    end
+
+    def set_exit_hook
+      server_pid = Process.pid
+
+      # We don't want this hook to run in any forks of the current process
+      at_exit { shutdown if Process.pid == server_pid }
+    end
+
+    def shutdown
+      log "shutting down"
+
+      [env.socket_path, env.pidfile_path].each do |path|
+        if path.exist?
+          path.unlink rescue nil
+        end
+      end
+
+      env.applications.values.map { |a| Expedite.failsafe_thread { a.stop } }.map(&:join)
+    end
+
+    def write_pidfile
+      if @pidfile.flock(File::LOCK_EX | File::LOCK_NB)
+        @pidfile.truncate(0)
+        @pidfile.write("#{Process.pid}\n")
+        @pidfile.fsync
+      else
+        raise "Failed to lock #{@env.pidfile_path}"
+      end
+    end
+
+    # We need to redirect STDOUT and STDERR, otherwise the server will
+    # keep the original FDs open which would break piping. (e.g.
+    # `spring rake -T | grep db` would hang forever because the server
+    # would keep the stdout FD open.)
+    def redirect_output
+      [STDOUT, STDERR].each { |stream| stream.reopen(env.log_file) }
+    end
+
+    def set_process_title
+      $0 = "expedite server | #{env.app_name}"
+    end
+
+    private
+
+    def default_env
+      Env.new(log_file: default_log_file)
+    end
+
+    def default_log_file
+      if foreground? && !ENV["SPRING_LOG"]
+        $stdout
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/expedite/signals.rb

@@ -0,0 +1,5 @@
+module Expedite
+  module Signals
+    IGNORE_SIGNALS = %w(INT QUIT)
+  end
+end

data/lib/expedite/variants.rb

@@ -0,0 +1,89 @@
+
+module Expedite
+  class Variant
+    attr_accessor :parent
+
+    ##
+    # [parent] Name of parent variant.
+    # [after_fork] Block is executed when variant is first preloaded.
+    def initialize(parent: nil, &after_fork)
+      @parent = parent
+      @after_fork_proc = after_fork
+    end
+
+    ##
+    # Called when variant if first preloaded. This version calls the after_fork
+    # block provided in the initializer.
+    def after_fork(variant)
+      @after_fork_proc&.call(variant)
+    end
+  end
+
+  class Variants
+    Registration = Struct.new(:matcher, :variant) do
+      def match?(name)
+        File.fnmatch?(matcher, name)
+      end
+    end
+
+    def self.current
+      @current ||= Variants.new
+    end
+
+    ##
+    # Retrieves the specified variant
+    def self.lookup(variant)
+      self.current.lookup(variant)
+    end
+
+    ##
+    # Registers a variant. Variants are matched in the
+    # order they are registered.
+    #
+    # [matcher] Wildcard to match a name against.
+    # [named_options] Variant options.
+    # [after_fork] Optional block that is called when
+    #              variant is preloaded.
+    #
+    # = Example
+    #   Expedite::Variants.register('base' do |name|
+    #     puts "Base #{name} started"
+    #   end
+    #   Expedite::Variants.register('development/abc', parent: 'base') do |name|
+    #     puts "Variant #{name} started"
+    #   end
+    def self.register(matcher, **named_options, &after_fork)
+      self.current.register(matcher, **named_options, &after_fork)
+    end
+
+    ##
+    # Resets registrations to default
+    def self.reset
+      self.current.reset
+    end
+
+    def initialize
+      @registrations = []
+    end
+
+    def lookup(variant)
+      ret = @registrations.find do |r|
+        r.match?(variant)
+      end
+      raise NotImplementedError, "Variant #{variant.inspect} not found" if ret.nil?
+      ret.variant
+    end
+
+    def register(matcher, **named_options, &after_fork)
+      @registrations << Registration.new(
+        matcher,
+        Variant.new(**named_options, &after_fork)
+      )
+    end
+
+    def reset
+      @registrations = {}
+      nil
+    end
+  end
+end

data/lib/expedite/version.rb

@@ -0,0 +1,3 @@
+module Expedite
+  VERSION = '0.0.1'
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: expedite
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Bing-Chang Lai
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-06-12 00:00:00.000000000 Z
+dependencies: []
+description: Manages Ruby processes that can be used to spawn child processes faster.
+email: johnny.lai@me.com
+executables:
+- expedite
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/expedite
+- lib/expedite.rb
+- lib/expedite/application.rb
+- lib/expedite/application/boot.rb
+- lib/expedite/application_manager.rb
+- lib/expedite/cli.rb
+- lib/expedite/cli/server.rb
+- lib/expedite/cli/stop.rb
+- lib/expedite/client.rb
+- lib/expedite/command/basic.rb
+- lib/expedite/command/boot.rb
+- lib/expedite/command/info.rb
+- lib/expedite/commands.rb
+- lib/expedite/env.rb
+- lib/expedite/errors.rb
+- lib/expedite/failsafe_thread.rb
+- lib/expedite/load_helper.rb
+- lib/expedite/send_json.rb
+- lib/expedite/server.rb
+- lib/expedite/signals.rb
+- lib/expedite/variants.rb
+- lib/expedite/version.rb
+homepage: https://rubygems.org/gems/expedite
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key:
+specification_version: 4
+summary: Expedite startup of Ruby process
+test_files: []