oats 0.1.0 → 0.1.1

data/Gemfile

@@ -1,7 +1,7 @@
 source 'http://rubygems.org'
 
-unless defined?(OATS_GEM_IS_ALREADY_INCLUDED)
-  OATS_GEM_IS_ALREADY_INCLUDED = true
+unless defined?(OATS_IS_ALREADY_INCLUDED)
+  OATS_IS_ALREADY_INCLUDED = true
 
   gemspec
   # Include Gemfile from dir_tests

data/bin/oats

@@ -1,10 +1,3 @@
 #!/usr/bin/env ruby
-
-dir = File.dirname(__FILE__)
-$:.unshift File.expand_path('../lib', dir )
-require 'oats'
-if $oats_execution['options']["_:agent"]
-  Oats::Driver.agent
-else
-  Oats.run
-end
+require File.expand_path('../../lib/oats', __FILE__ )
+Oats.run

data/lib/oats/driver.rb

@@ -9,39 +9,7 @@ module Oats
 
   module Driver
 
-    def Driver.agent
-      ENV['KILL_AGENT' ] = 'KILL_AGENT' if $oats_execution['options']["_:kill_agent"]
-      ENV['OATS_USER' ] = $oats_execution['options']["_:oats_user"] if $oats_execution['options']["_:oats_user"]
-      ENV['OATS_TESTS_REPOSITORY_VERSION' ] = $oats_execution['options']["_:repository_version"] if $oats_execution['options']["_:repository_version"]
-      nick = $oats_execution['options']["execution:occ:agent_nickname"]
-      ENV['OATS_AGENT_NICKNAME' ] = nick if nick
-      port = $oats_execution['options']["execution:occ:agent_port"].to_s
-      ENV['OATS_AGENT_PORT'] = port if port
-      dir = ENV['HOME'] + "/results_archive/#{nick}/agent_logs"
-      FileUtils.mkdir_p(dir) unless File.exists?(dir)
-      ENV['OATS_AGENT_CONFIG_FILE'] = "#{dir}/config-agent.txt"
-      dat = `date +'%m%d%H%M%S'`.chomp
-      log_file = "#{dir}/agent_#{dat}.log"
-      ENV['OATS_AGENT_LOGFILE'] = log_file
-      agent_log_file = "#{dir}/agent.log"
-      cmd = ENV['OATS_HOME'] + '/bin/agent'
-      pid = `#{cmd}`.chomp
-      puts "Running PID: " + pid + ', Log: ' + log_file
-      #      echo "$NICKNAME $PORT $PID $DISPLAY_NUM"  >| $config_agent_file
-      10.times do
-        if File.exist? log_file
-          FileUtils.rm_f agent_log_file
-          FileUtils.ln log_file, agent_log_file
-          break
-        end
-        sleep 1
-      end
-    end
-
-    # Main method that starts oats execution in either agent or standalone mode.
-    # Parameters are command-line arguments
-    # Returns oats_info object containing execution results
-    def Driver.run(args)
+    def Driver.init(args=nil)
       unless ENV['HOSTNAME']
         if RUBY_PLATFORM =~ /(mswin|mingw)/
           ENV['HOSTNAME'] = ENV['COMPUTERNAME']
@@ -49,7 +17,6 @@ module Oats
           ENV['HOSTNAME'] = `hostname`.chomp
         end
       end
