expedite 0.0.1

data/lib/expedite/cli.rb

@@ -0,0 +1,42 @@
+require 'expedite/cli/server'
+require 'expedite/cli/stop'
+
+module Expedite
+  module Cli
+    class Help
+      def run(args)
+        puts "Expected: <command>"
+        puts
+        puts "Commands:"
+
+        cmds = Expedite::Cli::COMMANDS
+        cmds.keys.sort!.each do |cmd|
+          c = cmds[cmd].new
+          puts "  #{cmd}: #{c.summary}"
+        end
+      end
+
+      def summary
+        'Prints usage documentation'
+      end
+    end
+
+    module_function
+
+    COMMANDS = {
+      'help'   => Cli::Help,
+      'server' => Cli::Server,
+      'stop'   => Cli::Stop,
+    }
+
+    def run(args)
+      command(args.first).run(args[1..])
+    end
+
+    def command(cmd)
+      klass = COMMANDS[cmd]
+      raise NotImplementedError, "Unknown command '#{cmd}'" if klass.nil?
+      klass.new
+    end
+  end
+end

data/lib/expedite/cli/server.rb

@@ -0,0 +1,16 @@
+module Expedite
+  module Cli
+    class Server
+      def run(args)
+        require 'expedite/server'
+
+        server = Expedite::Server.new(foreground: true)
+        server.boot
+      end
+
+      def summary
+        'Starts the expedite server'
+      end
+    end
+  end
+end

data/lib/expedite/cli/stop.rb

@@ -0,0 +1,16 @@
+module Expedite
+  module Cli
+    class Stop
+      def run(args)
+        require 'expedite/server'
+
+        server = Expedite::Server.new
+        server.stop
+      end
+
+      def summary
+        'Stops the expedite server'
+      end
+    end
+  end
+end

data/lib/expedite/client.rb

@@ -0,0 +1,235 @@
+
+# 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/basic.rb

@@ -0,0 +1,20 @@
+
+module Expedite
+  module Command
+    class Basic
+      attr_reader :runs_in
+      
+      def initialize(runs_in: :application, &block)
+        @runs_in = runs_in
+        @block = block
+      end
+
+      def call(*args)
+        @block.call(*args)
+      end
+
+      def setup(_)
+      end
+    end
+  end
+end

data/lib/expedite/command/boot.rb

@@ -0,0 +1,27 @@
+module Expedite
+  module Command
+    class Boot
+      def call
+        variant = ARGV[0]
+
+        require "expedite/application"
+        
+        Expedite::Application.new(
+          variant,
+          UNIXSocket.for_fd(@child_socket.fileno),
+          {},
+          Expedite::Env.new(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

data/lib/expedite/command/info.rb

@@ -0,0 +1,47 @@
+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,
+          UNIXSocket.for_fd(@child_socket.fileno),
+          {},
+          Expedite::Env.new(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/commands.rb

@@ -0,0 +1,62 @@
+require 'expedite/command/basic'
+require 'expedite/command/boot'
+
+module Expedite
+  class Commands
+    def self.current
+      @current ||= Commands.new
+    end
+
+    def self.lookup(name)
+      self.current.lookup(name)
+    end
+
+    ##
+    # Registers a command. If multiple commands are registered with the
+    # same name, the last one takes precedence.
+    #
+    # [name] Name of the command. Expedite internal commands are prefixed
+    #        with "expedite/"
+    # [klass_or_nil] Class of the command. If omitted, will default to
+    #                Expedite::Command::Basic.
+    # [named_options] Command options. Passed to the initializer.
+    def self.register(name, klass_or_nil = nil, **named_options, &block)
+      self.current.register(name, klass_or_nil, **named_options, &block)
+    end
+
+    ##
+    # Restores existing registrations to default
+    def self.reset
+      self.current.reset
+    end
+
+    def initialize
+      reset
+    end
+
+    def lookup(name)
+       ret = @registrations[name]
+       raise NotImplementedError, "Command #{name.inspect} not found" if ret.nil?
+       ret
+    end
+
+    def register(name, klass_or_nil = nil, **named_options, &block)
+      cmd = if klass_or_nil.nil?
+        Command::Basic.new(**named_options, &block)
+      else
+        klass_or_nil.new(**named_options)
+      end
+
+      @registrations[name] = cmd
+    end
+
+    def reset
+      @registrations = {}
+
+      # Default registrations
+      register("expedite/boot", Expedite::Command::Boot)
+
+      nil
+    end
+  end
+end