kymera 0.1.0

data/lib/kymera/cucumber/cucumber_test_runner.rb

@@ -0,0 +1,76 @@
+require 'cucumber'
+module Kymera
+  module Cucumber
+    class Runner
+
+      #This is the test runner. It is responsible for the actual running of the test.  It takes in 3 parameters. The first being options(Array). These are the options to be used
+      #for the cucumber test run. The run_id(String), this is a unique id identifying the test run that this test is for.  It is used as the channel name for publishing results
+      #on the results bus.  And lastly results_bus(SSocket), this is a socket object representing the results bus. This is what is used for publishing results to that bus
+      def initialize(options, run_id, result_bus = nil)
+        @options = options
+        @result_bus = result_bus
+        @run_id = run_id
+        ENV["AUTOTEST"] = "1" if $stdout.tty?
+      end
+
+      #This is kicking off the test. Takes in 3 parameters, test(String) is the test to be executed. options(Array) is an array of the options to be used with this test run. By default,
+      #it uses the options passed in with the constructor. run_id(String) is the id of test run that this test is associated with. This is also defaulted with what was passed in
+      #with the constructor
+      def run_test(test, branch, options = @options, run_id = @run_id)
+        _results = ''
+        _options = ''
+        options.each do |option|
+          _options += " #{option}"
+        end
+
+        switch_to_branch(branch)
+
+        puts "Running test: #{test}"
+        io = Object::IO.popen("bundle exec cucumber #{test} #{_options}")
+        until io.eof? do
+          result = io.gets
+          unless @result_bus.nil?
+            @result_bus.publish_message(run_id, result)
+          end
+          _results += result
+        end
+        Process.wait2(io.pid)
+        _results
+      end
+
+      private
+
+      #TODO - add support for git
+      #The worker machines have to be setup for public/private key authentication with hg. Otherwise, this will lockup the system waiting for a password
+      def switch_to_branch(branch)
+        io = Object::IO.popen('hg branch')
+        current_branch = io.gets.chomp
+        if current_branch == branch
+          update_current_branch
+        else
+          output = ''
+          io = Object::IO.popen("hg update #{branch}")
+          until io.eof?
+            output << io.gets
+          end
+          Process.wait2(io.pid)
+          puts output
+          update_current_branch
+        end
+      end
+
+      def update_current_branch
+        output = ''
+        io = Object::IO.popen("hg pull -b . -u")
+        until io.eof?
+          output << io.gets
+        end
+        Process.wait2(io.pid)
+        puts output
+      end
+
+    end
+  end
+
+
+end

data/lib/kymera/cucumber/dry_run_formatter.rb

@@ -0,0 +1,31 @@
+module Kymera
+  module Cucumber
+    class DryRunFormatter
+
+      def initialize(step_mother, io, options)
+        @io = io
+      end
+
+      def scenario_name(*args)
+        #if args[0].include?("Outline")
+        #  @scenario_name = args[2].split(':')[0]
+        #else
+        $stdout << args[2]
+        $stdout << "\n"
+        #end
+      end
+
+      #def before_table_row(*args)
+      #
+      #  args.each do |arg|
+      #    unless arg.line < 1 || arg.send(:header?) == true
+      #      $stdout << "#{@scenario_name + ":" + arg.line.to_s }"
+      #      $stdout << "\n"
+      #    end
+      #
+      #  end
+      #end
+    end
+  end
+end
+

data/lib/kymera/cucumber/test_parser.rb

@@ -0,0 +1,36 @@
+require_relative 'dry_run_formatter'
+
+module Kymera
+
+  module Cucumber
+    class TestParser
+
+      def initialize(tests, options)
+        @tests = tests
+        @options = options
+      end
+
+      def parse_tests
+        tests = dry_run(["cucumber", @tests, '--dry-run -f DryRunFormatter', @options].compact.join(" ")).split("\n")
+        refined_tests =[]
+        tests.delete_at(0) if tests[0].downcase.include?('using')
+        tests.each do |test|
+          refined_tests << test.gsub('\\','/')
+        end
+        $stdout << "The number of scenarios found to be executed: #{refined_tests.count}"
+        $stdout << "\n"
+        refined_tests
+      end
+
+      private
+
+      def dry_run(cmd)
+        $stdout << "Preprocessing test files"
+        $stdout << "\n"
+        tr = Thread.new(cmd) { |c| `#{c}`}
+        tr.join
+        tr.value
+      end
+    end
+  end
+end

