giga-safe-hub 0.0.1

data/spring-4.7.0/lib/spring/client/run.rb

@@ -0,0 +1,297 @@
+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
+      ServerReadTimeout = Class.new(StandardError)
+
+      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(server_process_env, env.server_command, out: File::NULL)
+        timeout = Time.now + Spring.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 #{Spring.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 reset_env
+        ENV.slice(*Spring.reset_on_env)
+      end
+
+      def server_process_env
+        reset_env.merge(gem_env)
+      end
+
+      def stop_server
+        server.close
+        @server = nil
+        env.stop
+      end
+
+      def verify_server_version
+        begin
+          line = read_server_line
+        rescue ServerReadTimeout
+          if waiting_for_server_boot?
+            begin
+              # Try again, but with same timeout as booting, as server might still be booting
+              #   from another client starting it.
+              line = read_server_line(Spring.boot_timeout)
+            rescue ServerReadTimeout
+              reboot_or_raise_connection_error
+              return
+            end
+          else
+            reboot_or_raise_connection_error
+            return
+          end
+        end
+
+        if line.nil?
+          reboot_or_raise_connection_error
+          return
+        end
+
+        server_version = line.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 read_server_line(timeout = Spring.connect_timeout)
+        raise ServerReadTimeout if IO.select([server], [], [], timeout).nil?
+
+        server.gets
+      end
+
+      def waiting_for_server_boot?
+        !server_booted? && env.server_running?
+      end
+
+      def reboot_or_raise_connection_error
+        if server_booted?
+          raise "Error connecting to Spring server"
+        else
+          stop_server
+          cold_run
+        end
+      end
+
+      def connect_to_application(client)
+        server.send_io client
+        send_json server, "args" => args, "default_rails_env" => default_rails_env, "spawn_env" => spawn_env, "reset_env" => reset_env
+
+        if IO.select([server], [], [], Spring.connect_timeout)
+          server.gets or raise CommandNotFound
+        else
+          raise "Error connecting to Spring server"
+        end
+      end
+
+      def run_command(client, application)
+        application.send_io STDOUT
+        application.send_io STDERR
+        application.send_io STDIN
+
+        log "waiting for the application to be preloaded"
+        preload_status = application.gets
+        preload_status = preload_status.chomp if preload_status
+        log "app preload status: #{preload_status}"
+        exit 1 if preload_status == "1"
+
+        log "sending command"
+        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
+          log "got exit status #{status.inspect}"
+
+          # Status should always be an integer. If it is empty, something unexpected must have happened to the server.
+          if status.to_s.strip.empty?
+            log "unexpected empty exit status, app crashed?"
+            exit 1
+          end
+
+          exit status.to_i
+        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
+
+      def spawn_env
+        Spring.spawn_on_env.to_h do |key|
+          [key, ENV[key]]
+        end
+      end
+    end
+  end
+end

data/spring-4.7.0/lib/spring/client/server.rb

@@ -0,0 +1,18 @@
+module Spring
+  module Client
+    class Server < Command
+      def self.description
+        "Explicitly start a Spring server in the foreground"
+      end
+
+      def call
+        require "spring/server"
+        Spring::Server.boot(foreground: foreground?)
+      end
+
+      def foreground?
+        !args.include?("--background")
+      end
+    end
+  end
+end

data/spring-4.7.0/lib/spring/client/status.rb

