spring 1.0.0 → 1.1.0

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,58 @@ module Spring
     end
 
     def stop
-      Process.kill('TERM', pid) if pid
+      @state = :stopping
+
+      if pid
+        Process.kill('TERM', pid)
+        Process.wait(pid)
+      end
     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"

data/lib/spring/client/binstub.rb

@@ -1,46 +1,164 @@
+require 'set'
+
 module Spring
   module Client
     class Binstub < Command
-      attr_reader :bindir, :commands
+      SHEBANG = /\#\!.*\n/
+
+      # If loading the bin/spring file works, it'll run spring which will
+      # eventually call Kernel.exit. This means that in the client process
+      # we will never execute the lines after this block. But if the spring
+      # client is not invoked for whatever reason, then the Kernel.exit won't
+      # happen, and so we'll fall back to the lines after this block, which
+      # should cause the "unsprung" version of the command to run.
+      LOADER = <<CODE
+begin
+  load File.expand_path("../spring", __FILE__)
+rescue LoadError
+end
+CODE
+
+      # The defined? check ensures these lines don't execute when we load the
+      # binstub from the application process. Which means that in the application
+      # process we'll execute the lines which come after the LOADER block, which
+      # is what we want.
+      #
+      # Parsing the lockfile in this way is pretty nasty but reliable enough
+      # The regex ensures that the match must be between a GEM line and an empty
+      # line, so it won't go on to the next section.
+      SPRING = <<'CODE'
+#!/usr/bin/env ruby
+
+# This file loads spring without using Bundler, in order to be fast
+# It gets overwritten when you run the `spring binstub` command
+
+unless defined?(Spring)
+  require "rubygems"
+  require "bundler"
+
+  if match = Bundler.default_lockfile.read.match(/^GEM$.*?^    spring \((.*?)\)$.*?^$/m)
+    ENV["GEM_PATH"] = ([Bundler.bundle_path.to_s] + Gem.path).join(File::PATH_SEPARATOR)
+    ENV["GEM_HOME"] = ""
+    Gem.paths = ENV
+
+    gem "spring", match[1]
+    require "spring/binstub"
+  end
+end
+CODE
+
+      OLD_BINSTUB = %{if !Process.respond_to?(:fork) || Gem::Specification.find_all_by_name("spring").empty?}
+
+      class Item
+        attr_reader :command, :existing
+
+        def initialize(command)
+          @command = command
+
+          if command.binstub.exist?
+            @existing = command.binstub.read
+          elsif command.name == "rails"
+            scriptfile = Spring.application_root_path.join("script/rails")
+            @existing = scriptfile.read if scriptfile.exist?
+          end
+        end
+
+        def status(text, stream = $stdout)
+          stream.puts "* #{command.binstub_name}: #{text}"
+        end
+
+        def add
+          if existing
+            if existing.include?(OLD_BINSTUB)
+              fallback = existing.match(/#{Regexp.escape OLD_BINSTUB}\n(.*)else/m)[1]
+              fallback.gsub!(/^  /, "")
+              fallback = nil if fallback.include?("exec")
+              generate(fallback)
+              status "upgraded"
+            elsif existing =~ /load .*spring/
+              status "spring already present"
+            else
+              head, shebang, tail = existing.partition(SHEBANG)
+
+              if shebang.include?("ruby")
+                unless command.binstub.exist?
+                  FileUtils.touch command.binstub
+                  command.binstub.chmod 0755
+                end
+
+                File.write(command.binstub, "#{head}#{shebang}#{LOADER}#{tail}")
+                status "spring inserted"
+              else
+                status "doesn't appear to be ruby, so cannot use spring", $stderr
+                exit 1
+              end
+            end
+          else
+            generate
+            status "generated with spring"
+          end
+        end
+
+        def generate(fallback = nil)
+          unless fallback
+            fallback = "require 'bundler/setup'\n" \
+                       "load Gem.bin_path('#{command.gem_name}', '#{command.exec_name}')\n"
+          end
+
+          File.write(command.binstub, "#!/usr/bin/env ruby\n#{LOADER}#{fallback}")
+          command.binstub.chmod 0755
+        end
+
+        def remove
+          if existing
+            File.write(command.binstub, existing.sub(LOADER, ""))
+            status "spring removed"
+          end
+        end
+      end
+
+      attr_reader :bindir, :items
 
       def self.description
         "Generate spring based binstubs. Use --all to generate a binstub for all known commands."
       end
 
+      def self.rails_command
+        @rails_command ||= CommandWrapper.new("rails")
+      end
+
       def self.call(args)
         require "spring/commands"
         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")
-        @commands = args.drop(1).inject({}) { |mem, name| mem.merge(find_commands(name)) }
+        @bindir = env.root.join("bin")
+        @all    = false
+        @mode   = :add
+        @items  = args.drop(1)
+                      .map { |name| find_commands name }
+                      .inject(Set.new, :|)
+                      .map { |command| Item.new(command) }
       end
 
       def find_commands(name)
         case name
         when "--all"
-          commands = Spring.commands
+          @all = true
+          commands = Spring.commands.dup
           commands.delete_if { |name, _| name.start_with?("rails_") }
-          commands["rails"] = RailsCommand.new
-          commands
+          commands.values + [self.class.rails_command]
+        when "--remove"
+          @mode = :remove
+          []
         when "rails"
-          { name => RailsCommand.new }
+          [self.class.rails_command]
         else
           if command = Spring.commands[name]
-            { name => command }
+            [command]
           else
             $stderr.puts "The '#{name}' command is not known to spring."
             exit 1
@@ -49,32 +167,25 @@ CODE
       end
 
       def call
-        bindir.mkdir unless bindir.exist?
-        commands.each { |name, command| generate_binstub(name, command) }
-      end
-
-      def generate_binstub(name, command)
-        File.write(bindir.join(name), <<CODE)
-#!/usr/bin/env ruby
+        case @mode
+        when :add
+          bindir.mkdir unless bindir.exist?
 
-if !Process.respond_to?(:fork) || Gem::Specification.find_all_by_name("spring").empty?
-#{fallback(name, command).strip.gsub(/^/, "  ")}
-else
-  ARGV.unshift "#{name}"
-  load Gem.bin_path("spring", "spring")
-end
-CODE
-
-        bindir.join(name).chmod 0755
-      end
+          File.write(spring_binstub, SPRING)
+          spring_binstub.chmod 0755
 
-      def fallback(name, command)
-        if command.respond_to?(:fallback)
-          command.fallback
+          items.each(&:add)
+        when :remove
+          spring_binstub.delete if @all
+          items.each(&:remove)
         else
-          %{exec "bundle", "exec", "#{name}", *ARGV}
+          raise ArgumentError
         end
       end
+
+      def spring_binstub
+        bindir.join("spring")
+      end
     end
   end
 end

data/lib/spring/client/help.rb

@@ -20,6 +20,8 @@ module Spring
         @spring_commands      = spring_commands      || Spring::Client::COMMANDS.dup
         @application_commands = application_commands || Spring.commands.dup
 
+        @spring_commands.delete_if { |k, v| k.start_with?("-") }
+
         @application_commands["rails"] = @spring_commands.delete("rails")
       end
 
@@ -46,19 +48,9 @@ module Spring
         spring_commands.merge application_commands
       end
 
-      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
-      end
-
       def display(name, command)
-        if description = description_for_command(command)
-          "  #{name.ljust(max_name_width)}  #{description}"
+        if command.description
+          "  #{name.ljust(max_name_width)}  #{command.description}"
         end
       end
 

data/lib/spring/client/rails.rb

@@ -24,9 +24,7 @@ module Spring
         else
           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"
+          load Dir.glob(Spring.application_root_path.join("{bin,script}/rails")).first
         end
       end
     end

data/lib/spring/client/version.rb

@@ -0,0 +1,11 @@
+require "spring/version"
+
+module Spring
+  module Client
+    class Version < Command
+      def call
+        puts "Spring version #{Spring::VERSION}"
+      end
+    end
+  end
+end

data/lib/spring/client.rb

@@ -8,15 +8,18 @@ require "spring/client/binstub"
 require "spring/client/stop"
 require "spring/client/status"
 require "spring/client/rails"
+require "spring/client/version"
 
 module Spring
   module Client
     COMMANDS = {
-      "help"    => Client::Help,
-      "binstub" => Client::Binstub,
-      "stop"    => Client::Stop,
-      "status"  => Client::Status,
-      "rails"   => Client::Rails
+      "help"      => Client::Help,
+      "binstub"   => Client::Binstub,
+      "stop"      => Client::Stop,
+      "status"    => Client::Status,
+      "rails"     => Client::Rails,
+      "-v"        => Client::Version,
+      "--version" => Client::Version
     }
 
     def self.run(args)

data/lib/spring/command_wrapper.rb

@@ -0,0 +1,86 @@
+require "spring/configuration"
+
+module Spring
+  class CommandWrapper
+    attr_reader :name, :command
+
+    def initialize(name, command = nil)
+      @name    = name
+      @command = command
+      @setup   = false
+    end
+
+    def description
+      if command.respond_to?(:description)
+        command.description
+      else
+        "Runs the #{name} command"
+      end
+    end
+
+    def setup?
+      @setup
+    end
+
+    def setup
+      if !setup? && command.respond_to?(:setup)
+        command.setup
+        @setup = true
+        return true
+      else
+        @setup = true
+        return false
+      end
+    end
+
+    def call
+      if command.respond_to?(:call)
+        command.call
+      else
+        load exec
+      end
+    end
+
+    def process_title
+      ["spring", name, *ARGV].join(" ")
+    end
+
+    def gem_name
+      if command.respond_to?(:gem_name)
+        command.gem_name
+      else
+        exec_name
+      end
+    end
+
+    def exec_name
+      if command.respond_to?(:exec_name)
+        command.exec_name
+      else
+        name
+      end
+    end
+
+    def binstub
+      Spring.application_root_path.join(binstub_name)
+    end
+
+    def binstub_name
+      "bin/#{name}"
+    end
+
+    def exec
+      if binstub.exist?
+        binstub.to_s
+      else
+        Gem.bin_path(gem_name, exec_name)
+      end
+    end
+
+    def env(args)
+      if command.respond_to?(:env)
+        command.env(args)
+      end
+    end
+  end
+end

data/lib/spring/commands/rails.rb

@@ -3,8 +3,7 @@ module Spring
     class Rails
       def call
         ARGV.unshift command_name
-        Object.const_set(:APP_PATH, ::Rails.root.join('config/application'))
-        require "rails/commands"
+        load Dir.glob(::Rails.root.join("{bin,script}/rails")).first
       end
 
       def description

data/lib/spring/commands/rake.rb

@@ -23,10 +23,6 @@ module Spring
 
         nil
       end
-
-      def exec_name
-        "rake"
-      end
     end
 
     Spring.register_command "rake", Rake.new

data/lib/spring/commands.rb

@@ -1,4 +1,5 @@
 require "spring/watcher"
+require "spring/command_wrapper"
 
 module Spring
   @commands = {}
@@ -7,8 +8,8 @@ module Spring
     attr_reader :commands
   end
 
-  def self.register_command(name, klass)
-    commands[name] = klass
+  def self.register_command(name, command = nil)
+    commands[name] = CommandWrapper.new(name, command)
   end
 
   def self.command?(name)

data/lib/spring/configuration.rb

@@ -22,15 +22,24 @@ module Spring
 
     def application_root_path
       @application_root_path ||= begin
-        path = Pathname.new(File.expand_path(application_root || find_project_root))
+        if application_root
+          path = Pathname.new(File.expand_path(application_root))
+        else
+          path = project_root_path
+        end
+
         raise MissingApplication.new(path) unless path.join("config/application.rb").exist?
         path
       end
     end
 
+    def project_root_path
+      @project_root_path ||= find_project_root(Pathname.new(File.expand_path(Dir.pwd)))
+    end
+
     private
 
-    def find_project_root(current_dir = Pathname.new(Dir.pwd))
+    def find_project_root(current_dir)
       if current_dir.join(gemfile).exist?
         current_dir
       elsif current_dir.root?

data/lib/spring/env.rb

@@ -14,14 +14,19 @@ module Spring
     attr_reader :log_file
 
     def initialize(root = nil)
-      @root     = root
-      @log_file = File.open(ENV["SPRING_LOG"] || "/dev/null", "a")
+      @root         = root
+      @project_root = root
+      @log_file     = File.open(ENV["SPRING_LOG"] || "/dev/null", "a")
     end
 
     def root
       @root ||= Spring.application_root_path
     end
 
+    def project_root
+      @project_root ||= Spring.project_root_path
+    end
+
     def version
       Spring::VERSION
     end
@@ -33,7 +38,7 @@ module Spring
     end
 
     def application_id
-      Digest::MD5.hexdigest(root.to_s)
+      Digest::MD5.hexdigest(project_root.to_s)
     end
 
     def socket_path
@@ -60,7 +65,7 @@ module Spring
     end
 
     def server_running?
-      pidfile = pidfile_path.open('r')
+      pidfile = pidfile_path.open('r+')
       !pidfile.flock(File::LOCK_EX | File::LOCK_NB)
     rescue Errno::ENOENT
       false
@@ -71,12 +76,8 @@ module Spring
       end
     end
 
-    def bundle_mtime
-      [Bundler.default_lockfile, Bundler.default_gemfile].select(&:exist?).map(&:mtime).max
-    end
-
     def log(message)
-      log_file.puts "[#{Time.now}] #{message}"
+      log_file.puts "[#{Time.now}] [#{Process.pid}] #{message}"
       log_file.flush
     end
   end