data/lib/kymera/mongo_driver.rb

@@ -0,0 +1,39 @@
+require_relative 'szmq/szmq'
+require 'json'
+require 'mongo'
+
+module Kymera
+
+  class MongoDriver
+    include Mongo
+
+
+    def self.log_results(log, address = "localhost", port = 27017, database = 'default_db', collection = 'default_collection')
+      puts "Sending results to mongodb..."
+      MongoDriver.new(address, port, database, collection).write_log(log)
+    end
+
+
+    #This can be initialized by specifying the address and the port of the mongodb server. By default, this expects that the
+    #mongodb server is located on the same machine as the calling code. A collection name will also be defaulted if not passed in.
+    #By default, this will be 'default_db'
+    def initialize(address = "localhost", port = 27017, database = 'default_db', collection = 'default_db')
+      puts "Initializing db connection.."
+      @db_client = MongoClient.new(address, port).db(database)
+      puts "Assigning collection..."
+      @collection = collection
+    end
+
+
+    #The @param log needs to be a JSON string.
+    def write_log(log)
+      puts "Getting collection..."
+      coll = @db_client["#{@collection}"]
+      puts "Sending insert request.."
+      coll.insert(JSON.parse log)
+      puts "Request completed"
+    end
+
+  end
+
+end

data/lib/kymera/platform_utils.rb

@@ -0,0 +1,64 @@
+require 'socket'
+
+module Kymera
+
+  def self.processor_count
+    @processor_count ||= case RbConfig::CONFIG['host_os']
+       when /darwin9/
+         `hwprefs cpu_count`.to_i
+       when /darwin/
+         (hwprefs_available? ? `hwprefs thread_count` : `sysctl -n hw.ncpu`).to_i
+       when /linux|cygwin/
+         `grep -c ^processor /proc/cpuinfo`.to_i
+       when /(net|open|free)bsd/
+         `sysctl -n hw.ncpu`.to_i
+       when /mswin|mingw/
+         require 'win32ole'
+         wmi = WIN32OLE.connect("winmgmts://")
+         cpu = wmi.ExecQuery("select NumberOfLogicalProcessors from Win32_Processor")
+         cpu.to_enum.first.NumberOfLogicalProcessors
+       when /solaris2/
+         `psrinfo -p`.to_i # this is physical cpus afaik
+       else
+         $stderr.puts "Unknown architecture ( #{RbConfig::CONFIG["host_os"]} ) assuming one processor."
+         1
+     end
+  end
+
+  def self.is_linux?
+    case RbConfig::CONFIG['host_os']
+      when /linux|darwin/
+        true
+      else
+        false
+    end
+
+  end
+
+
+  def self.ip_address
+    ips = Socket.ip_address_list
+    ip = ''
+    ips.each do |i|
+      ip = i.ip_address if i.ipv4? && i.ip_address.start_with?("10")
+    end
+    ip
+  end
+
+
+
+  def self.host_name
+    Socket.gethostname
+  end
+
+  def self.wait_for(&block)
+    found = false
+    i = 0
+    until i == 60 || found
+      found = yield
+      sleep 1
+      i +=1
+    end
+    found
+  end
+end

data/lib/kymera/results_bus.rb

