rrrspec-client 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 187ea5b96b3437a7c839c23b3e5f1aa3df3b5716
+  data.tar.gz: d83a9df93ffa5ae672b5909e887a52173f6941ff
+SHA512:
+  metadata.gz: c6583325da9e6865baca29415e524f662ecfcdf1a7d2be524b3769748855a20f6629cfe9dae6102bf035534fd4a314a4271e5ace84e421780e56ed5121d435af
+  data.tar.gz: b1f67aba5e30a24d1ee5dad72ae4dc15587d5b25470546c29ebc290be512c3b63743ae43a1b3e630619abb1b9d1308563ad2d0347d8ed7c9cc004431e611a93e

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.ruby-version

@@ -0,0 +1 @@
+2.0.0-p247

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/rrrspec

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+case ARGV[0]
+when "server", "worker"
+  require 'rrrspec/server/cli'
+  RRRSpec::Server::CLI.start
+when "scaler", "scalerspy"
+  require 'rrrspec/scaler/cli'
+  RRRSpec::Scaler::CLI.start
+else
+  require 'rrrspec/client/cli'
+  RRRSpec::Client::CLI.start
+end

data/bin/rrrspec-client

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require 'rrrspec/client/cli'
+RRRSpec::Client::CLI.start

data/lib/rrrspec/client/cli.rb

@@ -0,0 +1,131 @@
+require 'rrrspec/client'
+require 'launchy'
+require 'thor'
+
+module RRRSpec
+  module Client
+    class CLI < Thor
+      WAIT_POLLING_SEC = 10
+
+      package_name 'RRRSpec'
+      default_command 'help'
+      class_option :config, aliases: '-c',  type: :string, default: ''
+
+      no_commands do
+        def setup(conf)
+          RRRSpec.setup(conf, options[:config].split(':'))
+        end
+
+        def log_exception
+          yield
+        rescue
+          RRRSpec.logger.error($!)
+          raise
+        end
+      end
+
+      option :'key-only', type: :boolean
+      option :'rsync-name', type: :string, default: ENV['USER']
+      option :'worker-type', type: :string
+      desc 'start', 'start RRRSpec'
+      def start
+        setup(ClientConfiguration.new)
+        if options[:'worker-type']
+          RRRSpec.configuration.worker_type = options[:'worker-type']
+        end
+        taskset = Support.start_taskset(RRRSpec.configuration, options[:'rsync-name'])
+        puts taskset.key
+
+        if RRRSpec.configuration.rrrspec_web_base && !options[:'key-only']
+          url = "#{RRRSpec.configuration.rrrspec_web_base}/tasksets/#{taskset.key}"
+          Launchy.open(url)
+        end
+      end
+
+      desc 'cancel', 'cancel the taskset'
+      def cancel(taskset_id)
+        setup(Configuration.new)
+        taskset = Taskset.new(taskset_id)
+        exit(1) unless taskset.exist?
+        taskset.cancel
+      end
+
+      desc 'cancelall', 'cancel all tasksets whose rsync name is specified name'
+      def cancelall(rsync_name)
+        setup(Configuration.new)
+        ActiveTaskset.all_tasksets_of(rsync_name).each do |taskset|
+          taskset.cancel
+        end
+      end
+
+      desc 'actives', 'list up the active tasksets'
+      def actives
+        setup(Configuration.new)
+        ActiveTaskset.list.each { |taskset| puts taskset.key }
+      end
+
+      desc 'nodes', 'list up the active nodes'
+      def nodes
+        setup(Configuration.new)
+        puts "Server:"
+        puts "\t#{RSyncInfo.exist? ? "Yes" : "No"}"
+        puts "Workers:"
+        Worker.list.each { |worker| puts "\t#{worker.key}" }
+      end
+
+      option :pollsec, type: :numeric, default: WAIT_POLLING_SEC
+      desc 'waitfor', 'wait for the taskset'
+      def waitfor(taskset_id)
+        setup(Configuration.new)
+        taskset = Taskset.new(taskset_id)
+        exit(1) unless taskset.exist?
+
+        rd, wt = IO.pipe
+        Signal.trap(:TERM) { wt.write("1") }
+        Signal.trap(:INT) { wt.write("1") }
+
+        loop do
+          rs, ws, = IO.select([rd], [], [], options[:pollsec])
+          if rs == nil
+            break if taskset.persisted?
+          elsif rs.size != 0
+            rs[0].getc
+            taskset.cancel
+          end
+        end
+      end
+
+      option :'failure-exit-code', type: :numeric, default: 1
+      option :verbose, type: :boolean, default: false
+      desc 'show', 'show the result of the taskset'
+      def show(taskset_id)
+        setup(Configuration.new)
+        taskset = Taskset.new(taskset_id)
+        exit 1 unless taskset.exist?
+        Support.show_result(taskset, options[:verbose])
+
+        if taskset.status != 'succeeded'
+          exit options[:'failure-exit-code']
+        end
+      end
+
+      desc 'slave', 'run RRRSpec as a slave'
+      def slave(working_dir=nil, taskset_key=nil)
+        $0 = 'rrrspec slave'
+        working_dir ||= ENV['RRRSPEC_WORKING_DIR']
+        taskset_key ||= ENV['RRRSPEC_TASKSET_KEY']
+        exit 1 unless taskset_key && working_dir
+
+        setup(Configuration.new)
+        log_exception do
+          slave = Slave.create
+          slave_runner = SlaveRunner.new(slave, working_dir, taskset_key)
+          Thread.abort_on_exception = true
+          Thread.fork { RRRSpec.pacemaker(slave, 60, 5) }
+          Thread.fork { slave_runner.work_loop }
+          Kernel.sleep
+        end
+      end
+    end
+  end
+end