@@ -0,0 +1,30 @@
+module Spring
+  module Client
+    class Status < Command
+      def self.description
+        "Show current status."
+      end
+
+      def call
+        if env.server_running?
+          puts "Spring is running:"
+          puts
+          print_process env.pid
+          application_pids.each { |pid| print_process pid }
+        else
+          puts "Spring is not running."
+        end
+      end
+
+      def print_process(pid)
+        puts `ps -p #{pid} -o pid= -o command=`
+      end
+
+      def application_pids
+        candidates = `ps -ax -o ppid= -o pid=`.lines
+        candidates.select { |l| l =~ /^(\s+)?#{env.pid} / }
+                  .map    { |l| l.split(" ").last   }
+      end
+    end
+  end
+end

data/spring-4.7.0/lib/spring/client/stop.rb

@@ -0,0 +1,22 @@
+require "spring/version"
+
+module Spring
+  module Client
+    class Stop < Command
+      def self.description
+        "Stop all Spring processes for this project."
+      end
+
+      def call
+        case env.stop
+        when :stopped
+          puts "Spring stopped."
+        when :killed
+          $stderr.puts "Spring did not stop; killing forcibly."
+        when :not_running
+          puts "Spring is not running"
+        end
+      end
+    end
+  end
+end

data/spring-4.7.0/lib/spring/client/version.rb

@@ -0,0 +1,11 @@
+require "spring/version"
+
+module Spring
+  module Client
+    class Version < Command
+      def call
+        puts "Spring version #{Spring::VERSION}"
+      end
+    end
+  end
+end

data/spring-4.7.0/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/spring-4.7.0/lib/spring/command_wrapper.rb

@@ -0,0 +1,82 @@
+require "spring/configuration"
+
+module Spring
+  class CommandWrapper
+    attr_reader :name, :command
+
+    def initialize(name, command = nil)
+      @name    = name
+      @command = command
+      @setup   = false
+    end
+
+    def description
+      if command.respond_to?(:description)
+        command.description
+      else
+        "Runs the #{name} command"
+      end
+    end
+
+    def setup?
+      @setup
+    end
+
+    def setup
+      if !setup? && command.respond_to?(:setup)
+        command.setup
+        @setup = true
+        return true
+      else
+        @setup = true
+        return false
+      end
+    end
+
+    def call
+      if command.respond_to?(:call)
+        command.call
+      else
+        load exec
+      end
+    end
+
+    def gem_name
+      if command.respond_to?(:gem_name)
+        command.gem_name
+      else
+        exec_name
+      end
+    end
+
+    def exec_name
+      if command.respond_to?(:exec_name)
+        command.exec_name
+      else
+        name
+      end
+    end
+
+    def binstub
+      Spring.application_root_path.join(binstub_name)
+    end
+
+    def binstub_name
+      "bin/#{name}"
+    end
+
+    def exec
+      if binstub.exist?
+        binstub.to_s
+      else
+        Gem.bin_path(gem_name, exec_name)
+      end
+    end
+
+    def env(args)
+      if command.respond_to?(:env)
+        command.env(args)
+      end
+    end
+  end
+end

data/spring-4.7.0/lib/spring/commands/rails.rb

@@ -0,0 +1,112 @@
+module Spring
+  module Commands
+    class Rails
+      def call
+        ARGV.unshift command_name
+        load Dir.glob(::Rails.root.join("{bin,script}/rails")).first
+      end
+
+      def description
+        nil
+      end
+    end
+
+    class RailsConsole < Rails
+      def env(args)
+        return args.first if args.first && !args.first.index("-")
+
+        environment = nil
+
+        args.each.with_index do |arg, i|
+          if arg =~ /--environment=(\w+)/
+            environment = $1
+          elsif i > 0 && args[i - 1] == "-e"
+            environment = arg
+          end
+        end
+
+        environment
+      end
+
+      def command_name
+        "console"
+      end
+    end
+
+    class RailsGenerate < Rails
+      def command_name
+        "generate"
+      end
+    end
+
+    class RailsDestroy < Rails
+      def command_name
+        "destroy"
+      end
+    end
+
+    class RailsRunner < Rails
+      def call
+        ARGV.replace extract_environment(ARGV).first
+        super
+      end
+
+      def env(args)
+        extract_environment(args).last
+      end
+
+      def command_name
+        "runner"
+      end
+
+      def extract_environment(args)
+        environment = nil
+
+        args = args.select.with_index { |arg, i|
+          case arg
+          when "-e"
+            false
+          when /--environment=(\w+)/
+            environment = $1
+            false
+          else
+            if i > 0 && args[i - 1] == "-e"
+              environment = arg
+              false
+            else
+              true
+            end
+          end
+        }
+
+        [args, environment]
+      end
+    end
+
+    class RailsTest < Rails
+      def env(args)
+        environment = "test"
+
+        args.each.with_index do |arg, i|
+          if arg =~ /--environment=(\w+)/
+            environment = $1
+          elsif i > 0 && args[i - 1] == "-e"
+            environment = arg
+          end
+        end
+
+        environment
+      end
+
+      def command_name
+        "test"
+      end
+    end
+
+    Spring.register_command "rails_console",  RailsConsole.new
+    Spring.register_command "rails_generate", RailsGenerate.new
+    Spring.register_command "rails_destroy",  RailsDestroy.new
+    Spring.register_command "rails_runner",   RailsRunner.new
+    Spring.register_command "rails_test",     RailsTest.new
+  end
+end

data/spring-4.7.0/lib/spring/commands/rake.rb

@@ -0,0 +1,30 @@
+module Spring
+  module Commands
+    class Rake
+      class << self
+        attr_accessor :environment_matchers
+      end
+
+      self.environment_matchers = {
+        :default     => "test",
+        /^test($|:)/ => "test"
+      }
+
+      def env(args)
+        # This is an adaption of the matching that Rake itself does.
+        # See: https://github.com/jimweirich/rake/blob/3754a7639b3f42c2347857a0878beb3523542aee/lib/rake/application.rb#L691-L692
+        if env = args.grep(/^(RAILS|RACK)_ENV=(.*)$/m).last
+          return env.split("=").last
+        end
+
+        self.class.environment_matchers.each do |matcher, environment|
+          return environment if matcher === (args.first || :default)
+        end
+
+        nil
+      end
+    end
+
+    Spring.register_command "rake", Rake.new
+  end
+end

data/spring-4.7.0/lib/spring/commands.rb

@@ -0,0 +1,57 @@
+require "spring/watcher"
+require "spring/command_wrapper"
+
+module Spring
+  @commands = {}
+
+  class << self
+    attr_reader :commands
+  end
+
+  def self.register_command(name, command = nil)
+    commands[name] = CommandWrapper.new(name, command)
+  end
+
+  def self.command?(name)
+    commands.include? name
+  end
+
+  def self.command(name)
+    commands.fetch name
+  end
+
+  require "spring/commands/rails"
+  require "spring/commands/rake"
+
+  # Load custom commands, if any.
+  # needs to be at the end to allow modification of existing commands.
+  config = File.expand_path("~/.spring.rb")
+  require config if File.exist?(config)
+
+  # We force the TTY so bundler doesn't show a backtrace in case gems are missing.
+  old_env = ENV["BUNDLER_FORCE_TTY"]
+  ENV["BUNDLER_FORCE_TTY"] = "true"
+  begin
+    # If the config/spring.rb contains requires for commands from other gems,
+    # then we need to be under bundler.
+    require "bundler/setup"
+  ensure
+    ENV["BUNDLER_FORCE_TTY"] = old_env
+  end
+
+  # Auto-require any Spring extensions which are in the Gemfile
+  Gem::Specification.map(&:name).grep(/^spring-/).each do |command|
+    begin
+      require command
+    rescue LoadError => error
+      if error.message.include?(command)
+        require command.gsub("-", "/")
+      else
+        raise
+      end
+    end
+  end
+
+  config = File.expand_path("./config/spring.rb")
+  require config if File.exist?(config)
+end