nrispring 2.1.1

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,10 @@
+require "socket"
+require "thread"
+
+require "spring/configuration"
+require "spring/env"
+require "spring/process_title_updater"
+require "spring/json"
+require "spring/watcher"
+require "spring/failsafe_thread"
+

data/lib/spring/client.rb

@@ -0,0 +1,48 @@
+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/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,
+      "server"    => Client::Server,
+    }
+
+    def self.run(args)
+      command_for(args.first).call(args)
+    rescue CommandNotFound
+      Client::Help.call(args)
+    rescue ClientError => e
+      $stderr.puts e.message
+      exit 1
+    end
+
+    def self.command_for(name)
+      COMMANDS[name] || Client::Run
+    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/client/binstub.rb

@@ -0,0 +1,197 @@
+require 'set'
+
+module Spring
+  module Client
+    class Binstub < Command
+      SHEBANG = /\#\!.*\n(\#.*\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 => e
+  raise unless e.message.include?('spring')
+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.
+      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'
+
+  lockfile = Bundler::LockfileParser.new(Bundler.default_lockfile.read)
+  spring = lockfile.specs.detect { |spec| spec.name == 'spring' }
+  if spring
+    Gem.use_paths Gem.dir, Bundler.bundle_path.to_s, *Gem.path
+    gem 'spring', spring.version
+    require 'spring/binstub'
+  end
+end
+CODE
+
+      OLD_BINSTUB = %{if !Process.respond_to?(:fork) || Gem::Specification.find_all_by_name("spring").empty?}
+
+      BINSTUB_VARIATIONS = Regexp.union [
+        %{begin\n  load File.expand_path('../spring', __FILE__)\nrescue LoadError\nend\n},
+        %{begin\n  spring_bin_path = File.expand_path('../spring', __FILE__)\n  load spring_bin_path\nrescue LoadError => e\n  raise unless e.message.end_with? spring_bin_path, 'spring/binstub'\nend\n},
+        LOADER
+      ].map { |binstub| /#{Regexp.escape(binstub).gsub("'", "['\"]")}/ }
+
+      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.include?(LOADER)
+              status "Spring already present"
+            elsif existing =~ BINSTUB_VARIATIONS
+              upgraded = existing.sub(BINSTUB_VARIATIONS, LOADER)
+              File.write(command.binstub, upgraded)
+              status "upgraded"
+            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(BINSTUB_VARIATIONS, ""))
+            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. Use --remove to revert."
+      end
+
+      def self.rails_command
+        @rails_command ||= CommandWrapper.new("rails")
+      end
+
+      def self.call(args)
+        require "spring/commands"
+        super
+      end
+
+      def initialize(args)
+        super
+
+        @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"
+          @all = true
+          commands = Spring.commands.dup
+          commands.delete_if { |command_name, _| command_name.start_with?("rails_") }
+          commands.values + [self.class.rails_command]
+        when "--remove"
+          @mode = :remove
+          []
+        when "rails"
+          [self.class.rails_command]
+        else
+          if command = Spring.commands[name]
+            [command]
+          else
+            $stderr.puts "The '#{name}' command is not known to spring."
+            exit 1
+          end
+        end
+      end
+
+      def call
+        case @mode
+        when :add
+          bindir.mkdir unless bindir.exist?
+
+          File.write(spring_binstub, SPRING)
+          spring_binstub.chmod 0755
+
+          items.each(&:add)
+        when :remove
+          spring_binstub.delete if @all
+          items.each(&:remove)
+        else
+          raise ArgumentError
+        end
+      end
+
+      def spring_binstub
+        bindir.join("spring")
+      end
+    end
+  end
+end

data/lib/spring/client/command.rb

@@ -0,0 +1,18 @@
+require "spring/env"
+
+module Spring
+  module Client
+    class Command
+      def self.call(args)
+        new(args).call
+      end
+
+      attr_reader :args, :env
+
+      def initialize(args)
+        @args = args
+        @env  = Env.new
+      end
+    end
+  end
+end

data/lib/spring/client/help.rb