@@ -0,0 +1,26 @@
+require_relative 'szmq/szmq'
+require 'json'
+
+module Kymera
+
+  class ResultsBus
+
+    def initialize
+      config = Kymera::Config.new
+      @zmq = Kymera::SZMQ.new
+      @incoming_socket = @zmq.socket("tcp://*:#{config.result_bus["pub_port"]}", 'xsub')
+      @outgoing_socket = @zmq.socket("tcp://*:#{config.result_bus["sub_port"]}", 'xpub')
+    end
+
+    def start_bus
+      puts "Results bus started..."
+      @zmq.start_pub_sub_proxy(@incoming_socket, @outgoing_socket)
+    end
+
+
+
+
+  end
+
+
+end

data/lib/kymera/szmq/szmq.rb

@@ -0,0 +1,252 @@
+require 'ffi-rzmq'
+
+module Kymera
+  class SZMQ
+
+    def initialize()
+      SZMQ.context
+
+    end
+
+    def self.context
+      @context ||= ZMQ::Context.new
+    end
+
+    #returns a SSocket object
+    def socket(address, type)
+      SSocket.new(address, type)
+    end
+
+    #Takes two SSocket objects. One representing the client and other representing the worker. Upon receiving a INT command (ctrl + c), the proxy still be shut down
+    #and the frontend and backend sockets will be closed
+    def start_proxy(frontend_socket, backend_socket)
+
+      trap ("INT") do
+        puts "\nStopping proxy..."
+        frontend_socket.close
+        backend_socket.close
+        @close = true
+      end
+
+      frontend_socket.bind
+      backend_socket.bind
+
+      ZMQ::Device.new(frontend_socket.send(:get_socket), backend_socket.send(:get_socket))
+      #ZMQ::Device.new(backend_socket.send(:get_socket), frontend_socket.send(:get_socket))
+
+      #while !@close do
+      #  text = "\r"
+      #  text << "Online"
+      #  space = " "
+      #  0.upto(2) do
+      #    STDOUT.print text
+      #    sleep 0.5
+      #    STDOUT.print "\r#{space * (text.length - 1)}"
+      #    sleep 0.5
+      #  end
+      #end
+    end
+
+    def start_pub_sub_proxy(front_end, back_end)
+      trap ("INT") do
+        puts "\nStopping proxy..."
+        front_end.close
+        back_end.close
+        @close = true
+      end
+
+      front_end.bind
+      back_end.bind
+
+      ZMQ::Device.new(front_end.send(:get_socket), back_end.send(:get_socket))
+
+
+    end
+
+
+    private
+
+    def error_check(rc)
+      if ZMQ::Util.resultcode_ok?(rc)
+        false
+      else
+        STDERR.puts "Operation failed, [#{ZMQ::Util.errno}] description [#{ZMQ::Util.error_string}]"
+        caller(1).each { |callstack| STDERR.puts(callstack)}
+        raise SystemExit
+      end
+    end
+  end
+
+  class SSocket
+
+    def initialize(address, type)
+      @socket_types = %w(request reply dealer router pub sub push pull xpub xsub)
+      @context = SZMQ.context
+      @address = address
+      @socket_type_string = type
+      @socket_type = get_socket_type(type)
+      if @socket_types.include?(type.downcase)
+        @socket = @context.socket(@socket_type)
+        #for some reason if the socket is a push socket the linger option is causing the message not to get sent
+        @socket.setsockopt(ZMQ::LINGER, 0) unless @socket_type_string == 'push'
+      else
+        raise "#{type} is not a valid socket type"
+      end
+    end
+
+    def bind(address = @address)
+      if address.nil?
+        raise "An address must be set or passed"
+      end
+      error_check(@socket.bind(address))
+    end
+
+    def connect(address = @address)
+      if address.nil?
+        raise "An address must be set or passed"
+      end
+      error_check(@socket.connect(address))
+    end
+
+    def subscribe(channels, &block)
+      raise "This socket is not of type SUB and cannot subscribe to a channel" unless @socket_type_string == 'sub'
+      if channels.is_a? String
+        #Debug code
+        #puts "Subscribing to #{channels}"
+        error_check(@socket.setsockopt(ZMQ::SUBSCRIBE, channels))
+      elsif channels.is_a? Array
+        channels.each do |channel|
+          #debug code
+          #puts "Subscribing to #{channel}"
+          error_check(@socket.setsockopt(ZMQ::SUBSCRIBE, channel))
+        end
+      end
+      connect
+      channel = ''
+      message = ''
+      loop do
+        @socket.recv_string(channel)
+        @socket.recv_string(message)
+        if block_given?
+          yield(channel, message)
+        else
+          [channel, message]
+        end
+      end
+    end
+
+    def publish_message(channel, message)
+      raise 'this socket is not of type PUB and cannot publish a message' unless @socket_type_string == 'pub'
+      @socket.send_string(channel, ZMQ::SNDMORE)
+      @socket.send_string(message)
+    end
+
+    def close
+      error_check(@socket.close)
+    end
+
+    def send_message(message)
+      trap ("INT") do
+        puts "Received interrupt..."
+        @socket.close
+      end
+      if @socket_type == ZMQ::REQ
+        @socket.send_string(message)
+        reply = ''
+        @socket.recv_string(reply)
+        reply
+        #end
+      else
+        @socket.send_string(message)
+        nil
+      end
+    end
+
+    #This method listens for messages coming in and then processes them will the block passed into the method. If no block is passed, messages will be received but
+    #will then be dropped on the floor. If the socket is of type REP and no block is given, the receive method will reply with "0" indicating that the message was received
+    #currently, the result of the block is sent back as a reply for REP sockets.  This may change later
+    #TODO - Currently, the send_string method is causing the interupt to be delayed until the next message is received. need to find a way to fix this
+    #TODO - add support for SUB sockets
+    def receive(&block)
+
+      trap ("INT") do
+        puts "Received interrupt..."
+        @close = true
+      end
+      received_message = ''
+
+      if @socket_type == ZMQ::PULL
+        loop do
+          break if @close
+          @socket.recv_string(received_message)
+          if block_given?
+            yield(received_message)
+          end
+        end
+
+      elsif @socket_type == ZMQ::REP
+        reply_message = ''
+        loop do
+          break if @close
+          unless @socket.recv_string(received_message) == -1
+            @socket.recv_string(received_message)
+            if block_given?
+              reply_message = yield(received_message)
+            else
+              reply_message = "0"
+            end
+          end
+          @socket.send_string(reply_message)
+        end
+      else
+        raise "Socket type of #{@socket_type_string} does not receive messages"
+      end
+    end
+
+
+    private
+
+    def error_check(rc)
+      if ZMQ::Util.resultcode_ok?(rc)
+        false
+      else
+        STDERR.puts "Operation failed, [#{ZMQ::Util.errno}] description [#{ZMQ::Util.error_string}]"
+        caller(1).each { |callstack| STDERR.puts(callstack)}
+        raise SystemExit
+      end
+    end
+
+    def get_socket
+      @socket
+    end
+
+    def get_socket_type(type)
+      case type
+        when 'request'
+          ZMQ::REQ
+        when 'reply'
+          ZMQ::REP
+        when 'dealer'
+          ZMQ::DEALER
+        when 'router'
+          ZMQ::ROUTER
+        when 'pub'
+          ZMQ::PUB
+        when 'sub'
+          ZMQ::SUB
+        when 'push'
+          ZMQ::PUSH
+        when 'pull'
+          ZMQ::PULL
+        when 'xpub'
+          ZMQ::XPUB
+        when 'xsub'
+          ZMQ::XSUB
+        else
+          nil
+      end
+    end
+
+  end
+end
+

