nitra 0.9.4 → 0.9.5

data/README.md

@@ -0,0 +1,88 @@
+# Nitra
+Nitra is a multi-process, optionally multi-server rspec and cucumber runner that uses forking to reduce memory usage and IPC to distribute builds amongst available CPUs efficiently.
+
+## Philosophy
+* Nitra attempts to do the simplest thing possible
+* Nitra (ab)uses unix primitives where possible
+* Nitra doesn't do thing that unix already does better (eg. rsync)
+* IPC is accomplished via pipes and select
+* Forking is used heavily for several reasons
+* Running nitra locally should be easy
+* Running nitra on a cluster should be easy too (though verbose)
+* Config files are a nuisance and should be stuffed into rake files (deals with the verbosity)
+
+## Usage
+      nitra [options] [spec_filename [...]]
+          -c, --cpus NUMBER                Specify the number of CPUs to use on the host, or if specified after a --slave, on the slave
+              --cucumber                   Add full cucumber run, causes any files you list manually to be ignored
+              --debug                      Print debug output
+          -p, --print-failures             Print failures immediately when they occur
+          -q, --quiet                      Quiet; don't display progress bar
+              --rake-after-runner task:1,task:2,task:3
+                                           The list of rake tasks to run, once per runner, in the runner's environment, just before the runner exits
+              --rake-before-runner task:1,task:2,task:3
+                                           The list of rake tasks to run, once per runner, in the runner's environment, after the runner starts
+              --rake-before-worker task:1,task:2,task:3
+                                           The list of rake tasks to run, once per worker, in the worker's environment, before the worker starts
+              --reset                      r
+                                           Reset database, equivalent to --rake-before-worker db:reset
+              --slave-mode                 Run in slave mode; ignores all other command-line options
+              --slave CONNECTION_COMMAND   Provide a command that executes "nitra --slave-mode" on another host
+              --rspec                      Add full rspec run, causes any files you list manually to be ignored
+          -e, --environment ENV            Set the RAILS_ENV to load
+          -h, --help                       Show this message
+
+### Getting started
+First things first add nitra to your Gemfile:
+
+    gem 'nitra'
+
+Then run your specs locally across your cpu's cores:
+
+    bundle exec nitra --rspec
+
+This will just run all your specs using the default number of cpu's reported by your system. Hyperthreaded intels will report a high number which might not be a good fit, you can tune this with the -c option.
+
+Clustered commands run slightly differently. Effectively nitra will fork and exec a command that it expects will be a nitra slave, this means we can use ssh as our tunnel of choice. It looks something like this:
+
+    bundle exec nitra --rspec --slave "ssh your.server.name 'cd your/project && bundle exec nitra --slave-mode'"
+
+When nitra --slave command it forks, execs it, and assumes it's another process that's running "nitra --slave-mode".
+
+### Running a build cluster
+Nitra doesn't prescribe how you get your code onto the other machines in your cluster. For example you can run a git checkout on the boxes you want to build on if it's the fastest way for you. For our part - we've had the most success with rsync.
+
+Our build is run via rake tasks so we end up with a bunch of generated code to rsync files back and forth - here's a basic version that might help get you up and running:
+
+    namespace :nitra do
+      task :config do
+          @servers = [
+            {:name => "server1", :port => "66666", :c => "4"},
+            {:name => "server2", :port => "99999", :c => "2"},
+            {:name => "server3", :port => "77777", :c => "8"},
+            {:name => "server4", :port => "88888", :c => "4"}
+          ]
+      end
+
+      desc "Sync the local directory and install the gems onto the remote servers"
+      task :prep => :config do
+        @servers.each do |server|
+          fork do
+            system "ssh -p #{server[:port]} #{server[:name]} 'mkdir -p nitra/projects/your_project'"
+            exec %(rsync -aze 'ssh -q -p #{server[:port]}' --exclude .git --delete ./ #{server[:name]}:nitra/projects/your_project/ && ssh -q -t -p #{server[:port]} #{server[:name]} 'cd nitra/projects/your_project && bundle install --quiet --path ~/gems')
+          end
+        end
+        Process.waitall
+      end
+
+      task :all => :config do
+        cmd = %(bundle exec nitra -p -q --rspec --cucumber --rake-before-worker db:reset)
+        @servers.each do |server|
+          cmd << %( --slave "ssh -p #{server[:port]} #{server[:name]} 'cd nitra/projects/your_project && bundle exec nitra --slave-mode'" -c#{server[:c]})
+        end
+        system cmd
+      end
+    end
+
+## Copyright
+Copyright 2012-2013 Roger Nesbitt, Powershop Limited, YouDo Limited.  MIT licence.

data/bin/nitra

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
 
 require 'nitra'
 
@@ -7,5 +8,5 @@ Nitra::CommandLine.new(configuration, ARGV)
 if configuration.slave_mode
   Nitra::Slave::Server.new.run
 else
-  exit Nitra::Client.new(configuration, ARGV).run ? 0 : 1
+  exit Nitra::Master.new(configuration, ARGV).run ? 0 : 1
 end

data/lib/nitra/channel.rb

@@ -1,48 +1,50 @@
 require 'yaml'
 
-class Nitra::Channel
-  ProtocolInvalidError = Class.new(StandardError)
+module Nitra
+  class Channel
+    ProtocolInvalidError = Class.new(StandardError)
 
-  attr_reader :rd, :wr
-  attr_accessor :raise_epipe_on_write_error
+    attr_reader :rd, :wr
+    attr_accessor :raise_epipe_on_write_error
 
-  def initialize(rd, wr)
-    @rd = rd
-    @wr = wr
-  end
+    def initialize(rd, wr)
+      @rd = rd
+      @wr = wr
+    end
 
-  def self.pipe
-    c_rd, s_wr = IO.pipe
-    s_rd, c_wr = IO.pipe
-    [new(c_rd, c_wr), new(s_rd, s_wr)]
-  end
+    def self.pipe
+      c_rd, s_wr = IO.pipe
+      s_rd, c_wr = IO.pipe
+      [new(c_rd, c_wr), new(s_rd, s_wr)]
+    end
 
-  def self.read_select(channels)
-    fds = IO.select(channels.collect(&:rd))
-    fds.first.collect do |fd|
-      channels.detect {|c| c.rd == fd}
+    def self.read_select(channels)
+      fds = IO.select(channels.collect(&:rd))
+      fds.first.collect do |fd|
+        channels.detect {|c| c.rd == fd}
+      end
     end
-  end
 
-  def close
-    rd.close
-    wr.close
-  end
+    def close
+      rd.close
+      wr.close
+    end
 
-  def read
-    return unless line = rd.gets
-    if result = line.strip.match(/\ANITRA,(\d+)\z/)
-      data = rd.read(result[1].to_i)
-      YAML.load(data)
-    else
-      raise ProtocolInvalidError, "Expected nitra length line, got #{line.inspect}"
+    def read
+      return unless line = rd.gets
+      if result = line.strip.match(/\ANITRA,(\d+)\z/)
+        data = rd.read(result[1].to_i)
+        YAML.load(data)
+      else
+        raise ProtocolInvalidError, "Expected nitra length line, got #{line.inspect}"
+      end
     end
-  end
 
-  def write(data)
-    encoded = YAML.dump(data)
-    wr.write("NITRA,#{encoded.length}\n#{encoded}")
-  rescue Errno::EPIPE
-    raise if raise_epipe_on_write_error
+    def write(data)
+      encoded = YAML.dump(data)
+      wr.write("NITRA,#{encoded.bytesize}\n#{encoded}")
+    rescue Errno::EPIPE
+      raise if raise_epipe_on_write_error
+    end
   end
 end

data/lib/nitra/command_line.rb

@@ -1,54 +1,74 @@
 require 'optparse'
 
-class Nitra::CommandLine
-  attr_reader :configuration
+module Nitra
+  class CommandLine
+    attr_reader :configuration
 
-  def initialize(configuration, argv)
-    @configuration = configuration
+    def initialize(configuration, argv)
+      @configuration = configuration
 
-    OptionParser.new(argv) do |opts|
-      opts.banner = "Usage: nitra [options] [spec_filename [...]]"
+      OptionParser.new do |opts|
+        opts.banner = "Usage: nitra [options] [spec_filename [...]]"
 
-      opts.on("-c", "--cpus NUMBER", Integer, "Specify the number of CPUs to use on the host, or if specified after a --slave, on the slave") do |n|
-        configuration.set_process_count n
-      end
+        opts.on("-c", "--cpus NUMBER", Integer, "Specify the number of CPUs to use on the host, or if specified after a --slave, on the slave") do |n|
+          configuration.set_process_count n
+        end
 
-      opts.on("-e", "--environment STRING", String, "The Rails environment to use, defaults to 'nitra'") do |environment|
-        configuration.environment = environment
-      end
+        opts.on("--cucumber", "Add full cucumber run, causes any files you list manually to be ignored") do
+          configuration.add_framework "cucumber"
+        end
 
-      opts.on("--load", "Load schema into database before running specs") do
-        configuration.load_schema = true
-      end
+        opts.on("--debug", "Print debug output") do
+          configuration.debug = true
+        end
 
-      opts.on("--migrate", "Migrate database before running specs") do
-        configuration.migrate = true
-      end
+        opts.on("-p", "--print-failures", "Print failures immediately when they occur") do
+          configuration.print_failures = true
+        end
 
-      opts.on("-q", "--quiet", "Quiet; don't display progress bar") do
-        configuration.quiet = true
-      end
+        opts.on("-q", "--quiet", "Quiet; don't display progress bar") do
+          configuration.quiet = true
+        end
 
-      opts.on("-p", "--print-failures", "Print failures immediately when they occur") do
-        configuration.print_failures = true
-      end
+        opts.on("--rake-after-runner task:1,task:2,task:3", Array, "The list of rake tasks to run, once per runner, in the runner's environment, just before the runner exits") do |rake_tasks|
+          configuration.add_rake_task(:after_runner, rake_tasks)
+        end
 
-      opts.on("--slave CONNECTION_COMMAND", String, "Provide a command that executes \"nitra --slave-mode\" on another host") do |connection_command|
-        configuration.slaves << {:command => connection_command, :cpus => nil}
-      end
+        opts.on("--rake-before-runner task:1,task:2,task:3", Array, "The list of rake tasks to run, once per runner, in the runner's environment, after the runner starts") do |rake_tasks|
+          configuration.add_rake_task(:before_runner, rake_tasks)
+        end
 
-      opts.on("--slave-mode", "Run in slave mode; ignores all other command-line options") do
-        configuration.slave_mode = true
-      end
+        opts.on("--rake-before-worker task:1,task:2,task:3", Array, "The list of rake tasks to run, once per worker, in the worker's environment, before the worker starts") do |rake_tasks|
+          configuration.add_rake_task(:before_worker, rake_tasks)
+        end
 
-      opts.on("--debug", "Print debug output") do
-        configuration.debug = true
-      end
+        opts.on("-r", "--reset", "Reset database, equivalent to --rake-before-worker db:reset") do
+          configuration.add_rake_task(:before_worker, "db:reset")
+        end
 
-      opts.on_tail("-h", "--help", "Show this message") do
-        puts opts
-        exit
-      end
-    end.parse!
+        opts.on("--slave-mode", "Run in slave mode; ignores all other command-line options") do
+          configuration.slave_mode = true
+        end
+
+        opts.on("--slave CONNECTION_COMMAND", String, "Provide a command that executes \"nitra --slave-mode\" on another host") do |connection_command|
+          configuration.add_slave connection_command
+        end
+
+        opts.on("--rspec", "Add full rspec run, causes any files you list manually to be ignored") do
+          configuration.add_framework "rspec"
+        end
+
+        opts.on("-e", "--environment ENV", String, "Set the RAILS_ENV to load") do |env|
+          configuration.environment = env
+        end
+
+        opts.on_tail("-h", "--help", "Show this message") do
+          puts opts
+          exit
+        end
+      end.parse!(argv)
+
+      configuration.set_default_framework
+    end
   end
 end

data/lib/nitra/configuration.rb

@@ -1,22 +1,44 @@
-class Nitra::Configuration
-  attr_accessor :load_schema, :migrate, :debug, :quiet, :print_failures, :fork_for_each_file
-  attr_accessor :process_count, :environment, :slaves, :slave_mode
-
-  def initialize
-    self.environment = "nitra"
-    self.fork_for_each_file = true
-    self.slaves = []
-  end
+require 'nitra/utils'
 
-  def calculate_default_process_count
-    self.process_count ||= Nitra::Utils.processor_count
-  end
+module Nitra
+  class Configuration
+    attr_accessor :debug, :quiet, :print_failures, :rake_tasks
+    attr_accessor :process_count, :environment, :slaves, :slave_mode, :framework, :frameworks
+
+    def initialize
+      self.environment = "nitra"
+      self.slaves = []
+      self.rake_tasks = {}
+      self.frameworks = []
+      calculate_default_process_count
+    end
+
+    def add_framework(framework)
+      frameworks << framework
+    end
+
+    def add_rake_task(name, list)
+      rake_tasks[name] = list
+    end
+
+    def add_slave(command)
+      slaves << {:command => command, :cpus => nil}
+    end
+
+    def set_default_framework
+      self.framework = frameworks.first if frameworks.any?
+    end
+
+    def calculate_default_process_count
+      self.process_count ||= Nitra::Utils.processor_count
+    end
 
-  def set_process_count(n)
-    if slaves.empty?
-      self.process_count = n
-    else
-      slaves.last[:cpus] = n
+    def set_process_count(n)
+      if slaves.empty?
+        self.process_count = n
+      else
+        slaves.last[:cpus] = n
+      end
     end
   end
 end

data/lib/nitra/ext/cucumber.rb

@@ -0,0 +1,32 @@
+require 'cucumber/rb_support/rb_language'
+require 'cucumber/runtime'
+module Cucumber
+  module RbSupport
+    class RbLanguage
+      # Reloading support files is bad for us. Idealy we'd subclass but since
+      # Cucumber's internals are a bit shit and insists on using the new keyword
+      # everywhere we have to monkeypatch it out or spend another 6 months
+      # rewriting it and getting patches accepted...
+      def load_code_file(code_file)
+        require File.expand_path(code_file)
+      end
+    end
+  end
+  class ResetableRuntime < Runtime
+    # Cucumber lacks a reset hook like the one Rspec has so we need to patch one in...
+    # Call this after configure so that the correct configuration is used to create the result set.
+    def reset
+      @results = Results.new(nil)
+    end
+
+    # Cucumber > 1.1.0 memoizes @loader which means we can't load in new files.
+    # Patch it back to how it used to work.
+    def features
+      @loader = Runtime::FeaturesLoader.new(
+        @configuration.feature_files, 
+        @configuration.filters, 
+        @configuration.tag_expression)
+      @loader.features
+    end
+  end
+end

data/lib/nitra/formatter.rb

@@ -0,0 +1,59 @@
+##
+# Nitra::Formatter print out data regarding the run.
+#
+module Nitra
+  class Formatter
+    attr_accessor :start_time, :progress, :configuration
+
+    def initialize(progress, configuration)
+      self.progress = progress
+      self.configuration = configuration
+    end
+
+    def start
+      self.start_time = Time.now
+      print_progress
+    end
+
+    def print_progress
+      print_failures
+      print_bar
+    end
+
+    def finish
+      puts progress.filtered_output
+
+      puts "\n#{overview}"
+      puts "#{$aborted ? "Aborted after" : "Finished in"} #{"%0.1f" % (Time.now-start_time)} seconds"
+    end
+
+    private
+
+    ##
+    # Print the progress bar, doesn't do anything if we're in debug.
+    #
+    def print_bar
+      return if configuration.quiet || configuration.debug || progress.file_count == 0
+      total = 50
+      completed = (progress.files_completed / progress.file_count.to_f * total).to_i
+      print "\r[#{"X" * completed}#{"." * (total - completed)}] #{overview}\r"
+      $stdout.flush
+    end
+
+    ##
+    # Prints the output in the progress object and resets it if we've got eager printing turned on.
+    #
+    def print_failures
+      return unless progress.output.length > 0 && configuration.print_failures
+      puts progress.filtered_output
+      progress.output = ""
+    end
+
+    ##
+    # A simple overview of files processed so far and success/failure numbers.
+    #
+    def overview
+      "#{progress.files_completed}/#{progress.file_count} files | #{progress.example_count} examples, #{progress.failure_count} failures"
+    end
+  end
+end

data/lib/nitra/master.rb

@@ -1,18 +1,24 @@
 class Nitra::Master
-  attr_reader :configuration, :files
+  attr_reader :configuration, :files, :frameworks, :current_framework
 
   def initialize(configuration, files = nil)
     @configuration = configuration
-    @files = files
+    @frameworks = configuration.frameworks
+    if @frameworks.any?
+      load_files_from_framework_list
+    else
+      map_files_to_frameworks(files)
+    end
+    @current_framework = @frameworks.shift
+    @configuration.framework = @current_framework
   end
 
   def run
-    @files = Dir["spec/**/*_spec.rb"] if files.nil? || files.empty?
-    return if files.empty?
+    return if files_remaining == 0
 
     progress = Nitra::Progress.new
-    progress.file_count = @files.length
-    yield progress, nil
+    progress.file_count = files_remaining
+    formatter = Nitra::Formatter.new(progress, configuration)
 
     runners = []
 
@@ -27,24 +33,40 @@ class Nitra::Master
     end
 
     slave = Nitra::Slave::Client.new(configuration)
-    runners += slave.connect("")
+    runners += slave.connect
+
+    formatter.start
 
     while runners.length > 0
       Nitra::Channel.read_select(runners).each do |channel|
         if data = channel.read
           case data["command"]
           when "next"
-            channel.write "filename" => files.shift
+            if files_remaining == 0
+              channel.write "command" => "drain"
+            elsif data["framework"] == current_framework
+              channel.write "command" => "file", "filename" => next_file
+            else
+              channel.write "command" => "framework", "framework" => current_framework
+            end
+
           when "result"
-            progress.files_completed += 1
-            progress.example_count += data["example_count"] || 0
-            progress.failure_count += data["failure_count"] || 0
-            progress.output << data["text"]
-            yield progress, data
+            examples = data["example_count"] || 0
+            failures = data["failure_count"] || 0
+            failure = data["return_code"].to_i != 0
+            progress.file_progress(examples, failures, failure, data["text"])
+            formatter.print_progress
+
+          when "error"
+            progress.fail("ERROR " + data["process"] + " " + data["text"])
+            formatter.progress
+            runners.delete channel
+
           when "debug"
             if configuration.debug
               puts "[DEBUG] #{data["text"]}"
             end
+
           when "stdout"
             if configuration.debug
               puts "STDOUT for #{data["process"]} #{data["filename"]}:\n#{data["text"]}" unless data["text"].empty?
@@ -58,11 +80,44 @@ class Nitra::Master
 
     debug "waiting for all children to exit..."
     Process.waitall
-    progress
+
+    formatter.finish
+
+    !$aborted && progress.files_completed == progress.file_count && progress.failure_count.zero? && !progress.failure
   end
 
   protected
   def debug(*text)
     puts "master: #{text.join}" if configuration.debug
   end
+
+  def map_files_to_frameworks(files)
+    @files = files.group_by do |filename|
+     framework_name, framework_class = Nitra::Workers::Worker.worker_classes.find {|framework_name, framework_class| framework_class.filename_match?(filename)}
+     framework_name
+    end
+    @frameworks = @files.keys
+  end
+
+  def load_files_from_framework_list
+    @files = frameworks.inject({}) do |result, framework_name|
+      result[framework_name] = Nitra::Workers::Worker.worker_classes[framework_name].files
+      result
+    end
+  end
+
+  def files_remaining
+    files.values.inject(0) {|sum, filenames| sum + filenames.length}
+  end
+
+  def current_framework_files
+    files[current_framework]
+  end
+
+  def next_file
+    raise if files_remaining == 0
+    file = current_framework_files.shift
+    @current_framework = frameworks.shift if current_framework_files.length == 0
+    file
+  end
 end

data/lib/nitra/progress.rb

@@ -1,8 +1,26 @@
 class Nitra::Progress
-  attr_accessor :file_count, :files_completed, :example_count, :failure_count, :output
+  attr_accessor :file_count, :files_completed, :example_count, :failure_count, :output, :failure
 
   def initialize
     @file_count = @files_completed = @example_count = @failure_count = 0
     @output = ""
+    @failure = false
+  end
+
+  def file_progress(examples, failures, failure, text)
+    self.files_completed += 1
+    self.example_count += examples
+    self.failure_count += failures
+    self.failure ||= failure
+    self.output.concat text
+  end
+
+  def fail(message)
+    self.failure = true
+    self.output.concat message
+  end
+
+  def filtered_output
+    output.gsub(/\n\n\n+/, "\n\n")
   end
 end

data/lib/nitra/rails_tooling.rb

@@ -0,0 +1,22 @@
+module Nitra
+  class RailsTooling
+    ##
+    # Find the database config for the current TEST_ENV_NUMBER and manually initialise a connection.
+    #
+    def self.connect_to_database
+      return unless defined?(Rails)
+      # Config files are read at load time. Since we load rails in one env then
+      # change some flags to get different environments through forking we need
+      # always reload our database config...
+      ActiveRecord::Base.configurations = YAML.load(ERB.new(IO.read("#{Rails.root}/config/database.yml")).result)
+
+      ActiveRecord::Base.clear_all_connections!
+      ActiveRecord::Base.establish_connection
+    end
+
+    def self.reset_cache
+      return unless defined?(Rails)
+      Rails.cache.reset if Rails.cache.respond_to?(:reset)
+    end
+  end
+end