fast_rake 0.0.1

data/README.rdoc

@@ -0,0 +1,49 @@
+= fast_rake
+
+* TODO url
+
+== SYNOPSIS
+
+TODO description
+
+=== Usage
+
+  TODO (code sample of usage)
+
+== REQUIREMENTS
+
+* TODO (list of requirements)
+
+== INSTALLATION
+
+  sudo gem install fast_rake
+
+== DEVELOPMENT
+
+TODO developer advice
+
+== LICENSE
+
+(The MIT License)
+
+Copyright (c) 2012 TODO
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/lib/fast_rake/fast_runner.rb

@@ -0,0 +1,172 @@
+require "rake"
+require 'timeout'
+
+class FastRake::FastRunner
+
+  GREEN = "\033[32m"
+  RED = "\033[31m"
+  YELLOW = "\e[33m"
+  RESET = "\033[0m"
+
+  def initialize(tasks, process_count)
+    @tasks = tasks
+    @process_count = process_count
+    @children = {}
+    @parent = true
+    @env_number = 0
+    @failed=false
+    #put_w_time "Parent PID is: #{Process.pid}"
+  end
+
+  def run
+    clean_previous_results
+    check_if_previous_processes_really_finished
+    @start = Time.now
+
+    put_w_time %{Started at #{Time.now.strftime("%H:%M:%S")}}
+    at_exit { kill_remaining_children }
+
+    start_some_children
+
+    wait_for_tasks_to_finish
+    put_w_time "#{@failed ? RED : GREEN}Elapsed time: #{distance_of_time_to_now(@start)}#{RESET}"
+    raise 'failed fast' if @failed
+  end
+
+  private
+
+  def check_if_previous_processes_really_finished
+    process = `ps aux | grep -E "ruby|selenium" | grep -vE "grep|foreman|script\/worker|guard|memcached|growl_notify_buildlight|gem server|#{Process.pid}"`
+    lines = process.split("\n")
+    if lines.length > 0
+      puts lines
+      prompt = "#{YELLOW}These ruby|selenium processes were found to be running. Do you want to continue (Y)? (ctrl-c to stop)#{RESET}"
+      puts prompt
+      STDIN.each_line do |line|
+        return if line.downcase.chomp == 'y'
+        puts prompt
+      end
+    end
+  end
+
+  def results_folder
+    Rails.root.join('tmp', 'build')
+  end
+
+  def clean_previous_results
+    `rm -rf "#{results_folder}"`
+  end
+
+  def distance_of_time_to_now(time)
+    seconds = Time.now - time
+    total_minutes = (seconds / 1.minutes).floor
+    seconds_in_last_minute = (seconds - total_minutes.minutes.seconds).floor
+    "%02dm %02ds" % [total_minutes, seconds_in_last_minute]
+  end
+
+  def kill_remaining_children
+    return unless @parent
+
+    @children.each do |pid, task|
+      begin
+        put_w_time "Sending SIGINT to #{pid} (#{task[:name]})"
+        Process.kill("INT", pid)
+        Process.kill("INT", pid) # Twice - cbr / rspec ignore the first one for some reason...
+      rescue Exception
+        nil
+      end
+    end
+    @children.each do |pid, task|
+      put_w_time "Waiting for #{pid} (#{task[:name]})"
+      wait_for_task_with_timeout(pid)
+    end
+    @children={}
+  end
+
+  def put_w_time(thing)
+    puts %{[#{distance_of_time_to_now(@start)}] #{thing}}
+  end
+
+  def run_in_new_env(task_name, env_number)
+    @parent = false
+    ENV['TEST_ENV_NUMBER'] = env_number.to_s
+
+    output_path = results_folder.join(task_string(task_name))
+    `mkdir -p #{output_path}`
+    STDOUT.reopen(output_path.join('stdout'), 'w')
+    STDERR.reopen(output_path.join('stderr'), 'w')
+
+    setup_database(task_name)
+    Rake::Task[task_name].invoke
+  end
+
+  def setup_database(task_name)
+    ENV["ATLAS_TEST_DB_NAME"] = "atlas_test_#{task_string(task_name)}"
+    Rake::Task["db:create"].reenable
+    Rake::Task["db:create"].invoke
+    Rake::Task["db:test:prepare"].reenable
+    Rake::Task["db:test:prepare"].invoke
+  end
+
+  def start_some_children
+    while @children.length < @process_count && @tasks.length > 0
+      task_name = @tasks.shift
+      if !task_name.nil?
+        @env_number += 1
+        pid = Process.fork { @parent=false; sleep(@env_number / 10); run_in_new_env(task_name, @env_number) }
+        put_w_time "[#{task_name}] started (pid #{pid}); #{@tasks.length} jobs left to start."
+        @children[pid] = {:name => task_name, :start => Time.now}
+      end
+    end
+  end
+
+  def task_string(task_name)
+    task_name.to_s.gsub(':', '_')
+  end
+
+  def puts_still_running
+    return if @children.length == 0
+    put_w_time "#{YELLOW}Still running: #{@children.values.collect{|v|v[:name]}.join(' ')}#{RESET}"
+    put_w_time "#{YELLOW}Remaining: #{@tasks.join(' ')}#{RESET}"
+  end
+
+  def wait_for_task_with_timeout(pid, timeout=5)
+    begin
+      Timeout::timeout(timeout) {
+        Process.wait(pid) rescue nil
+      }
+    rescue Timeout::Error
+      begin
+        Process.kill("KILL",pid)
+      rescue
+      end
+    end
+  end
+
+  def wait_for_tasks_to_finish
+    begin
+      while true do # When there are no more child processes wait2 raises Errno::ECHILD
+        pid, status = Process.wait2
+        task = @children.delete(pid)
+        next if task.nil?
+        output_path = results_folder.join(task_string(task[:name]))
+        if status.success?
+          put_w_time "#{GREEN}[#{task[:name]}] finished. Elapsed time was #{distance_of_time_to_now(task[:start])}.#{RESET}"
+          put_w_time "#{GREEN}[#{task[:name]}] Output is in #{output_path}#{RESET}"
+          puts_still_running
+          start_some_children
+        else
+          if !@failed
+            put_w_time "#{RED}[#{task[:name]}] Build failed. Output can be found in #{output_path}#{RESET}"
+            puts_still_running
+            @failed=true
+            kill_remaining_children
+          end
+        end
+      end
+    rescue Errno::ECHILD
+      # Errno::ECHILD indicates you have no child process to wait on.
+    end
+  end
+
+end

data/lib/fast_rake/version.rb

@@ -0,0 +1,6 @@
+module FastRake
+  VERSION_MAJOR = 0
+  VERSION_MINOR = 0
+  VERSION_PATCH = 1
+  VERSION = [VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH].join('.')
+end

data/lib/fast_rake.rb

@@ -0,0 +1,27 @@
+require 'fast_rake/version'
+require 'fast_rake/fast_runner'
+
+module FastRake
+
+  def self.fast_runner(setup_tasks, run_tasks)
+    fast_runner_task(:two, 2, setup_tasks, run_tasks)
+    fast_runner_task(:four, 4, setup_tasks, run_tasks)
+    fast_runner_task(:eight, 8, setup_tasks, run_tasks)
+  end
+
+  def self.fast_runner_task(name, processes, setup_tasks, run_tasks)
+
+    desc "Fast test runner for #{processes} cpus"
+    task name, [:list] => setup_tasks do |t, args|
+      tasks_to_run = if !args[:list].nil?
+        args[:list].split(' ')
+      else
+        run_tasks
+      end
+      #puts %{\n\e[33mTo rerun: ber "fast:#{name}[#{tasks_to_run.join(' ')}]"\033[0m\n\n}
+      FastRunner.new(tasks_to_run, processes).run
+    end
+  end
+
+
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+name: fast_rake
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Jonathan Ricketson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-03-15 00:00:00 +11:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: gemma
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 2
+        - 1
+        - 0
+        version: 2.1.0
+  type: :development
+  version_requirements: *id001
+description: "\n    Runs a small number of setup tasks, followed by a bunch of expensive tasks in parallel.\n    This manages the number of running tasks and keeps the visible output to a small and useful amount.\n  "
+email: 
+- jonathan.ricketson@lonelyplanet.com.au
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- lib/fast_rake/version.rb
+- lib/fast_rake/fast_runner.rb
+- lib/fast_rake.rb
+- README.rdoc
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+- --title
+- fast_rake-0.0.1 Documentation
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: fast_rake
+rubygems_version: 1.5.3
+signing_key: 
+specification_version: 3
+summary: Runs a small number of setup tasks, followed by a bunch of expensive tasks in parallel.
+test_files: []
+