spring 1.2.0 → 4.7.0

data/lib/spring/client/run.rb

@@ -1,27 +1,63 @@
 require "rbconfig"
 require "socket"
+require "bundler"
 
 module Spring
   module Client
     class Run < Command
-      FORWARDED_SIGNALS = %w(INT QUIT USR1 USR2 INFO) & Signal.list.keys
-      TIMEOUT = 1
+      FORWARDED_SIGNALS = %w(INT QUIT USR1 USR2 INFO WINCH) & Signal.list.keys
+      ServerReadTimeout = Class.new(StandardError)
+
+      attr_reader :server
 
       def initialize(args)
         super
-        @signal_queue = []
+
+        @signal_queue  = []
+        @server_booted = false
       end
 
       def log(message)
         env.log "[client] #{message}"
       end
 
-      def server
-        @server ||= UNIXSocket.open(env.socket_name)
+      def connect
+        @server = UNIXSocket.open(env.socket_name)
       end
 
       def call
-        boot_server unless env.server_running?
+        begin
+          connect
+        rescue Errno::ENOENT, Errno::ECONNRESET, Errno::ECONNREFUSED
+          cold_run
+        else
+          warm_run
+        end
+      ensure
+        server.close if server
+      end
+
+      def warm_run
+        run
+      rescue CommandNotFound
+        require "spring/commands"
+
+        if Spring.command?(args.first)
+          # Command installed since Spring started
+          stop_server
+          cold_run
+        else
+          raise
+        end
+      end
+
+      def cold_run
+        boot_server
+        connect
+        run
+      end
+
+      def run
         verify_server_version
 
         application, client = UNIXSocket.pair
@@ -31,43 +67,123 @@ module Spring
         run_command(client, application)
       rescue Errno::ECONNRESET
         exit 1
-      ensure
-        server.close if @server
       end
 
       def boot_server
         env.socket_path.unlink if env.socket_path.exist?
 
-        pid = fork {
-          require "spring/server"
-          Spring::Server.boot
-        }
+        pid     = Process.spawn(server_process_env, env.server_command, out: File::NULL)
+        timeout = Time.now + Spring.boot_timeout
+
+        @server_booted = true
 
         until env.socket_path.exist?
           _, status = Process.waitpid2(pid, Process::WNOHANG)
-          exit status.exitstatus if status
+
+          if status
+            exit status.exitstatus
+          elsif Time.now > timeout
+            $stderr.puts "Starting Spring server with `#{env.server_command}` " \
+                         "timed out after #{Spring.boot_timeout} seconds"
+            exit 1
+          end
+
           sleep 0.1
         end
       end
 
+      def server_booted?
+        @server_booted
+      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
+
+      def reset_env
+        ENV.slice(*Spring.reset_on_env)
+      end
+
+      def server_process_env
+        reset_env.merge(gem_env)
+      end
+
+      def stop_server
+        server.close
+        @server = nil
+        env.stop
+      end
+
       def verify_server_version
-        server_version = server.gets.chomp
+        begin
+          line = read_server_line
+        rescue ServerReadTimeout
+          if waiting_for_server_boot?
+            begin
+              # Try again, but with same timeout as booting, as server might still be booting
+              #   from another client starting it.
+              line = read_server_line(Spring.boot_timeout)
+            rescue ServerReadTimeout
+              reboot_or_raise_connection_error
+              return
+            end
+          else
+            reboot_or_raise_connection_error
+            return
+          end
+        end
+
+        if line.nil?
+          reboot_or_raise_connection_error
+          return
+        end
+
+        server_version = line.chomp
         if server_version != env.version
-          $stderr.puts <<-ERROR
-There is a version mismatch between the spring client and the server.
-You should restart the server and make sure to use the same version.
+          $stderr.puts "There is a version mismatch between the Spring client " \
+                         "(#{env.version}) and the server (#{server_version})."
 
-CLIENT: #{env.version}, SERVER: #{server_version}
-ERROR
-          exit 1
+          if server_booted?
+            $stderr.puts "We already tried to reboot the server, but the mismatch is still present."
+            exit 1
+          else
+            $stderr.puts "Restarting to resolve."
+            stop_server
+            cold_run
+          end
+        end
+      end
+
+      def read_server_line(timeout = Spring.connect_timeout)
+        raise ServerReadTimeout if IO.select([server], [], [], timeout).nil?
+
+        server.gets
+      end
+
+      def waiting_for_server_boot?
+        !server_booted? && env.server_running?
+      end
+
+      def reboot_or_raise_connection_error
+        if server_booted?
+          raise "Error connecting to Spring server"
+        else
+          stop_server
+          cold_run
         end
       end
 
       def connect_to_application(client)
         server.send_io client
