gorgon 0.0.1

data/lib/gorgon/source_tree_syncer.rb

@@ -0,0 +1,37 @@
+class SourceTreeSyncer
+  attr_accessor :exclude
+  attr_reader :sys_command
+
+  SYS_COMMAND = 'rsync'
+  OPTS = '-az'
+  EXCLUDE_OPT = "--exclude"
+
+  def initialize source_tree_path
+    @source_tree_path = source_tree_path
+    @exclude = []
+  end
+
+  def sync
+    @tempdir = Dir.mktmpdir("gorgon")
+    Dir.chdir(@tempdir)
+
+    exclude_opt = build_exclude_opt
+    @sys_command = "#{SYS_COMMAND} #{OPTS} #{exclude_opt} -r --rsh=ssh #{@source_tree_path}/* ."
+    system(@sys_command)
+
+    return $?.exitstatus == 0
+  end
+
+  def remove_temp_dir
+    FileUtils::remove_entry_secure(@tempdir)
+  end
+
+  private
+
+  def build_exclude_opt
+    return "" if @exclude.nil? or @exclude.empty?
+
+    @exclude.unshift("")
+    @exclude.join(" #{EXCLUDE_OPT} ")
+  end
+end

data/lib/gorgon/testunit_runner.rb

@@ -0,0 +1,50 @@
+require 'test/unit'
+require 'test/unit/testresult'
+
+Test::Unit.run = true # This stops testunit from running the file as soon as it is included. Yep. That's correct. True.
+
+module GorgonTestCases
+  def self.cases
+    @gorgon_cases ||= []
+  end
+
+  def self.clear_cases!
+    @gorgon_cases = []
+  end
+end
+
+
+if defined? ActiveSupport::TestCase
+  class ActiveSupport::TestCase
+    def self.inherited(klass)
+      GorgonTestCases.cases << klass
+    end
+  end
+end
+
+class Test::Unit::TestCase
+  def self.inherited(klass)
+    GorgonTestCases.cases << klass
+  end
+end
+
+class TestRunner
+  def self.run_file(filename)
+    GorgonTestCases.clear_cases!
+    load filename
+
+    result = Test::Unit::TestResult.new
+    output = []
+    result.add_listener(Test::Unit::TestResult::FAULT) do |value|
+      output << value
+    end
+
+    GorgonTestCases.cases.each do |klass|
+      # Not all descendants of TestCase are actually runnable, but they do all implement #suite
+      # Calling suite.run will give us only runnable tests
+      klass.suite.run(result) {|s,n|;}
+    end
+
+    output
+  end
+end

data/lib/gorgon/version.rb

@@ -0,0 +1,3 @@
+module Gorgon
+  VERSION = "0.0.1"
+end

data/lib/gorgon/worker.rb

@@ -0,0 +1,103 @@
+require "gorgon/configuration"
+require "gorgon/amqp_service"
+require 'gorgon/callback_handler'
+require "gorgon/g_logger"
+
+require "uuidtools"
+require "awesome_print"
+require "socket"
+
+module WorkUnit
+  def self.run_file filename
+    require "gorgon/testunit_runner"
+    start_t = Time.now
+    results = TestRunner.run_file(filename)
+    length = Time.now - start_t
+
+    if results.empty?
+      {:failures => [], :type => :pass, :time => length}
+    else
+      {:failures => results, :type => :fail, :time => length}
+    end
+  end
+end
+
+class Worker
+  include GLogger
+
+  def self.build(config)
+    Signal.trap("INT") { interrupted }
+
+    payload = Yajl::Parser.new(:symbolize_keys => true).parse($stdin.read)
+    job_definition = JobDefinition.new(payload)
+
+    connection_config = config[:connection]
+    amqp = AmqpService.new connection_config
+
+    callback_handler = CallbackHandler.new(job_definition.callbacks)
+
+    worker_id = UUIDTools::UUID.timestamp_create.to_s
+    ENV["GORGON_WORKER_ID"] = worker_id
+
+    params = {
+      :amqp => amqp,
+      :file_queue_name => job_definition.file_queue_name,
+      :reply_exchange_name => job_definition.reply_exchange_name,
+      :worker_id => worker_id,
+      :test_runner => WorkUnit,
+      :callback_handler => callback_handler,
+      :log_file => config[:log_file]
+    }
+
+    new(params)
+  end
+
+  def initialize(params)
+    initialize_logger params[:log_file]
+
+    @amqp = params[:amqp]
+    @file_queue_name = params[:file_queue_name]
+    @reply_exchange_name = params[:reply_exchange_name]
+    @worker_id = params[:worker_id]
+    @test_runner = params[:test_runner]
+    @callback_handler = params[:callback_handler]
+  end
+
+  def work
+    log "Running before_start callback"
+    @callback_handler.before_start
+
+    @amqp.start_worker @file_queue_name, @reply_exchange_name do |queue, exchange|
+      while filename = queue.pop
+        exchange.publish make_start_message(filename)
+        test_results = run_file(filename)
+        exchange.publish make_finish_message(filename, test_results)
+      end
+    end
+    ensure # this 'ensure' that we run after_complete even after an 'INT' signal
+      clean_up
+  end
+
+  private
+
+  def clean_up
+    log "Running after_complete callback"
+    @callback_handler.after_complete
+  end
+
+  def run_file(filename)
+    @test_runner.run_file(filename)
+  end
+
+  def make_start_message(filename)
+    {:action => :start, :hostname => Socket.gethostname, :worker_id => @worker_id, :filename => filename}
+  end
+
+  def make_finish_message(filename, results)
+    {:action => :finish, :hostname => Socket.gethostname, :worker_id => @worker_id, :filename => filename}.merge(results)
+  end
+
+  def self.interrupted
+    exit # to avoid raising "INT" exception
+  end
+end

