spring 0.0.8 → 1.0.0

data/lib/spring/application.rb

@@ -1,87 +1,162 @@
 require "set"
-require "json"
-
-require "spring/configuration"
 require "spring/watcher"
+require "thread"
 
 module Spring
   class Application
-    attr_reader :manager, :watcher
+    attr_reader :manager, :watcher, :spring_env
 
     def initialize(manager, watcher = Spring.watcher)
-      @manager = manager
-      @watcher = watcher
-      @setup   = Set.new
+      @manager    = manager
+      @watcher    = watcher
+      @setup      = Set.new
+      @spring_env = Env.new
+      @preloaded  = false
+      @mutex      = Mutex.new
+      @waiting    = 0
+      @exiting    = false
 
       # Workaround for GC bug in Ruby 2 which causes segfaults if watcher.to_io
       # instances get dereffed.
       @fds = [manager, watcher.to_io]
     end
 
-    def start
+    def log(message)
+      spring_env.log "[application:#{ENV['RAILS_ENV']}] #{message}"
+    end
+
+    def preloaded?
+      @preloaded
+    end
+
+    def exiting?
+      @exiting
+    end
+
+    def preload
+      log "preloading app"
+
       require Spring.application_root_path.join("config", "application")
 
-      # The test environment has config.cache_classes = true set by default.
-      # However, we don't want this to prevent us from performing class reloading,
-      # so this gets around that.
+      # config/environments/test.rb will have config.cache_classes = true. However
+      # we want it to be false so that we can reload files. This is a hack to
+      # override the effect of config.cache_classes = true. We can then actually
+      # set config.cache_classes = false after loading the environment.
       Rails::Application.initializer :initialize_dependency_mechanism, group: :all do
         ActiveSupport::Dependencies.mechanism = :load
       end
 
       require Spring.application_root_path.join("config", "environment")
 
+      Rails.application.config.cache_classes = false
+      disconnect_database
+
       watcher.add loaded_application_features
-      watcher.add "Gemfile", "Gemfile.lock"
+      watcher.add Spring.gemfile, "#{Spring.gemfile}.lock"
       watcher.add Rails.application.paths["config/initializers"]
 
-      run
+      @preloaded = true
     end
 
     def run
+      log "running"
       watcher.start
 
       loop do
         IO.select(@fds)
 
         if watcher.stale?
-          exit
+          log "watcher stale; exiting"
+          manager.close
+          @exiting = true
+          try_exit
+          sleep
         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 }
-      args    = JSON.parse(client.read(client.gets.to_i))
-      command = Spring.command(args.shift)
+      [STDOUT, STDERR].zip(streams).each { |a, b| a.reopen(b) }
+
+      preload unless preloaded?
+
+      args, env = JSON.load(client.read(client.gets.to_i)).values_at("args", "env")
+      command   = Spring.command(args.shift)
 
+      connect_database
       setup command
 
-      ActionDispatch::Reloader.cleanup!
-      ActionDispatch::Reloader.prepare!
+      if Rails.application.reloaders.any?(&:updated?)
+        ActionDispatch::Reloader.cleanup!
+        ActionDispatch::Reloader.prepare!
+      end
 
       pid = fork {
         Process.setsid
-        [STDOUT, STDERR, STDIN].zip(streams).each { |a, b| a.reopen(b) }
+        STDIN.reopen(streams.last)
         IGNORE_SIGNALS.each { |sig| trap(sig, "DEFAULT") }
+
+        ARGV.replace(args)
+
+        # Delete all env vars which are unchanged from before spring started
+        Spring.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 }
+
+        connect_database
+        srand
+
         invoke_after_fork_callbacks
-        command.call(args)
+        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
       }
 
+      disconnect_database
+      [STDOUT, STDERR].each { |stream| stream.reopen(spring_env.log_file) }
+
+      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}"
+
         streams.each(&:close)
         client.puts(status.exitstatus)
         client.close
+
+        @mutex.synchronize { @waiting -= 1 }
+        try_exit
       }
 
     rescue => e
+      log "exception: #{e}"
       streams.each(&:close) if streams
       client.puts(1)
       client.close
@@ -110,5 +185,31 @@ module Spring
     def loaded_application_features
       $LOADED_FEATURES.select { |f| f.start_with?(File.realpath(Rails.root)) }
     end
