spring 1.6.4 → 1.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7188079e7e8285351c6d8a0604cc9198a2052bfd
-  data.tar.gz: 2a0d6caceb3960e1ecd88ed86ec7f786b94aa388
+  metadata.gz: d14dc08475fd37c9118d173aea5ec37900657430
+  data.tar.gz: d6fbda6c06dfe77c7bdaa27f6a5cc45019ca5266
 SHA512:
-  metadata.gz: 294d493fe0500ef7e1265fabc0586ecc77be34f95b56504e9c972468eb3378ec8fad63c4793bfcad330274e269aad000463b8d161a3054bede5bbf3514f3a881
-  data.tar.gz: fe2b858e97d0553e7bcb0b3b1a960587e29a090d584878a7b5cde6622bda0d9bb3920f2610dfb1a767db755ae4f5bf661de212b4405e68e63efb766a8b0ba70e
+  metadata.gz: bb7c61300a47f81d7ca46c5bf6bb50f679c665bb076b7d05fcacf923d8dc06a8b03b85313ea3f1f465e83fedb4f9ff38641270f9185439156261b03232a58201
+  data.tar.gz: e5bf9351f6bd9af0150cd0cdba8a04b556445a5cf485e69d89d2b6c3007cd91800a9f19c45732cae1e315805153cbab18911f6191d3c7508efc74c516170ad55

data/README.md

@@ -290,6 +290,13 @@ false
 So to avoid this problem, don't save off references to application
 constants in your initialization code.
 
