expedite 0.0.2 → 0.1.1

data/lib/expedite/application_manager.rb

@@ -1,187 +0,0 @@
-# Based on https://github.com/rails/spring/blob/master/lib/spring/application_manager.rb
-
-require 'bundler'
-require 'expedite/failsafe_thread'
-require 'expedite/send_json'
-require 'expedite/variants'
-
-module Expedite
-  class ApplicationManager
-    include SendJson
-
-    attr_reader :pid, :child, :name, :env, :status, :variant
-
-    def initialize(name, env)
-      @name  = name
-      @env   = env
-      @mutex = Mutex.new
-      @state = :running
-      @pid   = nil
-
-      @variant = Expedite::Variants.lookup(@name)
-    end
-
-    def log(message)
-      env.log "[application_manager:#{name}] #{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 child
-          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 child
-          end
-        else
-          log "child not running; starting"
-          start
-          yield child
-        end
-      end
-    end
-
-    # Returns the pid of the process running the command, or nil if the application process died.
-    def run(client)
-      @client = client
-      with_child do |child|
-        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
-
-    def keep_alive
-      variant.keep_alive
-    end
-
-    def parent
-      variant.parent
-    end
-
-    private
-
-    def start_child(preload = false)
-      if parent
-        fork_child(preload)
-      else
-        spawn_child(preload)
-      end
-    end
-
-    def fork_child(preload = false)
-      @child, child_socket = UNIXSocket.pair
-
-      # Compose command
-      wr, rd = UNIXSocket.pair
-      wr.send_io STDOUT
-      wr.send_io STDERR
-      wr.send_io STDIN
-
-      send_json wr, 'args' => ['expedite/boot', name], 'env' => {}
-      wr.send_io child_socket
-      wr.send_io env.log_file
-      wr.close
-
-      @pid = env.applications[parent].run(rd)
-
-      start_wait_thread(pid, child) if child.gets
-      child_socket.close
-    end
-
-    def spawn_child(preload = false)
-      @child, child_socket = UNIXSocket.pair
-
-      Bundler.with_original_env do
-        bundler_dir = File.expand_path("../..", $LOADED_FEATURES.grep(/bundler\/setup\.rb$/).first)
-        @pid = Process.spawn(
-          {
-            "EXPEDITE_VARIANT" => name,
-            "EXPEDITE_ROOT" => env.root,
-          },
-          "ruby",
-          *(bundler_dir != RbConfig::CONFIG["rubylibdir"] ? ["-I", bundler_dir] : []),
-          "-I", File.expand_path("../..", __FILE__),
-          "-e", "require 'expedite/application/boot'",
-          3 => child_socket,
-          4 => env.log_file,
-        )
-      end
-
-      start_wait_thread(pid, child) if child.gets
-      child_socket.close
-    end
-
-    def start_wait_thread(pid, child)
-      Process.detach(pid)
-
-      Expedite.failsafe_thread do
-        # 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 if keep_alive
-          end
-        }
-      end
-    end
-  end
-end

data/lib/expedite/client.rb

@@ -1,235 +0,0 @@
-
-# Based on https://github.com/rails/spring/blob/master/lib/spring/client/run.rb
-
-require 'bundler'
-require 'json'
-require 'rbconfig'
-require 'socket'
-
-require 'expedite/env'
-require 'expedite/errors'
-require 'expedite/send_json'
-
-module Expedite
-  class Client
-    include SendJson
-
-    FORWARDED_SIGNALS = %w(INT QUIT USR1 USR2 INFO WINCH) & Signal.list.keys
-    CONNECT_TIMEOUT   = 1
-    BOOT_TIMEOUT      = 20
-
-    attr_reader :args, :env, :variant
-    attr_reader :server
-
-    def initialize(env: nil, variant: nil)
-      @env = env || Env.new
-      @variant = variant
-
-      @signal_queue  = []
-      @server_booted = false
-    end
-
-    def log(message)
-      env.log "[client] #{message}"
-    end
-
-    def connect
-      @server = UNIXSocket.open(env.socket_path)
-    end
-
-    def call(*args)
-      @args = args
-      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
-      raise
-      require "expedite/command"
-
-      if Expedite.command(args.first)
-        # Command installed since Expedite 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
-          # Server did not start
-          raise ArgumentError, "Server exited: #{status.exitstatus}"
-        elsif Time.now > timeout
-          $stderr.puts "Starting Expedite 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 Expedite 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, "variant" => variant
-
-      if IO.select([server], [], [], CONNECT_TIMEOUT)
-        server.gets or raise CommandNotFound
-      else
-        raise "Error connecting to Expedite 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
-  end
-end

