cukeq 0.0.1.dev

data/lib/cukeq/broker.rb

@@ -0,0 +1,65 @@
+module CukeQ
+  class Broker
+    attr_reader :user, :pass, :host, :port, :vhost
+
+    def initialize(uri, opts = {})
+      uri = URI.parse(uri) if uri.kind_of? String
+
+      @user    = uri.user     || raise(ArgumentError, "no user given")
+      @pass    = uri.password || 'cukeq123'
+      @host    = uri.host     || 'localhost'
+      @port    = uri.port     || 5672
+      @vhost   = uri.path     || '/cukeq'
+
+      @timeout = Integer(opts[:timeout] || 20)
+      @queues  = {}
+    end
+
+    def start
+      log self.class, :start, "#{@host}:#{@port}#{@vhost}"
+
+      AMQP.start(amqp_options) do
+        create_queues
+        yield if block_given?
+      end
+    end
+
+    def publish(queue_name, json)
+      queue_for(queue_name).publish(json)
+    end
+
+    def subscribe(queue_name, &blk)
+      queue_for(queue_name).subscribe(&blk)
+    end
+
+    def unsubscribe(queue_name, &blk)
+      queue_for(queue_name).unsubscribe(&blk)
+    end
+
+    def queue_for(name)
+      @queues[name] || raise("unknown queue: #{name.inspect}")
+    end
+
+    private
+
+    def create_queues
+      @queues[:ping]    = MQ.new.queue("cukeq.ping")
+      @queues[:pong]    = MQ.new.queue("cukeq.pong")
+
+      @queues[:results] = MQ.new.queue("cukeq.results")
+      @queues[:jobs]    = MQ.new.queue("cukeq.jobs")
+    end
+
+    def amqp_options
+      {
+        :host    => @host,
+        :port    => @port,
+        :user    => @user,
+        :pass    => @pass,
+        :vhost   => @vhost,
+        :timeout => 20
+      }
+    end
+
+  end # QueueHandler
+end # CukeQ

data/lib/cukeq/em/system3.rb

@@ -0,0 +1,53 @@
+module EventMachine
+
+  #
+  # http://github.com/eventmachine/eventmachine/issues#issue/15
+  #
+
+  def self.system3(cmd, *args, &cb)
+    cb ||= args.pop if args.last.is_a? Proc
+    init = args.pop if args.last.is_a? Proc
+
+    # merge remaining arguments into the command
+    cmd = ([cmd] + args.map{|a|a.to_s.dump}).join(' ')
+
+    new_stderr = $stderr.dup
+
+    rd, wr = IO::pipe
+
+    result_count = 0
+
+    err_result = nil
+    std_result = nil
+    stderr_connection = nil
+
+    err_proc = proc {|output, status|
+      stderr_connection = nil
+      err_result = output
+      result_count+=1
+      if result_count == 2
+        cb[std_result, err_result, status]
+      end
+    }
+
+    std_proc = proc {|output, status|
+      stderr_connection.close_connection if stderr_connection
+      rd.close
+      std_result = output
+      result_count += 1
+      if result_count == 2
+        cb[std_result, err_result, status]
+      end
+    }
+
+    $stderr.reopen(wr)
+    signature = EM.popen(cmd, SystemCmd, std_proc) do |c|
+      init[c] if init
+    end.signature
+    stderr_connection = EM.attach(rd, SystemCmd, err_proc)
+    $stderr.reopen(new_stderr)
+    wr.close
+
+    return EventMachine.get_subprocess_pid(signature)
+  end unless EventMachine.respond_to?(:system3)
+end

data/lib/cukeq/job_clearer.rb

@@ -0,0 +1,19 @@
+
+module CukeQ
+
+  #
+  # TODO: must be a better way
+  #
+
+  class JobClearer < Slave
+
+    def poll
+      EM.next_tick {
+        job = @broker.queue_for(:jobs).pop
+        log(self.class, :ignoring, job)
+        poll
+      }
+    end
+
+  end # JobClearer
+end # CukeQ

data/lib/cukeq/master.rb