data/lib/gorgon/worker_manager.rb

@@ -0,0 +1,148 @@
+require "gorgon/worker"
+require "gorgon/g_logger"
+require 'gorgon/callback_handler'
+require 'gorgon/pipe_manager'
+require 'gorgon/job_definition'
+
+require 'eventmachine'
+
+class WorkerManager
+  include PipeManager
+  include GLogger
+
+  def self.build listener_config_file
+    @listener_config_file = listener_config_file
+    config = Configuration.load_configuration_from_file(listener_config_file)
+
+    new config
+  end
+
+  def initialize config
+    initialize_logger config[:log_file]
+    @worker_pids = []
+
+    @config = config
+
+    payload = Yajl::Parser.new(:symbolize_keys => true).parse($stdin.read)
+    @job_definition = JobDefinition.new(payload)
+
+    @callback_handler = CallbackHandler.new(@job_definition.callbacks)
+    @available_worker_slots = config[:worker_slots]
+
+    connect
+  end
+
+  def manage
+    fork_workers @available_worker_slots
+  end
+
+  private
+
+  def connect
+    @bunny = Bunny.new(@config[:connection])
+    @bunny.start
+    @reply_exchange = @bunny.exchange(@job_definition.reply_exchange_name)
+
+    @originator_queue = @bunny.queue("", :exclusive => true, :auto_delete => true)
+    exchange = @bunny.exchange("gorgon.worker_managers", :type => :fanout)
+    @originator_queue.bind(exchange)
+  end
+
+  def fork_workers n_workers
+    log "Running before_creating_workers callback"
+    @callback_handler.before_creating_workers
+
+    log "Forking #{n_workers} worker(s)"
+    EventMachine.run do
+      n_workers.times do
+        fork_a_worker
+      end
+
+      subscribe_to_originator_queue
+    end
+  end
+
+  def fork_a_worker
+    @available_worker_slots -= 1
+    ENV["GORGON_CONFIG_PATH"] = @listener_config_filename
+
+    pid, stdin, stdout, stderr = pipe_fork_worker
+    @worker_pids << pid
+    stdin.write(@job_definition.to_json)
+    stdin.close
+
+    watcher = proc do
+      ignore, status = Process.waitpid2 pid
+      @worker_pids.delete(pid)
+      log "Worker #{pid} finished"
+      status
+    end
+
+    worker_complete = proc do |status|
+      if status.exitstatus != 0
+        log_error "Worker #{pid} crashed with exit status #{status.exitstatus}!"
+        error_msg = stderr.read
+        log_error "ERROR MSG: #{error_msg}"
+
+        # originator may have cancel job and exit, so only try to send message
+        begin
+          reply = {:type => :crash,
+            :hostname => Socket.gethostname,
+            :stdout => stdout.read,
+            :stderr => error_msg}
+          @reply_ecxhange.publish(Yajl::Encoder.encode(reply))
+          # TODO: find a way to stop the whole system when a worker crashes or do something more clever
+        rescue Exception => e
+          log_error "Exception raised when trying to report crash to originator:"
+          log_error e.message
+          log_error e.backtrace.join("\n")
+        end
+      end
+      on_worker_complete
+    end
+    EventMachine.defer(watcher, worker_complete)
+  end
+
+  def on_worker_complete
+    @available_worker_slots += 1
+    on_current_job_complete if current_job_complete?
+  end
+
+  def current_job_complete?
+    @available_worker_slots == @config[:worker_slots]
+  end
+
+  def on_current_job_complete
+    log "Job '#{@job_definition.inspect}' completed"
+
+    EventMachine.stop_event_loop
+    @bunny.stop
+  end
+
+  def subscribe_to_originator_queue
+
+    originator_watcher = proc do
+      while true
+        if (payload = @originator_queue.pop[:payload]) != :queue_empty
+          break
+        end
+        sleep 0.5
+      end
+      Yajl::Parser.new(:symbolize_keys => true).parse(payload)
+    end
+
+    handle_message = proc do |payload|
+      if payload[:action] == "cancel_job"
+        log "Cancel job received!!!!!!"
+
+        log "Sending 'INT' signal to #{@worker_pids}"
+        Process.kill("INT", *@worker_pids)
+        log "Signal sent"
+      else
+        EventMachine.defer(originator_watcher, handle_message)
+      end
+    end
+
+    EventMachine.defer(originator_watcher, handle_message)
+  end
+end

