testbot 0.2.6

data/lib/server/build.rb

@@ -0,0 +1,29 @@
+class Build < Sequel::Model
+
+  def self.create_and_build_jobs(hash)
+    hash["jruby"] = (hash["jruby"] == "true") ? 1 : 0
+    build = create(hash.reject { |k, v| k == 'available_runner_usage' })
+    build.create_jobs!(hash['available_runner_usage'])
+    build
+  end
+  
+  def create_jobs!(available_runner_usage)
+    groups = Group.build(self[:files].split, self[:sizes].split.map { |size| size.to_i },
+                     Runner.total_instances.to_f * (available_runner_usage.to_i / 100.0), self[:type])
+    groups.each do |group|
+      Job.create(:files => group.join(' '),
+                 :root => self[:root],
+                 :project => self[:project],
+                 :type => self[:type],
+                 :requester_mac => self[:requester_mac],
+                 :build_id => self[:id],
+                 :jruby => self[:jruby])
+    end
+  end
+  
+  def destroy
+    Job.filter([ 'build_id = ?', self[:id] ]).each { |job| job.destroy }
+    super
+  end
+  
+end

data/lib/server/db.rb

@@ -0,0 +1,44 @@
+require 'sequel'
+
+DB = Sequel.sqlite
+
+DB.create_table :builds do
+  primary_key :id
+  String :files
+  String :sizes
+  String :results, :default => ''
+  String :root
+  String :project
+  String :type
+  String :requester_mac
+  Integer :jruby
+  Boolean :done, :default => false
+end
+
+
+DB.create_table :jobs do
+  primary_key :id
+  String :files
+  String :result
+  String :root
+  String :project
+  String :type
+  String :requester_mac
+  Integer :jruby
+  Integer :build_id
+  Integer :taken_by_id
+  Datetime :taken_at, :default => nil
+end
+
+DB.create_table :runners do
+  primary_key :id
+  String :ip
+  String :hostname
+  String :uid
+  String :username
+  String :version
+  Integer :idle_instances
+  Integer :max_instances
+  Datetime :last_seen_at
+end
+

data/lib/server/group.rb

@@ -0,0 +1,44 @@
+require 'rubygems'
+
+class Group
+  
+  DEFAULT = nil
+
+  def self.build(files, sizes, instance_count, type)
+    tests_with_sizes = slow_tests_first(map_files_and_sizes(files, sizes))
+    
+    groups = []
+    current_group, current_size = 0, 0
+    tests_with_sizes.each do |test, size|
+      # inserts into next group if current is full and we are not in the last group
+      if (0.5*size + current_size) > group_size(tests_with_sizes, instance_count) and instance_count > current_group + 1
+        current_size = size
+        current_group += 1
+      else
+        current_size += size
+      end
+      groups[current_group] ||= []
+      groups[current_group] << test
+    end
+    
+    groups.compact
+  end
+    
+  private
+  
+  def self.group_size(tests_with_sizes, group_count)
+    total = tests_with_sizes.inject(0) { |sum, test| sum += test[1] }
+    total / group_count.to_f
+  end
+  
+  def self.map_files_and_sizes(files, sizes)
+    list = []
+    files.each_with_index { |file, i| list << [ file, sizes[i] ] }
+    list
+  end
+  
+  def self.slow_tests_first(tests)
+    tests.sort_by { |test, time| time.to_i }.reverse
+  end
+
+end

data/lib/server/job.rb

@@ -0,0 +1,41 @@
+require File.join(File.dirname(__FILE__), 'db.rb') unless defined?(DB)
+
+class Job < Sequel::Model
+  def update(hash)
+    super(hash)
+    if build = Build.find([ "id = ?", self[:build_id] ])
+      done = Job.filter([ "result IS NULL AND build_id = ?", self[:build_id] ]).count == 0
+      build.update(:results => build[:results].to_s + hash[:result].to_s,
+                   :done => done)
+    end
+  end
+  
+  def self.next(params, remove_addr)
+    clean_params = params.reject { |k, v| [ "requester_mac", "no_jruby" ].include?(k) }
+    runner = Runner.record! clean_params.merge({ :ip => remove_addr, :last_seen_at => Time.now })
+    return unless Server.valid_version?(params[:version])
+    [ next_job_query(params["requester_mac"], params["no_jruby"]).first, runner ]
+  end
+  
+  private
+  
+  def self.next_job_query(requester_mac, no_jruby)
+    release_jobs_taken_by_missing_runners!
+    query = Job.filter("taken_at IS NULL").order("Random()".lit)
+    filters = []
+    filters << "requester_mac = '#{requester_mac}'" if requester_mac
+    filters << "jruby != 1" if no_jruby
+    if filters.empty?
+      query
+    else
+      query.filter(filters.join(' AND ')) 
+    end
+  end
+  
+  def self.release_jobs_taken_by_missing_runners!
+    missing_runners = Runner.filter([ "last_seen_at < ?", (Time.now - Runner.timeout) ])
+    missing_runners.each { |r|
+      Job.filter(:taken_by_id => r[:id]).update(:taken_at => nil)
+    }    
+  end
+end