@@ -0,0 +1,146 @@
+module CukeQ
+  class Master
+    DEFAULT_BROKER_URI = URI.parse("amqp://cukeq-master:cukeq123@localhost:5672/cukeq")
+    DEFAULT_WEBAPP_URI = URI.parse("http://0.0.0.0:9292")
+
+    class << self
+      def execute(argv)
+        configured_instance(argv).start
+      end
+
+      def configured_instance(argv)
+        opts = parse(argv)
+
+        raise ArgumentError, "must provide --scm" unless opts[:scm]
+        raise ArgumentError, "must provide --report_to" unless opts[:report_to]
+
+        if b = opts[:broker]
+          b.user     ||= DEFAULT_BROKER_URI.user
+          b.password ||= DEFAULT_BROKER_URI.password
+          b.host     ||= DEFAULT_BROKER_URI.host
+          b.port     ||= DEFAULT_BROKER_URI.port
+          b.path     = b.path.empty? ? DEFAULT_BROKER_URI.path : b.path
+        else
+          opts[:broker] = DEFAULT_BROKER_URI
+        end
+
+        if w = opts[:webapp]
+          w.host ||= DEFAULT_WEBAPP_URI.host
+          w.port ||= DEFAULT_WEBAPP_URI.port
+        else
+          opts[:webapp] = DEFAULT_WEBAPP_URI
+        end
+
+        new(
+          Broker.new(opts[:broker]),
+          WebApp.new(opts[:webapp]),
+          Scm.new(opts[:scm]),
+          Reporter.new(opts[:report_to]),
+          ScenarioExploder.new
+        )
+      end
+
+      def parse(argv)
+        options = {}
+
+        argv.extend OptionParser::Arguable
+        argv.options do |opts|
+          opts.on("-b", "--broker URI (default: #{DEFAULT_BROKER_URI})") do |str|
+            options[:broker] = URI.parse(str)
+          end
+
+          opts.on("-w", "--webapp URI (default: http://localhost:9292)") do |str|
+            options[:webapp] = URI.parse(str)
+          end
+
+          opts.on("-s", "--scm SCM-URL") do |url|
+            options[:scm] = URI.parse(url)
+          end
+
+          opts.on("-r", "--report-to REPORTER-URL") do |url|
+            options[:report_to] = URI.parse(url)
+          end
+        end.parse!
+
+        options
+      end
+    end # class << self
+
+    attr_reader :broker, :webapp, :scm, :reporter, :exploder
+
+    def initialize(broker, webapp, scm, reporter, exploder)
+      @broker   = broker
+      @webapp   = webapp
+      @scm      = scm
+      @reporter = reporter
+      @exploder = exploder
+    end
+
+    def start
+      @scm.update {
+        @broker.start {
+          subscribe
+          start_webapp
+        }
+      }
+    end
+
+    def ping(&blk)
+      log log_name, :ping
+      @broker.subscribe :pong, &blk
+      @broker.publish   :ping, '{}'
+    end
+
+    #
+    # This is triggered by POSTs to the webapp
+    #
+    # data:
+    #
+    # { 'features' => (sent to exploder), 'run_id' => ID }
+    #
+
+    def run(data)
+      Dir.chdir(@scm.working_copy) do
+        @exploder.explode(data['features']) { |units| publish_units(data, units) }
+      end
+    end
+
+    def publish_units(data, units)
+      scm = { :revision => @scm.current_revision, :url => @scm.url }
+      run = { :id => data['run_id'], :no_of_units => units.size}
+
+      units.each do |unit|
+        @broker.publish(
+          :jobs, {
+            :run         => run,
+            :scm         => scm,
+            :unit        => unit,
+          }.to_json
+        )
+
+        log self.class, :published, unit
+      end
+    end
+
+    #
+    # Called whenever a result is received on the results queue
+    #
+
+    def result(message)
+      log self.class, :result, message['run']
+      @reporter.report message
+    end
+
+    def subscribe
+      @broker.subscribe :results do |message|
+        next unless message
+        result(JSON.parse(message))
+      end
+    end
+
+    def start_webapp
+      @webapp.run method(:run)
+    end
+
+  end # Master
+end # CukeQ

data/lib/cukeq/reporter.rb

@@ -0,0 +1,22 @@
+module CukeQ
+  class Reporter
+    attr_reader :uri
+
+    def initialize(uri)
+      @uri = uri
+    end
+
+    def report(message)
+      EM::P::HttpClient.request(
+        :host    => uri.host,
+        :port    => uri.port,
+        :verb    => "POST",
+        :request => uri.path.empty? ? "/" : uri.path,
+        :content => message.to_json
+      )
+    rescue => e # EM raises a RuntimeError..
+      log self.class, "error for #{uri}: #{e.message}"
+    end
+
+  end # Reporter
+end # CukeQ

data/lib/cukeq/runner.rb

@@ -0,0 +1,63 @@
+module CukeQ
+  class Runner
+
+    DEFAULT_TRIGGER_URI = URI.parse("http://localhost:9292/")
+
+    def self.execute(args)
+      opts = parse(args)
+      uri = opts.delete(:uri)
+
+      EM.run {
+        http = EM::P::HttpClient.request(
+          :host    => uri.host,
+          :port    => uri.port,
+          :verb    => "POST",
+          :request => uri.path.empty? ? "/" : uri.path,
+          :content => opts.to_json
+        )
+
+        http.callback do |response|
+          log :success, response
+          EM.stop
+        end
+
+        http.errback do |error|
+          log :error, error[:status], uri.to_s
+
+          EM.stop
+        end
+
+      }
+    end
+
+    private
+
+    def self.parse(argv)
+      options = {:uri => DEFAULT_TRIGGER_URI}
+
+      argv.extend OptionParser::Arguable
+      argv.options do |opts|
+        opts.on("-u", "--uri URI (default: #{DEFAULT_TRIGGER_URI})") do |str|
+          options[:uri] = URI.parse(str)
+        end
+
+        opts.on("-i", "--id RUN_ID") do |str|
+          options[:run_id] = str
+        end
+      end.parse!
+
+      if argv.empty?
+        raise "must provide list of features"
+      end
+
+      unless options[:run_id]
+        raise "must provide --id"
+      end
+
+      options[:features] = argv
+
+      options
+    end
+
+  end # Runner
+end # CukeQ