-
       Log4r::Logger.root.level = Log4r::DEBUG
       Log4r::StdoutOutputter.new('console', :level=>1,
         :formatter=>Log4r::PatternFormatter.new(:depth=>50,
@@ -62,33 +29,15 @@ module Oats
       @@quiet = options['_:quiet'] # save quiet option from initial commandline options
       $log.remove('console') if @@quiet
       ENV['HOME'] = Util.expand_path(ENV['HOME']) if ENV['HOME'] # Normalize for cygwin
-      if $oats_execution['agent']
-        require 'oats/ragent'
-        # $oats_execution['agent'] (used by framework) == Oats.global['agent'] (by YAMLs) === options
-        $oats = OatsData.load(options['_:ini_file'])
-        $oats['_']['options'] = options
-        Roptions.override(options)
-        # $oats would be reset and and regenerated by agents across jobs.
-
-        options['execution:occ:agent_host'] = $oats['execution']['occ']['agent_host']
-        options['execution:occ:agent_port'] = $oats['execution']['occ']['agent_port']
-        options['execution:occ:agent_nickname'] = ($oats['execution']['occ']['agent_nickname'] ||  options['execution:occ:agent_host'].sub(/\..*/,''))
-        $oats['execution']['occ']['agent_nickname'] = options['execution:occ:agent_nickname']
-
-        if options['_:command']
-          require 'oats/rclient'
-          options['_:id'] = Time.now.to_i.to_s
-          request = { :command => options['_:command'], :args => options['_:args'] }
-          request[:id] = options['_:id'] if options['_:id']
-          EventMachine::run { EventMachine::connect options['execution:occ:agent_host'],
-            options['execution:occ:agent_port'].to_i, Rclient, options['execution:occ:agent_host'], request
-          }
-        else
-          Ragent.start $oats['execution']['occ']
-        end
-      else
-        Driver.start(nil,options)
-      end
+      options
+    end
+    
+    # Main method that starts oats execution in either agent or standalone mode.
+    # Parameters are command-line arguments
+    # Returns oats_info object containing execution results
+    def Driver.run(args)
+      options = Driver.init(args)
+      Driver.start(nil,options)
       $oats_info
     end
 

data/lib/oats/report.rb

@@ -140,8 +140,8 @@ module Oats
         $log.error exc
         return oats_info
       end
+      OatsAgent::Ragent.snapshot_oats_info(rinfo) if $oats_execution['agent']
       begin
-        Ragent.snapshot_oats_info(rinfo) if $oats_execution['agent']
         FileUtils.mv(results_file_tmp, results_file)
       rescue
         $log.error "Error moving [#{results_file_tmp}]. Skipping saving the intermediate results."

data/lib/oats/user_api.rb

@@ -183,7 +183,7 @@ module Oats
     oats_data['execution']['dir_results'] = Util.expand_path(oats_data['execution']['dir_results'])
     oats_data['result_archive_dir'] = oats_data['execution']['dir_results'] + '_archive'
     if $oats_execution['agent']
-      agent_nickname = Ragent.occ['agent_nickname']
+      agent_nickname = OatsAgent::Ragent.occ['agent_nickname']
       if oats_data['execution']['dir_results'] !~ /#{agent_nickname}$/
         # Should move to a better place.This is unrelated to results, Just picking up the agent file.
         agent_ini_file = File.join(ENV['HOME'], agent_nickname + '_oats.yml')

data/lib/oats/version.rb

@@ -1,3 +1,3 @@
 module Oats
-  VERSION = "0.1.0"
+  VERSION = "0.1.1                                    "
 end

data/lib/oats.rb

@@ -23,9 +23,8 @@ require 'oats/keywords'
 
 # GEMS needed by OATS.
 require 'rubygems'
-require "bundler/setup"
+#require "bundler/setup"
 #Bundler.require
-#gem 'log4r'
 #require 'deep_merge' # Need modified version of https://github.com/danielsdeleo/deep_merge for 1.9 compatibility
 require 'log4r'  # http://log4r.sourceforge.net/rdoc/index.html
 

data/oats.gemspec

@@ -17,7 +17,7 @@ Gem::Specification.new do |s|
     s.test_files    = File.directory?('.git') ? `git ls-files -- {test,spec,features}/*`.split("\n") : []
   end
   #  s.test_files = ["test/test_cgi_wrapper.rb" ]
-  s.executables   = %w{oats occ}
+  s.executables   = %w{oats}
   s.require_paths = ["lib"]
 
   #   s.extra_rdoc_files = ["CHANGELOG", "COPYING", "lib/oats/oats.rb", "LICENSE", "README"]
@@ -32,12 +32,5 @@ Gem::Specification.new do |s|
 
   if RUBY_PLATFORM =~ /(mswin|mingw)/ # Assume won't use the agent
     s.add_dependency 'win32-process'
-  else
-    s.add_dependency 'json'
-    s.add_dependency 'em-http-request'
-    if RUBY_PLATFORM =~ /linux/ # Seems to be needed by Ubuntu
-      s.add_dependency 'execjs'
-      s.add_dependency 'therubyracer'
-    end
   end
 end

data/oats_tests/bin/oats

@@ -1,8 +1,2 @@
 #!/usr/bin/env ruby
-unless defined? Gem
-  require 'rubygems'
-  gem 'oats'
-end
-require 'oats'
-ENV['OATS_TESTS'] ||= File.expand_path(File.dirname(File.dirname(__FILE__)))
-Oats.run
+require File.expand_path('../oats', __FILE__)

data/oats_tests/bin/oats.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+ENV['OATS_TESTS'] ||= File.expand_path(File.dirname(File.dirname(__FILE__)))
+oats_lib = File.expand_path('../oats/lib', ENV['OATS_TESTS'])
+if File.directory?(oats_lib) and false
+  $:.unshift(oats_lib)
+else
+  require 'rubygems' unless defined? Gem
+  gem 'oats'
+end
+require 'oats'
+Oats.run

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: oats
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 25
   prerelease: 
   segments: 
   - 0
   - 1
-  - 0
-  version: 0.1.0
+  - 1
+  version: 0.1.1
 platform: ruby
 authors: 
 - Levent Atasoy
@@ -45,40 +45,11 @@ dependencies:
         version: "0"
   type: :runtime
   version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: json
-  prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  type: :runtime
-  version_requirements: *id003
-- !ruby/object:Gem::Dependency 
-  name: em-http-request
-  prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  type: :runtime
-  version_requirements: *id004
 description: A flexible automated system integration regression test framework.
 email: 
 - levent.atasoy@gmail.com
 executables: 
 - oats
-- occ
 extensions: []
 
 extra_rdoc_files: []
@@ -89,10 +60,7 @@ files:
 - Gemfile
 - README.txt
 - Rakefile
-- bin/agent
 - bin/oats
-- bin/occ
-- bin/results_cleanup
 - doc/COPYING
 - doc/LICENSE
 - doc/OATS_Framework.doc
@@ -119,9 +87,6 @@ files:
 - lib/oats/oats_selenium_api.rb
 - lib/oats/oselenium.rb
 - lib/oats/ossh.rb
-- lib/oats/patches_for_eventmachine_12.10.rb
-- lib/oats/ragent.rb
-- lib/oats/rclient.rb
 - lib/oats/report.rb
 - lib/oats/roptions.rb
 - lib/oats/test_case.rb
@@ -141,6 +106,7 @@ files:
 - oats_tests/Gemfile
 - oats_tests/aut_ini.yml
 - oats_tests/bin/oats
+- oats_tests/bin/oats.rb
 - oats_tests/environments/qa.yml
 - oats_tests/environments/qa_chrome.yml
 - oats_tests/examples/core/coreExamples.yml

data/bin/agent

@@ -1,174 +0,0 @@
-#!/bin/bash
-# This script is used to start OATS in agent mode and communicate with OCC.
-
-[ "$OS" ] || export OS=$(uname)                     
-if [ "$OS" == "Windows_NT" ]; then
-    export PATH="$PATH:/cygdrive/c/apps/cygwin/bin"
-    [ "$HOSTNAME" ] || HOSTNAME="$COMPUTERNAME"
-else
-    [ "$HOSTNAME" ] || HOSTNAME=`hostname`
-fi
-export HOSTNAME
-[ "$OATS_AGENT_NICKNAME" ] || OATS_AGENT_NICKNAME=${HOSTNAME/.*}
-doc="
-Starts OATS agent to be used with OCC
-
-USAGE: agent [-k[ill]] [-n[ickname] OATS_AGENT_NICKNAME] [ -p[ort]  OATS_AGENT_PORT ]
-             [ -r[epo] OATS_TESTS_REPOSITORY_VERSION ] [ -u OATS_USER]
-
-Parameters: (also can be passed in via environment variables
- -n OATS_AGENT_NICKNAME OCC ID of the agent.
- -p OATS_AGENT_PORT Agent port to communicate with OCC. Default is port previously
-    used for OATS_AGENT_NICKNAME.
- -u OATS_USER who started the agent. Used for logging purposes only.
- -r OATS_TESTS_REPOSITORY_VERSION Required to update the agent.
- -k kill the agent, or set OATS_KILL_AGENT
-
-Example:
-/home/occadmin/oats/bin/agent -p 3011 -n occ_1 -r 403cc620c265db84dbd3fb7d7cce4d57416bff09
-
-The agent script should be in the path so that ssh from occ can pick it up.
-Git requires definition of OATS_TESTS_GIT_REPOSITORY environment variable.
- "
-input_pars="$@"
-while [ "$1" ]; do
-    case $1 in
-	-p*) shift; OATS_AGENT_PORT="$1" ;;
-	-n*) shift; OATS_AGENT_NICKNAME="$1" ;;
-	-u*) shift; OATS_USER="$1" ;;
-	-k*) OATS_KILL_AGENT='OATS_KILL_AGENT' ;;
-	-r*) shift; OATS_TESTS_REPOSITORY_VERSION="$1" ;;
-	-d*) shift; DISPLAY_NUM="$1" ;;
-	*) echo "Unrecognized parameter: $1" ;
-	    echo "$doc"
-	    exit ;;
-    esac
-    shift
-done
-
-function agent_echo {
-    echo "$(date +'%m/%d/%H:%M:%S') $*"
-}
-function fkill {
-    agent_echo "Killing PID: $each_pid"
-    if [ "$OS" == "Windows_NT" ]; then
-	pskill $1
-    else
-	kill -9 $1
-    fi
-}
-
-{
-    agent_echo  "Invoking $0 $input_pars"
-
-    # Need these off when called by OCC, otherwise they OCC values are inherited
-    unset RUBYOPT BUNDLE_BIN_PATH BUNDLE_GEMFILE  # GEM_HOME GEM_PATH # RAILS_ENV
-    [ "$OATS_TESTS_GIT_REPOSITORY" ] && export OATS_TESTS="$HOME/results_archive/$OATS_AGENT_NICKNAME"/oats_tests
-    ruby_com="$(dirname $(type -p $0))/oats -n $OATS_AGENT_NICKNAME -p $OATS_AGENT_PORT"
-    if [ -e "$config_agent_file" ]; then
-	line=$(grep "^$OATS_AGENT_NICKNAME" "$config_agent_file")
-	read nickname PREV_OATS_AGENT_PORT pid display<<< $line
-	[ "$OATS_AGENT_PORT" ] || OATS_AGENT_PORT=$PREV_OATS_AGENT_PORT
-	[ "$PID" ] || PID=$pid
-	if [ -z "$DISPLAY_NUM" ]; then
-	    if [ "$display" ]; then
-		DISPLAY_NUM=$(echo "$display" | sed -e 's/.*:\(.\).*/\1/')
-		[ "$DISPLAY_NUM" ] || DISPLAY_NUM="$display"
-	    else
-		DISPLAY_NUM='0'
-	    fi
-	fi
-    fi
-    if [ -z "$OATS_AGENT_PORT" ]; then
-	agent_echo "$0: Must specify a port, exiting..." >&2
-	exit 1
-    fi
-
-    [ "$OATS_AGENT_PORT" == "$PREV_OATS_AGENT_PORT" ] && PREV_OATS_AGENT_PORT=''
-    for OATS_AGENT_PORT_VAR in $PREV_OATS_AGENT_PORT $OATS_AGENT_PORT; do
-	skip_port=''
-	if [ "$PID" -a "$OATS_AGENT_PORT_VAR" == "$PREV_OATS_AGENT_PORT" ]; then
-            agent_echo "Attempting to kill agent $OATS_AGENT_NICKNAME with PID: $PID"
-	    fkill $PID
-	    [ $? == 0 ] && skip_port=skip_port
-	fi
-	if [ -z "$skip_port" ]; then
-	    # agent_echo "Attempting to kill process holding on to port $OATS_AGENT_PORT_VAR"
-	    if [ "$OS" == Darwin ]; then
-		lines=$(ps -ef|grep "$ruby_com"|grep -v grep)
-		PID=$(echo $(cut -c 6-11 <<< "$lines"))
-	    else
-		if [ "$OS" == Windows_NT ]; then # Killing the top level bash process doesn't cut it
-		    lines=$(netstat -a -o 2>/dev/null| grep "$OATS_AGENT_PORT_VAR .* LISTEN" )
-		else
-		    lines=$(netstat -n -p -l 2>/dev/null| grep "$OATS_AGENT_PORT_VAR .* LISTEN" )
-		fi
-		PID=$(echo "$line" | sed 's/.* LISTEN[^ ]* *//;s/.ruby .*//')
-		[ "$PID" -a "$PID" != "$line" ] || PID=''
-	    fi
-	    if [ "$PID" ]; then
-		agent_echo "PS line(s): $lines"
-		for each_pid in $PID; do
-		    fkill $each_pid
-		done
-	    # else
-	    # 	agent_echo "No agent is found on port $OATS_AGENT_PORT_VAR"
-	    fi
-	fi
-    done
-    [ "$OATS_KILL_AGENT" ] && return
-
-    if [ -d $OATS_TESTS/.svn ]; then
-	COUNTER=0
-	[ "$OATS_TESTS_REPOSITORY_VERSION" ] && agent_echo "Requested OATS Version: $OATS_TESTS_REPOSITORY_VERSION"
-	while [ $COUNTER -lt 5 ]; do
-            let COUNTER=COUNTER+1
-	    OATS_TESTS_CODE_VERSION=$(svn info $OATS_TESTS | sed -n 's/Last Changed Rev: *//p')
-	    [ "$OATS_TESTS_REPOSITORY_VERSION" ] || break
-	    [ "$OATS_TESTS_CODE_VERSION" -ge "$OATS_TESTS_REPOSITORY_VERSION" ] && break
-	    [ $COUNTER -eq 1 ] || sleep 3
-	    svn update $OATS_TESTS 2>&1
-	done
-	if [ $COUNTER -eq 5 ]; then
-	    agent_echo "Could not update the code version $OATS_TESTS_CODE_VERSION to $OATS_TESTS_REPOSITORY_VERSION" >&2
-	    return 2
-	fi
-	agent_echo "Current OATS code version: $OATS_TESTS_CODE_VERSION"
-    elif [ "$OATS_TESTS_GIT_REPOSITORY" ]; then
-	[ -d $OATS_TESTS ] || git clone $OATS_TESTS_GIT_REPOSITORY $OATS_TESTS
-	cd $OATS_TESTS
-        origin="$OATS_TESTS_GIT_REPOSITORY"
-        [ "$origin" ] || origin=origin
-	if [ "$OATS_TESTS_REPOSITORY_VERSION" ]; then
-	    for i in 1 2; do
-		out=$(git checkout $OATS_TESTS_REPOSITORY_VERSION 2>&1) && break # may detach HEAD, but it is OK
-		if [ "$out" == "fatal: reference is not a tree: $OATS_TESTS_REPOSITORY_VERSION" ]; then
-		    echo -n "Need to pull requested version: $OATS_TESTS_REPOSITORY_VERSION "
-		else
-		    echo "$out"
-		fi
-		git pull $origin master # fast-forward master from origin
-	    done
-        else
-            git pull $origin master # fast-forward master from origin
-	fi
-	OATS_TESTS_CODE_VERSION=$(git rev-list HEAD -1) # last commit in checked out version
-	if [ "${OATS_TESTS_CODE_VERSION##$OATS_TESTS_REPOSITORY_VERSION*}" ]; then
-	    agent_echo "Could not update the code version $OATS_TESTS_CODE_VERSION to $OATS_TESTS_REPOSITORY_VERSION" >&2
-	    return 2
-	fi
-	[ "$OATS_TESTS_REPOSITORY_VERSION" ] || agent_echo "Using OATS code version: $OATS_TESTS_CODE_VERSION"
-    else
-	OATS_TESTS_CODE_VERSION=$OATS_TESTS_REPOSITORY_VERSION
-	[ "$OATS_TESTS_CODE_VERSION" ] && agent_echo "Setting OATS code version to the requested version: $OATS_TESTS_CODE_VERSION]" # This is not set for development/debug
-    fi
-    export OATS_TESTS_CODE_VERSION
-    cd $OATS_HOME  # Needed for bundler
-    agent_echo "Starting agent $OATS_AGENT_NICKNAME on port $OATS_AGENT_PORT"
-    $ruby_com
-} >> $OATS_AGENT_LOGFILE 2>&1 &
-
-PID=$(jobs -p)
-echo "Initiated PID: $PID"  >> $OATS_AGENT_LOGFILE
-echo "$PID"
-echo "$OATS_AGENT_NICKNAME $OATS_AGENT_PORT $PID $DISPLAY_NUM"  >| $OATS_AGENT_CONFIG_FILE