data/lib/server/runner.rb

@@ -0,0 +1,38 @@
+require File.join(File.dirname(__FILE__), 'db.rb') unless defined?(DB)
+
+class Runner < Sequel::Model
+
+  def self.record!(hash)
+    create_or_update_by_mac!(hash)
+  end
+  
+  def self.create_or_update_by_mac!(hash)
+    if (runner = find(:uid => hash[:uid]))
+      runner.update hash
+    else
+      Runner.create hash
+    end
+  end
+  
+  def self.timeout
+    10
+  end
+  
+  def self.find_all_outdated
+    DB[:runners].filter("version != ? OR version IS NULL", Testbot::VERSION)
+  end
+  
+  def self.find_all_available
+    DB[:runners].filter("version = ? AND last_seen_at > ?", Testbot::VERSION, Time.now - Runner.timeout)
+  end  
+  
+  def self.available_instances
+    find_all_available.inject(0) { |sum, r| r[:idle_instances] + sum }
+  end
+  
+  def self.total_instances
+    return 1 if ENV['INTEGRATION_TEST']
+    find_all_available.inject(0) { |sum, r| r[:max_instances] + sum }
+  end
+  
+end

data/lib/shared/simple_daemonize.rb

@@ -0,0 +1,19 @@
+class SimpleDaemonize
+  
+  def self.start(proc, pid_path)    
+    pid = fork { 
+      STDOUT.reopen "/dev/null"
+      proc.call
+    }
+    
+    File.open(pid_path, 'w') { |file| file.write(pid) }
+    pid
+  end
+  
+  def self.stop(pid_path)
+    return unless File.exists?(pid_path)
+    system "kill #{File.read(pid_path)} &> /dev/null"
+    system "rm #{pid_path} &> /dev/null"
+  end
+  
+end

data/lib/shared/ssh_tunnel.rb

@@ -0,0 +1,36 @@
+require 'rubygems'
+require 'net/ssh'
+
+class SSHTunnel
+  
+  def initialize(host, user, local_port = 2288)
+    @host, @user, @local_port = host, user, local_port
+  end
+  
+  def open
+    connect
+    
+    start_time = Time.now
+    while true
+      break if @up
+      sleep 0.5
+      
+      if Time.now - start_time > 5
+        puts "SSH connection failed, trying again..."
+        start_time = Time.now
+        connect
+      end
+    end
+  end
+  
+  def connect
+    @thread.kill! if @thread
+    @thread = Thread.new do
+      Net::SSH.start(@host, @user, { :timeout => 1 }) do |ssh|
+        ssh.forward.local(@local_port, 'localhost', Testbot::SERVER_PORT)
+        ssh.loop {  @up = true }
+      end
+    end    
+  end
+  
+end

data/lib/tasks/testbot.rake

@@ -0,0 +1,32 @@
+require File.dirname(__FILE__) + '/../adapters/adapter'
+
+namespace :testbot do
+  
+  def run_and_show_results(adapter, custom_path)
+    Rake::Task["testbot:before_request"].invoke
+        
+    require File.join(File.dirname(__FILE__), '..', "requester.rb")
+    requester = Requester.create_by_config("#{Rails.root}/config/testbot.yml")
+
+    puts "Running #{adapter.pluralized}..."
+    start_time = Time.now
+    
+    path = custom_path ? "#{adapter.base_path}/#{custom_path}" : adapter.base_path
+    success = requester.run_tests(adapter, path)
+    
+    puts
+    puts requester.result_lines.join("\n")
+    puts
+    puts "Finished in #{Time.now - start_time} seconds."
+    success
+  end
+  
+  Adapter.all.each do |adapter|
+
+    desc "Run the #{adapter.name} tests using testbot"
+    task adapter.type, :custom_path do |_, args|
+      exit 1 unless run_and_show_results(adapter, args[:custom_path])
+    end
+    
+  end
+end

data/lib/testbot.rb

