expedite 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c3af01b23cd76fd62beb91411f18fd9535c49cca41b530496f2031abc294b67
-  data.tar.gz: 260e78502a54f80f3c101f0880a79f738d68bf414adc401253d5cfec0a2837b9
+  metadata.gz: da93957645e66819877d4c8638d2d42eb4880c631d6b4f8f224a3a9502c45a36
+  data.tar.gz: 179e78a453744f0375f6b184ffa1a2cff321b7ab92deafc9be5297fb00c63c4b
 SHA512:
-  metadata.gz: 0b0fdaa31cf55dd0fde167748208e5f1f1be5b8cb1b2def68cae75516df458614855e4c1c2bb4affec937dc7d7c43c4d8f04bb830998ff5c9ab7d6c6b65bf9e7
-  data.tar.gz: d59acca092ec657cadc977c2af264cf811b4cf1b601e5bd8074bd21d91424b3fc07e81930bde3443bdce51e05965541dd132a819a1d5fa4812f6fd32b0809b95
+  metadata.gz: 8cf3e2d403eab2d5cb7960a1d5cc43a4f94c3d0495ce36b360d32ec77ad7e5f9887a0e7aca183afa2e441ac3ff23a555ec6254f8441d971783376bdfc84db471
+  data.tar.gz: 30f00102d8d8c6cc59f138841caa116421f3002871551dca20718dfc5100aec80f469e8bb31b1d1ee8158020852090b2c053bff5d5fd7c9c728fdc26e4c3c6d0

data/README.md

