spring 1.0.0 → 1.3.0

data/lib/spring/application.rb

@@ -1,41 +1,84 @@
+require "spring/boot"
 require "set"
-require "spring/watcher"
-require "thread"
+require "pty"
 
 module Spring
   class Application
-    attr_reader :manager, :watcher, :spring_env
+    attr_reader :manager, :watcher, :spring_env, :original_env
+
+    def initialize(manager, original_env)
+      @manager      = manager
+      @original_env = original_env
+      @spring_env   = Env.new
+      @mutex        = Mutex.new
+      @waiting      = Set.new
+      @preloaded    = false
+      @state        = :initialized
+      @interrupt    = IO.pipe
+    end
 
-    def initialize(manager, watcher = Spring.watcher)
-      @manager    = manager
-      @watcher    = watcher
-      @setup      = Set.new
-      @spring_env = Env.new
-      @preloaded  = false
-      @mutex      = Mutex.new
-      @waiting    = 0
-      @exiting    = false
+    def state(val)
+      return if exiting?
+      log "#{@state} -> #{val}"
+      @state = val
+    end
 
-      # Workaround for GC bug in Ruby 2 which causes segfaults if watcher.to_io
-      # instances get dereffed.
-      @fds = [manager, watcher.to_io]
+    def state!(val)
+      state val
+      @interrupt.last.write "."
+    end
+
+    def app_env
+      ENV['RAILS_ENV']
+    end
+
+    def app_name
+      spring_env.app_name
     end
 
     def log(message)
-      spring_env.log "[application:#{ENV['RAILS_ENV']}] #{message}"
+      spring_env.log "[application:#{app_env}] #{message}"
     end
 
     def preloaded?
       @preloaded
     end
 
+    def preload_failed?
+      @preloaded == :failure
+    end
+
     def exiting?
-      @exiting
+      @state == :exiting
+    end
+
+    def terminating?
+      @state == :terminating
+    end
+
+    def watcher_stale?
+      @state == :watcher_stale
+    end
+
+    def initialized?
+      @state == :initialized
+    end
+
+    def start_watcher
+      @watcher = Spring.watcher
+      @watcher.on_stale { state! :watcher_stale }
+      @watcher.start
     end
 
     def preload
       log "preloading app"
 
+      begin
+        require "spring/commands"
+      ensure
+        start_watcher
+      end
+
       require Spring.application_root_path.join("config", "application")
 
       # config/environments/test.rb will have config.cache_classes = true. However
@@ -48,47 +91,54 @@ module Spring
 
       require Spring.application_root_path.join("config", "environment")
 
+      @original_cache_classes = Rails.application.config.cache_classes
       Rails.application.config.cache_classes = false
+
       disconnect_database
 
+      @preloaded = :success
+    rescue Exception => e
+      @preloaded = :failure
+      watcher.add e.backtrace.map { |line| line.match(/^(.*)\:\d+\:in /)[1] }
+      raise e unless initialized?
+    ensure
       watcher.add loaded_application_features
       watcher.add Spring.gemfile, "#{Spring.gemfile}.lock"
-      watcher.add Rails.application.paths["config/initializers"]
 
-      @preloaded = true
+      if defined?(Rails) && Rails.application
+        watcher.add Rails.application.paths["config/initializers"]
+        watcher.add Rails.application.paths["config/database"]
+        if secrets_path = Rails.application.paths["config/secrets"]
+          watcher.add secrets_path
+        end
+      end
+    end
+
+    def eager_preload
+      with_pty { preload }
     end
 
     def run
-      log "running"
-      watcher.start
+      state :running
+      manager.puts
 
       loop do
-        IO.select(@fds)
-
-        if watcher.stale?
-          log "watcher stale; exiting"
-          manager.close
-          @exiting = true
-          try_exit
-          sleep
+        IO.select [manager, @interrupt.first]
+
+        if terminating? || watcher_stale? || preload_failed?
+          exit
         else
           serve manager.recv_io(UNIXSocket)
         end
       end
     end
 
-    def try_exit
-      @mutex.synchronize {
-        exit if exiting? && @waiting == 0
-      }
-    end
-
     def serve(client)
       log "got client"
       manager.puts
 