@@ -0,0 +1,126 @@
+require File.join(File.dirname(__FILE__), '/shared/simple_daemonize')
+require File.join(File.dirname(__FILE__), '/adapters/adapter')
+require 'fileutils'
+
+module Testbot
+  require 'railtie' if defined?(Rails)
+
+  VERSION = "0.2.6"
+  SERVER_PID = "/tmp/testbot_server.pid"
+  RUNNER_PID = "/tmp/testbot_runner.pid"
+  DEFAULT_WORKING_DIR = "/tmp/testbot"
+  DEFAULT_SERVER_PATH = "/tmp/testbot/#{ENV['USER']}"
+  DEFAULT_USER = "testbot"
+  DEFAULT_PROJECT = "project"
+  DEFAULT_RUNNER_USAGE = "100%"
+  SERVER_PORT = ENV['INTEGRATION_TEST'] ? 22880 : 2288
+  
+  class CLI
+    
+    def self.run(argv)
+      return false if argv == []
+      opts = parse_args(argv)
+
+      if opts[:help]
+        return false
+      elsif opts[:version]
+        puts "Testbot #{Testbot::VERSION}"
+      elsif [ true, 'run', 'start' ].include?(opts[:server])
+        start_server(opts[:server])
+      elsif opts[:server] == 'stop'
+        stop('server', Testbot::SERVER_PID)
+      elsif [ true, 'run', 'start' ].include?(opts[:runner])
+        require File.join(File.dirname(__FILE__), '/runner')
+        return false unless valid_runner_opts?(opts)
+        start_runner(opts)
+      elsif opts[:runner] == 'stop'
+        stop('runner', Testbot::RUNNER_PID)
+      elsif adapter = Adapter.all.find { |adapter| opts[adapter.type.to_sym] }
+        require File.join(File.dirname(__FILE__), '/requester')
+        start_requester(opts, adapter)
+      end
+    
+      true
+    end
+  
+    def self.parse_args(argv)
+      last_setter = nil
+      hash = {}
+      str = ''
+      argv.each_with_index do |arg, i|
+        if arg.include?('--')
+          str = ''
+          last_setter = arg.split('--').last.to_sym
+          hash[last_setter] = true if (i == argv.size - 1) || argv[i+1].include?('--')
+        else
+          str += ' ' + arg
+          hash[last_setter] = str.strip
+        end
+      end
+      hash
+    end
+  
+    def self.start_runner(opts)
+      stop('runner', Testbot::RUNNER_PID)
+    
+      proc = lambda {
+        working_dir = opts[:working_dir] || Testbot::DEFAULT_WORKING_DIR
+        FileUtils.mkdir_p(working_dir)
+        Dir.chdir(working_dir)
+        runner = Runner.new(:server_host => opts[:connect],
+                            :auto_update => opts[:auto_update], :max_instances => opts[:cpus],
+                            :ssh_tunnel => opts[:ssh_tunnel], :user => opts[:user],
+                            :max_jruby_instances => opts[:max_jruby_instances],
+                            :jruby_opts => opts[:jruby_opts])
+        runner.run!
+      }
+    
+      if opts[:runner] == 'run'
+        proc.call
+      else
+        pid = SimpleDaemonize.start(proc, Testbot::RUNNER_PID)
+        puts "Testbot runner started (pid: #{pid})"
+      end
+    end
+  
+    def self.start_server(type)
+      stop('server', Testbot::SERVER_PID)
+    
+      if type == 'run'
+        require File.join(File.dirname(__FILE__), '/server')
+        Sinatra::Application.run! :environment => "production"
+      else
+        pid = SimpleDaemonize.start(lambda {
+          ENV['DISABLE_LOGGING'] = "true"
+          require File.join(File.dirname(__FILE__), '/server')
+          Sinatra::Application.run! :environment => "production"
+        }, Testbot::SERVER_PID)
+        puts "Testbot server started (pid: #{pid})"
+      end
+    end
+  
+    def self.stop(name, pid)
+      puts "Testbot #{name} stopped" if SimpleDaemonize.stop(pid)
+    end
+  
+    def self.start_requester(opts, adapter)
+      requester = Requester.new(:server_host => opts[:connect],
+                                :rsync_path => opts[:rsync_path],
+                                :rsync_ignores => opts[:rsync_ignores].to_s,
+                                :available_runner_usage => nil,
+                                :project => opts[:project],
+                                :ssh_tunnel => opts[:ssh_tunnel], :server_user => opts[:user])
+      requester.run_tests(adapter, adapter.base_path)
+    end
+  
+    def self.valid_runner_opts?(opts)
+      opts[:connect].is_a?(String)
+    end
+  
+    def self.lib_path
+      File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+    end
+  
+  end
+
+end

data/testbot.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require File.expand_path("lib/testbot")
+
+Gem::Specification.new do |s|
+  s.name        = "testbot"
+  s.version     = Testbot::VERSION
+  s.authors     = ["Joakim Kolsjö"]
+  s.email       = ["joakim.kolsjo@gmail.com"]
+  s.homepage    = "http://github.com/joakimk/testbot"
+  s.summary     = %q{A test distribution tool.}
+  s.description = %q{Testbot is a test distribution tool that works with Rails, RSpec, Test::Unit and Cucumber.}
+  s.bindir      = "bin"
+  s.executables = [ "testbot" ]
+  s.files       = Dir.glob("lib/**/*") + %w(Gemfile testbot.gemspec CHANGELOG README.markdown bin/testbot)
+  s.add_dependency('sinatra', '=1.0.0') # To be able to use rack 1.0.1 which is compatible with rails 2.
+  s.add_dependency('httparty', '>= 0.6.1')
+  s.add_dependency('macaddr', '>= 1.0.0')
+  s.add_dependency('net-ssh', '>= 2.0.23')
+  s.add_dependency('sequel', '>= 3.16.0')
+  s.add_dependency('sqlite3-ruby', '>= 1.2.5')
+  s.add_dependency('json', '>= 1.4.6')
+  
+  # Because sinatra's "disable :logging" does not work with WEBrick.
+  # Also, using a version that builds on ruby 1.9.2.
+  s.add_dependency('mongrel', '1.2.0.pre2')  
+end