data/lib/gorgon/worker_watcher.rb

@@ -0,0 +1,22 @@
+require 'eventmachine'
+require 'socket'
+
+class WorkerWatcher < EventMachine::ProcessWatch
+  def initialize(options = {})
+    @pid = options[:pid]
+    @stdout = options[:stdout]
+    @stderr = options[:stderr]
+    @reply_exchange = options[:reply_exchange]
+  end
+
+  def process_exited
+    ignored, status = Process::waitpid2 @pid
+    if status.exitstatus != 0
+      reply = {:type => :crash,
+               :hostname => Socket.gethostname,
+               :stdout => @stdout.read,
+               :stderr => @stderr.read}
+      @reply_exchange.publish(Yajl::Encoder.encode(reply))
+    end
+  end
+end

data/spec/callback_handler_spec.rb

@@ -0,0 +1,77 @@
+require 'gorgon/callback_handler'
+
+describe CallbackHandler do
+
+  let(:config) {
+    {
+      :before_start => "some/file.rb",
+      :after_complete => "some/other/file.rb",
+      :before_creating_workers => "callbacks/before_creating_workers_file.rb",
+      :after_sync => "callbacks/after_sync_file.rb"
+    }
+  }
+
+  it "calls before hook" do
+    handler = CallbackHandler.new(config)
+
+    handler.should_receive(:load).with("some/file.rb")
+
+    handler.before_start
+  end
+
+  it "does not attempt to load the before start script when before_start is not defined" do
+    handler = CallbackHandler.new({})
+
+    handler.should_not_receive(:load)
+
+    handler.before_start
+  end
+
+  it "calls after hook" do
+    handler = CallbackHandler.new(config)
+
+    handler.should_receive(:load).with("some/other/file.rb")
+
+    handler.after_complete
+  end
+
+  it "does not attempt to load the after complete script when before_start is not defined" do
+    handler = CallbackHandler.new({})
+
+    handler.should_not_receive(:load)
+
+    handler.after_complete
+  end
+
+  it "calls before fork hook" do
+    handler = CallbackHandler.new(config)
+
+    handler.should_receive(:load).with("callbacks/before_creating_workers_file.rb")
+
+    handler.before_creating_workers
+  end
+
+  it "does not attempt to load the before creating workers script when before_creating_workers is not defined" do
+    handler = CallbackHandler.new({})
+
+    handler.should_not_receive(:load)
+
+    handler.before_creating_workers
+  end
+
+  it "calls after sync hook" do
+    handler = CallbackHandler.new(config)
+
+    handler.should_receive(:load).with("callbacks/after_sync_file.rb")
+
+    handler.after_sync
+  end
+
+  it "does not attempt to load the after-sync script when after_sync is not defined" do
+    handler = CallbackHandler.new({})
+
+    handler.should_not_receive(:load)
+
+    handler.after_sync
+  end
+end