data/lib/rrrspec/client/configuration.rb

@@ -0,0 +1,82 @@
+module RRRSpec
+  module Client
+    class ClientConfiguration < Configuration
+      attr_accessor :packaging_dir
+      attr_accessor :packaging_rsync_options
+      attr_writer :spec_files
+      attr_accessor :setup_command, :slave_command
+      attr_accessor :taskset_class, :worker_type
+      attr_accessor :max_workers, :max_trials
+      attr_accessor :rrrspec_web_base
+      attr_accessor :unknown_spec_timeout_sec, :least_timeout_sec
+
+      def spec_files
+        case @spec_files
+        when Proc then @spec_files.call
+        when String then [@spec_files]
+        else @spec_files
+        end
+      end
+
+      def initialize
+        super()
+        @type = :client
+        @unknown_spec_timeout_sec = 5 * 60
+        @least_timeout_sec = 30
+      end
+
+      def check_validity
+        validity = super
+
+        unless Dir.exists?(packaging_dir)
+          $stderr.puts("The packaging_dir does not exists: '#{packaging_dir}'")
+          validity = false
+        end
+
+        unless spec_files.is_a?(Array)
+          $stderr.puts("The spec_files should be an Array: '#{spec_files}'")
+          validity = false
+        else
+          spec_files.each do |filepath|
+            unless File.exists?(File.join(packaging_dir, filepath))
+              $stderr.puts("One of the spec_files does not exists '#{filepath}'")
+              validity = false
+            end
+          end
+        end
+
+        unless max_workers.is_a?(Integer)
+          $stderr.puts("The max_workers should be an Integer: '#{max_workers}'")
+          validity = false
+        else
+          unless max_workers >= 1
+            $stderr.puts("The max_workers should not be less than 1: #{max_workers}")
+            validity = false
+          end
+        end
+
+        unless max_trials.is_a?(Integer)
+          $stderr.puts("The max_trials should be an Integer: '#{max_trials}'")
+          validity = false
+        end
+
+        unless taskset_class.is_a?(String)
+          $stderr.puts("The taskset_class should be a String: '#{taskset_class}'")
+          validity = false
+        end
+
+        unless unknown_spec_timeout_sec.is_a?(Integer)
+          $stderr.puts("The unknown_spec_timeout_sec should be an Integer: '#{unknown_spec_timeout_sec}'")
+          validity = false
+        end
+
+        unless least_timeout_sec.is_a?(Integer)
+          $stderr.puts("The least_timeout_sec should be an Integer: '#{least_timeout_sec}'")
+          validity = false
+        end
+
+        validity
+      end
+    end
+  end
+end

data/lib/rrrspec/client/rspec_runner.rb

