oats_agent 0.0.2

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+/nbproject/private/

data/.rvmrc

@@ -0,0 +1,52 @@
+#!/usr/bin/env bash
+
+# This is an RVM Project .rvmrc file, used to automatically load the ruby
+# development environment upon cd'ing into the directory
+
+# First we specify our desired <ruby>[@<gemset>], the @gemset name is optional,
+# Only full ruby name is supported here, for short names use:
+#     echo "rvm use 1.8.7" > .rvmrc
+environment_id="ruby-1.8.7-p358@oats"
+
+# Uncomment the following lines if you want to verify rvm version per project
+# rvmrc_rvm_version="1.13.4 (stable)" # 1.10.1 seams as a safe start
+# eval "$(echo ${rvm_version}.${rvmrc_rvm_version} | awk -F. '{print "[[ "$1*65536+$2*256+$3" -ge "$4*65536+$5*256+$6" ]]"}' )" || {
+#   echo "This .rvmrc file requires at least RVM ${rvmrc_rvm_version}, aborting loading."
+#   return 1
+# }
+
+# First we attempt to load the desired environment directly from the environment
+# file. This is very fast and efficient compared to running through the entire
+# CLI and selector. If you want feedback on which environment was used then
+# insert the word 'use' after --create as this triggers verbose mode.
+if [[ -d "${rvm_path:-$HOME/.rvm}/environments"
+  && -s "${rvm_path:-$HOME/.rvm}/environments/$environment_id" ]]
+then
+  \. "${rvm_path:-$HOME/.rvm}/environments/$environment_id"
+  [[ -s "${rvm_path:-$HOME/.rvm}/hooks/after_use" ]] &&
+    \. "${rvm_path:-$HOME/.rvm}/hooks/after_use" || true
+  if [[ $- == *i* ]] # check for interactive shells
+  then echo "Using: $(tput setaf 2)$GEM_HOME$(tput sgr0)" # show the user the ruby and gemset they are using in green
+  else echo "Using: $GEM_HOME" # don't use colors in non-interactive shells
+  fi
+else
+  # If the environment file has not yet been created, use the RVM CLI to select.
+  rvm --create use  "$environment_id" || {
+    echo "Failed to create RVM environment '${environment_id}'."
+    return 1
+  }
+fi
+
+# # If you use bundler, this might be useful to you:
+#  if [[ -s Gemfile ]] && {
+#    ! builtin command -v bundle >/dev/null ||
+#    builtin command -v bundle | GREP_OPTIONS= \grep $rvm_path/bin/bundle >/dev/null
+#  }
+#  then
+#    printf "%b" "The rubygem 'bundler' is not installed. Installing it now.\n"
+#    gem install bundler
+#  fi
+#  if [[ -s Gemfile ]] && builtin command -v bundle >/dev/null
+#  then
+#    bundle install | GREP_OPTIONS= \grep -vE '^Using|Your bundle is complete'
+#  fi

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in oats_agent.gemspec
+gemspec

data/README.md

@@ -0,0 +1,29 @@
+# OatsAgent
+
+With this gem OATS can start in agent mode in the background so that it can 
+communicate with OCC.
+
+For more information on OATS and OCC see the READMEs in
+     https://github.com/latasoy/oats
+     https://github.com/latasoy/occ
+
+## Installation
+
+Install this gem on the machines that will have OATS agents.
+
+    $ gem install oats_agent
+
+
+## Usage
+
+   Register the OATS agent with OCC:
+    $ oats_agent -n <agent_nickname> -p <agent_port>
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/bin/agent.sh~

