oats 0.0.1

data/doc/rdoc-style.css

@@ -0,0 +1,208 @@
+
+body {
+    font-family: Verdana,Arial,Helvetica,sans-serif;
+    font-size:   90%;
+    margin: 0;
+    margin-left: 40px;
+    padding: 0;
+    background: white;
+}
+
+h1,h2,h3,h4 { margin: 0; color: #efefef; background: transparent; }
+h1 { font-size: 150%; }
+h2,h3,h4 { margin-top: 1em; }
+
+a { background: #eef; color: #039; text-decoration: none; }
+a:hover { background: #039; color: #eef; }
+
+/* Override the base stylesheet's Anchor inside a table cell */
+td > a {
+  background: transparent;
+  color: #039;
+  text-decoration: none;
+}
+
+/* and inside a section title */
+.section-title > a {
+  background: transparent;
+  color: #eee;
+  text-decoration: none;
+}
+
+/* === Structural elements =================================== */
+
+div#index {
+    margin: 0;
+    margin-left: -40px;
+    padding: 0;
+    font-size: 90%;
+}
+
+
+div#index a {
+    margin-left: 0.7em;
+}
+
+div#index .section-bar {
+   margin-left: 0px;
+   padding-left: 0.7em;
+   background: #ccc;
+   font-size: small;
+}
+
+
+div#classHeader, div#fileHeader {
+    width: auto;
+    color: white;
+    padding: 0.5em 1.5em 0.5em 1.5em;
+    margin: 0;
+    margin-left: -40px;
+    border-bottom: 3px solid #006;
+}
+
+div#classHeader a, div#fileHeader a {
+    background: inherit;
+    color: white;
+}
+
+div#classHeader td, div#fileHeader td {
+    background: inherit;
+    color: white;
+}
+
+
+div#fileHeader {
+    background: #057;
+}
+
+div#classHeader {
+    background: #048;
+}
+
+
+.class-name-in-header {
+  font-size:  180%;
+  font-weight: bold;
+}
+
+
+div#bodyContent {
+    padding: 0 1.5em 0 1.5em;
+}
+
+div#description {
+    padding: 0.5em 1.5em;
+    background: #efefef;
+    border: 1px dotted #999;
+}
+
+div#description h1,h2,h3,h4,h5,h6 {
+    color: #125;;
+    background: transparent;
+}
+
+div#validator-badges {
+    text-align: center;
+}
+div#validator-badges img { border: 0; }
+
+div#copyright {
+    color: #333;
+    background: #efefef;
+    font: 0.75em sans-serif;
+    margin-top: 5em;
+    margin-bottom: 0;
+    padding: 0.5em 2em;
+}
+
+
+/* === Classes =================================== */
+
+table.header-table {
+    color: white;
+    font-size: small;
+}
+
+.type-note {
+    font-size: small;
+    color: #DEDEDE;
+}
+
+.xxsection-bar {
+    background: #eee;
+    color: #333;
+    padding: 3px;
+}
+
+.section-bar {
+   color: #333;
+   border-bottom: 1px solid #999;
+    margin-left: -20px;
+}
+
+
+.section-title {
+    background: #79a;
+    color: #eee;
+    padding: 3px;
+    margin-top: 2em;
+    margin-left: -30px;
+    border: 1px solid #999;
+}
+
+.top-aligned-row {  vertical-align: top }
+.bottom-aligned-row { vertical-align: bottom }
+
+/* --- Context section classes ----------------------- */
+
+.context-row { }
+.context-item-name { font-family: monospace; font-weight: bold; color: black; }
+.context-item-value { font-size: small; color: #448; }
+.context-item-desc { color: #333; padding-left: 2em; }
+
+/* --- Method classes -------------------------- */
+.method-detail {
+    background: #efefef;
+    padding: 0;
+    margin-top: 0.5em;
+    margin-bottom: 1em;
+    border: 1px dotted #ccc;
+}
+.method-heading {
+  color: black;
+  background: #ccc;
+  border-bottom: 1px solid #666;
+  padding: 0.2em 0.5em 0 0.5em;
+}
+.method-signature { color: black; background: inherit; }
+.method-name { font-weight: bold; }
+.method-args { font-style: italic; }
+.method-description { padding: 0 0.5em 0 0.5em; }
+
+/* --- Source code sections -------------------- */
+
+a.source-toggle { font-size: 90%; }
+div.method-source-code {
+    background: #262626;
+    color: #ffdead;
+    margin: 1em;
+    padding: 0.5em;
+    border: 1px dashed #999;
+    overflow: hidden;
+}
+
+div.method-source-code pre { color: #ffdead; overflow: hidden; }
+
+/* --- Ruby keyword styles --------------------- */
+
+.standalone-code { background: #221111; color: #ffdead; overflow: hidden; }
+
+.ruby-constant  { color: #7fffd4; background: transparent; }
+.ruby-keyword { color: #00ffff; background: transparent; }
+.ruby-ivar    { color: #eedd82; background: transparent; }
+.ruby-operator  { color: #00ffee; background: transparent; }
+.ruby-identifier { color: #ffdead; background: transparent; }
+.ruby-node    { color: #ffa07a; background: transparent; }
+.ruby-comment { color: #b22222; font-weight: bold; background: transparent; }
+.ruby-regexp  { color: #ffa07a; background: transparent; }
+.ruby-value   { color: #7fffd4; background: transparent; }

data/lib/deep_merge/.gitignore

@@ -0,0 +1,2 @@
+pkg/*
+*.gemspec

data/lib/deep_merge/core.rb

@@ -0,0 +1,195 @@
+module DeepMerge
+  
+  class InvalidParameter < StandardError; end
+  
+  #  DEFAULT_FIELD_KNOCKOUT_PREFIX = '--'
+
+  # Deep Merge core documentation.
+  # deep_merge! method permits merging of arbitrary child elements. The two top level
+  # elements must be hashes. These hashes can contain unlimited (to stack limit) levels
+  # of child elements. These child elements to not have to be of the same types.
+  # Where child elements are of the same type, deep_merge will attempt to merge them together.
+  # Where child elements are not of the same type, deep_merge will skip or optionally overwrite
+  # the destination element with the contents of the source element at that level.
+  # So if you have two hashes like this:
+  #   source = {:x => [1,2,3], :y => 2}
+  #   dest =   {:x => [4,5,'6'], :y => [7,8,9]}
+  #   dest.deep_merge!(source)
+  #   Results: {:x => [1,2,3,4,5,'6'], :y => 2}
+  # By default, "deep_merge!" will overwrite any unmergeables and merge everything else.
+  # To avoid this, use "deep_merge" (no bang/exclamation mark)
+  # 
+  # Options:
+  #   Options are specified in the last parameter passed, which should be in hash format:
+  #   hash.deep_merge!({:x => [1,2]}, {:knockout_prefix => '--'})
+  #   :preserve_unmergeables  DEFAULT: false
+  #      Set to true to skip any unmergeable elements from source
+  #   :overwrite_arrays  DEFAULT: false
+  #      Set to true to not merge but overwrite arrays
+  #   :knockout_prefix        DEFAULT: nil
+  #      Set to string value to signify prefix which deletes elements from existing element
+  #   :sort_merged_arrays     DEFAULT: false
+  #      Set to true to sort all arrays that are merged together
+  #   :unpack_arrays          DEFAULT: nil
+  #      Set to string value to run "Array::join" then "String::split" against all arrays
+  #   :merge_debug            DEFAULT: false
+  #      Set to true to get console output of merge process for debugging
+  #
+  # Selected Options Details:
+  # :knockout_prefix => The purpose of this is to provide a way to remove elements 
+  #   from existing Hash by specifying them in a special way in incoming hash
+  #    source = {:x => ['--1', '2']}
+  #    dest   = {:x => ['1', '3']}
+  #    dest.ko_deep_merge!(source)
+  #    Results: {:x => ['2','3']}
+  #   Additionally, if the knockout_prefix is passed alone as a string, it will cause
+  #   the entire element to be removed:
+  #    source = {:x => '--'}
+  #    dest   = {:x => [1,2,3]}
+  #    dest.ko_deep_merge!(source)
+  #    Results: {:x => ""}
+  # :unpack_arrays => The purpose of this is to permit compound elements to be passed
+  #   in as strings and to be converted into discrete array elements
+  #   irsource = {:x => ['1,2,3', '4']}
+  #   dest   = {:x => ['5','6','7,8']}
+  #   dest.deep_merge!(source, {:unpack_arrays => ','})
+  #   Results: {:x => ['1','2','3','4','5','6','7','8'}
+  #   Why: If receiving data from an HTML form, this makes it easy for a checkbox 
+  #    to pass multiple values from within a single HTML element
+  # 
+  # There are many tests for this library - and you can learn more about the features
+  # and usages of deep_merge! by just browsing the test examples
+  def self.deep_merge!(source, dest, options = {})
+    # turn on this line for stdout debugging text
+    merge_debug = options[:merge_debug] || false
+    overwrite_unmergeable = !options[:preserve_unmergeables]
+    knockout_prefix = options[:knockout_prefix] || nil
+    raise InvalidParameter, "knockout_prefix cannot be an empty string in deep_merge!" if knockout_prefix == ""
+    raise InvalidParameter, "overwrite_unmergeable must be true if knockout_prefix is specified in deep_merge!" if knockout_prefix && !overwrite_unmergeable
+    # if present: we will split and join arrays on this char before merging
+    array_split_char = options[:unpack_arrays] || false
+    # Don't merge but overwrite arrays
+    overwrite_arrays = options[:overwrite_arrays] || false
+    # request that we sort together any arrays when they are merged
+    sort_merged_arrays = options[:sort_merged_arrays] || false
+    di = options[:debug_indent] || ''
+    # do nothing if source is nil
+    return dest if source.nil? || (source.respond_to?(:blank?) && source.blank?)
+    # if dest doesn't exist, then simply copy source to it
+    if !(dest) && overwrite_unmergeable
+      dest = source; return dest
+    end
+
+    puts "#{di}Source class: #{source.class.inspect} :: Dest class: #{dest.class.inspect}" if merge_debug
+    if source.kind_of?(Hash)
+      puts "#{di}Hashes: #{source.inspect} :: #{dest.inspect}" if merge_debug
+      source.each do |src_key, src_value|
+        if dest.kind_of?(Hash)
+          puts "#{di} looping: #{src_key.inspect} => #{src_value.inspect} :: #{dest.inspect}" if merge_debug
+          if dest[src_key]
+            puts "#{di} ==>merging: #{src_key.inspect} => #{src_value.inspect} :: #{dest[src_key].inspect}" if merge_debug
+            dest[src_key] = deep_merge!(src_value, dest[src_key], options.merge(:debug_indent => di + '  '))
+          else # dest[src_key] doesn't exist so we want to create and overwrite it (but we do this via deep_merge!)
+            puts "#{di} ==>merging over: #{src_key.inspect} => #{src_value.inspect}" if merge_debug
+            # note: we rescue here b/c some classes respond to "dup" but don't implement it (Numeric, TrueClass, FalseClass, NilClass among maybe others)
+            begin
+              src_dup = src_value.dup # we dup src_value if possible because we're going to merge into it (since dest is empty)
+            rescue TypeError
+              src_dup = src_value
+            end
+            dest[src_key] = deep_merge!(src_value, src_dup, options.merge(:debug_indent => di + '  '))
+          end
+        else # dest isn't a hash, so we overwrite it completely (if permitted)
+          if overwrite_unmergeable
+            puts "#{di}  overwriting dest: #{src_key.inspect} => #{src_value.inspect} -over->  #{dest.inspect}" if merge_debug
+            dest = overwrite_unmergeables(source, dest, options)
+          end
+        end
+      end
+    elsif source.kind_of?(Array)
+      puts "#{di}Arrays: #{source.inspect} :: #{dest.inspect}" if merge_debug
+      # if we are instructed, join/split any source arrays before processing
+      if array_split_char
+        puts "#{di} split/join on source: #{source.inspect}" if merge_debug
+        source = source.join(array_split_char).split(array_split_char)
+        if dest.kind_of?(Array)
+          dest = dest.join(array_split_char).split(array_split_char)
+        end
+      end
+      # if there's a naked knockout_prefix in source, that means we are to truncate dest
+      if source.index(knockout_prefix)
+        dest = clear_or_nil(dest); source.delete(knockout_prefix)
+      end
+      if dest.kind_of?(Array) and ! overwrite_arrays
+        if knockout_prefix
+          print "#{di} knocking out: " if merge_debug
+          # remove knockout prefix items from both source and dest
+          source.delete_if do |ko_item|
+            retval = false
+            item = ko_item.respond_to?(:gsub) ? ko_item.gsub(%r{^#{knockout_prefix}}, "") : ko_item
+            if item != ko_item
+              print "#{ko_item} - " if merge_debug
+              dest.delete(item)
+              dest.delete(ko_item)
+              retval = true
+            end
+            retval
+          end
+          puts if merge_debug
+        end
+        puts "#{di} merging arrays: #{source.inspect} :: #{dest.inspect}" if merge_debug
+        dest = dest | source
+        dest.sort! if sort_merged_arrays
+      elsif overwrite_unmergeable or overwrite_arrays
+        puts "#{di} overwriting dest: #{source.inspect} -over-> #{dest.inspect}" if merge_debug
+        dest = overwrite_unmergeables(source, dest, options)
+      end
+    else # src_hash is not an array or hash, so we'll have to overwrite dest
+      puts "#{di}Others: #{source.inspect} :: #{dest.inspect}" if merge_debug
+      dest = overwrite_unmergeables(source, dest, options)
+    end
+    puts "#{di}Returning #{dest.inspect}" if merge_debug
+    dest
+  end # deep_merge!
+
+  # allows deep_merge! to uniformly handle overwriting of unmergeable entities
+  def self.overwrite_unmergeables(source, dest, options)
+    merge_debug = options[:merge_debug] || false
+    overwrite_unmergeable = !options[:preserve_unmergeables]
+    knockout_prefix = options[:knockout_prefix] || false
+    di = options[:debug_indent] || ''
+    if knockout_prefix && overwrite_unmergeable
+      if source.kind_of?(String) # remove knockout string from source before overwriting dest
+        if options[:overwrite_arrays] # Don't knock out strings for OATs
+          src_tmp = source
+        else
+          src_tmp = source.gsub(%r{^#{knockout_prefix}},"") 
+        end
+      elsif source.kind_of?(Array) # remove all knockout elements before overwriting dest
+        src_tmp = source.delete_if {|ko_item| ko_item.kind_of?(String) && ko_item.match(%r{^#{knockout_prefix}}) }
+      else
+        src_tmp = source
+      end
+      if src_tmp == source # if we didn't find a knockout_prefix then we just overwrite dest
+        puts "#{di}#{src_tmp.inspect} -over-> #{dest.inspect}" if merge_debug
+        dest = src_tmp
+      else # if we do find a knockout_prefix, then we just delete dest
+        puts "#{di}\"\" -over-> #{dest.inspect}" if merge_debug
+        dest = ""
+      end
+    elsif overwrite_unmergeable
+      dest = source
+    end
+    dest
+  end
+
+  def self.clear_or_nil(obj)
+    if obj.respond_to?(:clear)
+      obj.clear
+    else
+      obj = nil
+    end
+    obj
+  end
+
+end # module DeepMerge

data/lib/deep_merge/deep_merge.rb

@@ -0,0 +1 @@
+require 'deep_merge/deep_merge_hash'

data/lib/deep_merge/deep_merge_hash.rb

@@ -0,0 +1,28 @@
+require 'deep_merge/core'
+
+module DeepMerge
+  module DeepMergeHash
+    # ko_hash_merge! will merge and knockout elements prefixed with DEFAULT_FIELD_KNOCKOUT_PREFIX
+    def ko_deep_merge!(source, options = {})
+      default_opts = {:knockout_prefix => "--", :preserve_unmergeables => false}
+      DeepMerge::deep_merge!(source, self, default_opts.merge(options))
+    end
+
+    # deep_merge! will merge and overwrite any unmergeables in destination hash
+    def deep_merge!(source, options = {})
+      default_opts = {:preserve_unmergeables => false}
+      DeepMerge::deep_merge!(source, self, default_opts.merge(options))
+    end
+
+    # deep_merge will merge and skip any unmergeables in destination hash
+    def deep_merge(source, options = {})
+      default_opts = {:preserve_unmergeables => true}
+      DeepMerge::deep_merge!(source, self, default_opts.merge(options))
+    end
+
+  end # DeepMergeHashExt
+end
+
+class Hash
+  include DeepMerge::DeepMergeHash
+end

data/lib/deep_merge/rails_compat.rb

@@ -0,0 +1,27 @@
+require 'deep_merge/core'
+
+module DeepMerge
+  module RailsCompat
+    # ko_hash_merge! will merge and knockout elements prefixed with DEFAULT_FIELD_KNOCKOUT_PREFIX
+    def ko_deeper_merge!(source, options = {})
+      default_opts = {:knockout_prefix => "--", :preserve_unmergeables => false}
+      DeepMerge::deep_merge!(source, self, default_opts.merge(options))
+    end
+
+    # deep_merge! will merge and overwrite any unmergeables in destination hash
+    def deeper_merge!(source, options = {})
+      default_opts = {:preserve_unmergeables => false}
+      DeepMerge::deep_merge!(source, self, default_opts.merge(options))
+    end
+
+    # deep_merge will merge and skip any unmergeables in destination hash
+    def deeper_merge(source, options = {})
+      default_opts = {:preserve_unmergeables => true}
+      DeepMerge::deep_merge!(source, self, default_opts.merge(options))
+    end
+  end
+end
+
+class Hash
+  include ::DeepMerge::RailsCompat
+end

data/lib/oats/application_logs.rb

@@ -0,0 +1,163 @@
+require 'timeout'
+require 'oats/ossh'
+# Returns all the matching IPs from the listed logs
+
+class ApplicationLogs
+
+  @@app_logs_error_getter = {} # webHostName => ApplicationLogs objects
+  @@ip = nil
+  @@plink_cmd_params = {} # webHostName => Extra parameters to connect or ''
+  PLINK_TIMEOUT = 5
+
+  # Call returns only errors occurring after the previous call.
+  def ApplicationLogs.new_errors(initial = false)
+    logs = $oats['env']['web']['logs']
+    logs = nil if logs.nil? or logs.empty?
+    return [] unless logs
+    host = $oats['env']['web']['host']
+    if @@app_logs_error_getter[host]
+      return [] if initial
+    else
+      @@app_logs_error_getter[host] = ApplicationLogs.new(host,logs)
+    end
+    return @@app_logs_error_getter[host].new_errors
+  end
+
+  def initialize(host,logs)
+    ApplicationLogs.set_ip unless @@ip
+    @logs = logs
+    @log_error_count = []
+    @command = "plink #{host} -l loguser sudo grep -i #{@@ip} " + @logs.join(' ')
+    ApplicationLogs.set_plink_cmd_params
+    @command_issue = @command
+  end
+
+  def new_errors
+    $log.debug "Interrogating the application logs: #{@command_issue}"
+    errors = IO.popen(@command).readlines
+    total_errors = 0
+    @log_error_count.each {|i| total_errors += i}
+    new_error = []
+    return new_error if total_errors == errors.length
+    i = 0
+    new_error_count = []
+    new_error_count[0] = 0
+    errors.each do |line|
+      prefix = Regexp.new('^'+@logs[i]+':')
+      unless prefix =~ line
+        @log_error_count[i] = new_error_count[i]
+        i += 1
+        break if i == @logs.length
+        new_error_count[i] = 0
+        redo
+      end
+      new_error_count[i] += 1
+      new_error << line if new_error_count[i] > (@log_error_count[i] ? @log_error_count[i] : 0)
+    end
+    @log_error_count[i] = new_error_count[i]
+    return new_error
+  end
+
+  # Tails logs continuously.
+  def ApplicationLogs.tail_errors
+    tail_ip = $oats['execution']['tail_logs_ip']
+    logs = $oats['env']['web']['logs']
+    logs = nil if logs.nil? or logs.empty?
+    host = $oats['env']['web']['host']
+    if tail_ip
+      raise(OatsBadInput, "The execution:tail_logs_ip is set to [#{tail_ip}] but env:web:logs is empty.") unless logs
+    else
+      return
+    end
+    if tail_ip and tail_ip.instance_of?(String)
+      if /^\d\d\.\d\d*\.\d\d*\.\d\d*$/ =~ tail_ip
+        @@ip = tail_ip
+      else
+        raise(OatsBadInput, "Input for execution:tail_logs_ip [#{tail_ip}] is not in proper IP format.")
+      end
+    else
+      ApplicationLogs.set_ip unless @@ip
+    end
+    ApplicationLogs.set_plink_cmd_params(true)
+    command = "plink #{host} -l loguser sudo tail -f " + logs.join(' ')
+    command_issue = command
+    puts "Filtering for [#{@@ip}] after executing command: #{command}"
+    IO.popen(command_issue) do |io|
+      while io.gets do
+        puts $_ if Regexp.new(@@ip) =~ $_ or /^==>/ =~ $_
+      end
+    end
+    exit 0 # Should never get here. User has to kill the process to quit
+  end
+
+  def ApplicationLogs.set_plink_cmd_params(from_tail = nil)
+    host = $oats['env']['web']['host']
+    return if @@plink_cmd_params[host]
+    # Ossh does not support this option anymore. Must go in via Paegant
+    # Clean-up the code below later.
+    @@plink_cmd_params = ''
+    error = 0
+    error_msg = nil
+    error_msg2 = nil
+    correct_response = false
+    cmd_issue = "plink #{host} -l loguser whoami 2>&1"
+    cmd_display = cmd_issue
+    $log.debug "Issuing: " + cmd_issue
+    $log.debug "Please start Paegant with loguser key if there is no response in {PLINK_TIMEOUT} seconds."
+    begin
+      timeout(PLINK_TIMEOUT) do
+        IO.popen(cmd_issue) do |ios|
+          while ios.gets(':') do
+            if /s password:/ =~ $_
+              error = 1
+              error_msg = "Received Plink authentication challenge from "
+              error_msg2 = "If you have not started Paegant already, please do so."
+            elsif /s password:/ =~ $_
+              error = 2
+              error_msg = "Received Plink authentication challenge from "
+              error_msg2 = "If you have not defined an entry for [#{host} on Putty already, please do so."
+            elsif /^Password:/ =~ $_
+              error = 3
+              error_msg = "Received 'sudo root' authentication challenge from "
+              error_msg2 = "Sudo password cash has timed out. Please type the following on a shell commandline: #{cmd_display}"
+            elsif /^Unable to open connection:/ =~ $_
+              error = 4
+              error_msg = "Could not connect to "
+              error_msg2 = "You need to unset error log interrogation to run this test in this environment."
+#            elsif /^root/ =~ $_
+            elsif /^loguser/ =~ $_
+              correct_response = true
+            end
+            $log.error $_ unless $_.nil? or correct_response
+            ios.gets
+            $log.error $_ unless $_.nil? or correct_response
+          end
+        end
+      end
+    rescue Timeout::Error
+      $log.error "plink command timed out after [#{PLINK_TIMEOUT}] seconds."
+    end
+    if error == 0 and correct_response
+      $log.info "Received proper response from Plink."
+      return
+    else
+      if error_msg
+        if error_msg2
+          $log.error error_msg + "[#{host}]"
+        else
+          raise(OatsSetupError,error_msg)
+        end
+        raise(OatsSetupError,error_msg2)
+      end
+    end
+  end
+
+  def ApplicationLogs.set_ip
+    IO.popen('ipconfig') do |io|
+      while io.gets do
+        @@ip = $_.chomp.sub(/.*IP Address.*: (\d.*\d).*/,'\1') if /IP Address.*: / =~ $_
+      end
+    end
+  end
+
+end

data/lib/oats/build_id.rb

@@ -0,0 +1,58 @@
+# Should be overridden by the user if desired
+module Oats
+
+  module BuildId
+    def BuildId.generate
+      return
+      dir_results = $oats['execution']['dir_results']
+      env_name = $oats['env']['name']
+      return unless env_name and $oats['execution']['build_version']
+      TestList.current.variations.last.env_name = env_name
+      run_info_file = File.join(dir_results,'run_info_' + env_name + '.txt')
+      unless File.exist?(run_info_file)
+        File.open(run_info_file, 'w') do |f|
+          YAML.dump($oats,f)
+        end
+      end
+      if Oats.context['build_version'] # Collected build data previously
+        return if Oats.context['build_version']['execution'] == $oats['execution']['build_version'] # no change
+        Oats.context['build_version']['execution'] = $oats['execution']['build_version'] # Use the latest, input from test list
+        return
+      end
+      # First time collecting build data
+      Oats.context['build_version'] = { 'execution' => $oats['execution']['build_version'] }
+      all_build_info = ''
+      build_id_file = File.join(dir_results,'buildID_' + env_name + '.txt')
+
+      for host in $oats['execution']['build_versions'] do
+        web_host = $oats['env'][host] && $oats['env'][host]['host']
+        next unless web_host
+        urls = $oats['env'][host]['buildID_url']
+        next unless urls
+        urls = [ urls ] unless urls.instance_of? Array
+        versions = ''
+        urls.each do |url|
+          begin
+            if RUBY_VERSION =~ /^1.9/
+              resp = Net::HTTP.new(web_host, 80).get(url) # 1.9 doesn't like the second parameter
+            else
+              resp = Net::HTTP.new(web_host, 80).get(url, nil )
+            end
+            build_info = resp.body if resp.code == '200'
+          rescue
+            $log.error $!.to_s
+            $log.error "Occurred after issuing get request to [http://#{web_host}#{url}]"
+            build_info = nil
+          end
+          if build_info
+            versions += ' ' unless versions == ''
+            versions += build_info[6..(build_info.index("\n")-1)]
+            all_build_info += "--- #{host} #{url} --- \n" + build_info + "\n"
+          end
+        end
+        Oats.context['build_version'][host] = versions
+      end if $oats['execution']['build_versions']
+      File.open(build_id_file, 'w') { |f| f.puts all_build_info } unless all_build_info == ''
+    end
+  end
+end