+
+    def disconnect_database
+      ActiveRecord::Base.remove_connection if defined?(ActiveRecord::Base)
+    end
+
+    def connect_database
+      ActiveRecord::Base.establish_connection if defined?(ActiveRecord::Base)
+    end
+
+    # This feels very naughty
+    def shush_backtraces
+      Kernel.module_eval do
+        old_raise = Kernel.method(:raise)
+        remove_method :raise
+        define_method :raise do |*args|
+          begin
+            old_raise.call(*args)
+          ensure
+            if $!
+              lib = File.expand_path("..", __FILE__)
+              $!.backtrace.reject! { |line| line.start_with?(lib) }
+            end
+          end
+        end
+      end
+    end
   end
 end

data/lib/spring/application_manager.rb

@@ -4,16 +4,19 @@ require "spring/application"
 
 module Spring
   class ApplicationManager
-    attr_reader :pid, :child, :app_env, :spring_env
-
-    def initialize(app_env)
-      super()
+    attr_reader :pid, :child, :app_env, :spring_env, :server
 
+    def initialize(server, app_env)
+      @server     = server
       @app_env    = app_env
       @spring_env = Env.new
       @mutex      = Mutex.new
     end
 
+    def log(message)
+      server.log(message)
+    end
+
     # We're not using @mutex.synchronize to avoid the weird "<internal:prelude>:10"
     # line which messes with backtraces in e.g. rspec
     def synchronize
@@ -29,9 +32,6 @@ module Spring
     end
 
     def restart
-      # Restarting is a background operation. If it fails, we don't want
-      # any terminal output. The user will see the output when they next
-      # try to run a command.
       start_child(true)
     end
 
@@ -47,10 +47,12 @@ module Spring
           rescue Errno::ECONNRESET, Errno::EPIPE
             # The child has died but has not been collected by the wait thread yet,
             # so start a new child and try again.
+            log "child dead; starting"
             start
             yield
           end
         else
+          log "child not running; starting"
           start
           yield
         end
@@ -64,8 +66,12 @@ module Spring
         child.gets
       end
 
-      child.gets.chomp.to_i # get the pid
-    rescue Errno::ECONNRESET, Errno::EPIPE
+      pid = child.gets
+      pid = pid.chomp.to_i if pid
+      log "got worker pid #{pid}"
+      pid
+    rescue Errno::ECONNRESET, Errno::EPIPE => e
+      log "#{e} while reading from child; returning no pid"
       nil
     ensure
       client.close
@@ -77,11 +83,11 @@ module Spring
 
     private
 
-    def start_child(silence = false)
+    def start_child(preload = false)
+      server.application_starting
+
       @child, child_socket = UNIXSocket.pair
       @pid = fork {
-        [STDOUT, STDERR].each { |s| s.reopen('/dev/null', 'w') } if silence
-
         (ObjectSpace.each_object(IO).to_a - [STDOUT, STDERR, STDIN, child_socket])
           .reject(&:closed?)
           .each(&:close)
@@ -92,7 +98,9 @@ module Spring
           "spring app    | #{spring_env.app_name} | started #{distance} ago | #{app_env} mode"
         }
 
-        Application.new(child_socket).start
+        app = Application.new(child_socket)
+        app.preload if preload
+        app.run
       }
       child_socket.close
     end

data/lib/spring/client/binstub.rb

@@ -1,10 +1,10 @@
 module Spring
   module Client
     class Binstub < Command
-      attr_reader :bindir, :name
+      attr_reader :bindir, :commands
 
       def self.description
-        "Generate spring based binstubs."
+        "Generate spring based binstubs. Use --all to generate a binstub for all known commands."
       end
 
       def self.call(args)
@@ -12,64 +12,68 @@ module Spring
         super
       end
 
+      class RailsCommand
+        def fallback
+          <<CODE
+APP_PATH = File.expand_path('../../config/application',  __FILE__)
+require_relative '../config/boot'
+require 'rails/commands'
+CODE
+        end
+      end
+
       def initialize(args)
         super
 
-        @bindir = env.root.join("bin")
-        @name   = args[1]
+        @bindir   = env.root.join("bin")
+        @commands = args.drop(1).inject({}) { |mem, name| mem.merge(find_commands(name)) }
       end
 
