spring-jruby 1.4.3

data/lib/spring-jruby/errors.rb

@@ -0,0 +1,36 @@
+module Spring
+  class ClientError < StandardError; end
+
+  class UnknownProject < StandardError
+    attr_reader :current_dir
+
+    def initialize(current_dir)
+      @current_dir = current_dir
+    end
+
+    def message
+      "Spring was unable to locate the root of your project. There was no Gemfile " \
+        "present in the current directory (#{current_dir}) or any of the parent " \
+        "directories."
+    end
+  end
+
+  class MissingApplication < ClientError
+    attr_reader :project_root
+
+    def initialize(project_root)
+      @project_root = project_root
+    end
+
+    def message
+      "Spring was unable to find your config/application.rb file. " \
+        "Your project root was detected at #{project_root}, so spring " \
+        "looked for #{project_root}/config/application.rb but it doesn't exist. You can " \
+        "configure the root of your application by setting Spring.application_root in " \
+        "config/spring.rb."
+    end
+  end
+
+  class CommandNotFound < ClientError
+  end
+end

data/lib/spring-jruby/impl/application.rb

@@ -0,0 +1,7 @@
+require "spring-jruby/platform"
+
+if Spring.fork?
+  require "spring-jruby/impl/fork/application"
+else
+  require "spring-jruby/impl/pool/application"
+end

data/lib/spring-jruby/impl/application_manager.rb

@@ -0,0 +1,7 @@
+require "spring-jruby/platform"
+
+if Spring.fork?
+  require "spring-jruby/impl/fork/application_manager"
+else
+  require "spring-jruby/impl/pool/application_manager"
+end

data/lib/spring-jruby/impl/fork/application.rb

@@ -0,0 +1,69 @@
+module Spring
+  module ApplicationImpl
+    def notify_manager_ready
+      manager.puts
+    end
+
+    def receive_streams(client)
+      3.times.map { IOWrapper.recv_io(client).to_io }
+    end
+
+    def reopen_streams(streams)
+      [STDOUT, STDERR, STDIN].zip(streams).each { |a, b| a.reopen(b) }
+    end
+
+    def eager_preload
+      with_pty { preload }
+    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
+
+    def fork_child(client, streams, child_started)
+      pid = fork { yield }
+      child_started[0] = true
+
+      disconnect_database
+      reset_streams
+
+      log "forked #{pid}"
+      manager.puts pid
+
+      wait pid, streams, client
+    end
+
+    def before_command
+      # NOP
+    end
+  end
+end

data/lib/spring-jruby/impl/fork/application_manager.rb

@@ -0,0 +1,137 @@
+module Spring
+  class ApplicationManager
+    attr_reader :pid, :child, :app_env, :spring_env, :status
+
+    def initialize(app_env)
+      @app_env    = app_env
+      @spring_env = Env.new
+      @mutex      = Mutex.new
+      @state      = :running
+    end
+
+    def log(message)
+      spring_env.log "[application_manager:#{app_env}] #{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
+      @mutex.lock
+      yield
+    ensure
+      @mutex.unlock
+    end
+
+    def start
+      start_child
+    end
+
+    def restart
+      return if @state == :stopping
+      start_child(true)
+    end
+
+    def alive?
+      @pid
+    end
+
+    def with_child
+      synchronize do
+        if alive?
+          begin
+            yield
+          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
+      end
+    end
+
+    # Returns the pid of the process running the command, or nil if the application process died.
+    def run(client)
+      with_child do
+        child.send_io client
+        child.gets or raise Errno::EPIPE
+      end
+
+      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
+    ensure
+      client.close
+    end
+
+    def stop
+      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)
+      @child, child_socket = UNIXSocket.pair
+
+      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-jruby/application/boot'",
+          3 => child_socket
+        )
+      end
+
+      start_wait_thread(pid, child) if child.gets
+      child_socket.close
+    end
+
+    def start_wait_thread(pid, child)
+      Process.detach(pid)
+
+      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
+end

data/lib/spring-jruby/impl/fork/run.rb

