expedite 0.1.1 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 909035b6bad8ef3ccf6333cd38e136fd0c935197c2d467fe962ffc6bb04cb13c
-  data.tar.gz: 7f375e9c3d42219f7d737300fc9ea89db06ca51de3e8514fa515ebd144a9d2b6
+  metadata.gz: '0218f397835f80f748b0c255e8097aad9b8e8063122d15415a19f88e35546335'
+  data.tar.gz: 643e16d53333346a199595b2cb9fcab21116f53c606a505a40675d6ca074baaf
 SHA512:
-  metadata.gz: 1ef388a4e305be7d6ece922be81b72d333e29d307de0e09e8e65ceb77562ade04b83394fe626028f4a8e75ada8cef00b20e798f4abd6243bcb6cd1e652f99dd8
-  data.tar.gz: e0bce02b6ed7a305dea12daf4cccc768fc13919bc375883f5f55fd9398f339da0e51bc1423d85be23012c605eebb0b6f90986ff4834630ef89ea71484b9365a9
+  metadata.gz: c27ae0ac8775724ae0da4983e2f4ec04754e1cacd29bd632043c36f2c7634dd3914b92fc2e9d15f0b263418fdf0813e4d34aef7d4191fa0b14c368fed4993fb9
+  data.tar.gz: '09d8bdf813c976cffe6bfb3c2a6a31f14f1e0e1e6577a06a8e67e2be66271dc09a1180723bda57e1fa91a891f152f0316c5d893f795357d33ba090139782b6aa'

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/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,3 +1,4 @@
+require 'expedite/cli/rails'
 require 'expedite/cli/server'
 require 'expedite/cli/status'
 require 'expedite/cli/stop'
@@ -13,7 +14,7 @@ module Expedite
         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}"
@@ -27,12 +28,18 @@ 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..])
@@ -42,7 +49,7 @@ module Expedite
     end
 
     def command(cmd)
-      klass = COMMANDS[cmd]
+      klass = commands[cmd]
       raise UnknownCommandError, "Unknown command '#{cmd}'" if klass.nil?
       klass.new
     end

data/lib/expedite/client/base.rb

@@ -0,0 +1,165 @@
+require 'socket'
+
+require 'expedite/env'
+require 'expedite/errors'
+require 'expedite/protocol'
+
+module Expedite
+  module Client
+    class Base
+      CONNECT_TIMEOUT   = 1
+      BOOT_TIMEOUT      = 20
+
+      attr_reader :args, :env, :agent
+      attr_reader :server
+
+      def initialize(env: nil, agent: nil)
+        @env = env || Env.new
+        @agent = agent
+
+        @server_booted = false
+      end
+
+      def call(*args)
+        begin
+          connect
+        rescue Errno::ENOENT, Errno::ECONNRESET, Errno::ECONNREFUSED
+          boot_server
+          connect
+        end
+
+        perform(*args)
+      ensure
+        server.close if server
+      end
+
+      def perform(*args)
+        verify_server_version
+
+        agent, client = UNIXSocket.pair
+        connect_to_agent(client, args)
+        run_command(client, agent, args)
+      end
+
+      def verify_server_version
+        server_version = server.gets.chomp
+        raise ArgumentError, "Server mismatch. Expected #{env.version}, got #{server_version}." if server_version != env.version
+      end
+
+      def connect_to_agent(client, args)
+        server.send_io client
+
+        server.send_object({"args" => args, "agent" => agent}, env)
+
+        if IO.select([server], [], [], CONNECT_TIMEOUT)
+          server.gets or raise CommandNotFound
+        else
+          raise "Error connecting to Expedite server"
+        end
+      end
+
+      def run_command(client, agent, args)
+        log "sending command"
+
+        agent.send_io STDOUT
+        agent.send_io STDERR
+        agent.send_io STDIN
+
+        agent.send_object({
+          "args" => args,
+          "env" => ENV.to_hash,
+          "method" => run_command_method,
+        }, env)
+
+        pid = server.gets
+        pid = pid.chomp if pid
+
+        # We must not close the client socket until we are sure that the application has
+        # received the FD. Otherwise the FD can end up getting closed while it's in the server
+        # socket buffer on OS X. This doesn't happen on Linux.
+        client.close
+
+        if pid && !pid.empty?
+          log "got pid: #{pid}"
+
+          ## suspend_resume_on_tstp_cont(pid)
+
+          ## forward_signals(application)
+          result = agent.recv_object
+          if result.key?("exception")
+            e = result["exception"]
+            log "got exception #{e}"
+            raise e
+          end
+
+          ret = result["return"]
+          log "got return value #{ret}"
+          return ret
+        else
+          log "got no pid"
+          raise UnknownError, "got no pid"
+        end
+      ensure
+        agent.close
+      end
+
+      def boot_server
+        env.socket_path.unlink if env.socket_path.exist?
+
+        pid     = Process.spawn(gem_env, env.server_command, out: File::NULL)
+        timeout = Time.now + BOOT_TIMEOUT
+
+        @server_booted = true
+
+        until env.socket_path.exist?
+          _, status = Process.waitpid2(pid, Process::WNOHANG)
+
+          if status
+            # Server did not start
+            raise ArgumentError, "Server exited: #{status.exitstatus}"
+          elsif Time.now > timeout
+            $stderr.puts "Starting Expedite server with `#{env.server_command}` " \
+                         "timed out after #{BOOT_TIMEOUT} seconds"
+            exit 1
+          end
+
+          sleep 0.1
+        end
+      end
+
+      def server_booted?
+        @server_booted
+      end
+
+      def stop_server
+        server.close
+        @server = nil
+        env.stop
+      end
+
+      def log(message)
+        env.log "[client] #{message}"
+      end
+
+      def connect
+        @server = UNIXSocket.open(env.socket_path)
+      end
+
+      def gem_env
+        bundle = Bundler.bundle_path.to_s
+        paths  = Gem.path + ENV["GEM_PATH"].to_s.split(File::PATH_SEPARATOR)
+
+        {
+          "GEM_PATH" => [bundle, *paths].uniq.join(File::PATH_SEPARATOR),
+          "GEM_HOME" => bundle
+        }
+      end
+
+
+    protected
+      def run_command_method
+        raise NotImplementedError, "run_command_method must be overriden"
+      end
+    end
+  end
+end