-        send_json server, "args" => args, "default_rails_env" => default_rails_env
+        send_json server, "args" => args, "default_rails_env" => default_rails_env, "spawn_env" => spawn_env, "reset_env" => reset_env
 
-        if IO.select([server], [], [], TIMEOUT)
+        if IO.select([server], [], [], Spring.connect_timeout)
           server.gets or raise CommandNotFound
         else
           raise "Error connecting to Spring server"
@@ -75,12 +191,17 @@ ERROR
       end
 
       def run_command(client, application)
-        log "sending command"
-
         application.send_io STDOUT
         application.send_io STDERR
         application.send_io STDIN
 
+        log "waiting for the application to be preloaded"
+        preload_status = application.gets
+        preload_status = preload_status.chomp if preload_status
+        log "app preload status: #{preload_status}"
+        exit 1 if preload_status == "1"
+
+        log "sending command"
         send_json application, "args" => args, "env" => ENV.to_hash
 
         pid = server.gets
@@ -94,12 +215,19 @@ ERROR
         if pid && !pid.empty?
           log "got pid: #{pid}"
 
-          forward_signals(pid.to_i)
-          status = application.read.to_i
+          suspend_resume_on_tstp_cont(pid)
+
+          forward_signals(application)
+          status = application.read
+          log "got exit status #{status.inspect}"
 
-          log "got exit status #{status}"
+          # Status should always be an integer. If it is empty, something unexpected must have happened to the server.
+          if status.to_s.strip.empty?
+            log "unexpected empty exit status, app crashed?"
+            exit 1
+          end
 
-          exit status
+          exit status.to_i
         else
           log "got no pid"
           exit 1
@@ -114,26 +242,38 @@ ERROR
         end
       end
 
-      def forward_signals(pid)
-        @signal_queue.each { |sig| kill sig, pid }
+      def suspend_resume_on_tstp_cont(pid)
+        trap("TSTP") {
+          log "suspended"
+          Process.kill("STOP", pid.to_i)
+          Process.kill("STOP", Process.pid)
+        }
+        trap("CONT") {
+          log "resumed"
+          Process.kill("CONT", pid.to_i)
+        }
+      end
+
+      def forward_signals(application)
+        @signal_queue.each { |sig| kill sig, application }
 
         FORWARDED_SIGNALS.each do |sig|
-          trap(sig) { forward_signal sig, pid }
+          trap(sig) { forward_signal sig, application }
         end
-      rescue Errno::ESRCH
       end
 
-      def forward_signal(sig, pid)
-        kill(sig, pid)
-      rescue Errno::ESRCH
-        # If the application process is gone, then don't block the
-        # signal on this process.
-        trap(sig, 'DEFAULT')
-        Process.kill(sig, Process.pid)
+      def forward_signal(sig, application)
+        if kill(sig, application) != 0
+          # If the application process is gone, then don't block the
+          # signal on this process.
+          trap(sig, 'DEFAULT')
+          Process.kill(sig, Process.pid)
+        end
       end
 
-      def kill(sig, pid)
-        Process.kill(sig, -Process.getpgid(pid))
+      def kill(sig, application)
+        application.puts(sig)
+        application.gets.to_i
       end
 
       def send_json(socket, data)
@@ -146,6 +286,12 @@ ERROR
       def default_rails_env
         ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
       end
+
+      def spawn_env
+        Spring.spawn_on_env.to_h do |key|
+          [key, ENV[key]]
+        end
+      end
     end
   end
 end

data/lib/spring/client/server.rb

@@ -0,0 +1,18 @@
+module Spring
+  module Client
+    class Server < Command
+      def self.description
+        "Explicitly start a Spring server in the foreground"
+      end
+
+      def call
+        require "spring/server"
+        Spring::Server.boot(foreground: foreground?)
+      end
+
+      def foreground?
+        !args.include?("--background")
+      end
+    end
+  end
+end

data/lib/spring/client/status.rb

@@ -17,11 +17,11 @@ module Spring
       end
 
       def print_process(pid)
-        puts `ps -p #{pid} -o pid= -o args=`
+        puts `ps -p #{pid} -o pid= -o command=`
       end
 
       def application_pids