@@ -0,0 +1,47 @@
+module Spring
+  module Client
+    module RunImpl
+      TIMEOUT = 1
+      FORWARDED_SIGNALS = %w(INT QUIT USR1 USR2 INFO) & Signal.list.keys
+
+      def queue_signals
+        RunImpl::FORWARDED_SIGNALS.each do |sig|
+          trap(sig) { @signal_queue << sig }
+        end
+      end
+
+      def send_std_io_to(application)
+        application.send_io STDOUT
+        application.send_io STDERR
+        application.send_io STDIN
+      end
+
+      def run_on(application, pid)
+        forward_signals(pid.to_i)
+        status = application.read.to_i
+
+        log "got exit status #{status}"
+
+        exit status
+      end
+
+      def forward_signals(pid)
+        @signal_queue.each { |sig| kill sig, pid }
+
+        RunImpl::FORWARDED_SIGNALS.each do |sig|
+          trap(sig) { forward_signal sig, pid }
+        end
+      rescue Errno::ESRCH
+      end
+
+      def forward_signal(sig, pid)
+        kill(sig, pid)
+      rescue Errno::ESRCH
+        # 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
+  end
+end

data/lib/spring-jruby/impl/pool/application.rb

@@ -0,0 +1,47 @@
+module Spring
+  module ApplicationImpl
+    def notify_manager_ready
+      manager.puts Process.pid
+    end
+
+    def receive_streams(client)
+      []
+    end
+
+    def reopen_streams(streams)
+      # NOP
+    end
+
+    def eager_preload
+      preload
+    end
+
+    def screen_attached?
+      !system(%{screen -ls | grep "#{ENV['SPRING_SCREEN_NAME']}" | grep Detached > /dev/null})
+    end
+
+    def screen_move_to_bottom
+      puts "\033[22B"
+    end
+
+    def fork_child(client, streams, child_started)
+      manager.puts ENV["SPRING_SCREEN_NAME"]
+      child_started[0] = true
+      exitstatus = 0
+      begin
+        log "started #{Process.pid}"
+        yield
+      rescue SystemExit => ex
+        exitstatus = ex.status
+      end
+
+      log "#{Process.pid} exited with #{exitstatus}"
+      exit
+    end
+
+    def before_command
+      screen_move_to_bottom
+      sleep 0.1 until screen_attached?
+    end
+  end
+end

data/lib/spring-jruby/impl/pool/application_manager.rb