@@ -0,0 +1,189 @@
+#!/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
+ -d DISPLAY_NUM Number of the VNC Display, for Linux only
+
+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
+    oats_bin="$OATS_HOME/bin"
+#    [ "$OS" == "Windows_NT" ] && oats_bin=$(cygpath -w $oats_bin)
+#    ruby_com="$oats_bin/oats -n $OATS_AGENT_NICKNAME -p $OATS_AGENT_PORT"
+    cur_dir=$(dirname $(type -p $0))
+    ruby_com="$cur_dir/internal_oats_agent_internal -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
+#    echo "$OATS_AGENT_NICKNAME $OATS_AGENT_PORT" >| $config_agent_file
+    if [ "$OS" == "Linux" ]; then # Do this with VNC displays
+	# Allocate 2x as display. VNC takes 592x, vino takes next available from 59++
+#	vnc_num="2$(echo $OATS_AGENT_PORT | cut -c 4)"
+	vnc_num="$DISPLAY_NUM"
+	[ "$vnc_num" ] || vnc_num="1"
+	pgrep -fl "Xvnc4 :$vnc_num" >/dev/null || vncserver :$vnc_num -SecurityTypes=None -geometry 1900x1060
+	export DISPLAY=":$vnc_num.0"
+	agent_echo "Setting DISPLAY to $DISPLAY"
+    fi
+    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/oats_agent

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+
+# To pickup non-gem oats for local debugging
+
+if File.directory? agent_dir = File.expand_path('../../../oats_agent/lib', __FILE__)
+  $:.unshift  agent_dir 
+  gem 'log4r'
+  require 'oats_agent' # bundler fails when it can't find the gem if not in here 
+end
+
+require 'oats_agent/commandline_options'
+require 'log4r'
+
+Log4r::Logger.root.level = Log4r::DEBUG
+Log4r::StdoutOutputter.new('console', :level=>1,
+  :formatter=>Log4r::PatternFormatter.new(:depth=>50,
+    :pattern => "%-5l %d %M", :date_pattern=>"%y-%m-%d %H:%M:%S"))
+$log = Log4r::Logger.new('R')
+$log.add('console')
+options = OatsAgent::CommandlineOptions.options(ARGV.dup)
+if options["agent_host"].nil? or options["agent_host"] == ENV['HOSTNAME']
+  OatsAgent.spawn(options)
+else
+  params = ARGV.dup
+  if RUBY_PLATFORM =~ /(mswin|mingw)/
+    cmd = "psexec.exe -d -i -n 10 -w " + ENV['HOME'] + '/results_archive' +
+      ' -u qa -p ' + 'passwd' + ' \\\\' + options["agent_host"] +
+      ' ruby oats_agent ' + params.join(' ')
+  else
+    #  params.delete('-a')
+    #  params.delete(options["agent_host"])
+    #  options['agent_host'] = ENV['HOSTNAME']
+    cmd = "ssh " + options["agent_host"] + ' oats_agent ' + params.join(' ')
+  end
+  out = `#{cmd}`
+  $log.info out unless out == ''
+end

data/bin/occ

@@ -0,0 +1,29 @@
+#!/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

@@ -0,0 +1,6 @@
+#!/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_agent/commandline_options.rb

@@ -0,0 +1,68 @@
+require 'optparse' # http://www.ruby-doc.org/stdlib/libdoc/optparse/rdoc/index.html
+require 'log4r'  # http://log4r.sourceforge.net/rdoc/index.html
+
+module OatsAgent
+
+  module CommandlineOptions
+
+    @@OPTIONS = nil
+    def CommandlineOptions.options(argv = nil)
+
+      begin
+
+        # Hold all of the options parsed from the command-line by OptionParser.
+        options = {}
+        optparse = OptionParser.new do|opts|
+          opts.banner = "Usage: oats.rb [options] test1 test2 ..."
+          opts.separator "Options:"
+          
+          opts.on( '-p', '--port PORT', Integer,
+            'Port number for the Oats Agent.' ) do |t|
+            options['port'] = t if t
+          end
+          opts.on( '-n', '--nickname NICKNAME',
+            'Nickname to display on OCC for the Oats Agent.' ) do |t|
+            options['nickname'] = t if t
+          end
+          opts.on( '-u', '--user USER',
+            'Sets OATS_USER for agent' ) do |t|
+            options['user'] = t if t
+          end
+          opts.on( '-r', '--repository_version REPOSITORY_VERSION',
+            'Repository version requested' ) do |t|
+            options['repository_version'] = t
+          end
+          opts.on( '-a', '--agent_host HOSTNAME',
+            'Hostname where the agent should start.' ) do |t|
+            options['agent_host'] = t if t
+          end
+          opts.on( '-k', '--kill_agent',
+            'Kill the agent.' ) do |t|
+            options['kill_agent'] = true
+          end
+          opts.on( '-t', '--test_directory DIR_TESTS',
+            'Test directory to override environment variable OATS_TESTS.' ) do |t|
+            options['dir_tests'] = t
+          end
+          
+          
+          opts.on_tail( '-h', '--help', 'Display this screen' ) { $stderr.puts opts; exit }
+        end
+
+        optparse.parse!(argv)
+        if argv and ! argv.empty?
+          options['execution:test_files'] ||= []
+          options['execution:test_files'] += argv
+        end
+
+      rescue Exception => e
+        raise unless e.class.to_s =~ /^OptionParser::/
+        $stderr.puts e.message
+        $stderr.puts "Please type 'oats_agent -h' for valid options."
+        exit 1
+      end
+      @@OPTIONS = options
+    end
+
+  end
+end

