expedite 0.0.2 → 0.1.1

data/lib/expedite/server/controller.rb

@@ -0,0 +1,247 @@
+# Based on https://github.com/rails/spring/blob/master/lib/spring/server.rb
+require 'json'
+require 'socket'
+require "expedite/env"
+require "expedite/protocol"
+require "expedite/signals"
+
+module Expedite
+  module Server
+    class Controller
+      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
+        env.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
+
+        # Corresponds to Client::Invoke#connect_to_agent
+        app_client = client.recv_io
+        command    = client.recv_object
+
+        args, agent = command.values_at('args', 'agent')
+        cmd = args.first
+
+        if agent == '__server__'
+          case cmd
+          when 'application_pids'
+            # Corresponds to Client::Invoke#run_command
+            client.puts
+
+            unix_socket = UNIXSocket.for_fd(app_client.fileno)
+            _stdout = unix_socket.recv_io
+            _stderr = unix_socket.recv_io
+            _stdin = unix_socket.recv_io
+
+            client.puts Process.pid
+
+            application_pids = []
+            env.applications.each do |k, v|
+              application_pids << v.pid if v.pid
+            end
+            unix_socket.send_object("return" => application_pids)
+
+            unix_socket.close
+            client.close
+          else
+          end
+        elsif Expedite::Actions.lookup(cmd)
+          # Corresponds to Client::Invoke#run_command
+          log "running command #{cmd}: #{args}"
+
+          client.puts
+
+          begin
+            target = env.applications[agent]
+
+            client.puts target.run(app_client)
+          rescue AgentNotFoundError => e
+            unix_socket = UNIXSocket.for_fd(app_client.fileno)
+            _stdout = unix_socket.recv_io
+            _stderr = unix_socket.recv_io
+            _stdin = unix_socket.recv_io
+
+            args, env = unix_socket.recv_object.values_at("args", "env")
+
+            client.puts Process.pid
+
+            # boot only
+            #@child_socket = client.recv_io
+            #@log_file = client.recv_io
+            unix_socket.send_object("exception" => e)
+
+            unix_socket.close
+            client.close
+          end
+        else
+          log "command not found #{cmd}"
+          client.close
+        end
+      rescue AgentNotFoundError => e
+      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"]
+          $stderr
+        else
+          nil
+        end
+      end
+
+      # Server command
+      def application_pids
+        pids = []
+        env.applications.each do |k, v|
+          pids << v.pid if v.pid
+        end
+        return pids
+      end
+    end
+  end
+end

data/lib/expedite/syntax.rb

@@ -0,0 +1,26 @@
+require 'expedite/actions'
+require 'expedite/agents'
+
+module Expedite
+  module Syntax
+    def define(&block)
+      DSL.run(&block)
+    end
+    
+    class DSL
+      def action(name, &block)
+        Expedite::Actions.register(name, &block)
+      end
+
+      def agent(name, parent:nil, &block)
+        Expedite::Agents.register(name, parent: parent, &block)
+      end
+
+      def self.run(&block)
+        new.instance_eval(&block)
+      end
+    end
+  end
+
+  extend Syntax
+end

data/lib/expedite/version.rb

@@ -1,3 +1,3 @@
 module Expedite
-  VERSION = '0.0.2'
+  VERSION = '0.1.1'
 end

data/lib/expedite.rb

@@ -1,19 +1,33 @@
-require "expedite/client"
+require 'expedite/client/exec'
+require 'expedite/client/invoke'
+require 'expedite/syntax'
 
 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)
+  class AgentProxy
+    attr_accessor :env, :agent
+
+    def initialize(env:, agent:)
+      self.env = env
+      self.agent = agent
+    end
+
+    def exec(*args)
+      Client::Exec.new(env: env, agent: agent).call(*args)
+    end
+
+    def invoke(*args)
+      Client::Invoke.new(env: env, agent: agent).call(*args)
     end
-    @clients[variant]
   end
+end
 
+module Expedite
   ##
-  # Alias for self.variant
-  def self.v(variant)
-    self.variant(variant)
+  # Returns a client to dispatch actions to the specified agent
+  def self.agent(agent)
+    @clients ||= Hash.new do |h, k|
+      AgentProxy.new(env: Env.new, agent: agent)
+    end
+    @clients[agent]
   end
 end
-

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: expedite
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.1
 platform: ruby
 authors:
 - Bing-Chang Lai
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-07-03 00:00:00.000000000 Z
+date: 2022-12-08 00:00:00.000000000 Z
 dependencies: []
 description: Manages Ruby processes that can be used to spawn child processes faster.
 email: johnny.lai@me.com
@@ -20,24 +20,27 @@ files:
 - README.md
 - bin/expedite
 - lib/expedite.rb
-- lib/expedite/application.rb
-- lib/expedite/application/boot.rb
-- lib/expedite/application_manager.rb
+- lib/expedite/action/block.rb
+- lib/expedite/action/boot.rb
+- lib/expedite/actions.rb
+- lib/expedite/agents.rb
 - lib/expedite/cli.rb
 - lib/expedite/cli/server.rb
+- lib/expedite/cli/status.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/client/exec.rb
+- lib/expedite/client/invoke.rb
 - lib/expedite/env.rb
 - lib/expedite/errors.rb
 - lib/expedite/failsafe_thread.rb
-- lib/expedite/send_json.rb
-- lib/expedite/server.rb
+- lib/expedite/helper/rails.rb
+- lib/expedite/protocol.rb
+- lib/expedite/server/agent.rb
+- lib/expedite/server/agent_boot.rb
+- lib/expedite/server/agent_manager.rb
+- lib/expedite/server/controller.rb
 - lib/expedite/signals.rb
-- lib/expedite/variants.rb
+- lib/expedite/syntax.rb
 - lib/expedite/version.rb
 homepage: https://rubygems.org/gems/expedite
 licenses:
@@ -58,7 +61,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.1.6
 signing_key:
 specification_version: 4
 summary: Expedite startup of Ruby process

data/lib/expedite/application.rb

@@ -1,316 +0,0 @@
-# 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/signals'
-require 'expedite/variants'
-
-module Expedite
-  def self.variant
-    app.variant
-  end
-
-  def self.app=(app)
-    @app = app
-  end
-  def self.app
-    @app
-  end
-
-  class Application
-    include Signals
-
-    attr_reader :variant
-    attr_reader :manager, :env
-
-    def initialize(variant:, manager:, env:)
-      @variant      = variant
-      @manager      = manager
-      @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 }
-
-      env.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
-
-        # 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
-
-      # Boot makes a new application, so we don't wait for it
-      if command.is_a?(Expedite::Command::Boot)
-        Process.detach(pid)
-      else
-        wait pid, streams, client
-      end
-    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