nrispring 2.1.1

data/lib/spring/process_title_updater.rb

@@ -0,0 +1,65 @@
+module Spring
+  # Yes, I know this reimplements a bunch of stuff in Active Support, but
+  # I don't want the Spring client to depend on AS, in order to keep its
+  # load time down.
+  class ProcessTitleUpdater
+    SECOND = 1
+    MINUTE = 60
+    HOUR   = 60*60
+
+    def self.run(&block)
+      updater = new(&block)
+
+      Spring.failsafe_thread {
+        $0 = updater.value
+        loop { $0 = updater.next }
+      }
+    end
+
+    attr_reader :block
+
+    def initialize(start = Time.now, &block)
+      @start = start
+      @block = block
+    end
+
+    def interval
+      distance = Time.now - @start
+
+      if distance < MINUTE
+        SECOND
+      elsif distance < HOUR
+        MINUTE
+      else
+        HOUR
+      end
+    end
+
+    def next
+      sleep interval
+      value
+    end
+
+    def value
+      block.call(distance_in_words)
+    end
+
+    def distance_in_words(now = Time.now)
+      distance = now - @start
+
+      if distance < MINUTE
+        pluralize(distance, "sec")
+      elsif distance < HOUR
+        pluralize(distance / MINUTE, "min")
+      else
+        pluralize(distance / HOUR, "hour")
+      end
+    end
+
+    private
+
+    def pluralize(amount, unit)
+      "#{amount.to_i} #{amount.to_i == 1 ? unit : "#{unit}s"}"
+    end
+  end
+end

data/lib/spring/server.rb