data/bin/occ

@@ -1,29 +0,0 @@
-#!/usr/bin/env ruby
-#
-# This script is used to start OCC
-
-#[ "$RAILS_ENV"  ] || export RAILS_ENV="production"
-occ_home = ENV['OATS_OCC_HOME']
-unless occ_home
-  pwd = Dir.pwd
-  occ_home = pwd if File.basename(pwd) == 'occ'
-end
-occ_home = ENV['HOME'] + '/occ' unless occ_home
-occ_home = ENV['HOME'] + '/NetBeansProjects/occ' unless File.directory?(occ_home)
-
-raise "Must define OCC_HOME or be in occ directory to run this command." unless occ_home
-
-Dir.chdir(occ_home)
-exec 'ruby script/rails server mongrel' # -p 4000
-
-# By pass the following unless using distributed agents
-#  if [ "$OS" != "Windows_NT" ]; then
-#    if  [ -z "$SSH_AGENT_PID" ] || ! ps -ef | grep ${SSH_AGENT_PID} | grep ssh-agent$ > /dev/null ; then
-#      echo "Should start_agent for SSH first"
-#      # exit 1
-#      fi
-#      ssh-add -l ||  echo "*** WARNING *** Please add your ssh keys ssh-add"
-#      fi
-
-
-#mongrel_rails start -e production -p 3000 --log log\production.log