data/lib/cukeq/scenario_exploder.rb

@@ -0,0 +1,32 @@
+module CukeQ
+  class ScenarioExploder
+
+    def explode(file_colon_lines)
+      yield file_colon_lines.map { |f| {:file => f} } # temporary
+
+      # # cwd is now the working copy of the project
+      # units = []
+      #
+      # # we do the parsing in a subprocess to avoid having to restart the master
+      # # whenever gherkin/cucumber is updated.
+      # #
+      # # The slaves should do the same. CukeQ is just passing things through.
+      # #
+      # IO.popen("-") do |pipe|
+      #   if pipe
+      #     while json = pipe.gets
+      #       units << JSON.parse(json)
+      #     end
+      #   else
+      #     file_colon_lines.each do |f|
+      #       puts json_for(f)
+      #     end
+      #   end
+      # end
+      #
+      # yield units
+    end
+
+  end # ScenarioExploder
+end # CukeQ
+

data/lib/cukeq/scenario_runner.rb

@@ -0,0 +1,134 @@
+# encoding: utf-8
+
+require "tmpdir"
+require "fileutils"
+
+module CukeQ
+  class ScenarioRunner
+
+    def run(job, &callback)
+      scm = scm_for job
+
+      Dir.chdir scm.working_copy
+
+      run_job(scm.working_copy, job, callback)
+    rescue => ex
+      yield :success   => false,
+            :error     => ex.message,
+            :backtrace => ex.backtrace,
+            :run       => job['run']
+    end
+
+    def scm_for(job)
+      url = job['scm']['url']
+      rev = job['scm']['revision']
+
+      scm = Scm.new(url)
+      unless scm.current_revision.to_s == rev.to_s
+        # TODO(jari): this doesn't ensure that current_revision == rev - it
+        # would also make sense to move the logic to Scm
+        scm.update {} # hmm.
+      end
+
+      scm
+    end
+
+    def run_job(working_copy, job, callback)
+      AsyncJob.new(working_copy, job, callback).run
+    end
+
+  end # ScenarioRunner
+end # CukeQ
+
+class AsyncJob
+
+  def initialize(working_copy, job, callback)
+    @job          = job
+    @callback     = callback
+    @result       = {:success => true, :slave => CukeQ.identifier}
+    @invoked      = false
+    @working_copy = working_copy
+  end
+
+  def run
+    parse_job
+
+    EventMachine.system3 command, &method(:child_finished)
+  rescue => ex
+    handle_exception(ex)
+  end
+
+  private
+
+  def handle_exception(ex)
+    @result.merge!(:success => false, :error => ex.message, :backtrace => ex.backtrace, :cwd => Dir.pwd)
+    cleanup
+    invoke_callback
+  end
+
+  def invoke_callback
+    if @invoked
+      $stderr.puts "#{self} tried to invoke callback twice"
+      return
+    end
+
+    @invoked = true
+    @callback.call @result
+  end
+
+  def cleanup
+    FileUtils.rm_rf(output_file) if File.exist?(output_file)
+  end
+
+  def command
+    "cucumber -rfeatures --format Cucumber::Formatter::Json --out #{output_file} #{@feature_file}"
+  end
+
+  def child_finished(stdout, stderr, status)
+    output = <<-OUT
+stdout:
+#{stdout}
+
+stderr:
+#{stderr}
+    OUT
+
+    @result.merge!(
+      :output   => output,
+      :stderr   => stderr,
+      :stdout   => stdout,
+      :success  => status.success?,
+      :exitcode => status.exitstatus,
+      :results  => fetch_results,
+      :cwd      => Dir.pwd
+    )
+    cleanup
+    invoke_callback
+  rescue => ex
+    handle_exception ex
+  end
+
+  def fetch_results
+    return unless File.exist?(output_file)
+
+    content = File.read(output_file)
+    begin
+      JSON.parse(content)
+    rescue JSON::ParserError => ex
+      raise JSON::ParserError, "#{ex.message} (#{content.inspect})"
+    end
+  end
+
+  def parse_job
+    @feature_file = @job['unit']['file']
+    @run          = @job['run']
+    @scm          = @job['scm']
+
+    @result.merge!(:feature_file => @feature_file, :run => @run, :scm => @scm)
+  end
+
+  def output_file
+    @output_file ||= "#{CukeQ.identifier}-#{@run['id']}.json"
+  end
+
+end