data/lib/oats_agent/ragent.rb

@@ -0,0 +1,323 @@
+#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 OatsAgent
+
+  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
+    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.logger
+      @@logger ||= Log4r::Logger.new('A')
+    end
+
+    def Ragent.start(occ_def)
+      @@occ_default = occ_def # This should not change during agent execution
+      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 Oats::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 = Oats::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 = Oats::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 {
+            Oats::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({})
+                Oats::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_agent/rclient.rb

@@ -0,0 +1,42 @@
+module OatsAgent
+
+  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

data/lib/oats_agent/start.rb

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby
+if File.directory? oats_dir = File.expand_path('../../../../oats', __FILE__)
+  $:.unshift(oats_dir + '/lib')  # To pickup non-gem oats for local debugging
+else
+  require 'rubygems'
+  gem 'oats'
+  # Below are possibly needed when agent is off machine
+  #  if RUBY_PLATFORM =~ /linux/ # Seems to be needed by Ubuntu
+  #    gem 'execjs'
+  #    gem 'therubyracer'
+  #  end
+end
+
+require 'oats'
+require "oats/oats_data"
+require "oats/test_data"
+require 'oats/roptions'
+#require 'pp'
+$:.unshift File.expand_path('..', __FILE__)
+#pp $:
+require "ragent"
+require "rclient"
+
+options = Oats::Driver.init
+# $oats_execution['agent'] (used by framework) == Oats.global['agent'] (by YAMLs) === options
+$oats = Oats::OatsData.load(options['_:ini_file'])
+$oats['_']['options'] = options
+Oats::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 ENV['OATS_AGENT_LOGFILE'] 
+  # For windows always write to console
+  OatsAgent::Ragent.logger.add('console') if RUBY_PLATFORM =~ /(mswin|mingw)/ 
+else
+  # Otherwise agent should write to console only when running start.rb directly w/o logfile
+  OatsAgent::Ragent.logger.add('console') 
+  archive_dir = File.expand_path "results_archive", ENV['HOME']
+  log_dir = "#{archive_dir}/#{options['execution:occ:agent_nickname']}/agent_logs"
+  ENV['OATS_AGENT_LOGFILE'] = "#{log_dir}/agent_#{Time.new.to_i}.log"
+end
+
+Log4r::FileOutputter.new('agent',
+  :filename=>ENV['OATS_AGENT_LOGFILE'], :trunc=>false, :level=>0,
+  :formatter=>Log4r::PatternFormatter.new(:depth=>50,
+    :pattern => "%-5l %d %M", :date_pattern=>"%y-%m-%d %H:%M:%S"))
+#$log.info "Redirecting output to logfile: " + ENV['OATS_AGENT_LOGFILE']
+$log.add('agent')
+OatsAgent::Ragent.logger.add('agent')    
+
+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
+  OatsAgent::Ragent.start $oats['execution']['occ']
+end

data/lib/oats_agent/version.rb

@@ -0,0 +1,3 @@
+module OatsAgent
+  VERSION = "0.0.2"
+end

data/lib/oats_agent.rb

@@ -0,0 +1,183 @@
+#require 'rubygems'
+unless ENV['HOSTNAME']
+  if RUBY_PLATFORM =~ /(mswin|mingw)/
+    ENV['HOSTNAME'] = ENV['COMPUTERNAME']
+  else
+    ENV['HOSTNAME'] = `hostname`.chomp
+  end
+end
+ENV['HOSTNAME'] = ENV['HOSTNAME'].downcase
+require 'win32ole' if RUBY_PLATFORM =~ /(mswin|mingw)/
+
+module OatsAgent
+  class << self
+
+    def fkill(proc)
+      if proc.instance_of? Hash
+        pname = proc['cmd']
+        pid = proc['pid']
+        msg = " PID #{pid}: #{pname}"
+      else
+        pid = proc
+      end
+      $log.warn "Killing" + msg
+      if RUBY_PLATFORM =~ /(mswin|mingw)/
+        killed = Process.kill('KILL',pid.to_i)
+        killed = 0 if RUBY_VERSION =~ /^1.9/ and killed.empty?
+        $log.warn "Failed to kill" + msg if killed == 0
+      else
+        out = `kill -9 #{pid} 2>&1`
+        $log.warn out unless out == ''
+      end
+    end
+    
+    def kill_matching(cmd_string)
+      procs = []
+      if RUBY_PLATFORM =~ /(mswin|mingw)/
+        WIN32OLE.connect("winmgmts://").ExecQuery("select * from win32_process").each do |process|
+          #          puts [process.Commandline, process.ProcessId, process.name].inspect
+          procs.push 'pid' => process.ProcessId, 'cmd' => process.CommandLine if process.Commandline =~ /#{cmd_string}/
+        end
+        # Looking for port is too slow on windows
+        #        lines = "netstat -#{RUBY_PLATFORM =~ /(mswin|mingw)/ ?  'a' : 'n' } -o"
+        #        list = `#{lines}`.split(/\n/)
+        #        list.each do |p|
+        #          p =~ /:(\d+)\s+.*\s+LISTENING\s+(\d+)/
+        #          next unless $1 and $1 == port
+        #          procs.push({ 'pid' => $2, 'cmd' => 'LISTENING' }) 
+        #        end
+      else
+        ps_cmd = "ps -ew -o pid=,ppid=,command="
+        ps_list = `#{ps_cmd}`
+        list = ps_list.split(/\n/)
+        list.each do |p|
+          next unless p =~ /#{cmd_string}/
+          p =~ /(\d+)\s+(\d+)\s+(.*)/
+          procs.push({ 'pid' => $1, 'ppid' => $2, 'cmd' => $3 }) 
+        end
+      end
+      procs.each { |p| fkill(p) }
+    end
+
+    # Initiates process to run agent in the background
+    #  Options Hash Keys:
+    #    required: agent_nickname, agent_port, 
+    #    optional: oats_user, test_directory, repository_version
+      
+    def spawn(options)
+      agent_host = options["agent_host"] || ENV['HOSTNAME']
+      nick = options["nickname"] || ENV['HOSTNAME']
+      port = options["port"] || 3010
+      port = port.to_s
+      user = options["user"]
+      repo_version = options["repository_version"]
+      dir_tests = options["test_directory"] || ENV['OATS_TESTS']
+
+      archive_dir = File.expand_path "results_archive", ENV['HOME']
+      log_dir = "#{archive_dir}/#{nick}/agent_logs"
+      log_file = "#{log_dir}/agent_#{Time.new.to_i}.log"
+      config_file = "#{log_dir}/config-agent.txt"
+      agent_log_file = "#{log_dir}/agent.log"
+      params =  "-n #{nick} -p #{port}"
+
+      FileUtils.mkdir_p(log_dir) unless File.exists?(log_dir)
+      ENV['OATS_AGENT_LOGFILE'] = log_file
+
+      ruby_cmd = File.expand_path('../oats_agent/start.rb', __FILE__) + ' ' + params
+      
+      # Need these off when called by OCC, otherwise the OCC values are inherited
+      %w(RUBYOPT BUNDLE_BIN_PATH BUNDLE_GEMFILE).each { |e| ENV[e] = nil }
+      kill_matching ruby_cmd
+      exit if options["kill_agent"]
+
+      if File.directory?(dir_tests + '/.svn') and ENV['OATS_TESTS_SVN_REPOSITORY']
+        svn_out =nil
+        $log.info "Requested OATS Version: #{repo_version}" if repo_version
+        code_version = nil
+   
+        3.times do
+          code_version = `svn info #{dir_tests} | sed -n 's/Last Changed Rev: *//p'`
+          code_version = nil if code_version == ''
+          break if code_version.nil? or (repo_version and  code_version >= repo_version)
+          cmd = "svn update #{dir_tests} 2>&1"
+          svn_out = `#{cmd}`
+          svn_out.chomp!
+          $log.info svn_out
+          case svn_out 
+          when/^At revision/
+            code_version = svn_out.sub(/At revision *(\d+).*/,'\1')
+          when/Cleanup/
+          when/Could not resolve hostname/
+            break
+          end
+          if code_version == ''
+            code_version = nil 
+            sleep 3
+          else
+            break
+          end
+        end
+        if svn_out.nil? and ENV['OATS_TESTS_SVN_REPOSITORY']
+          $log.error "Could not update the code version " +( code_version || '') + ( repo_version ? "to #{repo_version}" : '')
+          exit 2
+        end
+
+      elsif ENV["$OATS_TESTS_GIT_REPOSITORY"]
+        dir_tests = archive_dir + ENV['OATS_AGENT_NICKNAME'] + '/oats_tests'
+        `git clone git_rep dir_tests if File.directory?(dir_tests)`
+        Dir.chdir dir_tests
+        origin = ENV["$OATS_TESTS_GIT_REPOSITORY"] || 'origin'
+
+        if repo_version
+          2.times do
+            # may detach HEAD, but it is OK
+            out = `git checkout #{repo_version} 2>&1`
+            break if status == 0
+            if out == "fatal: reference is not a tree: #{repo_version}"
+              $log.info "Need to pull requested version: #{repo_version} "
+            else
+              $log.info "$out"
+            end
+            $log.info `git pull #{origin} master` # fast-forward master from origin
+          end
+        else
+          $log.info `git pull #{origin} master` # fast-forward master from origin
+        end
+        code_version = `git rev-list HEAD -1` # last commit in checked out version
+        if code_version =~ /#{repo_version}/
+          $log.info "Could not update the code version #{code_version} to #{repo_version}" 
+          exit 2
+        end
+        $log.info "Using OATS code version: #{code_version}" unless repo_version
+      else
+        code_version = repo_version
+        $log.info "Setting OATS code version to the requested version: #{code_version}" if code_version 
+      end if dir_tests
+      ENV['OATS_TESTS_CODE_VERSION'] = code_version
+
+      msg = ''
+      msg += "User: #{user} " if user
+      msg += "Repo version: #{repo_version} " if repo_version
+      $log.info "#{msg}Starting: #{ruby_cmd}"
+      if RUBY_PLATFORM =~ /(mswin|mingw)/
+        archiv = ENV['HOME'] + '/results_archive'
+        cmd = "psexec.exe -d -i -n 10 -w #{archiv} ruby #{ruby_cmd} 2>&1"
+      else
+        cmd = "#{ruby_cmd} >/dev/null 2>&1 &" 
+      end
+      out = `#{cmd}`
+      $log.info out unless out == ''
+      File.open(config_file, 'w') {|f| f.puts(nick +' '+ port) }
+
+      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
+  end
+end

data/nbproject/configs/start.properties

@@ -0,0 +1 @@
+main.file=oats_agent/start.rb

data/nbproject/project.properties

@@ -0,0 +1,7 @@
+file.reference.oats_agent-lib=lib
+javac.classpath=
+main.file=oats_agent
+platform.active=Ruby_0
+source.encoding=UTF-8
+src.bin.dir=bin
+src.lib.dir=lib

data/nbproject/project.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://www.netbeans.org/ns/project/1">
+    <type>org.netbeans.modules.ruby.rubyproject</type>
+    <configuration>
+        <data xmlns="http://www.netbeans.org/ns/ruby-project/1">
+            <name>oats_agent</name>
+            <source-roots>
+                <root id="src.bin.dir"/>
+                <root id="src.lib.dir"/>
+            </source-roots>
+            <test-roots/>
+        </data>
+    </configuration>
+</project>

data/oats_agent.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/oats_agent/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Levent Atasoy"]
+  gem.email         = ["levent.atasoy@gmail.com"]
+  gem.description   = %q{With this gem OATS can start in agent mode in the background so that it can communicate with OCC.}
+  gem.summary       = gem.description.dup
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "oats_agent"
+  gem.require_paths = ["lib"]
+  gem.version       = OatsAgent::VERSION
+  
+  gem.add_dependency 'oats'
+  gem.add_dependency 'log4r'
+
+  
+  gem.add_dependency 'json'
+  gem.add_dependency 'em-http-request'
+  if RUBY_PLATFORM =~ /linux/ # Seems to be needed by Ubuntu
+    gem.add_dependency 'execjs'
+    gem.add_dependency 'therubyracer'
+  end
+end

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification 
+name: oats_agent
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- Levent Atasoy
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-05-28 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: oats
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: log4r
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        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: With this gem OATS can start in agent mode in the background so that it can communicate with OCC.
+email: 
+- levent.atasoy@gmail.com
+executables: 
+- agent.sh~
+- oats_agent
+- occ
+- results_cleanup
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rvmrc
+- Gemfile
+- README.md
+- Rakefile
+- bin/agent.sh~
+- bin/oats_agent
+- bin/occ
+- bin/results_cleanup
+- lib/oats_agent.rb
+- lib/oats_agent/commandline_options.rb
+- lib/oats_agent/ragent.rb
+- lib/oats_agent/rclient.rb
+- lib/oats_agent/start.rb
+- lib/oats_agent/version.rb
+- nbproject/configs/agent_host.properties
+- nbproject/configs/start.properties
+- nbproject/project.properties
+- nbproject/project.xml
+- oats_agent.gemspec
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: With this gem OATS can start in agent mode in the background so that it can communicate with OCC.
+test_files: []
+