data/bin/results_cleanup

@@ -1,6 +0,0 @@
-#!/bin/bash
-rm -fr  ~/results
-cd ~/results_archive
-rm -fr */8*  # Cleanup older dated results 
-rm -f */agent_logs/ag*_*.log  # cleanup old agent logs 
-rm -fr incomplete

data/lib/oats/patches_for_eventmachine_12.10.rb

@@ -1,66 +0,0 @@
-module EventMachine
-
-  def self.event_callback conn_binding, opcode, data # :nodoc:
-    #
-    # Changed 27Dec07: Eliminated the hookable error handling.
-    # No one was using it, and it degraded performance significantly.
-    # It's in original_event_callback, which is dead code.
-    #
-    # Changed 25Jul08: Added a partial solution to the problem of exceptions
-    # raised in user-written event-handlers. If such exceptions are not caught,
-    # we must cause the reactor to stop, and then re-raise the exception.
-    # Otherwise, the reactor doesn't stop and it's left on the call stack.
-    # This is partial because we only added it to #unbind, where it's critical
-    # (to keep unbind handlers from being re-entered when a stopping reactor
-    # runs down open connections). It should go on the other calls to user
-    # code, but the performance impact may be too large.
-    #
-    if opcode == ConnectionUnbound
-      if c = @conns.delete( conn_binding )
-        begin
-          c.unbind
-        rescue
-          @wrapped_exception = $!
-          stop
-        end
-      elsif c = @acceptors.delete( conn_binding )
-        # no-op
-      else
-        # raise ConnectionNotBound, "recieved ConnectionUnbound for an unknown signature: #{conn_binding}"
-      end
-    elsif opcode == ConnectionAccepted
-      accep,args,blk = @acceptors[conn_binding]
-      raise NoHandlerForAcceptedConnection unless accep
-      c = accep.new data, *args
-      @conns[data] = c
-      blk and blk.call(c)
-      c # (needed?)
-    elsif opcode == ConnectionCompleted
-      c = @conns[conn_binding]
-      if c
-        c.connection_completed
-        # else
-        # raise ConnectionNotBound, "received ConnectionCompleted for unknown signature: #{conn_binding}"
-      end
-      ##
-      # The remaining code is a fallback for the pure ruby and java reactors.
-      # In the C++ reactor, these events are handled in the C event_callback() in rubymain.cpp
-    elsif opcode == TimerFired
-      t = @timers.delete( data )
-      return if t == false # timer cancelled
-      t or raise UnknownTimerFired, "timer data: #{data}"
-      t.call
-    elsif opcode == ConnectionData
-      c = @conns[conn_binding] or raise ConnectionNotBound, "received data #{data} for unknown signature: #{conn_binding}"
-      c.receive_data data
-    elsif opcode == LoopbreakSignalled
-      run_deferred_callbacks
-    elsif opcode == ConnectionNotifyReadable
-      c = @conns[conn_binding] or raise ConnectionNotBound
-      c.notify_readable
-    elsif opcode == ConnectionNotifyWritable
-      c = @conns[conn_binding] or raise ConnectionNotBound
-      c.notify_writable
-    end
-  end
-end