data/lib/expedite/client/exec.rb

@@ -1,18 +1,10 @@
 
 # Based on https://github.com/rails/spring/blob/master/lib/spring/client/run.rb
-
-require 'bundler'
-require 'rbconfig'
-require 'socket'
-
-require 'expedite/client/invoke'
-require 'expedite/env'
-require 'expedite/errors'
-require 'expedite/protocol'
+require 'expedite/client/base'
 
 module Expedite
   module Client
-    class Exec < Invoke
+    class Exec < Base
       FORWARDED_SIGNALS = %w(INT QUIT USR1 USR2 INFO WINCH) & Signal.list.keys
 
       def initialize(env: nil, agent: nil)
@@ -58,7 +50,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
@@ -119,6 +120,11 @@ module Expedite
         application.puts(sig)
         application.gets.to_i
       end
+
+    protected
+      def run_command_method
+        "exec"
+      end
     end
   end
 end

data/lib/expedite/client/invoke.rb

@@ -1,154 +1,13 @@
 require 'socket'
 
-require 'expedite/env'
-require 'expedite/errors'
-require 'expedite/protocol'
+require 'expedite/client/base'
 
 module Expedite
   module Client
-    class Invoke
-      CONNECT_TIMEOUT   = 1
-      BOOT_TIMEOUT      = 20
-
-      attr_reader :args, :env, :agent
-      attr_reader :server
-
-      def initialize(env: nil, agent: nil)
-        @env = env || Env.new
-        @agent = agent
-
-        @server_booted = false
-      end
-
-      def call(*args)
-        begin
-          connect
-        rescue Errno::ENOENT, Errno::ECONNRESET, Errno::ECONNREFUSED
-          boot_server
-          connect
-        end
-
-        perform(*args)
-      ensure
-        server.close if server
-      end
-
-      def perform(*args)
-        verify_server_version
-
-        agent, client = UNIXSocket.pair
-        connect_to_agent(client, args)
-        run_command(client, agent, args)
-      end
-
-      def verify_server_version
-        server_version = server.gets.chomp
-        raise ArgumentError, "Server mismatch. Expected #{env.version}, got #{server_version}." if server_version != env.version
-      end
-
-      def connect_to_agent(client, args)
-        server.send_io client
-
-        server.send_object("args" => args, "agent" => agent)
-
-        if IO.select([server], [], [], CONNECT_TIMEOUT)
-          server.gets or raise CommandNotFound
-        else
-          raise "Error connecting to Expedite server"
-        end
-      end
-
-      def run_command(client, agent, args)
-        log "sending command"
-
-        agent.send_io STDOUT
-        agent.send_io STDERR
-        agent.send_io STDIN
-
-        agent.send_object("args" => args, "env" => ENV.to_hash)
-
-        pid = server.gets
-        pid = pid.chomp if pid
-
-        # We must not close the client socket until we are sure that the application has
-        # received the FD. Otherwise the FD can end up getting closed while it's in the server
-        # socket buffer on OS X. This doesn't happen on Linux.
-        client.close
-
-        if pid && !pid.empty?
-          log "got pid: #{pid}"
-
-          ## suspend_resume_on_tstp_cont(pid)
-
-          ## forward_signals(application)
-          result = agent.recv_object
-          if result.key?("exception")
-            e = result["exception"]
-            log "got exception #{e}"
-            raise e
-          end
-
-          ret = result["return"]
-          log "got return value #{ret}"
-          return ret
-        else
-          log "got no pid"
-          raise UnknownError, "got no pid"
-        end
-      ensure
-        agent.close
-      end
-
-      def boot_server
-        env.socket_path.unlink if env.socket_path.exist?
-
-        pid     = Process.spawn(gem_env, env.server_command, out: File::NULL)
-        timeout = Time.now + BOOT_TIMEOUT
-
-        @server_booted = true
-
-        until env.socket_path.exist?
-          _, status = Process.waitpid2(pid, Process::WNOHANG)
-
-          if status
-            # Server did not start
-            raise ArgumentError, "Server exited: #{status.exitstatus}"
-          elsif Time.now > timeout
-            $stderr.puts "Starting Expedite server with `#{env.server_command}` " \
-                         "timed out after #{BOOT_TIMEOUT} seconds"
-            exit 1
-          end
-
-          sleep 0.1
-        end
-      end
-
-      def server_booted?
-        @server_booted
-      end
-
-      def stop_server
-        server.close
-        @server = nil
-        env.stop
-      end
-
-      def log(message)
-        env.log "[client] #{message}"
-      end
-
-      def connect
-        @server = UNIXSocket.open(env.socket_path)
-      end
-
-      def gem_env
-        bundle = Bundler.bundle_path.to_s
-        paths  = Gem.path + ENV["GEM_PATH"].to_s.split(File::PATH_SEPARATOR)
-
-        {
-          "GEM_PATH" => [bundle, *paths].uniq.join(File::PATH_SEPARATOR),
-          "GEM_HOME" => bundle
-        }
+    class Invoke < Base
+    protected
+      def run_command_method
+        "invoke"
       end
     end
   end

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/helper/rails.rb