-      def call
-        if Spring.command?(name) || name == "rails"
-          bindir.mkdir unless bindir.exist?
-          generate_spring_binstub
-          generate_command_binstub
+      def find_commands(name)
+        case name
+        when "--all"
+          commands = Spring.commands
+          commands.delete_if { |name, _| name.start_with?("rails_") }
+          commands["rails"] = RailsCommand.new
+          commands
+        when "rails"
+          { name => RailsCommand.new }
         else
-          $stderr.puts "The '#{name}' command is not known to spring."
-          exit 1
+          if command = Spring.commands[name]
+            { name => command }
+          else
+            $stderr.puts "The '#{name}' command is not known to spring."
+            exit 1
+          end
         end
       end
 
-      def spring_binstub
-        bindir.join("spring")
-      end
-
-      def command_binstub
-        bindir.join(name)
+      def call
+        bindir.mkdir unless bindir.exist?
+        commands.each { |name, command| generate_binstub(name, command) }
       end
 
-      def generate_spring_binstub
-        File.write(spring_binstub, <<'CODE')
+      def generate_binstub(name, command)
+        File.write(bindir.join(name), <<CODE)
 #!/usr/bin/env ruby
 
-# This is a special way of invoking the spring gem in order to
-# work around the performance issue discussed in
-# https://github.com/rubygems/rubygems/pull/435
-
-glob       = "{#{Gem::Specification.dirs.join(",")}}/spring-*.gemspec"
-candidates = Dir[glob].to_a.sort
-
-spec = Gem::Specification.load(candidates.last)
-
-if spec
-  spec.activate
-  load spec.bin_file("spring")
+if !Process.respond_to?(:fork) || Gem::Specification.find_all_by_name("spring").empty?
+#{fallback(name, command).strip.gsub(/^/, "  ")}
 else
-  $stderr.puts "Could not find spring gem in #{Gem::Specification.dirs.join(", ")}."
-  exit 1
+  ARGV.unshift "#{name}"
+  load Gem.bin_path("spring", "spring")
 end
 CODE
 
-        spring_binstub.chmod 0755
+        bindir.join(name).chmod 0755
       end
 
-      def generate_command_binstub
-        File.write(command_binstub, <<CODE)
-#!/usr/bin/env bash
-exec $(dirname $0)/spring #{name} "$@"
-CODE
-
-        command_binstub.chmod 0755
+      def fallback(name, command)
+        if command.respond_to?(:fallback)
+          command.fallback
+        else
+          %{exec "bundle", "exec", "#{name}", *ARGV}
+        end
       end
     end
   end

data/lib/spring/client/help.rb

@@ -28,7 +28,8 @@ module Spring
       end
 
       def formatted_help
-        ["Usage: spring COMMAND [ARGS]\n",
+        ["Version: #{env.version}\n",
+         "Usage: spring COMMAND [ARGS]\n",
          *command_help("spring itself", spring_commands),
          '',
          *command_help("your application", application_commands)].join("\n")
@@ -48,6 +49,8 @@ module Spring
       def description_for_command(command)
         if command.respond_to?(:description)
           command.description
+        elsif command.respond_to?(:exec_name)
+          "Runs the #{command.exec_name} command"
         else
           "No description given."
         end

data/lib/spring/client/rails.rb

@@ -3,12 +3,13 @@ require "set"
 module Spring
   module Client
     class Rails < Command
-      COMMANDS = Set.new %w(console runner generate)
+      COMMANDS = Set.new %w(console runner generate destroy)
 
       ALIASES = {
         "c" => "console",
         "r" => "runner",
-        "g" => "generate"
+        "g" => "generate",
+        "d" => "destroy"
       }
 
       def self.description
@@ -21,7 +22,11 @@ module Spring
         if COMMANDS.include?(command_name)
           Run.call(["rails_#{command_name}", *args.drop(2)])
         else
-          exec "bundle", "exec", *args
+          require "spring/configuration"
+          ARGV.shift
+          Object.const_set(:APP_PATH, Spring.application_root_path.join("config/application").to_s)
+          require Spring.application_root_path.join("config/boot")
+          require "rails/commands"
         end
       end
     end

data/lib/spring/client/run.rb

@@ -1,19 +1,20 @@
 require "rbconfig"
 require "socket"
-require "json"
 
 module Spring
   module Client
     class Run < Command
       FORWARDED_SIGNALS = %w(INT QUIT USR1 USR2 INFO) & Signal.list.keys
 
+      def log(message)
+        env.log "[client] #{message}"
+      end
+
       def server
         @server ||= UNIXSocket.open(env.socket_name)
       end
 
       def call
-        Spring.verify_environment!
-
         boot_server unless env.server_running?
         verify_server_version
 
@@ -29,15 +30,24 @@ module Spring
 
       def boot_server
         env.socket_path.unlink if env.socket_path.exist?
-        Process.spawn("spring", "start")
-        sleep 0.1 until env.socket_path.exist?
+
+        pid = fork {
+          require "spring/server"
+          Spring::Server.boot
+        }
+
+        until env.socket_path.exist?
+          _, status = Process.waitpid2(pid, Process::WNOHANG)
+          exit status.exitstatus if status
+          sleep 0.1
+        end
       end
 
       def verify_server_version
         server_version = server.gets.chomp
         if server_version != env.version
           $stderr.puts <<-ERROR
-There is a version mismatch beween the spring client and the server.
+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}
@@ -48,16 +58,18 @@ ERROR
 
       def connect_to_application(client)
         server.send_io client