@@ -0,0 +1,150 @@
+module Spring
+  ORIGINAL_ENV = ENV.to_hash
+end
+
+require "spring/boot"
+require "spring/application_manager"
+
+# Must be last, as it requires bundler/setup, which alters the load path
+require "spring/commands"
+
+module Spring
+  class Server
+    def self.boot(options = {})
+      new(options).boot
+    end
+
+    attr_reader :env
+
+    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
+
+    def boot
+      Spring.verify_environment
+
+      write_pidfile
+      set_pgid unless foreground?
+      ignore_signals unless foreground?
+      set_exit_hook
+      set_process_title
+      start_server
+    end
+
+    def start_server
+      server = UNIXServer.open(env.socket_name)
+      log "started on #{env.socket_name}"
+      loop { serve server.accept }
+    rescue Interrupt
+    end
+
+    def serve(client)
+      log "accepted client"
+      client.puts env.version
+
+      app_client = client.recv_io
+      command    = JSON.load(client.read(client.gets.to_i))
+
+      args, default_rails_env = command.values_at('args', 'default_rails_env')
+
+      if Spring.command?(args.first)
+        log "running command #{args.first}"
+        client.puts
+        client.puts @applications[rails_env_for(args, default_rails_env)].run(app_client)
+      else
+        log "command not found #{args.first}"
+        client.close
+      end
+    rescue SocketError => e
+      raise e unless client.eof?
+    ensure
+      redirect_output
+    end
+
+    def rails_env_for(args, default_rails_env)
+      Spring.command(args.first).env(args.drop(1)) || default_rails_env
+    end
+
+    # Boot the server into the process group of the current session.
+    # This will cause it to be automatically killed once the session
+    # ends (i.e. when the user closes their terminal).
+    def set_pgid
+      Process.setpgid(0, SID.pgid)
+    end
+
+    # Ignore SIGINT and SIGQUIT otherwise the user typing ^C or ^\ on the command line
+    # will kill the server/application.
+    def ignore_signals
+      IGNORE_SIGNALS.each { |sig| trap(sig, "IGNORE") }
+    end
+
+    def set_exit_hook
+      server_pid = Process.pid
+
+      # We don't want this hook to run in any forks of the current process
+      at_exit { shutdown if Process.pid == server_pid }
+    end
+
+    def shutdown
+      log "shutting down"
+
+      [env.socket_path, env.pidfile_path].each do |path|
+        if path.exist?
+          path.unlink rescue nil
+        end
+      end
+
+      @applications.values.map { |a| Spring.failsafe_thread { a.stop } }.map(&:join)
+    end
+
+    def write_pidfile
+      if @pidfile.flock(File::LOCK_EX | File::LOCK_NB)
+        @pidfile.truncate(0)
+        @pidfile.write("#{Process.pid}\n")
+        @pidfile.fsync
+      else
+        exit 1
+      end
+    end
+
+    # We need to redirect STDOUT and STDERR, otherwise the server will
+    # keep the original FDs open which would break piping. (e.g.
+    # `spring rake -T | grep db` would hang forever because the server
+    # would keep the stdout FD open.)
+    def redirect_output
+      [STDOUT, STDERR].each { |stream| stream.reopen(env.log_file) }
+    end
+
+    def set_process_title
+      ProcessTitleUpdater.run { |distance|
+        "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/sid.rb

@@ -0,0 +1,42 @@
+begin
+  # If rubygems is present, keep it out of the way when loading fiddle,
+  # otherwise if fiddle is not installed then rubygems will load all
+  # gemspecs in its (futile) search for fiddle, which is slow.
+  if respond_to?(:gem_original_require, true)
+    gem_original_require 'fiddle'
+  else
+    require 'fiddle'
+  end
+rescue LoadError
+end
+
+module Spring
+  module SID
+    def self.fiddle_func
+      @fiddle_func ||= Fiddle::Function.new(
+        DL::Handle::DEFAULT['getsid'],
+        [Fiddle::TYPE_INT],
+        Fiddle::TYPE_INT
+      )
+    end
+
+    def self.sid
+      @sid ||= begin
+        if Process.respond_to?(:getsid)
+          # Ruby 2
+          Process.getsid
+        elsif defined?(Fiddle) and defined?(DL)
+          # Ruby 1.9.3 compiled with libffi support
+          fiddle_func.call(0)
+        else
+          # last resort: shell out
+          `ps -p #{Process.pid} -o sess=`.to_i
+        end
+      end
+    end
+
+    def self.pgid
+      Process.getpgid(sid)
+    end
+  end
+end

data/lib/spring/version.rb

@@ -0,0 +1,3 @@
+module Spring
+  VERSION = "2.1.1"
+end

data/lib/spring/watcher.rb

@@ -0,0 +1,30 @@
+require "spring/watcher/abstract"
+require "spring/configuration"
+
+module Spring
+  class << self
+    attr_accessor :watch_interval
+    attr_writer :watcher
+    attr_reader :watch_method
+  end
+
+  def self.watch_method=(method)
+    if method.is_a?(Class)
+      @watch_method = method
+    else
+      require "spring/watcher/#{method}"
+      @watch_method = Watcher.const_get(method.to_s.gsub(/(^.|_.)/) { $1[-1].upcase })
+    end
+  end
+
+  self.watch_interval = 0.2
+  self.watch_method = :polling
+
+  def self.watcher
+    @watcher ||= watch_method.new(Spring.application_root_path, watch_interval)
+  end
+
+  def self.watch(*items)
+    watcher.add(*items)
+  end
+end

data/lib/spring/watcher/abstract.rb

@@ -0,0 +1,117 @@
+require "set"
+require "pathname"
+require "mutex_m"
+
+module Spring
+  module Watcher
+    # A user of a watcher can use IO.select to wait for changes:
+    #
+    #   watcher = MyWatcher.new(root, latency)
+    #   IO.select([watcher]) # watcher is running in background
+    #   watcher.stale? # => true
+    class Abstract
+      include Mutex_m
+
+      attr_reader :files, :directories, :root, :latency
+
+      def initialize(root, latency)
+        super()
+
+        @root        = File.realpath(root)
+        @latency     = latency
+        @files       = Set.new
+        @directories = Set.new
+        @stale       = false
+        @listeners   = []
+
+        @on_debug    = nil
+      end
+
+      def on_debug(&block)
+        @on_debug = block
+      end
+
+      def debug
+        @on_debug.call(yield) if @on_debug
+      end
+
+      def add(*items)
+        debug { "watcher: add: #{items.inspect}" }
+
+        items = items.flatten.map do |item|
+          item = Pathname.new(item)
+
+          if item.relative?
+            Pathname.new("#{root}/#{item}")
+          else
+            item
+          end
+        end
+
+        items = items.select do |item|
+          if item.symlink?
+            item.readlink.exist?.tap do |exists|
+              if !exists
+                debug { "add: ignoring dangling symlink: #{item.inspect} -> #{item.readlink.inspect}" }
+              end
+            end
+          else
+            item.exist?
+          end
+        end
+
+        synchronize {
+          items.each do |item|
+            if item.directory?
+              directories << item.realpath.to_s
+            else
+              begin
+                files << item.realpath.to_s
+              rescue Errno::ENOENT
+                # Race condition. Ignore symlinks whose target was removed
+                # since the check above, or are deeply chained.
+                debug { "add: ignoring now-dangling symlink: #{item.inspect} -> #{item.readlink.inspect}" }
+              end
+            end
+          end
+
+          subjects_changed
+        }
+      end
+
+      def stale?
+        @stale
+      end
+
+      def on_stale(&block)
+        debug { "added listener: #{block.inspect}" }
+        @listeners << block
+      end
+
+      def mark_stale
+        return if stale?
+        @stale = true
+        debug { "marked stale, calling listeners: listeners=#{@listeners.inspect}" }
+        @listeners.each(&:call)
+      end
+
+      def restart
+        debug { "restarting" }
+        stop
+        start
+      end
+
+      def start
+        raise NotImplementedError
+      end
+
+      def stop
+        raise NotImplementedError
+      end
+
+      def subjects_changed
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/spring/watcher/polling.rb

@@ -0,0 +1,98 @@
+require "spring/watcher/abstract"
+
+module Spring
+  module Watcher
+    class Polling < Abstract
+      attr_reader :mtime
+
+      def initialize(root, latency)
+        super
+        @mtime  = 0
+        @poller = nil
+      end
+
+      def check_stale
+        synchronize do
+          computed = compute_mtime
+          if mtime < computed
+            debug { "check_stale: mtime=#{mtime.inspect} < computed=#{computed.inspect}" }
+            mark_stale
+          end
+        end
+      end
+
+      def add(*)
+        check_stale if @poller
+        super
+      end
+
+      def start
+        debug { "start: poller=#{@poller.inspect}" }
+        unless @poller
+          @poller = Thread.new {
+            Thread.current.abort_on_exception = true
+
+            begin
+              until stale?
+                Kernel.sleep latency
+                check_stale
+              end
+            rescue Exception => e
+              debug do
+                "poller: aborted: #{e.class}: #{e}\n  #{e.backtrace.join("\n  ")}"
+              end
+              raise
+            ensure
+              @poller = nil
+            end
+          }
+        end
+      end
+
+      def stop
+        debug { "stopping poller: #{@poller.inspect}" }
+        if @poller
+          @poller.kill
+          @poller = nil
+        end
+      end
+
+      def running?
+        @poller && @poller.alive?
+      end
+
+      def subjects_changed
+        computed = compute_mtime
+        debug { "subjects_changed: mtime #{@mtime} -> #{computed}" }
+        @mtime = computed
+      end
+
+      private
+
+      def compute_mtime
+        expanded_files.map do |f|
+          # Get the mtime of symlink targets. Ignore dangling symlinks.
+          if File.symlink?(f)
+            begin
+              File.mtime(f)
+            rescue Errno::ENOENT
+              0
+            end
+          # If a file no longer exists, treat it as changed.
+          else
+            begin
+              File.mtime(f)
+            rescue Errno::ENOENT
+              debug { "compute_mtime: no longer exists: #{f}" }
+              Float::MAX
+            end
+          end.to_f
+        end.max || 0
+      end
+
+      def expanded_files
+        files + Dir["{#{directories.map { |d| "#{d}/**/*" }.join(",")}}"]
+      end
+    end
+  end
+end