data/lib/expedite/command/info.rb

@@ -1,49 +0,0 @@
-module Expedite
-  module Command
-    class Info
-      def call
-        puts "1"
-        client.puts
-        puts "2"
-        unix_socket = UNIXSocket.for_fd(app_client.fileno)
-        _stdout, stderr, _stdin = streams = 3.times.map do
-          puts "4"
-          unix_socket.recv_io
-        end
-        puts "5"
-        client.puts Process.pid
-        puts "6"
-        unix_socket.puts 11 #application_pids.to_json
-        puts "7"
-        unix_socket.puts 10
-        puts "8"
-        unix_socket.close
-        client.close
-
-        variant = ARGV[0]
-
-        require "expedite/application"
-
-        Expedite::Application.new(
-          variant: variant,
-          manager: UNIXSocket.for_fd(@child_socket.fileno),
-          env: Expedite::Env.new(
-            root: ENV['EXPEDITE_ROOT'],
-            log_file: @log_file,
-          ),
-        ).boot
-      end
-
-      def setup(client)
-        @child_socket = client.recv_io
-        @log_file = client.recv_io
-      end
-
-      def runs_in
-        :server
-      end
-    end
-  end
-end
-
-Expedite::Commands.register("expedite/info", Expedite::Command::Info)

data/lib/expedite/send_json.rb

@@ -1,10 +0,0 @@
-module Expedite
-  module SendJson
-    def send_json(socket, data)
-      data = JSON.dump(data)
-
-      socket.puts  data.bytesize
-      socket.write data
-    end
-  end
-end

data/lib/expedite/server.rb

@@ -1,188 +0,0 @@
-# Based on https://github.com/rails/spring/blob/master/lib/spring/server.rb
-require 'json'
-require 'socket'
-require "expedite/application_manager"
-require "expedite/env"
-require "expedite/signals"
-
-module Expedite
-  class Server
-    include Signals
-
-    def self.boot(options = {})
-      new(options).boot
-    end
-
-    attr_reader :env
-
-    def initialize(foreground: true, env: nil)
-      @foreground   = foreground
-      @env          = env || default_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
-      env.load_helper
-
-      write_pidfile
-      set_pgid unless foreground?
-      ignore_signals unless foreground?
-      set_exit_hook
-      set_process_title
-      start_server
-      exit 0
-    end
-
-    def pid
-      @env.pidfile_path.read.to_i
-    rescue Errno::ENOENT
-      nil
-    end
-
-    def running?
-      pidfile = @env.pidfile_path.open('r+')
-      !pidfile.flock(File::LOCK_EX | File::LOCK_NB)
-    rescue Errno::ENOENT
-      false
-    ensure
-      if pidfile
-        pidfile.flock(File::LOCK_UN)
-        pidfile.close
-      end
-    end
-
-    # timeout: Defaults to 2 seconds
-    def stop
-      if running?
-        timeout = Time.now + @env.graceful_termination_timeout
-        kill 'TERM'
-        sleep 0.1 until !running? || Time.now >= timeout
-
-        if running?
-          kill 'KILL'
-          :killed
-        else
-          :stopped
-        end
-      else
-        :not_running
-      end
-    end
-
-    def kill(sig)
-      pid = self.pid
-      Process.kill(sig, pid) if pid
-    rescue Errno::ESRCH
-      # already dead
-    end
-
-    def start_server
-      server = UNIXServer.open(env.socket_path)
-      log "started on #{env.socket_path}"
-      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, variant = command.values_at('args', 'variant')
-      cmd = args.first
-      if true #Expedite.command(cmd)
-        log "running command #{cmd}"
-        client.puts
-
-        target = env.applications[variant]
-        client.puts target.run(app_client)
-      else
-        log "command not found #{cmd}"
-        client.close
-      end
-    rescue SocketError => e
-      raise e unless client.eof?
-    ensure
-      redirect_output
-    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
-
-      env.applications.values.map { |a| Expedite.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
-        raise "Failed to lock #{@env.pidfile_path}"
-      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
-      $0 = "expedite server | #{env.app_name}"
-    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