data/lib/oats/ragent.rb

@@ -1,321 +0,0 @@
-#require 'eventmachine' # http://eventmachine.rubyforge.org/EventMachine.html#M000486
-#require 'patches_for_eventmachine_12.10'
-require 'em-http-request' # https://github.com/igrigorik/em-http-request/wiki/Issuing-Requests
-require 'json'
-
-module Oats
-
-  class Ragent < EventMachine::Connection
-    attr_accessor :job_count, :jid, :occ_reintroduction_wait_time
-    attr_reader :request
-    @@logger = nil
-    @@oats_info_snapshot = {}
-    @@job_count = 1
-    @@occ_default = nil
-    @@logger = Log4r::Logger.new('A')
-    include EM::P::ObjectProtocol
-
-
-    # Non-nil if in the state of requesting for the next job
-    def Ragent.in_next_job
-      @@in_next_job
-    end
-    def Ragent.in_next_job=(v)
-      @@in_next_job = v
-    end
-    def Ragent.is_busy=(jid)
-      @@is_busy = jid
-    end
-    # Current/Last jobid worked on, or false
-    def Ragent.is_busy
-      @@is_busy
-    end
-
-    # Contains YAML OCC entries if oats is started in agent mode
-    def Ragent.occ
-      @@occ_default
-    end
-
-    def Ragent.start(occ_def)
-      @@occ_default = occ_def # This should not change during agent execution
-      @@logger.add('console')
-      3.times do |count| # In case of unexpected exceptions
-        begin
-          @@occ_reintroduction_wait_time = nil
-          @@is_busy = false # If agent is started from scratch assume previous one is gone
-          @@in_next_job = false
-          @@logger.info "====================================================================================="
-          mach_port = ENV['HOSTNAME'] + ':' + $oats['execution']['occ']['port'].to_s
-          @@logger.info "Started OATS Server execution-#{count} on #{mach_port} at #{Time.now} "
-          EventMachine::run do
-            EventMachine::start_server @@occ_default['agent_host'], @@occ_default['agent_port'].to_i, Ragent
-            EventMachine.next_tick do
-              Ragent.server_logger nil,'Initiating contact with OCC '
-              Ragent.start_next_job unless Ragent.is_busy
-            end
-          end
-          break # Shutdown requested
-        rescue Exception => exc
-          @@logger.error exc
-        end
-      end
-    end
-
-    #  def Ragent.force_close_connection
-    #  end
-    def Ragent.job_count=(val)
-      @@job_count = val
-    end
-    def Ragent.job_count
-      @@job_count
-    end
-
-    def Ragent.snapshot_oats_info(oats_info)
-      @@oats_info_snapshot = oats_info
-    end
-
-    # Generates summary data into the input oats_info
-    def regen_results_summary!(oats_info)
-      return Report.results(oats_info['test_files'],true)
-    rescue
-      server_logger $!.inspect + "\n" + $!.backtrace.join("\n  ")
-      false
-    end
-
-    # Results_status: Early, Partial, Current, Archived, Missing, Error
-    def get_oats_info
-      if @request[:jobid] == Ragent.is_busy # working on it now
-        if @request[:jobid] == @@oats_info_snapshot['jobid'] # first test started processing
-          if regen_results_summary!(@@oats_info_snapshot) # summary succeeded
-            oats_info = Marshal.load(Marshal.dump(@@oats_info_snapshot))
-            oats_info['results_status'] = 'Partial'
-          else
-            server_logger "[ERROR] Can not regen_results_summary from the snapshot"
-            oats_info = {'results_status' => 'Error'}
-          end
-        elsif @@oats_info_snapshot['jobid']
-          msg = "ERROR: Unexpected condition. Request jobid: #{@request[:jobid]} does not match stored job id: #{@@oats_info_snapshot['jobid']}"
-          server_logger msg
-          oats_info = { 'jobid' => @request[:jobid], 'results_status' => 'Error', 'error_message' => msg }
-        else
-          oats_info = Marshal.load(Marshal.dump(Oats.context))
-          oats_info['results_status'] = 'Early'
-          oats_info['jobid'] = Ragent.is_busy
-        end
-      else # Search for request on disk in archive or results
-        res_dir = File.join(Oats.result_archive_dir, @request[:jobid].to_s)
-        results_file = File.join( res_dir,'results.dump')
-        if File.readable?(results_file) # Archived ones should have summary
-          oats_info = Report.oats_info_retrieve(results_file)
-          oats_info['results_status'] = 'Archived'
-        else # May have to regenerate the summary, in case test had died
-          results_file = File.join( $oats['execution']['dir_results'], 'results.dump')
-          if File.readable?(results_file)
-            oats_info = Report.oats_info_retrieve(results_file)
-            if regen_results_summary!(oats_info) and @request[:jobid] == oats_info['jobid']
-              oats_info['results_status'] = 'Current'
-            else
-              oats_info = {} unless oats_info.instance_of?(Hash)
-              oats_info['debug_message'] = "request_jobid: #{@request[:jobid]}, current oats_info jobid: #{oats_info['jobid']}"
-              oats_info['results_status'] = 'Missing'
-            end
-          else
-            oats_info = { 'results_status' => 'Missing' ,
-              'debug_message' => "No readable: #{results_file}" }
-          end
-        end
-      end
-      # Convert object to hash
-      oats_info['test_files'] = oats_info['test_files'].testlist_hash if oats_info['test_files']
-      return oats_info
-    rescue
-      server_logger $!.inspect + "\n" + $!.backtrace.join("\n  ")
-    end
-
-    def receive_object(request)
-      @request = request
-      password = @request.delete(:password)
-      server_logger "Received " + @request.inspect
-      @request[:password] = password
-      response = {}
-      case @request[:command]
-
-      when 'status'
-        EventMachine.next_tick { run_next_job } unless Ragent.is_busy
-
-      when 'start'
-        if Ragent.is_busy
-          server_logger "Not getting next job again because Ragent.is_busy: #{Ragent.is_busy}"
-        else
-          EventMachine.next_tick { run_next_job }
-        end
-
-      when 'results'
-        begin
-          response[:oats_info] = get_oats_info
-        rescue
-          server_logger $!.inspect + "\n" + $!.backtrace.join("\n  ")
-        end
-
-      when 'run' # only called from oats client, not from OCC
-        EventMachine.defer( proc {
-            Driver.start(@request[:jobid], @request[:args])
-          } ) unless Ragent.is_busy
-
-      when 'stop' # any further test execution for this jobid
-        Oats.context['stop_oats'] = @request[:id] if @request[:stop_jobs].include?(Oats.context['jobid'])
-
-      when 'shutdown'
-      else
-        response[:unknown_command] = true
-        server_logger "Unknown command #{@request[:command]}"
-      end
-      response[:is_busy] = Ragent.is_busy
-      stop_oats = Oats.context && Oats.context['stop_oats']
-      response[:is_signal_oats_to_stop] = stop_oats if stop_oats
-      server_logger "Sending " + response.inspect
-      response[:password] = password
-      send_object(response)
-      close_connection_after_writing
-    rescue
-      server_logger $!.inspect + "\n" + $!.backtrace.join("\n  ")
-    end
-
-    def unbind
-      if @request[:command] == 'shutdown'
-        server_logger "Shutting down the server."
-        EventMachine::stop_event_loop
-      end
-    end
-
-    def run_next_job(prev_jobid = nil)
-      return unless @request[:occ_host] # Bad input or invoked via client, not occ
-      occ = @@occ_default.clone
-      occ['server_host'] = @request[:occ_host]
-      occ['server_port'] = @request[:occ_port]
-      Ragent.start_next_job(occ, self, prev_jobid)
-    end
-
-    def self.start_next_job(occ = @@occ_default, ra = nil, prev_jobid = nil)
-      if Ragent.in_next_job or Ragent.is_busy
-        msg = if Ragent.in_next_job
-          if Ragent.in_next_job  == nil.object_id
-            "already getting the initial job."
-          else
-            "already getting job for #{Ragent.in_next_job}]"
-          end
-        else
-          "became busy with #{Ragent.is_busy}"
-        end
-        Ragent.server_logger ra, "Not requesting new job since #{msg}"
-        return false
-      end
-      Ragent.in_next_job = ra.object_id
-      # Double check that this agent has the busy lock
-      if not Ragent.in_next_job or Ragent.in_next_job != ra.object_id
-        Ragent.server_logger(ra, "Not requesting new job since " +
-            "now another Ragent #{ra.object_id} is requesting next job besides current #{Ragent.in_next_job}")
-        return false
-      end
-      query = {
-        'nickname' => occ['agent_nickname'],
-        'machine' => occ['agent_host'],
-        'port' => occ['agent_port'] }
-      query['jobid'] = prev_jobid if prev_jobid
-      query['repo'] = ENV['OATS_TESTS_CODE_VERSION'].to_s if ENV['OATS_TESTS_CODE_VERSION'] and ENV['OATS_TESTS_CODE_VERSION'] != ''
-      query['logfile'] = File.basename(ENV['OATS_AGENT_LOGFILE']||'agent.log')
-      Ragent.server_logger ra, "Getting next OCC job: " + query.inspect
-      query['password='] = ra.request[:password] if ra and ra.request[:password]
-      # Default inactivity_timeout of 10 is not enough when OCC is restarting too
-      # many agents. Agent gives up in 10secs but OCC hands over the job in 20secs.
-      # As a result OCC thinks job is received but agent has never seen the job.
-      connection_options = { :connect_timeout => 60,:inactivity_timeout => 60}
-      http_req = EventMachine::HttpRequest.new('http://' + occ['server_host'] + ":#{occ['server_port']}",connection_options)
-      http = http_req.get :path => '/jobs/nxt', :query => query
-      http.errback  { self.no_response(occ,ra, prev_jobid) }
-      http.callback do
-        status = http.response_header.status
-        if status == 200
-          data =http.response
-          nxt_job = JSON.parse(data) if data
-          if nxt_job['jid']
-            Ragent.is_busy = nxt_job['jid']
-            Ragent.in_next_job = false
-            if ra
-              ra.jid = nxt_job['jid']
-              ra.occ_reintroduction_wait_time = nil # Reset wait time to default if heard from OCC
-            end
-            Ragent.server_logger ra, "Job-#{Ragent.job_count} #{nxt_job.inspect}"
-            EventMachine.defer do
-              begin
-                opts= {'execution:environments' => [nxt_job['env']],
-                  'execution:test_files' => [nxt_job['list']] }
-                opts['_:options'] = nxt_job['options'].split(',') if nxt_job['options'] and nxt_job['options'] != ''
-                Ragent.snapshot_oats_info({})
-                Driver.start(nxt_job['jid'],opts)
-              ensure
-                Ragent.is_busy = false
-              end
-              Ragent.job_count += 1
-              if ra
-                ra.run_next_job(nxt_job['jid'] )
-              else
-                Ragent.start_next_job(occ,ra,nxt_job['jid'])
-              end
-            end
-          else
-            Ragent.in_next_job = false
-            Ragent.server_logger ra, "No more pending jobs at OCC. Pausing processing.\n"
-            Ragent.job_count = 1
-            Ragent.server_logger ra, "***********************************************************\n"
-          end
-        else
-          self.no_response(occ,ra, prev_jobid)
-        end
-      end
-    rescue RuntimeError  => e.message
-      Ragent.in_next_job = false
-      if e.message == 'eventmachine not initialized: evma_connect_to_server'
-        Ragent.server_logger ra, "Shutting down..."
-      else
-        Ragent.server_logger ra, $!.inspect + "\n" + $!.backtrace.join("\n  ")
-      end
-    end
-
-    def self.no_response(occv,ra, prev_jobid)
-      Ragent.in_next_job = false
-      Ragent.server_logger ra, "OCC did not respond."
-      wait = ra ? ra.occ_reintroduction_wait_time : @@occ_reintroduction_wait_time
-      wait ||= $oats['execution']['occ']['timeout_waiting_for_occ']
-      # Keep retrying to introduce, doubling the intervals
-      self.server_logger ra, "Will retry in #{wait} seconds."
-      EM.add_timer(wait) do
-        Ragent.start_next_job(occv,ra, prev_jobid) unless Ragent.is_busy # by now
-      end
-      wait *= (1.5 + rand(101)/100.0)
-      wait = wait.round
-      if ra
-        ra.occ_reintroduction_wait_time = wait
-      else
-        @@occ_reintroduction_wait_time = wait
-      end
-    end
-
-    def server_logger(arg)
-      Ragent.server_logger self, arg
-    end
-
-    def Ragent.server_logger(ra, arg)
-      if ra
-        req = ra.request
-        jid = ra.jid
-        rt = ":R#{(req and req[:id]) ? req[:id] : ra.object_id}"
-        rt += "#{" J:#{jid}" if jid }"
-      end
-      @@logger.info "[RS#{rt}] #{arg}"
-    rescue
-      @@logger.error $!.inspect + "\n" + $!.backtrace.join("\n  ")
-    end
-
-  end
-end

data/lib/oats/rclient.rb

@@ -1,42 +0,0 @@
-module Oats
-
-  class Rclient < EventMachine::Connection
-    attr_reader :response
-    include EM::P::ObjectProtocol
-    #  def serializer
-    #    YAML
-    #  end
-    #
-    def initialize(host, request)
-      @host = host
-      @request = request
-    end
-
-    def receive_object(response)
-      @response = response
-      password = response.delete(:password)
-      length = 500
-      resp = response.inspect
-      resp = resp[0..length] + ' ..... ' + resp[-length..-1] if resp.size > 2*length
-      client_logger "Received " + resp + " from"
-      response[:password] = password
-      client_logger "Command was not recognized" if response[:unknown_command]
-    end
-
-    def client_logger(arg)
-      $log.info arg + " #{@request[:id]}@#{@host} at " + Time.now.strftime("%y-%m-%d %H:%M:%S")
-    end
-
-    def post_init
-      password = @request.delete(:password)
-      client_logger "Sending " + @request.inspect + " to"
-      @request[:password] = password
-      send_object(@request)
-    end
-    def unbind
-      client_logger "Did not hear from " unless @response
-      EventMachine::stop_event_loop
-    end
-  end
-
-end