@@ -0,0 +1,83 @@
+require 'rspec'
+require 'rspec/core/formatters/base_text_formatter'
+
+module RRRSpec
+  module Client
+    class RSpecRunner
+      def initialize
+        @options = RSpec::Core::ConfigurationOptions.new([])
+        @options.parse_options
+        @configuration = RSpec.configuration
+        @configuration.setup_load_path_and_require([])
+        @world = RSpec.world
+        @before_suite_run = false
+      end
+
+      def exc_safe_replace_stdouts
+        outbuf = ''
+        errbuf = ''
+        $stdout = StringIO.new(outbuf)
+        $stderr = StringIO.new(errbuf)
+        begin
+          yield
+        rescue Exception
+          $stdout.puts $!
+          $stdout.puts $!.backtrace.join("\n")
+        end
+        [outbuf, errbuf]
+      ensure
+        $stdout = STDOUT
+        $stderr = STDERR
+      end
+
+      def setup(filepath)
+        status = false
+        outbuf, errbuf = exc_safe_replace_stdouts do
+          begin
+            @options.configure(@configuration)
+            @configuration.files_to_run = [filepath]
+            @configuration.load_spec_files
+            @world.announce_filters
+            unless @before_suite_run
+              @configuration.run_hook(:before, :suite)
+              @before_suite_run = true
+            end
+            status = true
+          rescue Exception
+            $stdout.puts $!
+            $stdout.puts $!.backtrace.join("\n")
+            status = false
+          end
+        end
+
+        [status, outbuf, errbuf]
+      end
+
+      def run(*formatters)
+        status = false
+        outbuf, errbuf = exc_safe_replace_stdouts do
+          @configuration.formatters << RSpec::Core::Formatters::BaseTextFormatter.new($stdout)
+          formatters.each do |formatter|
+            @configuration.formatters << formatter
+          end
+          @configuration.reporter.report(
+            @world.example_count,
+            @configuration.randomize? ? @configuration.seed : nil
+          ) do |reporter|
+            @world.example_groups.ordered.each do |example_group|
+              example_group.run(reporter)
+            end
+          end
+          status = true
+        end
+
+        [status, outbuf, errbuf]
+      end
+
+      def reset
+        @world.example_groups.clear
+        @configuration.reset
+      end
+    end
+  end
+end

data/lib/rrrspec/client/slave_runner.rb

@@ -0,0 +1,128 @@
+require 'set'
+require 'extreme_timeout'
+require 'timeout'
+
+module RRRSpec
+  module Client
+    class SlaveRunner
+      attr_reader :key
+
+      TASKQUEUE_TASK_TIMEOUT = -1
+      TASKQUEUE_ARBITER_TIMEOUT = 20
+      TIMEOUT_EXITCODE = 42
+      class SoftTimeoutException < Exception; end
+
+      def initialize(slave, working_dir, taskset_key)
+        @slave = slave
+        @taskset = Taskset.new(taskset_key)
+        @timeout = TASKQUEUE_TASK_TIMEOUT
+        @rspec_runner = RSpecRunner.new
+        @working_path = File.join(working_dir, @taskset.rsync_name)
+        @unknown_spec_timeout_sec = @taskset.unknown_spec_timeout_sec
+        @least_timeout_sec = @taskset.least_timeout_sec
+        @worked_task_keys = Set.new
+      end
+
+      def work_loop
+        loop { work }
+      end
+
+      def spec_timeout_sec(task)
+        if task.estimate_sec == nil
+          soft_timeout_sec = @unknown_spec_timeout_sec
+          hard_timeout_sec = @unknown_spec_timeout_sec + 30
+        else
+          estimate_sec = task.estimate_sec
+          soft_timeout_sec = estimate_sec * 2
+          hard_timeout_sec = estimate_sec * 3
+        end
+        return [soft_timeout_sec, @least_timeout_sec].max, [hard_timeout_sec, @least_timeout_sec].max
+      end
+
+      def work
+        task = @taskset.dequeue_task(@timeout)
+        unless task
+          @timeout = TASKQUEUE_ARBITER_TIMEOUT
+          ArbiterQueue.check(@taskset)
+        else
+          @timeout = TASKQUEUE_TASK_TIMEOUT
+          if @worked_task_keys.include?(task.key)
+            @taskset.reversed_enqueue_task(task)
+            return
+          else
+            @worked_task_keys << task.key
+          end
+
+          return if task.status.present?
+          trial = Trial.create(task, @slave)
+
+          @rspec_runner.reset
+          status, outbuf, errbuf = @rspec_runner.setup(File.join(@working_path, task.spec_file))
+          unless status
+            trial.finish('error', outbuf, errbuf, nil, nil, nil)
+            ArbiterQueue.trial(trial)
+            return
+          end
+
+          soft_timeout_sec, hard_timeout_sec = spec_timeout_sec(task)
+
+          formatter = RedisReportingFormatter.new
+          trial.start
+          status, outbuf, errbuf = ExtremeTimeout::timeout(
+            hard_timeout_sec, TIMEOUT_EXITCODE
+          ) do
+            Timeout::timeout(soft_timeout_sec, SoftTimeoutException) do
+              @rspec_runner.run(formatter)
+            end
+          end
+          if status
+            trial.finish(formatter.status, outbuf, errbuf,
+                         formatter.passed, formatter.pending, formatter.failed)
+          else
+            trial.finish('error', outbuf, errbuf, nil, nil, nil)
+          end
+
+          ArbiterQueue.trial(trial)
+        end
+      end
+
+      class RedisReportingFormatter
+        attr_reader :passed, :pending, :failed
+
+        def initialize
+          @passed = 0
+          @pending = 0
+          @failed = 0
+          @timeout = false
+        end
+
+        def example_passed(example)
+          @passed += 1
+        end
+
+        def example_pending(example)
+          @pending += 1
+        end
+
+        def example_failed(example)
+          @failed += 1
+          if example.exception.is_a?(SoftTimeoutException)
+            @timeout = true
+          end
+        end
+
+        def status
+          if @timeout
+            'timeout'
+          elsif @failed != 0
+            'failed'
+          elsif @pending != 0
+            'pending'
+          else
+            'passed'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rrrspec/client/support.rb