@@ -0,0 +1,62 @@
+require "spring/version"
+
+module Spring
+  module Client
+    class Help < Command
+      attr_reader :spring_commands, :application_commands
+
+      def self.description
+        "Print available commands."
+      end
+
+      def self.call(args)
+        require "spring/commands"
+        super
+      end
+
+      def initialize(args, spring_commands = nil, application_commands = nil)
+        super args
+
+        @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
+
+      def call
+        puts formatted_help
+      end
+
+      def formatted_help
+        ["Version: #{env.version}\n",
+         "Usage: spring COMMAND [ARGS]\n",
+         *command_help("Spring itself", spring_commands),
+         '',
+         *command_help("your application", application_commands)].join("\n")
+      end
+
+      def command_help(subject, commands)
+        ["Commands for #{subject}:\n",
+        *commands.sort_by(&:first).map { |name, command| display(name, command) }.compact]
+      end
+
+      private
+
+      def all_commands
+        spring_commands.merge application_commands
+      end
+
+      def display(name, command)
+        if command.description
+          "  #{name.ljust(max_name_width)}  #{command.description}"
+        end
+      end
+
+      def max_name_width
+        @max_name_width ||= all_commands.keys.map(&:length).max
+      end
+    end
+  end
+end

data/lib/spring/client/rails.rb

@@ -0,0 +1,34 @@
+require "set"
+
+module Spring
+  module Client
+    class Rails < Command
+      COMMANDS = Set.new %w(console runner generate destroy test)
+
+      ALIASES = {
+        "c" => "console",
+        "r" => "runner",
+        "g" => "generate",
+        "d" => "destroy",
+        "t" => "test"
+      }
+
+      def self.description
+        "Run a rails command. The following sub commands will use Spring: #{COMMANDS.to_a.join ', '}."
+      end
+
+      def call
+        command_name = ALIASES[args[1]] || args[1]
+
+        if COMMANDS.include?(command_name)
+          Run.call(["rails_#{command_name}", *args.drop(2)])
+        else
+          require "spring/configuration"
+          ARGV.shift
+          load Dir.glob(Spring.application_root_path.join("{bin,script}/rails")).first
+          exit
+        end
+      end
+    end
+  end
+end

data/lib/spring/client/run.rb

@@ -0,0 +1,232 @@
+require "rbconfig"
+require "socket"
+require "bundler"
+
+module Spring
+  module Client
+    class Run < Command
+      FORWARDED_SIGNALS = %w(INT QUIT USR1 USR2 INFO WINCH) & Signal.list.keys
+      CONNECT_TIMEOUT   = 1
+      BOOT_TIMEOUT      = 20
+
+      attr_reader :server
+
+      def initialize(args)
+        super
+
+        @signal_queue  = []
+        @server_booted = false
+      end
+
+      def log(message)
+        env.log "[client] #{message}"
+      end
+
+      def connect
+        @server = UNIXSocket.open(env.socket_name)
+      end
+
+      def call
+        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
+
+        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, 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)
+
+          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)
+
+        {
+          "GEM_PATH" => [bundle, *paths].uniq.join(File::PATH_SEPARATOR),
+          "GEM_HOME" => bundle
+        }
+      end
+
+      def stop_server
+        server.close
+        @server = nil
+        env.stop
+      end
+
+      def verify_server_version
+        server_version = server.gets.chomp
+        if server_version != env.version
+          $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
+
+      def connect_to_application(client)
+        server.send_io client
+        send_json server, "args" => args, "default_rails_env" => default_rails_env
+
+        if IO.select([server], [], [], CONNECT_TIMEOUT)
+          server.gets or raise CommandNotFound
+        else
+          raise "Error connecting to Spring server"
+        end
+      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" => args, "env" => ENV.to_hash
+
+        pid = server.gets
+        pid = pid.chomp if pid
+
+        # We must not close the client socket until we are sure that the application has
+        # received the FD. Otherwise the FD can end up getting closed while it's in the server
+        # socket buffer on OS X. This doesn't happen on Linux.
+        client.close
+
+        if pid && !pid.empty?
+          log "got pid: #{pid}"
+
+          suspend_resume_on_tstp_cont(pid)
+
+          forward_signals(application)
+          status = application.read.to_i
+
+          log "got exit status #{status}"
+
+          exit status
+        else
+          log "got no pid"
+          exit 1
+        end
+      ensure
+        application.close
+      end
+
+      def queue_signals
+        FORWARDED_SIGNALS.each do |sig|
+          trap(sig) { @signal_queue << sig }
+        end
+      end
+
+      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, application }
+        end
+      end
+
+      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, application)
+        application.puts(sig)
+        application.gets.to_i
+      end
+
+      def send_json(socket, data)
+        data = JSON.dump(data)
+
+        socket.puts  data.bytesize
+        socket.write data
+      end
+
+      def default_rails_env
+        ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
+      end
+    end
+  end
+end