-        candidates = `ps -A -o ppid= -o pid=`.lines
+        candidates = `ps -ax -o ppid= -o pid=`.lines
         candidates.select { |l| l =~ /^(\s+)?#{env.pid} / }
                   .map    { |l| l.split(" ").last   }
       end

data/lib/spring/client/stop.rb

@@ -3,35 +3,20 @@ require "spring/version"
 module Spring
   module Client
     class Stop < Command
-      TIMEOUT = 2 # seconds
-
       def self.description
-        "Stop all spring processes for this project."
+        "Stop all Spring processes for this project."
       end
 
       def call
-        if env.server_running?
-          timeout = Time.now + TIMEOUT
-          kill 'TERM'
-          sleep 0.1 until !env.server_running? || Time.now >= timeout
-
-          if env.server_running?
-            $stderr.puts "Spring did not stop; killing forcibly."
-            kill 'KILL'
-          else
-            puts "Spring stopped."
-          end
-        else
+        case env.stop
+        when :stopped
+          puts "Spring stopped."
+        when :killed
+          $stderr.puts "Spring did not stop; killing forcibly."
+        when :not_running
           puts "Spring is not running"
         end
       end
-
-      def kill(sig)
-        pid = env.pid
-        Process.kill(sig, pid) if pid
-      rescue Errno::ESRCH
-        # already dead
-      end
     end
   end
 end

data/lib/spring/client.rb

@@ -9,17 +9,21 @@ require "spring/client/stop"
 require "spring/client/status"
 require "spring/client/rails"
 require "spring/client/version"
+require "spring/client/server"
 
 module Spring
   module Client
     COMMANDS = {
       "help"      => Client::Help,
+      "-h"        => Client::Help,
+      "--help"    => Client::Help,
       "binstub"   => Client::Binstub,
       "stop"      => Client::Stop,
       "status"    => Client::Status,
       "rails"     => Client::Rails,
       "-v"        => Client::Version,
-      "--version" => Client::Version
+      "--version" => Client::Version,
+      "server"    => Client::Server,
     }
 
     def self.run(args)
@@ -36,3 +40,9 @@ module Spring
     end
   end
 end
+
+# allow users to add hooks that do not run in the server
+# or modify start/stop
+if File.exist?("config/spring_client.rb")
+  require "./config/spring_client.rb"
+end

data/lib/spring/command_wrapper.rb

@@ -41,10 +41,6 @@ module Spring
       end
     end
 
-    def process_title
-      [name, *ARGV].join(" ")
-    end
-
     def gem_name
       if command.respond_to?(:gem_name)
         command.gem_name

data/lib/spring/commands/rails.rb

@@ -83,9 +83,30 @@ module Spring
       end
     end
 
+    class RailsTest < Rails
+      def env(args)
+        environment = "test"
+
+        args.each.with_index do |arg, i|
+          if arg =~ /--environment=(\w+)/
+            environment = $1
+          elsif i > 0 && args[i - 1] == "-e"
+            environment = arg
+          end
+        end
+
+        environment
+      end
+
+      def command_name
+        "test"
+      end
+    end
+
     Spring.register_command "rails_console",  RailsConsole.new
     Spring.register_command "rails_generate", RailsGenerate.new
     Spring.register_command "rails_destroy",  RailsDestroy.new
     Spring.register_command "rails_runner",   RailsRunner.new
+    Spring.register_command "rails_test",     RailsTest.new
   end
 end

data/lib/spring/commands.rb

@@ -28,11 +28,18 @@ module Spring
   config = File.expand_path("~/.spring.rb")
   require config if File.exist?(config)
 
-  # If the config/spring.rb contains requires for commands from other gems,
-  # then we need to be under bundler.
-  require "bundler/setup"
+  # We force the TTY so bundler doesn't show a backtrace in case gems are missing.
+  old_env = ENV["BUNDLER_FORCE_TTY"]
+  ENV["BUNDLER_FORCE_TTY"] = "true"
+  begin
+    # If the config/spring.rb contains requires for commands from other gems,
+    # then we need to be under bundler.
+    require "bundler/setup"
+  ensure
+    ENV["BUNDLER_FORCE_TTY"] = old_env
+  end
 
-  # Auto-require any spring extensions which are in the Gemfile
+  # Auto-require any Spring extensions which are in the Gemfile
   Gem::Specification.map(&:name).grep(/^spring-/).each do |command|
     begin
       require command

data/lib/spring/configuration.rb

@@ -1,11 +1,36 @@
 require "spring/errors"
 
 module Spring
+  @connect_timeout = 5
+  @boot_timeout = 20
+  @dangerously_allow_disabling_reloading = false
+
   class << self
-    attr_accessor :application_root
+    attr_accessor :application_root, :connect_timeout, :boot_timeout
+    attr_writer :quiet
+
+    # Opt-in: skip the `:ensure_reloading_is_enabled` initializer so Spring
+    # boots with `config.enable_reloading = false`. Default `false`. See
+    # README "Running Spring with reloading disabled" for what this gives up.
+    attr_accessor :dangerously_allow_disabling_reloading
 
     def gemfile
-      ENV['BUNDLE_GEMFILE'] || "Gemfile"
+      require "bundler"
+
+      if /\s1.9.[0-9]/ ===  Bundler.ruby_scope.gsub(/[\/\s]+/,'')
+        Pathname.new(ENV["BUNDLE_GEMFILE"] || "Gemfile").expand_path
+      else
+        Bundler.default_gemfile
+      end
+    end
+
+    def gemfile_lock
+      case gemfile.to_s
+      when /\bgems\.rb\z/
+        gemfile.sub_ext('.locked')
+      else
+        gemfile.sub_ext('.lock')
+      end
     end
 
     def after_fork_callbacks
@@ -16,6 +41,22 @@ module Spring
       after_fork_callbacks << block
     end
 
+    def after_environment_load_callbacks
+      @after_environment_load_callbacks ||= []
+    end
+
+    def after_environment_load(&block)
+      after_environment_load_callbacks << block
+    end
+
+    def spawn_on_env
+      @spawn_on_env ||= []
+    end
+
+    def reset_on_env
+      @reset_on_env ||= []
+    end
+
     def verify_environment
       application_root_path
     end
@@ -37,6 +78,10 @@ module Spring
       @project_root_path ||= find_project_root(Pathname.new(File.expand_path(Dir.pwd)))
     end
 
+    def quiet
+      @quiet || ENV.key?('SPRING_QUIET')
+    end
+
     private
 
     def find_project_root(current_dir)
@@ -49,4 +94,6 @@ module Spring
       end
     end
   end
+
+  self.quiet = false
 end

data/lib/spring/env.rb

@@ -1,22 +1,19 @@
 require "pathname"
-require "fileutils"
-require "digest/md5"
-require "tmpdir"
 
 require "spring/version"
-require "spring/sid"
 require "spring/configuration"
 
 module Spring
   IGNORE_SIGNALS = %w(INT QUIT)
+  STOP_TIMEOUT = 2 # seconds
 
   class Env
     attr_reader :log_file
 
-    def initialize(root = nil)
-      @root         = root
-      @project_root = root
-      @log_file     = File.open(ENV["SPRING_LOG"] || File::NULL, "a")
+    def initialize(options = {})
+      @root         = options[:root]
+      @project_root = options[:root]
+      @log_file     = options[:log_file] || File.open(ENV["SPRING_LOG"] || File::NULL, "a")
     end
 
     def root
@@ -32,17 +29,23 @@ module Spring
     end
 
     def tmp_path
-      path = Pathname.new(File.join(ENV['XDG_RUNTIME_DIR'] || Dir.tmpdir, "spring"))
+      require "tmpdir"
+      path = Pathname.new(
+        ENV["SPRING_TMP_PATH"] ||
+          File.join(ENV['XDG_RUNTIME_DIR'] || Dir.tmpdir, "spring-#{Process.uid}")
+      )
+      require "fileutils"
       FileUtils.mkdir_p(path) unless path.exist?
       path
     end
 
     def application_id
-      Digest::MD5.hexdigest(RUBY_VERSION + project_root.to_s)
+      require "digest/md5"
+      ENV["SPRING_APPLICATION_ID"] || Digest::MD5.hexdigest(RUBY_VERSION + project_root.to_s)
     end
 
     def socket_path
-      tmp_path.join(application_id)
+      Pathname.new(ENV["SPRING_SOCKET"] || tmp_path.join(application_id))
     end
 
     def socket_name
@@ -50,7 +53,7 @@ module Spring
     end
 
     def pidfile_path
-      tmp_path.join("#{application_id}.pid")
+      Pathname.new(ENV["SPRING_PIDFILE"] || socket_path.dirname.join("#{socket_path.basename(".*")}.pid"))
     end
 
     def pid
@@ -80,5 +83,33 @@ module Spring
       log_file.puts "[#{Time.now}] [#{Process.pid}] #{message}"
       log_file.flush
     end
+
+    def stop
+      if server_running?
+        timeout = Time.now + STOP_TIMEOUT
+        kill 'TERM'
+        sleep 0.1 until !server_running? || Time.now >= timeout
+
+        if server_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 server_command
+      ENV["SPRING_SERVER_COMMAND"] || "#{File.expand_path("../../../bin/spring", __FILE__)} server --background"
+    end
   end
 end

data/lib/spring/errors.rb

@@ -24,7 +24,7 @@ module Spring
 
     def message
       "Spring was unable to find your config/application.rb file. " \
-        "Your project root was detected at #{project_root}, so spring " \
+        "Your project root was detected at #{project_root}, so Spring " \
         "looked for #{project_root}/config/application.rb but it doesn't exist. You can " \
         "configure the root of your application by setting Spring.application_root in " \
         "config/spring.rb."

data/lib/spring/failsafe_thread.rb

@@ -0,0 +1,14 @@
+require 'thread'
+
+module Spring
+  class << self
+    def failsafe_thread
+      Thread.new {
+        begin
+          yield
+        rescue
+        end
+      }
+    end
+  end
+end