@@ -0,0 +1,147 @@
+module RRRSpec
+  module Client
+    module Support
+      module_function
+
+      def start_taskset(conf, rsync_name)
+        $stderr.puts '1/3) Making a package...'
+        if is_using_rsync?(rsync_name)
+          $stderr.puts 'It seems you are running rrrspec already'
+          $stderr.puts 'Please wait until the previous run finishes'
+          exit 1
+        end
+        unless run_rsync_package(rsync_name)
+          $stderr.puts 'rsync failed.'
+          exit 1
+        end
+
+        $stderr.puts '2/3) Uploading the package...'
+        taskset = Taskset.create(
+          rsync_name,
+          conf.setup_command,
+          conf.slave_command,
+          conf.worker_type,
+          conf.taskset_class,
+          conf.max_workers,
+          conf.max_trials,
+          conf.unknown_spec_timeout_sec,
+          conf.least_timeout_sec
+        )
+        estimate_sec_sorted(conf.taskset_class, conf.spec_files.uniq).reverse_each do |spec_file, estimate_sec|
+          task = Task.create(taskset, estimate_sec, spec_file)
+          taskset.add_task(task)
+          taskset.enqueue_task(task)
+        end
+
+        $stderr.puts '3/3) Enqueue the taskset...'
+        ActiveTaskset.add(taskset)
+        DispatcherQueue.notify
+        $stderr.puts 'Your request is successfully enqueued!'
+        return taskset
+      end
+
+      def show_result(taskset, verbose=false)
+        puts "Status:    #{taskset.status}"
+        puts "Created:   #{taskset.created_at}"
+        puts "Finished:  #{taskset.finished_at}"
+        puts "Tasks:     #{taskset.task_size}"
+        puts "Succeeded: #{taskset.succeeded_count}"
+        puts "Failed:    #{taskset.failed_count}"
+
+        if verbose
+          puts
+
+          puts "Log:"
+          taskset.log.split("\n").each { |line| puts "\t#{line}" }
+          puts
+
+          puts "Workers:"
+          taskset.worker_logs.each do |worker_log|
+            puts "\tKey: #{worker_log.key}"
+            puts "\tStarted:        #{worker_log.started_at}"
+            puts "\tRSync Finished: #{worker_log.rsync_finished_at}"
+            puts "\tSetup Finished: #{worker_log.setup_finished_at}"
+            puts "\tFinished:       #{worker_log.finished_at}"
+            puts "\tLog:"
+            worker_log.log.split("\n").each { |line| puts "\t\t#{line}" }
+          end
+          puts
+
+          puts "Slaves:"
+          taskset.slaves.each do |slave|
+            puts "\tKey:    #{slave.key}"
+            puts "\tStatus: #{slave.status}"
+            puts "\tTrials:"
+            slave.trials.each do |trial|
+              puts "\t\t#{trial.key}"
+            end
+            puts "\tLog:"
+            slave.log.split("\n").each { |line| puts "\t\t#{line}" }
+          end
+          puts
+
+          puts "Tasks:"
+          taskset.tasks.each do |task|
+            puts "\tKey:    #{task.key}"
+            puts "\tSpec:   #{task.spec_file}"
+            puts "\tStatus: #{task.status}"
+            puts "\tTrials:"
+            task.trials.each do |trial|
+              puts "\t\tKey:      #{trial.key}"
+              puts "\t\tSlave:    #{trial.slave.key}"
+              puts "\t\tStatus:   #{trial.status}"
+              puts "\t\tStarted:  #{trial.started_at}"
+              puts "\t\tFinished: #{trial.finished_at}"
+              puts "\t\tPassed:   #{trial.passed}"
+              puts "\t\tPending:  #{trial.pending}"
+              puts "\t\tFailed:   #{trial.failed}"
+              stdout = trial.stdout
+              if stdout
+                puts "\t\tSTDOUT:"
+                stdout.split("\n").each { |line| puts "\t\t\t#{line}" }
+              end
+              stderr = trial.stderr
+              if stderr
+                puts "\t\tSTDERR:"
+                stderr.split("\n").each { |line| puts "\t\t\t#{line}" }
+              end
+            end
+          end
+        end
+      end
+
+      def run_rsync_package(rsync_name)
+        conf = RRRSpec.configuration
+        remote_dir = File.join(RSyncInfo.rsync_dir, rsync_name)
+        remote_path = "#{RSyncInfo.rsync_server}:#{remote_dir}"
+        command = "rsync #{conf.packaging_rsync_options} #{conf.packaging_dir}/ #{remote_path}"
+        $stderr.puts command
+        system(command)
+        $?.success?
+      end
+
+      def is_using_rsync?(rsync_name)
+        ActiveTaskset.list.any? do |taskset|
+          taskset.rsync_name == rsync_name
+        end
+      end
+
+      # Public: Sort the spec filepaths by their estiamted spec execution times.
+      #
+      # Returns an array of [spec_file, estiamte_sec]
+      def estimate_sec_sorted(taskset_class, spec_files)
+        estimate_secs = TasksetEstimation.estimate_secs(taskset_class)
+        spec_files.map do |spec_file|
+          [spec_file, estimate_secs[spec_file]]
+        end.sort do |a, b|
+          case
+          when a[1] == nil && b[1] == nil then 0
+          when a[1] == nil && b[1] != nil then 1
+          when a[1] != nil && b[1] == nil then -1
+          else a[1] - b[1]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rrrspec/client/version.rb