-        send_json server, args: args, env: ENV
+        send_json server, "args" => args, "default_rails_env" => default_rails_env
         server.gets or raise CommandNotFound
       end
 
       def run_command(client, application)
+        log "sending command"
+
         application.send_io STDOUT
         application.send_io STDERR
         application.send_io STDIN
 
-        send_json application, args
+        send_json application, "args" => args, "env" => ENV.to_hash
 
         pid = server.gets
         pid = pid.chomp if pid
@@ -68,9 +80,16 @@ ERROR
         client.close
 
         if pid && !pid.empty?
+          log "got pid: #{pid}"
+
           forward_signals(pid.to_i)
-          exit application.read.to_i
+          status = application.read.to_i
+
+          log "got exit status #{status}"
+
+          exit status
         else
+          log "got no pid"
           exit 1
         end
       ensure
@@ -95,9 +114,13 @@ ERROR
       def send_json(socket, data)
         data = JSON.dump(data)
 
-        socket.puts  data.length
+        socket.puts  data.bytesize
         socket.write data
       end
+
+      def default_rails_env
+        ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
+      end
     end
   end
 end

data/lib/spring/client/status.rb

@@ -21,8 +21,8 @@ module Spring
       end
 
       def application_pids
-        candidates = `ps -a -o ppid= -o pid=`.lines
-        candidates.select { |l| l =~ /^#{env.pid} / }
+        candidates = `ps -A -o ppid= -o pid=`.lines
+        candidates.select { |l| l =~ /^(\s+)?#{env.pid} / }
                   .map    { |l| l.split(" ").last   }
       end
     end

data/lib/spring/client.rb

@@ -1,9 +1,10 @@
-require "spring/configuration"
+require "spring/errors"
+require "spring/json"
+
 require "spring/client/command"
 require "spring/client/run"
 require "spring/client/help"
 require "spring/client/binstub"
-require "spring/client/start"
 require "spring/client/stop"
 require "spring/client/status"
 require "spring/client/rails"
@@ -13,7 +14,6 @@ module Spring
     COMMANDS = {
       "help"    => Client::Help,
       "binstub" => Client::Binstub,
-      "start"   => Client::Start,
       "stop"    => Client::Stop,
       "status"  => Client::Status,
       "rails"   => Client::Rails

data/lib/spring/commands/rails.rb

@@ -0,0 +1,60 @@
+module Spring
+  module Commands
+    class Rails
+      def call
+        ARGV.unshift command_name
+        Object.const_set(:APP_PATH, ::Rails.root.join('config/application'))
+        require "rails/commands"
+      end
+
+      def description
+        nil
+      end
+    end
+
+    class RailsConsole < Rails
+      def env(args)
+        args.first if args.first && !args.first.index("-")
+      end
+
+      def command_name
+        "console"
+      end
+    end
+
+    class RailsGenerate < Rails
+      def command_name
+        "generate"
+      end
+    end
+
+    class RailsDestroy < Rails
+      def command_name
+        "destroy"
+      end
+    end
+
+    class RailsRunner < Rails
+      def env(tail)
+        previous_option = nil
+        tail.reverse.each do |option|
+          case option
+          when /--environment=(\w+)/ then return $1
+          when '-e' then return previous_option
+          end
+          previous_option = option
+        end
+        nil
+      end
+
+      def command_name
+        "runner"
+      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
+  end
+end