-      streams = 3.times.map { client.recv_io }
-      [STDOUT, STDERR].zip(streams).each { |a, b| a.reopen(b) }
+      stdout, stderr, stdin = streams = 3.times.map { client.recv_io }
+      [STDOUT, STDERR, STDIN].zip(streams).each { |a, b| a.reopen(b) }
 
       preload unless preloaded?
 
@@ -104,74 +154,84 @@ module Spring
       end
 
       pid = fork {
-        Process.setsid
-        STDIN.reopen(streams.last)
         IGNORE_SIGNALS.each { |sig| trap(sig, "DEFAULT") }
+        trap("TERM", "DEFAULT")
 
         ARGV.replace(args)
+        $0 = command.exec_name
 
         # Delete all env vars which are unchanged from before spring started
-        Spring.original_env.each { |k, v| ENV.delete k if ENV[k] == v }
+        original_env.each { |k, v| ENV.delete k if ENV[k] == v }
 
         # 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
 
-        if command.respond_to?(:call)
-          command.call
-        else
-          exec_name = command.exec_name
-          gem_name  = command.gem_name if command.respond_to?(:gem_name)
-
-          exec = Gem.bin_path(gem_name || exec_name, exec_name)
-          $0 = exec
-          load exec
-        end
+        command.call
       }
 
       disconnect_database
-      [STDOUT, STDERR].each { |stream| stream.reopen(spring_env.log_file) }
+      reset_streams
 
       log "forked #{pid}"
       manager.puts pid
 
-      # Wait in a separate thread so we can run multiple commands at once
-      Thread.new {
-        @mutex.synchronize { @waiting += 1 }
-
-        _, status = Process.wait2 pid
-        log "#{pid} exited with #{status.exitstatus}"
+      wait pid, streams, client
+    rescue Exception => e
+      log "exception: #{e}"
+      manager.puts unless pid
 
+      if streams && !e.is_a?(SystemExit)
+        print_exception(stderr, e)
         streams.each(&:close)
-        client.puts(status.exitstatus)
-        client.close
-
-        @mutex.synchronize { @waiting -= 1 }
-        try_exit
-      }
+      end
 
-    rescue => e
-      log "exception: #{e}"
-      streams.each(&:close) if streams
-      client.puts(1)
+      client.puts(1) if pid
       client.close
-      raise
+    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
 
     # The command might need to require some files in the
     # main process so that they are cached. For example a test command wants to
     # load the helper file once and have it cached.
     def setup(command)
-      return if @setup.include?(command.class)
-      @setup << command.class
-
-      if command.respond_to?(:setup)
-        command.setup
+      if command.setup
         watcher.add loaded_application_features # loaded features may have changed
       end
     end
@@ -183,15 +243,16 @@ module Spring
     end
 
     def loaded_application_features
-      $LOADED_FEATURES.select { |f| f.start_with?(File.realpath(Rails.root)) }
+      root = Spring.application_root_path.to_s
+      $LOADED_FEATURES.select { |f| f.start_with?(root) }
     end
 
     def disconnect_database
-      ActiveRecord::Base.remove_connection if defined?(ActiveRecord::Base)
+      ActiveRecord::Base.remove_connection if active_record_configured?
     end
 
     def connect_database
-      ActiveRecord::Base.establish_connection if defined?(ActiveRecord::Base)
+      ActiveRecord::Base.establish_connection if active_record_configured?
     end
 
     # This feels very naughty
@@ -209,7 +270,53 @@ module Spring
             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 }
+        Thread.new { master.read }
+        yield
+        reset_streams
+      end
+    end
+
+    def reset_streams
+      [STDOUT, STDERR].each { |stream| stream.reopen(spring_env.log_file) }
+      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
+      Thread.new {
+        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
+      }
+    end
+
+    private
+
+    def active_record_configured?
+      defined?(ActiveRecord::Base) && ActiveRecord::Base.configurations.any?
+    end
   end
 end

data/lib/spring/application_manager.rb

@@ -1,20 +1,16 @@
-require "socket"
-require "thread"
-require "spring/application"
-
 module Spring
   class ApplicationManager
-    attr_reader :pid, :child, :app_env, :spring_env, :server
+    attr_reader :pid, :child, :app_env, :spring_env, :status
 
-    def initialize(server, app_env)
-      @server     = server
+    def initialize(app_env)
       @app_env    = app_env
       @spring_env = Env.new
       @mutex      = Mutex.new