@@ -0,0 +1,5 @@
+module RRRSpec
+  module Client
+    VERSION = "0.2.0"
+  end
+end

data/lib/rrrspec/client.rb

@@ -0,0 +1,5 @@
+require 'rrrspec'
+require 'rrrspec/client/configuration'
+require 'rrrspec/client/rspec_runner'
+require 'rrrspec/client/slave_runner'
+require 'rrrspec/client/support'

data/lib/rrrspec/configuration.rb

@@ -0,0 +1,42 @@
+module RRRSpec
+  class Configuration
+    attr_accessor :loaded
+    attr_reader :type
+
+    def redis=(arg)
+      @redis_value = arg
+    end
+
+    def redis
+      case @redis_value
+      when Hash then Redis.new(@redis_value)
+      when Proc then @redis_value.call
+      else @redis_value
+      end
+    end
+
+    def check_validity
+      validity = true
+
+      unless @redis_value
+        $stderr.puts("Redis configuration is empty")
+        validity = false
+      end
+
+      validity
+    end
+
+    def load_files(files)
+      loaded = []
+      files.each do |filepath|
+        filepath = File.absolute_path(filepath)
+        next unless File.exists?(filepath)
+        $stderr.puts("Loading: #{filepath}")
+        load filepath
+        loaded << filepath
+      end
+
+      RRRSpec.configuration.loaded = loaded
+    end
+  end
+end