@@ -89,6 +89,13 @@ You can also start the server in the foreground.
 $ bundle exec expedite server
 ```
 
+If `rails` is in the `Gemfile`, then you can also start the rails commands through expedite.
+
+```
+$ bundle exec expedite rails console
+$ echo "puts ActiveRecord::Base.connection" | bundle exec expedite rails runner -
+```
+
 ## Acknowledgements
 
 Expedite's server core is modified from [Spring](https://github.com/rails/spring)

data/lib/expedite/actions.rb

@@ -35,9 +35,9 @@ module Expedite
     end
 
     def lookup(name)
-       ret = @registrations[name]
-       raise NotImplementedError, "Action #{name.inspect} not found" if ret.nil?
-       ret
+      ret = @registrations[name.to_s]
+      raise NotImplementedError, "Action #{name.inspect} not found" if ret.nil?
+      ret
     end
 
     def register(name, klass_or_nil = nil, **named_options, &block)
@@ -47,7 +47,7 @@ module Expedite
         klass_or_nil.new(**named_options)
       end
 
-      @registrations[name] = cmd
+      @registrations[name.to_s] = cmd
     end
 
     def reset

data/lib/expedite/agents.rb

@@ -82,7 +82,7 @@ module Expedite
       ret = @registrations.find do |r|
         r.match?(agent)
       end
-      raise NotImplementedError, "Agent #{agent.inspect} not found" if ret.nil?
+      raise AgentNotFoundError, "Agent #{agent.inspect} not found" if ret.nil?
       ret.agent
     end
 

data/lib/expedite/cli/rails.rb

@@ -0,0 +1,13 @@
+module Expedite
+  module Cli
+    class Rails
+      def run(args)
+        Expedite.agent(:rails_environment).exec(:rails_commands, args)
+      end
+
+      def summary
+        'Starts the expedite server'
+      end
+    end
+  end
+end

data/lib/expedite/cli.rb

@@ -1,16 +1,20 @@
+require 'expedite/cli/rails'
 require 'expedite/cli/server'
 require 'expedite/cli/status'
 require 'expedite/cli/stop'
 
 module Expedite
   module Cli
+    class UnknownCommandError < StandardError
+    end
+
     class Help
       def run(args)
         puts "Expected: <command>"
         puts
         puts "Commands:"
 
-        cmds = Expedite::Cli::COMMANDS
+        cmds = Expedite::Cli.commands
         cmds.keys.sort!.each do |cmd|
           c = cmds[cmd].new
           puts "  #{cmd}: #{c.summary}"
@@ -24,22 +28,29 @@ module Expedite
 
     module_function
 
-    COMMANDS = {
-      'help'   => Cli::Help,
-      'server' => Cli::Server,
-      'status' => Cli::Status,
-      'stop'   => Cli::Stop,
-    }
+    def commands
+      return @commands unless @commands.nil?
+
+      cmds = {
+        'help'   => Cli::Help,
+        'server' => Cli::Server,
+        'status' => Cli::Status,
+        'stop'   => Cli::Stop,
+      }
+      cmds['rails'] = Cli::Rails if Gem.loaded_specs["rails"]
+      @commands = cmds
+    end
 
     def run(args)
       command(args.first).run(args[1..])
-    rescue NotImplementedError
+    rescue UnknownCommandError => e
+      STDERR.puts e
       Cli::Help.new.run([])
     end
 
     def command(cmd)
-      klass = COMMANDS[cmd]
-      raise NotImplementedError, "Unknown command '#{cmd}'" if klass.nil?
+      klass = commands[cmd]
+      raise UnknownCommandError, "Unknown command '#{cmd}'" if klass.nil?
       klass.new
     end
   end

data/lib/expedite/client/exec.rb

@@ -58,7 +58,16 @@ module Expedite
       def run
         status = perform(*@args)
 
-        exit status.to_i
+        code = if status.respond_to?(:to_i)
+          status.to_i
+        elsif status == true
+          0
+        elsif status == false
+          1
+        else
+          126
+        end
+        exit code
       rescue Errno::ECONNRESET
         exit 1
       end

data/lib/expedite/client/invoke.rb

@@ -49,7 +49,7 @@ module Expedite
       def connect_to_agent(client, args)
         server.send_io client
 
-        server.send_object("args" => args, "agent" => agent)
+        server.send_object({"args" => args, "agent" => agent}, env)
 
         if IO.select([server], [], [], CONNECT_TIMEOUT)
           server.gets or raise CommandNotFound
@@ -65,7 +65,11 @@ module Expedite
         agent.send_io STDERR
         agent.send_io STDIN
 
-        agent.send_object("args" => args, "env" => ENV.to_hash)
+        agent.send_object({
+          "args" => args,
+          "env" => ENV.to_hash,
+          "method" => "invoke"
+        }, env)
 
         pid = server.gets
         pid = pid.chomp if pid

data/lib/expedite/env.rb

@@ -1,7 +1,7 @@
 require 'digest'
 require 'pathname'
 require 'expedite/version'
-require 'expedite/server/agent_manager'
+require 'expedite/server/application_manager'
 
 module Expedite
   class Env
@@ -18,9 +18,7 @@ module Expedite
       @application_id = Digest::SHA1.hexdigest(@root)
 
       env = self
-      @applications = Hash.new do |h, k|
-        h[k] = Server::AgentManager.new(k, env)
-      end
+      @applications = Server::ApplicationManager.new(env)
     end
 
     def version

data/lib/expedite/errors.rb

@@ -8,4 +8,7 @@ module Expedite
 
   class UnknownError < Error
   end
+
+  class AgentNotFoundError < Error
+  end
 end

data/lib/expedite/helper/rails.rb

@@ -0,0 +1,14 @@
+Expedite.define do
+  # Agent that rails environment loaded
+  agent :rails_environment do
+    app_root = Dir.pwd
+    require "#{app_root}/config/environment.rb"
+  end
+
+  # Actions that runs rails commands
+  action :rails_commands do |args|
+    ARGV.replace(args)
+    require "rails/commands"
+    true
+  end
+end

data/lib/expedite/protocol.rb

@@ -2,17 +2,20 @@ require 'socket'
 
 module Expedite
   module Protocol
-    def send_object(object)
+    def send_object(object, env)
+      env.log "send_object #{object.inspect}"
       data = Marshal.dump(object)
 
-      self.puts  data.bytesize
+      self.puts  data.bytesize.to_i
       self.write data
     end
 
     def recv_object
-      Marshal.load(self.read(self.gets.to_i))
+      len = self.gets.to_i
+      data = self.read(len)
+      Marshal.load(data)
     end
   end
 end
 
-UNIXSocket.include ::Expedite::Protocol
+IO.include ::Expedite::Protocol

data/lib/expedite/server/agent.rb

@@ -23,6 +23,13 @@ module Expedite
   end
 
   module Server
+    # This code runs in the process that has the actual code pre-loaded, and is
+    # used to serve requests.
+    # * An "invoke" request is handled in the agent itself.
+    # * A "fork" request causes the agent to fork, and the forked process handles
+    #   the request.
+    # Each agent processes a single request at a time, unless it is an
+    # Expedite::Action::Boot request which is used to make derived agents.
     class Agent
       include Signals
 
@@ -125,7 +132,7 @@ module Expedite
       end
 
       def serve(client)
-        log "got client"
+        puts "got client"
         manager.puts
 
         _stdout, stderr, _stdin = streams = 3.times.map { client.recv_io }
@@ -133,48 +140,23 @@ module Expedite
 
         preload unless preloaded?
 
-        args, env = client.recv_object.values_at("args", "env")
+        args, env, method = client.recv_object.values_at("args", "env", "method")
 
         exec_name = args.shift
         action    = Expedite::Actions.lookup(exec_name)
         action.setup(client)
 
-        connect_database
-
-        pid = fork do
-          Process.setsid
-          IGNORE_SIGNALS.each { |sig| trap(sig, "DEFAULT") }
-          trap("TERM", "DEFAULT")
-
-          # 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
-
-          begin
-            ret = action.call(*args)
-          rescue => e
-            client.send_object("exception" => e)
-          else
-            client.send_object("return" => ret )
-          end
+        connect_database # why are we connecting prior? is this for invoke?
+        pid = case method
+        when "invoke"
+          serve_invoke(client, action, args, env)
+        else
+          serve_fork(client, action, args, env)
         end
 
         disconnect_database
 
-        log "forked #{pid}"
+        log "forked #{pid}" # pid is current process
         manager.puts pid
 
         # Boot makes a new application, so we don't wait for it
@@ -201,6 +183,51 @@ module Expedite
         reset_streams
       end
 
+      # Returns pid of the current process
+      def serve_invoke(client, action, args, env)
+        begin
+          ret = action.call(*args)
+        rescue Exception => e
+          client.send_object({"exception" => e}, self.env)
+        else
+          client.send_object({"return" => ret}, self.env)
+        end
+        Process.pid
+      end
+
+      def serve_fork(client, action, args, env)
+        fork do
+          Process.setsid
+          IGNORE_SIGNALS.each { |sig| trap(sig, "DEFAULT") }
+          trap("TERM", "DEFAULT")
+
+          # 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
+
+          begin
+            ret = action.call(*args)
+          rescue => e
+            client.send_object({"exception" => e}, self.env)
+          else
+            client.send_object({"return" => ret}, self.env)
+          end
+        end
+      end
+
       def terminate
         if exiting?
           # Ensure that we do not ignore subsequent termination attempts
@@ -283,19 +310,28 @@ module Expedite
       end
 
       def wait(pid, streams, client)
-        @mutex.synchronize { @waiting << pid }
+        if pid != Process.pid
+          @mutex.synchronize { @waiting << pid }
+        end
 
         # Wait in a separate thread so we can run multiple actions at once
         Expedite.failsafe_thread {
           begin
-            _, status = Process.wait2 pid
-            log "#{pid} exited with #{status.exitstatus}"
+            exitstatue = if pid == Process.pid
+              log "#{pid} is current process"
+              0
+            else
+              _, status = Process.wait2 pid
+              log "#{pid} exited with #{status.exitstatus}"
+            end
 
             streams.each(&:close)
-            client.puts(status.exitstatus)
+            client.puts(exitstatus)
             client.close
           ensure
-            @mutex.synchronize { @waiting.delete pid }
+            if pid != Process.pid
+              @mutex.synchronize { @waiting.delete pid }
+            end
             exit_if_finished
           end
         }

data/lib/expedite/server/agent_manager.rb

@@ -7,6 +7,7 @@ require 'expedite/agents'
 
 module Expedite
   module Server
+    # Locates agent processes and spawns them if necessary
     class AgentManager
       attr_reader :pid, :child, :name, :env, :status, :agent
 
@@ -79,6 +80,10 @@ module Expedite
           log "got worker pid #{pid}"
           pid
         end
+      rescue Exception => e
+        # NotImplementedError is an Exception, not StandardError
+        client.send_object({"exception" => e}, env)
+        return Process.pid
       rescue Errno::ECONNRESET, Errno::EPIPE => e
         log "#{e} while reading from child; returning no pid"
         nil
@@ -116,6 +121,7 @@ module Expedite
         end
       end
 
+      # Creates a child that is forked from a parent
       def fork_child(preload = false)
         @child, child_socket = UNIXSocket.pair
 
@@ -125,42 +131,43 @@ module Expedite
         wr.send_io STDERR
         wr.send_io STDIN
 
-        wr.send_object(
+        wr.send_object({
           'args' => ['expedite/boot', name],
-          'env' => {}
-        )
+          'env' => {},
+          'method' => "fork",
+        }, env)
 
         wr.send_io child_socket
         wr.send_io env.log_file
         wr.close
 
-        @pid = env.applications[parent].run(rd)
+        @pid = env.applications.with(parent) do |target|
+          target.run(rd)
+        end
 
         start_wait_thread(pid, child) if child.gets
         child_socket.close
       end
 
+      # Creates a child that is started from scratch
       def spawn_child(preload = false)
         @child, child_socket = UNIXSocket.pair
 
-        Bundler.with_original_env do
-          puts File.expand_path("..", __FILE__)
-          bundler_dir = File.expand_path("../..", $LOADED_FEATURES.grep(/bundler\/setup\.rb$/).first)
-          @pid = Process.spawn(
-            {
-              "EXPEDITE_VARIANT" => name,
-              "EXPEDITE_ROOT" => env.root,
-            },
-            "ruby",
-            *(bundler_dir != RbConfig::CONFIG["rubylibdir"] ? ["-I", bundler_dir] : []),
-            "-I", File.expand_path("../../..", __FILE__),
-            "-e", "require 'expedite/server/agent_boot'",
-            3 => child_socket,
-            4 => env.log_file,
-          )
-        end
+        bundler_dir = File.expand_path("../..", $LOADED_FEATURES.grep(/bundler\/setup\.rb$/).first)
+        @pid = Process.spawn(
+          {
+            "EXPEDITE_VARIANT" => name,
+            "EXPEDITE_ROOT" => env.root,
+          },
+          "ruby",
+          *(bundler_dir != RbConfig::CONFIG["rubylibdir"] ? ["-I", bundler_dir] : []),
+          "-I", File.expand_path("../../..", __FILE__),
+          "-e", "require 'expedite/server/agent_boot'",
+          3 => child_socket,
+          4 => env.log_file,
+        )
 
-        start_wait_thread(pid, child) if child.gets
+        start_wait_thread(@pid, child) if child.gets
         child_socket.close
       end
 

data/lib/expedite/server/agent_pool.rb

@@ -0,0 +1,39 @@
+require 'set'
+require 'expedite/server/agent_manager'
+
+module Expedite
+  module Server
+    class AgentPool
+      def initialize(name, env)
+        @name = name
+        @env = env
+        @checked_in = []
+        @checked_out = Set.new
+      end
+
+      # Get a free agent from the pool
+      def checkout
+        agent = @checked_in.pop
+
+        agent = build_agent if agent.nil?
+        @checked_out.add(agent)
+
+        agent
+      end
+
+      def checkin(agent)
+        @checked_out.delete(agent)
+        @checked_in.push(agent)
+      end
+
+      def build_agent
+        Server::AgentManager.new(@name, @env)
+      end
+
+      # Returns all agents, both checked in and checked out
+      def all
+        @checked_in + @checked_out.to_a
+      end
+    end
+  end
+end

data/lib/expedite/server/application_manager.rb

@@ -0,0 +1,27 @@
+require 'expedite/server/agent_pool'
+
+module Expedite
+  module Server
+    class ApplicationManager
+      attr_reader :pools
+
+      def initialize(env)
+        @env = env
+        @pools = Hash.new do |h, k|
+          h[k] = AgentPool.new(k, @env)
+        end
+      end
+
+      def with(name)
+        pool = @pools[name]
+        target = pool.checkout
+        begin
+          ret = yield target
+        ensure
+          pool.checkin(target)
+        end
+        ret
+      end
+    end
+  end
+end

data/lib/expedite/server/controller.rb

@@ -97,42 +97,69 @@ module Expedite
         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')
+        args, agent = command.values_at("args", "agent")
         cmd = args.first
 
-        if agent == '__server__'
+        if agent == "__server__"
           case cmd
-          when 'application_pids'
+          when "application_pids"
+            # Corresponds to Client::Invoke#run_command
             client.puts
+
             unix_socket = UNIXSocket.for_fd(app_client.fileno)
-            _stdout, _stderr, _stdin = streams = 3.times.map do
-              unix_socket.recv_io
-            end
+            _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
+            env.applications.pools.each do |k, pool|
+              application_pids.concat(pool.all.map(&:pid))
             end
-            unix_socket.send_object("return" => application_pids)
+            unix_socket.send_object({"return" => application_pids}, env)
 
             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
 
-          target = env.applications[agent]
-          client.puts target.run(app_client)
+          begin
+            env.applications.with(agent) do |target|
+              client.puts target.run(app_client)
+            end
+          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}, env)
+
+            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
@@ -168,7 +195,13 @@ module Expedite
           end
         end
 
-        env.applications.values.map { |a| Expedite.failsafe_thread { a.stop } }.map(&:join)
+        thrs = []
+        env.applications.pools.each do |k, pool|
+          pool.all.each do |a|
+            thrs << Expedite.failsafe_thread { a.stop }
+          end
+        end
+        thrs.map(&:join)
       end
 
       def write_pidfile
@@ -201,11 +234,20 @@ module Expedite
 
       def default_log_file
         if foreground? && !ENV["SPRING_LOG"]
-          $stdout
+          $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/version.rb

@@ -1,3 +1,3 @@
 module Expedite
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/lib/expedite.rb

@@ -31,5 +31,3 @@ module Expedite
     @clients[agent]
   end
 end
-
-

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: expedite
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Bing-Chang Lai
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-12-08 00:00:00.000000000 Z
+date: 2022-12-16 00:00:00.000000000 Z
 dependencies: []
 description: Manages Ruby processes that can be used to spawn child processes faster.
 email: johnny.lai@me.com
@@ -25,6 +25,7 @@ files:
 - lib/expedite/actions.rb
 - lib/expedite/agents.rb
 - lib/expedite/cli.rb
+- lib/expedite/cli/rails.rb
 - lib/expedite/cli/server.rb
 - lib/expedite/cli/status.rb
 - lib/expedite/cli/stop.rb
@@ -33,10 +34,13 @@ files:
 - lib/expedite/env.rb
 - lib/expedite/errors.rb
 - lib/expedite/failsafe_thread.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/agent_pool.rb
+- lib/expedite/server/application_manager.rb
 - lib/expedite/server/controller.rb
 - lib/expedite/signals.rb
 - lib/expedite/syntax.rb