+## Using Spring with a containerized development environment
+
+As of Spring 1.7, there is some support for doing this. See [this
+example
+repository](https://github.com/jonleighton/spring-docker-example) for
+information about how to do it with [Docker](https://www.docker.com/).
+
 ## Configuration
 
 Spring will read `~/.spring.rb` and `config/spring.rb` for custom
@@ -365,13 +372,42 @@ a command runs:
 Spring.quiet = true
 ```
 
+### Environment variables
+
+The following environment variables are used by Spring:
+
+* `DISABLE_SPRING` - If set, Spring will be bypassed and your
+  application will boot in a foreground process
+* `SPRING_LOG` - The path to a file which Spring will write log messages
+  to.
+* `SPRING_TMP_PATH` - The directory where Spring should write its temporary
+  files (a pidfile and a socket). By default we use the
+  `XDG_RUNTIME_DIR` environment variable, or else `Dir.tmpdir`, and then
+  create a directory in that named `spring-$UID`. We don't use your
+  Rails application's `tmp/` directory because that may be on a
+  filesystem which doesn't support UNIX sockets.
+* `SPRING_APPLICATION_ID` - Used to identify distinct Rails
+  applications. By default it is an MD5 hash of the current
+  `RUBY_VERSION`, and the path to your Rails project root.
+* `SPRING_SOCKET` - The path which should be used for the UNIX socket
+  which Spring uses to communicate with the long-running Spring server
+  process. By default this is `SPRING_TMP_PATH/SPRING_APPLICATION_ID`.
+* `SPRING_PIDFILE` - The path which should be used to store the pid of
+  the long-running Spring server process. By default this is related to
+  the socket path; if the socket path is `/foo/bar/spring.sock` the
+  pidfile will be `/foo/bar/spring.pid`.
+* `SPRING_SERVER_COMMAND` - The command to run to start up the spring
+  server when it is not already running. Defaults to `spring _[version]_
+  server --background`.
+
 ## Troubleshooting
 
 If you want to get more information about what spring is doing, you can
-specify a log file with the `SPRING_LOG` environment variable:
+run spring explicitly in a separate terminal:
 
 ```
-spring stop # if spring is already running
-export SPRING_LOG=/tmp/spring.log
-spring rake -T
+$ spring server
 ```
+
+Logging output will be printed to stdout. You can also send log output
+to a file with the `SPRING_LOG` environment variable.

data/lib/spring/application.rb

@@ -6,10 +6,10 @@ module Spring
   class Application
     attr_reader :manager, :watcher, :spring_env, :original_env
 
-    def initialize(manager, original_env)
+    def initialize(manager, original_env, spring_env = Env.new)
       @manager      = manager
       @original_env = original_env
-      @spring_env   = Env.new
+      @spring_env   = spring_env
       @mutex        = Mutex.new
       @waiting      = Set.new
       @preloaded    = false
@@ -149,11 +149,17 @@ module Spring
       setup command
 
       if Rails.application.reloaders.any?(&:updated?)
-        ActionDispatch::Reloader.cleanup!
-        ActionDispatch::Reloader.prepare!
+        # Rails 5.1 forward-compat. AD::R is deprecated to AS::R in Rails 5.
+        if defined? ActiveSupport::Reloader
+          Rails.application.reloader.reload!
+        else
+          ActionDispatch::Reloader.cleanup!
+          ActionDispatch::Reloader.prepare!
+        end
       end
 
       pid = fork {
+        Process.setsid
         IGNORE_SIGNALS.each { |sig| trap(sig, "DEFAULT") }
         trap("TERM", "DEFAULT")
 
@@ -313,6 +319,17 @@ module Spring
           exit_if_finished
         end
       }
+
+      Thread.new {
+        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

data/lib/spring/application/boot.rb

@@ -5,7 +5,8 @@ require "spring/application"
 
 app = Spring::Application.new(
   UNIXSocket.for_fd(3),
-  Spring::JSON.load(ENV.delete("SPRING_ORIGINAL_ENV").dup)
+  Spring::JSON.load(ENV.delete("SPRING_ORIGINAL_ENV").dup),
+  Spring::Env.new(log_file: IO.for_fd(4))
 )
 
 Signal.trap("TERM") { app.terminate }

data/lib/spring/application_manager.rb

@@ -2,9 +2,9 @@ module Spring
   class ApplicationManager
     attr_reader :pid, :child, :app_env, :spring_env, :status
 
-    def initialize(app_env)
+    def initialize(app_env, spring_env)
       @app_env    = app_env
-      @spring_env = Env.new
+      @spring_env = spring_env
       @mutex      = Mutex.new
       @state      = :running
     end
@@ -104,7 +104,8 @@ module Spring
           "-I", File.expand_path("../..", $LOADED_FEATURES.grep(/bundler\/setup\.rb$/).first),
           "-I", File.expand_path("../..", __FILE__),
           "-e", "require 'spring/application/boot'",
-          3 => child_socket
+          3 => child_socket,
+          4 => spring_env.log_file,
         )
       end
 

data/lib/spring/client.rb

@@ -9,6 +9,7 @@ require "spring/client/stop"
 require "spring/client/status"
 require "spring/client/rails"
 require "spring/client/version"
+require "spring/client/server"
 
 module Spring
   module Client
@@ -22,6 +23,7 @@ module Spring
       "rails"     => Client::Rails,
       "-v"        => Client::Version,
       "--version" => Client::Version,
+      "server"    => Client::Server,
     }
 
     def self.run(args)

data/lib/spring/client/run.rb

@@ -6,31 +6,36 @@ module Spring
   module Client
     class Run < Command
       FORWARDED_SIGNALS = %w(INT QUIT USR1 USR2 INFO WINCH) & Signal.list.keys
-      TIMEOUT = 1
+      CONNECT_TIMEOUT   = 1
+      BOOT_TIMEOUT      = 10
+
+      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
-        if env.server_running?
-          warm_run
-        else
+        begin
+          connect
+        rescue Errno::ENOENT, Errno::ECONNRESET, Errno::ECONNREFUSED
           cold_run
+        else
+          warm_run
         end
-      rescue Errno::ECONNRESET
-        exit 1
       ensure
-        server.close if @server
+        server.close if server
       end
 
       def warm_run
@@ -49,6 +54,7 @@ module Spring
 
       def cold_run
         boot_server
+        connect
         run
       end
 
@@ -60,24 +66,37 @@ module Spring
         queue_signals
         connect_to_application(client)
         run_command(client, application)
+      rescue Errno::ECONNRESET
+        exit 1
       end
 
       def boot_server
         env.socket_path.unlink if env.socket_path.exist?
 
-        pid = Process.spawn(
-          gem_env,
-          "ruby",
-          "-e", "gem 'spring', '#{Spring::VERSION}'; require 'spring/server'; Spring::Server.boot"
-        )
+        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)
-          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 #{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)
@@ -97,13 +116,17 @@ module Spring
       def verify_server_version
         server_version = server.gets.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.
-
-CLIENT: #{env.version}, SERVER: #{server_version}
-ERROR
-          exit 1
+          $stderr.puts "There is a version mismatch between the spring client " \
+                         "(#{env.version}) and the server (#{server_version})."
+
+          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
 
@@ -111,7 +134,7 @@ ERROR
         server.send_io client
         send_json server, "args" => args, "default_rails_env" => default_rails_env
 
-        if IO.select([server], [], [], TIMEOUT)
+        if IO.select([server], [], [], CONNECT_TIMEOUT)
           server.gets or raise CommandNotFound
         else
           raise "Error connecting to Spring server"
@@ -138,7 +161,7 @@ ERROR
         if pid && !pid.empty?
           log "got pid: #{pid}"
 
-          forward_signals(pid.to_i)
+          forward_signals(application)
           status = application.read.to_i
 
           log "got exit status #{status}"
@@ -158,26 +181,26 @@ ERROR
         end
       end
 
-      def forward_signals(pid)
-        @signal_queue.each { |sig| kill sig, pid }
+      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)

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/env.rb

@@ -14,10 +14,10 @@ module Spring
   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
@@ -33,17 +33,20 @@ module Spring
     end
 
     def tmp_path
-      path = Pathname.new(File.join(ENV['XDG_RUNTIME_DIR'] || Dir.tmpdir, "spring-#{Process.uid}"))
+      path = Pathname.new(
+        ENV["SPRING_TMP_PATH"] ||
+          File.join(ENV['XDG_RUNTIME_DIR'] || Dir.tmpdir, "spring-#{Process.uid}")
+      )
       FileUtils.mkdir_p(path) unless path.exist?
       path
     end
 
     def application_id
-      Digest::MD5.hexdigest(RUBY_VERSION + project_root.to_s)
+      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
@@ -51,7 +54,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
@@ -105,5 +108,9 @@ module Spring
     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/server.rb

@@ -10,19 +10,24 @@ require "spring/commands"
 
 module Spring
   class Server
-    def self.boot
-      new.boot
+    def self.boot(options = {})
+      new(options).boot
     end
 
     attr_reader :env
 
-    def initialize(env = Env.new)
-      @env          = env
-      @applications = Hash.new { |h, k| h[k] = ApplicationManager.new(k) }
+    def initialize(options = {})
+      @foreground   = options.fetch(:foreground, false)
+      @env          = options[:env] || default_env
+      @applications = Hash.new { |h, k| h[k] = ApplicationManager.new(k, env) }
       @pidfile      = env.pidfile_path.open('a')
       @mutex        = Mutex.new
     end
 
+    def foreground?
+      @foreground
+    end
+
     def log(message)
       env.log "[server] #{message}"
     end
@@ -31,8 +36,8 @@ module Spring
       Spring.verify_environment
 
       write_pidfile
-      set_pgid
-      ignore_signals
+      set_pgid unless foreground?
+      ignore_signals unless foreground?
       set_exit_hook
       set_process_title
       start_server
@@ -42,6 +47,7 @@ module Spring
       server = UNIXServer.open(env.socket_name)
       log "started on #{env.socket_name}"
       loop { serve server.accept }
+    rescue Interrupt
     end
 
     def serve(client)
@@ -126,5 +132,19 @@ module Spring
         "spring server | #{env.app_name} | started #{distance} ago"
       }
     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/spring/test/acceptance_test.rb

@@ -28,6 +28,10 @@ module Spring
         @app ||= Spring::Test::Application.new("#{Spring::Test.root}/apps/tmp")
       end
 
+      def spring_env
+        app.spring_env
+      end
+
       def assert_output(artifacts, expected)
         expected.each do |stream, output|
           assert artifacts[stream].include?(output),
@@ -92,14 +96,14 @@ module Spring
 
       test "help message when called without arguments" do
         assert_success "bin/spring", stdout: 'Usage: spring COMMAND [ARGS]'
-        assert app.spring_env.server_running?
+        assert spring_env.server_running?
       end
 
       test "shows help" do
         assert_success "bin/spring help", stdout: 'Usage: spring COMMAND [ARGS]'
         assert_success "bin/spring -h", stdout: 'Usage: spring COMMAND [ARGS]'
         assert_success "bin/spring --help", stdout: 'Usage: spring COMMAND [ARGS]'
-        refute app.spring_env.server_running?
+        refute spring_env.server_running?
       end
 
       test "tells the user that spring is being used when used automatically via binstubs" do
@@ -184,10 +188,10 @@ module Spring
 
       test "stop command kills server" do
         app.run app.spring_test_command
-        assert app.spring_env.server_running?, "The server should be running but it isn't"
+        assert spring_env.server_running?, "The server should be running but it isn't"
 
         assert_success "bin/spring stop"
-        assert !app.spring_env.server_running?, "The server should not be running but it is"
+        assert !spring_env.server_running?, "The server should not be running but it is"
       end
 
       test "custom commands" do
@@ -400,7 +404,7 @@ module Spring
       end
 
       test "can define client tasks" do
-        File.write("#{app.spring_config.sub('.rb', '_client.rb')}", <<-RUBY)
+        File.write("#{app.spring_client_config}", <<-RUBY)
           Spring::Client::COMMANDS["foo"] = lambda { |args| puts "bar -- \#{args.inspect}" }
         RUBY
         assert_success "bin/spring foo --baz", stdout: "bar -- [\"foo\", \"--baz\"]\n"
@@ -508,6 +512,28 @@ module Spring
           2.times { assert_success "bundle exec rails runner ''" }
         end
       end
+
+      test "booting a foreground server" do
+        FileUtils.cd(app.root) do
+          assert !spring_env.server_running?
+          app.run "spring server &"
+
+          Timeout.timeout(1) do
+            sleep 0.1 until spring_env.server_running?
+          end
+
+          assert_success app.spring_test_command
+        end
+      end
+
+      test "server boot timeout" do
+        app.env["SPRING_SERVER_COMMAND"] = "sleep 1"
+        File.write("#{app.spring_client_config}", %(
+          Spring::Client::Run.const_set(:BOOT_TIMEOUT, 0.1)
+        ))
+
+        assert_failure "bin/rails runner ''", stderr: "timed out"
+      end
     end
   end
 end

data/lib/spring/test/application.rb

@@ -9,7 +9,7 @@ module Spring
 
       def initialize(root)
         @root       = Pathname.new(root)
-        @spring_env = Spring::Env.new(root)
+        @spring_env = Spring::Env.new(root: root)
       end
 
       def exists?
@@ -88,6 +88,10 @@ module Spring
         path "config/spring.rb"
       end
 
+      def spring_client_config
+        path "config/spring_client.rb"
+      end
+
       def run(command, opts = {})
         start_time = Time.now
 
@@ -117,7 +121,7 @@ module Spring
 
         output.merge(status: status, command: command)
       rescue Timeout::Error => e
-        raise e, "Output:\n\n#{dump_streams(command, read_streams)}"
+        raise Timeout::Error, "While running command:\n\n#{dump_streams(command, read_streams)}"
       end
 
       def with_timing

data/lib/spring/test/application_generator.rb

@@ -58,6 +58,10 @@ module Spring
           append_to_file(application.gemfile, "gem 'spring-commands-testunit'")
         end
 
+        if RUBY_VERSION == "1.9.3"
+          append_to_file(application.gemfile, "gem 'mime-types', '~> 2'")
+        end
+
         rewrite_file(application.gemfile) do |c|
           c.sub!("https://rubygems.org", "http://rubygems.org")
           c.gsub!(/(gem '(byebug|web-console|sdoc|jbuilder)')/, "# \\1")

data/lib/spring/version.rb

@@ -1,3 +1,3 @@
 module Spring
-  VERSION = "1.6.4"
+  VERSION = "1.7.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spring
 version: !ruby/object:Gem::Version
-  version: 1.6.4
+  version: 1.7.1
 platform: ruby
 authors:
 - Jon Leighton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-26 00:00:00.000000000 Z
+date: 2016-04-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -75,6 +75,7 @@ files:
 - lib/spring/client/help.rb
 - lib/spring/client/rails.rb
 - lib/spring/client/run.rb
+- lib/spring/client/server.rb
 - lib/spring/client/status.rb
 - lib/spring/client/stop.rb
 - lib/spring/client/version.rb