data/lib/kymera/test_results_collector.rb

@@ -0,0 +1,126 @@
+require_relative 'szmq/szmq'
+require_relative 'mongo_driver'
+require 'chronic'
+require 'json'
+
+module Kymera
+
+  class TestResultsCollector
+
+    def initialize
+      @config = Kymera::Config.new
+      @zmq = Kymera::SZMQ.new
+      @inc_socket = @zmq.socket("tcp://*:#{@config.result_collector["inc_listening_port"]}", 'pull')
+      @out_socket = @zmq.socket(@config.result_collector["result_bus_address"], 'pub')
+      @inc_socket.bind
+      @out_socket.connect
+    end
+
+    def listen
+      puts "Test collector started..."
+      test_count = ''
+      start_test_count = ''
+      @run_id = ''
+      results = ''
+      runner = ''
+      start_time = ''
+      count = 0
+      @inc_socket.receive do |message|
+        parsed_message = JSON.parse message
+        if count < 1
+          @run_id = parsed_message["run_id"]
+          test_count = parsed_message["test_count"].to_i
+          start_test_count = parsed_message["test_count"]
+          runner = parsed_message["runner"]
+          results << parsed_message["results"]
+          start_time = parsed_message["start_time"]
+          puts 'Results run started with the following configuration:'
+          puts "Run ID: #{@run_id}"
+          puts "Test count: #{test_count}"
+          test_count -= 1
+          count +=1
+        elsif test_count > 0
+          results << parsed_message["results"]
+          test_count -= 1
+        end
+
+        if test_count <= 0
+          finalize_results(start_test_count, @run_id, results, runner, start_time)
+          test_count = ''
+          @run_id = ''
+          results = ''
+          runner = ''
+          start_time = ''
+          count = 0
+        end
+
+
+      end
+
+    end
+
+    private
+
+    def finalize_results(test_count, run_id, results, runner, start_time)
+      if runner.downcase == 'cucumber'
+
+        begin
+          #r_results = Kymera::Cucumber::ResultsParser.summarize_results(results)
+          puts "Summarizing results.."
+          r_results = Kymera::Cucumber::ResultsParser.summarize_results(results)
+          puts "Getting pass count..."
+          pass_count = Kymera::Cucumber::ResultsParser.scenario_counts[:pass]
+          puts "Getting fail count..."
+          fail_count = Kymera::Cucumber::ResultsParser.scenario_counts[:fail]
+          # r_results = Kymera::Cucumber::ResultsParser.summarize_results(results)
+          puts "Converting results to html..."
+          html_results = Kymera::Cucumber::HTMLResultsParser.to_html(results)
+          puts "Converting summary to html..."
+          html_summary = Kymera::Cucumber::HTMLResultsParser.to_html(r_results)
+          puts "Setting end time"
+          end_time = Time.now
+          # puts html_results
+          # Kymera::MongoDriver.log_results(build_test_log(test_count, run_id, results, r_results), '10.6.49.83', 27017, 'apollo', 'test_runs')
+          puts "Starting database logging processes..."
+          Kymera::MongoDriver.log_results(build_test_log(test_count, run_id, html_results, html_summary, start_time, end_time.to_s, pass_count, fail_count), @config.result_collector["mongodb_address"],
+                                          @config.result_collector["mongodb_port"].to_i, @config.result_collector["mongodb_database_name"], @config.result_collector["mongodb_collection_name"])
+          puts "Setting run id..."
+        rescue => e
+          puts "There was an error in the logging process:"
+          puts e
+        ensure
+          run_id = "end_#{@run_id}"
+          puts "Sending results to client..."
+          @out_socket.publish_message(run_id, r_results)
+        end
+      end
+    end
+
+    def build_test_log(test_count, run_id, results, summary, start_time, end_time, pass_count, fail_count)
+      begin
+        log_message = {}
+        log_message["run_id"] = run_id
+        log_message["test_count"] = test_count
+        log_message["results"] = results
+        log_message["summary"] = summary
+        log_message["start_time"] = start_time
+        log_message["end_time"] = end_time
+        log_message["duration"] = Chronic.parse(end_time) - Chronic.parse(start_time)
+        log_message["pass_count"] = pass_count
+        log_message["fail_count"] = fail_count
+
+        JSON.generate log_message
+      rescue => e
+        puts e
+      end
+
+    end
+
+
+
+
+
+  end
+
+
+end

data/lib/kymera/version.rb

@@ -0,0 +1,3 @@
+module Kymera
+  VERSION = "0.1.0"
+end