+      @state      = :running
     end
 
     def log(message)
-      server.log(message)
+      spring_env.log "[application_manager:#{app_env}] #{message}"
     end
 
     # We're not using @mutex.synchronize to avoid the weird "<internal:prelude>:10"
@@ -28,10 +24,10 @@ module Spring
 
     def start
       start_child
-      start_wait_thread
     end
 
     def restart
+      return if @state == :stopping
       start_child(true)
     end
 
@@ -63,13 +59,15 @@ module Spring
     def run(client)
       with_child do
         child.send_io client
-        child.gets
+        child.gets or raise Errno::EPIPE
       end
 
-      pid = child.gets
-      pid = pid.chomp.to_i if pid
-      log "got worker pid #{pid}"
-      pid
+      pid = child.gets.to_i
+
+      unless pid.zero?
+        log "got worker pid #{pid}"
+        pid
+      end
     rescue Errno::ECONNRESET, Errno::EPIPE => e
       log "#{e} while reading from child; returning no pid"
       nil
@@ -78,45 +76,61 @@ module Spring
     end
 
     def stop
-      Process.kill('TERM', pid) if pid
+      log "stopping"
+      @state = :stopping
+
+      if pid
+        Process.kill('TERM', pid)
+        Process.wait(pid)
+      end
+    rescue Errno::ESRCH, Errno::ECHILD
+      # Don't care
     end
 
     private
 
     def start_child(preload = false)
-      server.application_starting
-
       @child, child_socket = UNIXSocket.pair
-      @pid = fork {
-        (ObjectSpace.each_object(IO).to_a - [STDOUT, STDERR, STDIN, child_socket])
-          .reject(&:closed?)
-          .each(&:close)
 
-        ENV['RAILS_ENV'] = ENV['RACK_ENV'] = app_env
-
-        ProcessTitleUpdater.run { |distance|
-          "spring app    | #{spring_env.app_name} | started #{distance} ago | #{app_env} mode"
-        }
+      Bundler.with_clean_env do
+        @pid = Process.spawn(
+          {
+            "RAILS_ENV"           => app_env,
+            "RACK_ENV"            => app_env,
+            "SPRING_ORIGINAL_ENV" => JSON.dump(Spring::ORIGINAL_ENV),
+            "SPRING_PRELOAD"      => preload ? "1" : "0"
+          },
+          "ruby",
+          "-I", File.expand_path("../..", __FILE__),
+          "-e", "require 'spring/application/boot'",
+          3 => child_socket
+        )
+      end
 
-        app = Application.new(child_socket)
-        app.preload if preload
-        app.run
-      }
+      start_wait_thread(pid, child) if child.gets
       child_socket.close
     end
 
-    def start_wait_thread
-      @wait_thread = Thread.new {
-        Thread.current.abort_on_exception = true
+    def start_wait_thread(pid, child)
+      Process.detach(pid)
 
-        while alive?
-          _, status = Process.wait2(pid)
-          @pid = nil
-
-          # In the forked child, this will block forever, so we won't
-          # return to the next iteration of the loop.
-          synchronize { restart if !alive? && status.success? }
+      Thread.new {
+        # The recv can raise an ECONNRESET, killing the thread, but that's ok
+        # as if it does we're no longer interested in the child
+        loop do
+          IO.select([child])
+          break if child.recv(1, Socket::MSG_PEEK).empty?
+          sleep 0.01
         end
+
+        log "child #{pid} shutdown"
+
+        synchronize {
+          if @pid == pid
+            @pid = nil
+            restart
+          end
+        }
       }
     end
   end

data/lib/spring/binstub.rb

@@ -0,0 +1,13 @@
+command  = File.basename($0)
+bin_path = File.expand_path("../../../bin/spring", __FILE__)
+
+if command == "spring"
+  load bin_path
+else
+  disable = ENV["DISABLE_SPRING"]
+
+  if Process.respond_to?(:fork) && (disable.nil? || disable.empty? || disable == "0")
+    ARGV.unshift(command)
+    load bin_path
+  end
+end

data/lib/spring/boot.rb

@@ -0,0 +1,8 @@
+require "socket"
+require "thread"
+
+require "spring/configuration"
+require "spring/env"
+require "spring/process_title_updater"
+require "spring/json"
+require "spring/watcher"