@@ -1,14 +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
 
-    require "#{app_root}/config/boot.rb"
-
-    require "rack"
-    rackup_file = "#{app_root}/config.ru"
-    Rack::Builder.load_file(rackup_file)
-
-    Rails.application.eager_load!
+  # 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,7 +2,8 @@ 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.to_i

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,25 @@ 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")
+        log "serve #{args} using #{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"
+          # TODO: Invoke in a worker process instead of the preloader
+          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 +185,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 +312,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
 
@@ -81,7 +82,7 @@ module Expedite
         end
       rescue Exception => e
         # NotImplementedError is an Exception, not StandardError
-        client.send_object("exception" => e)
+        client.send_object({"exception" => e}, env)
         return Process.pid
       rescue Errno::ECONNRESET, Errno::EPIPE => e
         log "#{e} while reading from child; returning no pid"
@@ -120,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
 
@@ -129,21 +131,25 @@ 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
 

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

@@ -101,12 +101,12 @@ module Expedite
         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
 
@@ -118,10 +118,10 @@ module Expedite
             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
@@ -134,9 +134,9 @@ module Expedite
           client.puts
 
           begin
-            target = env.applications[agent]
-
-            client.puts target.run(app_client)
+            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
@@ -150,7 +150,7 @@ module Expedite
             # boot only
             #@child_socket = client.recv_io
             #@log_file = client.recv_io
-            unix_socket.send_object("exception" => e)
+            unix_socket.send_object({"exception" => e}, env)
 
             unix_socket.close
             client.close
@@ -195,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

data/lib/expedite/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: expedite
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.1
 platform: ruby
 authors:
 - Bing-Chang Lai
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-12-08 00:00:00.000000000 Z
+date: 2022-12-17 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,9 +25,11 @@ 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
+- lib/expedite/client/base.rb
 - lib/expedite/client/exec.rb
 - lib/expedite/client/invoke.rb
 - lib/expedite/env.rb
@@ -38,6 +40,8 @@ files:
 - 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