@@ -0,0 +1,226 @@
+module Spring
+  class ApplicationManager
+    class Worker
+      attr_reader :screen_pid, :pid, :uuid, :socket, :screen_name
+      attr_accessor :on_done
+
+      def initialize(env, args)
+        @spring_env = Env.new
+        channel, @remote_socket = WorkerChannel.pair
+        @uuid = File.basename(@remote_socket.path).gsub('.sock', '')
+
+        Bundler.with_clean_env do
+          spawn_screen(
+            env.merge("SPRING_SOCKET" => @remote_socket.path),
+            args
+          )
+        end
+
+        @socket = channel.to_io
+      end
+
+      def spawn_screen(env, args)
+        @screen_name = "spring_#{@uuid}"
+
+        @screen_pid =
+          Process.spawn(
+            env.merge("SPRING_SCREEN_NAME" => screen_name),
+            "screen", "-d", "-m", "-S", screen_name,
+            *args
+          )
+
+        log "(spawn #{@screen_pid})"
+      end
+
+      def await_boot
+        Process.detach(screen_pid)
+        @pid = socket.gets.to_i
+        start_wait_thread(pid, socket) unless pid.zero?
+        @remote_socket.close
+      end
+
+      def start_wait_thread(pid, child)
+        Thread.new {
+          begin
+            Process.kill(0, pid) while sleep(1)
+          rescue Errno::ESRCH
+          end
+
+          log "child #{pid} shutdown"
+
+          on_done.call(self) if on_done
+        }
+      end
+
+      def log(message)
+        @spring_env.log "[worker:#{uuid}] #{message}"
+      end
+    end
+
+    class WorkerPool
+      def initialize(app_env, *app_args)
+        @app_env = app_env
+        @app_args = app_args
+        @spring_env = Env.new
+
+        @workers = []
+        @workers_in_use = []
+        @spawning_workers = []
+
+        @check_mutex = Mutex.new
+        @workers_mutex = Mutex.new
+
+        run
+      end
+
+      def add_worker
+        worker = Worker.new(@app_env, @app_args)
+        worker.on_done = method(:worker_done)
+        @workers_mutex.synchronize { @spawning_workers << worker }
+        Thread.new do
+          worker.await_boot
+          log "+ worker #{worker.pid} (#{worker.uuid})"
+          @workers_mutex.synchronize do
+            @spawning_workers.delete(worker)
+            @workers << worker
+          end
+        end
+      end
+
+      def worker_done(worker)
+        log "- worker #{worker.pid} (#{worker.uuid})"
+        @workers_mutex.synchronize do
+          @workers_in_use.delete(worker)
+        end
+      end
+
+      def get_worker(spawn_new = true)
+        add_worker if spawn_new && all_size == 0
+
+        worker = nil
+        while worker.nil? && all_size > 0
+          @workers_mutex.synchronize do
+            worker = @workers.shift
+            @workers_in_use << worker if worker
+          end
+          break if worker
+          sleep 1
+        end
+
+        Thread.new { check_min_free_workers } if spawn_new
+
+        worker
+      end
+
+      def check_min_free_workers
+        if @check_mutex.try_lock
+          # TODO: mutex, and dont do it if already in progress
+          # do this in thread
+          while all_size < Spring.pool_min_free_workers
+            unless Spring.pool_spawn_parallel
+              sleep 0.1 until @workers_mutex.synchronize { @spawning_workers.empty? }
+            end
+            add_worker
+          end
+          @check_mutex.unlock
+        end
+      end
+
+      def all_size
+        @workers_mutex.synchronize { @workers.size + @spawning_workers.size }
+      end
+
+      def stop!
+        if spawning_worker_pids.include?(nil)
+          log "Waiting for workers to quit..."
+          sleep 0.1 while spawning_worker_pids.include?(nil)
+        end
+
+        @workers_mutex.synchronize do
+          (@spawning_workers + @workers_in_use + @workers).each do |worker|
+            kill_worker(worker)
+          end
+        end
+      end
+    private
+      def kill_worker(worker)
+        log "- worker #{worker.pid} (#{worker.uuid})."
+        system("kill -9 #{worker.pid} > /dev/null 2>&1")
+        system("screen -S #{worker.screen_name} -X quit > /dev/null 2>&1")
+      rescue
+      end
+
+      def spawning_worker_pids
+        @spawning_workers.map { |worker| worker.pid }
+      end
+
+      def run
+        system("screen -wipe > /dev/null 2>&1")
+
+        check_min_free_workers
+      end
+
+      def log(message)
+        @spring_env.log "[worker:pool] #{message}"
+      end
+    end
+
+    def initialize(app_env)
+      @app_env    = app_env
+      @spring_env = Env.new
+      @pool       =
+        WorkerPool.new(
+          {
+            "RAILS_ENV"           => app_env,
+            "RACK_ENV"            => app_env,
+            "SPRING_ORIGINAL_ENV" => JSON.dump(Spring::ORIGINAL_ENV),
+            "SPRING_PRELOAD"      => "1",
+          },
+          Spring.ruby_bin,
+          "-I", File.expand_path("../..", __FILE__),
+          "-e", "require 'spring-jruby/application/boot'"
+        )
+    end
+
+    # Returns the name of the screen running the command, or nil if the application process died.
+    def run(client)
+      name = nil
+      with_child do |child|
+        client.forward_to(child.socket)
+        child.socket.gets or raise Errno::EPIPE
+
+        name = child.socket.gets
+      end
+
+      unless name.nil?
+        log "got worker name #{name}"
+        name
+      end
+    rescue Errno::ECONNRESET, Errno::EPIPE => e
+      log "#{e} while reading from child; returning no name"
+      nil
+    ensure
+      client.close
+    end
+
+    def stop
+      log "stopping"
+
+      @pool.stop!
+    rescue Errno::ESRCH, Errno::ECHILD
+      # Don't care
+    end
+
+    protected
+
+    attr_reader :app_env, :spring_env
+
+    def log(message)
+      spring_env.log "[application_manager:#{app_env}] #{message}"
+    end
+
+    def with_child
+      yield(@pool.get_worker)
+    end
+  end
+end