oats 0.0.1

data/lib/oats/oats_data.rb

@@ -0,0 +1,400 @@
+#require 'yaml'            # http://www.ruby-doc.org/core/classes/YAML.html
+module Oats
+
+  # Keeps history of YAML files loaded into the global $oats.
+  # if omit is true add the yaml name into the result directory hierarchy
+  class OatsDataLoadHistoryItem
+    attr_accessor :file, :omit, :in_result_dir
+    def initialize(file, omit = false)
+      @file = file
+      @omit = omit
+      @in_result_dir = true
+    end
+  end
+
+  class OatsData
+    @@oats_def_file = nil
+    @@resolve_path = []
+    # Resolves ENV[ entries in a oats_data
+    def OatsData.resolve(oats_data = nil)
+      oats_data = $oats unless oats_data
+      changed = false
+      oats_data.each do |key, val|
+        if val.instance_of?(String)
+          begin
+            next unless /Oats\.|ENV\[/ =~ val  # skip if no need for change
+            new_val = eval(val)
+            next if new_val.instance_of?(String) and /Oats\.|ENV\[/ =~ new_val # skip if change did not help
+            #          new_key = key.sub(/\s*\(wait4definition\)\s*/,'')
+            #          next unless new_key == key or new_val # skip if wait4defs in effect
+            #          oats_data[new_key] = new_val
+            oats_data[key] = if new_val == 'previous_oats_value'
+              oc = @@oats_copy
+              @@resolve_path.each { |k| oc = oc[k] }
+              oc[key]
+            else
+              new_val
+            end
+            changed = true
+            #          oats_data.delete(key) unless new_key == key
+          rescue Exception =>e
+            $log.error "While evaluating Oats.data #{key}: #{val}"
+            raise e
+          end
+        elsif val.instance_of?(Array)
+          val.each_with_index do | item, index |
+            if item.instance_of?(String)
+              begin
+                next unless /Oats\.|ENV\[/ =~ item  # skip if no need for change
+                new_val = eval(item)
+                next if /Oats\.|ENV\[/ =~ new_val # skip if change did not help
+                val[index] = if new_val == 'previous_oats_value'
+                  oc = @@oats_copy
+                  @@resolve_path.each { |k| oc = oc[k] }
+                  oc[key]
+                else
+                  new_val
+                end
+                changed = true
+              rescue Exception =>exc
+                $log.error "While evaluating [#{item}] for [#{index}]th entry in Rat.data #{key}: #{val}"
+                raise exc
+              end
+            elsif item.instance_of?(Hash)
+              begin
+                @@resolve_path.push(key)
+                res_return = resolve(item)
+              ensure
+                @@resolve_path.pop
+              end
+              changed = res_return || changed
+            end
+          end
+        elsif val.instance_of?(Hash)
+          begin
+            @@resolve_path.push(key)
+            res_return = resolve(val)
+          ensure
+            @@resolve_path.pop
+          end
+          changed = res_return || changed
+        end
+      end
+      while changed
+        changed = resolve(oats_data)
+      end
+      changed
+    end
+
+    # If no input, use default YAML file, overridden by user's HOME or OATS_INI
+    # Specified oats_file becomes the overriding file.
+    # If specified, oats_default data is used instead of the default YAML contents.
+    # Returns loaded data in $oats
+    @@define_always = nil
+    def OatsData.load(oats_file = ENV['OATS_INI'] , oats_default = nil)
+      @@define_always = nil
+      @@oats_def_file ||= ENV['OATS_HOME'] + '/oats_ini.yml'
+
+      if oats_file
+        raise(OatsError, "Can not locate: #{oats_file}") unless File.exist?(oats_file)
+      else
+        oats_file = ENV['HOME'] ? File.join( ENV['HOME'] , 'oats_user.yml') : nil
+        oats_file = nil unless oats_file and File.exist?(oats_file)
+      end
+      if oats_file
+        begin
+          oats_data = YAML.load_file(oats_file)
+        rescue
+          raise(OatsError, "While loading [#{oats_file}] " + $!)
+        end
+      end
+
+      if oats_default # make a deep copy
+        oats_default = Marshal.load(Marshal.dump(oats_default))
+      else  # Only the first time, when reading the _ini files
+        begin
+          oats_default = YAML.load_file(@@oats_def_file)
+        rescue
+          raise(OatsError,"Error loading [#{@@oats_def_file}]: " + $!)
+        end
+        $oats = oats_default # So that resolve can resolve Oats.data calls
+        begin
+          OatsData.resolve(oats_default)
+        rescue
+          $log.error "While resolving variables in: " + @@oats_def_file
+          #         raise(OatsError, $!.to_s)
+          raise $!
+        end
+        # Use this hash to persist internally used oats_data
+        oats_default['_'] = {}
+        oats_default['_']['load_history']  = [ OatsDataLoadHistoryItem.new(@@oats_def_file) ]
+        $oats = oats_default # $oats now has data resolved and has load_history
+        # For some reason OCC/Ubuntu needed the environment but not Mac
+        aut_dir_test = ENV['OATS_TESTS'] || oats_data['execution']['dir_tests'] || oats_default['execution']['dir_tests']
+        if aut_dir_test
+          aut_ini = aut_dir_test + '/aut_ini.yml'
+          oats_default['include_yaml'] ||= aut_ini if File.exists?(aut_ini)
+        end
+        OatsData.include_yaml_file(oats_default['include_yaml'], @@oats_def_file) if oats_default['include_yaml']
+        oats_default = $oats
+      end
+
+      if oats_data
+        incl_yamls = oats_data['include_yaml']
+        if incl_yamls and not oats_data['include_yaml_later']
+          oats_data['include_yaml'] = nil
+          OatsData.include_yaml_file(incl_yamls, oats_file)
+        end
+        begin
+          @@oats_copy = Marshal.load(Marshal.dump($oats))
+          merged = OatsData.merge($oats,oats_data)
+        rescue OatsError
+          $log.error "While merging: " + oats_file
+          raise(OatsError, $!.to_s)
+        rescue
+          $log.error "While merging: " + oats_file
+          raise
+        end
+        merged['_']['load_history'] << OatsDataLoadHistoryItem.new(oats_file)
+        $oats = merged
+        if incl_yamls and oats_data['include_yaml_later']
+          merged['include_yaml'] = nil
+          OatsData.include_yaml_file(incl_yamls, oats_file)
+        end
+        begin
+          OatsData.resolve(merged)
+        rescue
+          $log.error "While resolving variables in: " + oats_file
+          raise $!
+        end
+        result = $oats
+      else
+        $log.warn("Could not find oats-user.yml via OATS_INI or HOME definition. Using the system default.")
+        result = oats_default
+      end
+      return result
+    end
+
+    @@include_hist = []
+    # Handles include_yaml files. Calls OatsData.overlay to modify $oats. Returns nothing.
+    def OatsData.include_yaml_file(incl_yamls, oats_file = nil)
+      return unless incl_yamls
+      if incl_yamls
+        incl_yamls = [incl_yamls] if incl_yamls.instance_of?(String)
+        incl_yamls.each do |incl_yaml|
+          begin
+            incl_yaml_file = TestData.locate(incl_yaml, File.dirname(oats_file))
+            Oats.assert incl_yaml_file,  "Can not locate file: #{incl_yaml}"
+
+            hist = Oats.data['_']['load_history'].collect{|i| i.file} + @@include_hist
+            Oats.assert ! hist.include?(incl_yaml_file), "Attempt to re-include #{incl_yaml_file} into #{hist.inspect}"
+            begin
+              @@include_hist.push(incl_yaml_file)
+              OatsData.overlay(incl_yaml_file)
+            ensure
+              Oats.assert_equal incl_yaml_file, @@include_hist.pop
+            end
+          rescue
+            msg = "While including [#{incl_yaml}]"
+            msg += " from: " + oats_file if oats_file
+            #          raise(OatsError, msg + $!)
+            $log.error msg
+            raise $!
+          end
+        end
+        return
+      end
+    end
+
+    # Returns Oats.data history files in an array.
+    def OatsData.history(omit=false)
+      if omit
+        Oats.data['_']['load_history'].select{|i| i.omit and i.in_result_dir}.collect{|i| i.file}
+      else
+        Oats.data['_']['load_history'].collect{|i| i.file}
+      end
+    end
+
+    # Overrides config_ini hash tree with custom_ini.
+    # At each level keep only the items specified by the include_list array
+    def OatsData.merge(config_ini, custom_ini)
+      merged_config = config_ini
+      raise(OatsError, "Original YAML is not a hash: "  + config_ini.inspect) unless config_ini.class == Hash
+      return config_ini unless custom_ini # If input YAML is empty
+      raise(OatsError, "Override YAML is not a hash: "  + custom_ini.inspect) unless custom_ini.class == Hash
+      include_array = []
+      include_list_exists = false
+      @@define_always = custom_ini['define_always'] if custom_ini.include?('define_always')
+      custom_ini.each do |key, val|
+        if config_ini.has_key?(key)
+          old_val = config_ini[key]
+          unless old_val.nil? or val.nil?
+            if (old_val.class != val.class)
+              if val.instance_of?(FalseClass)  # If new value is different and false set it to nil
+                val = nil
+              elsif not ( (val.instance_of?(TrueClass) or val.instance_of?(FalseClass)) and
+                    (old_val.instance_of?(TrueClass) or old_val.instance_of?(FalseClass)) )
+                $log.error "Entry [#{key}] was previously set to [#{old_val}] with type [" + old_val.class.to_s + "]"
+                $log.error "  now being set to [#{val}] with type [" + val.class.to_s + "]"
+                $log.error "  entry [#{old_val}] of the original YAML entry is part of: " + config_ini.inspect
+                $log.error "  entry [#{val}] of over-ride YAML entry is part of: " + custom_ini.inspect
+                raise(OatsError, "Attempt to override OATS data with a different type.")
+              end
+            end
+          end
+        else
+          if key == "include_list"
+            raise(OatsError, "The include_list " + val.inspect + " is not an Array") unless val.class == Array
+            include_array = val
+            include_list_exists = true
+          else
+            add_key = key.sub(/\s*\(define\)\s*/,'')
+            if add_key == key and ! @@define_always
+              raise(OatsError, "Override YAML key [#{key}] is not defined in the master YAML: " + @@oats_def_file)
+            else
+              if merged_config.has_key?(add_key)
+                key = add_key
+                old_val = config_ini[key]
+              else
+                merged_config[add_key] = val
+                merged_config.delete(key) unless add_key == key
+                next
+              end
+            end
+          end
+        end
+        case val
+        when Hash then merged_config[key] = merge( old_val, val) # Deep copy for Hashes
+        when Array then # Only shallow copy for Arrays
+          new_arr = []
+          val.each { |e| new_arr << e }
+          merged_config[key] = new_arr
+        when String then merged_config[key] = val.dup
+        else
+          unless (val.nil? and (old_val.class == Hash) ) || key == "include_list"
+            merged_config[key] = val
+          end
+        end
+      end
+      if include_list_exists
+        return nil if  include_array.nil?
+        merged_config.delete_if { |key,value| not include_array.include?(key) }
+      end
+      merged_config
+    end
+    # Overlays $oats with contents of oats_file. Performs no compatibility checking.
+    def OatsData.overlay(oats_file)
+      if oats_file.instance_of?(Hash)
+        oats_overlay = oats_file
+        oats_file = oats_overlay.keys.first + '_' + oats_overlay.values.first.keys.first
+      else
+        if oats_file
+          raise(OatsError, "Can not locate [#{oats_file}]") unless File.exist?(oats_file)
+        else
+          raise(OatsError, "Must specify a oats_file")
+        end
+        begin
+          oats_overlay = YAML.load_file(oats_file)
+        rescue
+          raise(OatsError, "While loading [#{oats_file}] " + $!)
+        end
+      end
+      incl_yamls = oats_overlay['include_yaml']
+      if incl_yamls and not oats_overlay['include_yaml_later']
+        oats_overlay['include_yaml'] = nil
+        OatsData.include_yaml_file(incl_yamls, oats_file)
+      end
+      # Clone it, don't change the original
+      oats_new = Marshal.load(Marshal.dump($oats))
+      begin
+        OatsData.overlay_data(oats_overlay, oats_new)
+      rescue OatsError
+        $log.error "While overlaying: " + oats_file
+        raise(OatsError, $!.to_s)
+      rescue Exception
+        $log.error "While overlaying: " + oats_file
+        raise
+      end
+      oats_new['_']['load_history'] << OatsDataLoadHistoryItem.new(oats_file)
+
+      $oats = oats_new
+      if incl_yamls and oats_overlay['include_yaml_later']
+        oats_overlay['include_yaml'] = nil
+        OatsData.include_yaml_file(incl_yamls, oats_file)
+      end
+      begin
+        OatsData.resolve(oats_new)
+      rescue
+        $log.error "While resolving variables in: " + oats_file
+        raise $!
+      end
+      oats_new = $oats
+      return oats_new
+    end
+
+    # Recurse thru matching hash only, replace rest by overlay
+    def OatsData.overlay_data(overlay, oats_data)
+      overlay.each do |key, val|
+        default_key = key.sub(/\s*\((default|define)\)\s*/,'')
+        if default_key == key
+          default_key = nil
+        else
+          key = default_key
+        end
+        if val.instance_of?(Hash)
+          if oats_data[key].instance_of?(Hash)
+            OatsData.overlay_data(val, oats_data[key])
+          else
+            oats_data[key] = val if oats_data[key] == nil
+            OatsData.overlay_data(val, oats_data[key])
+          end
+        else
+          if default_key
+            oats_data[key] = val unless oats_data[key]
+          else
+            oats_data[key] = val
+          end
+        end
+      end
+    end
+
+    # Regenerates input file based on YAML. Assumes input is absolute path and exists.
+    # Return generated file path or nil if nothing is generated.
+    def OatsData.regenerate_file(file_in)
+      file_in_root = file_in.sub(/(.*)\..*$/,'\1')
+      file_in_extn = File.extname(file_in)
+      yaml_in = file_in_root + '.yml'
+      return nil unless File.exist?(yaml_in)
+      file_gen = file_in_root + '.gen' + file_in_extn
+      yml_out = file_in_root + '.gen.yml'
+      $log.debug "Regenerating [#{file_in}] into [#{file_gen}] based on [#{yaml_in}]"
+      file_contents = IO.read(file_in)
+      test_data = YAML.load_file(yaml_in)
+      if OatsData.map_file_contents(Oats.data, test_data, file_contents)
+        File.open( file_gen, 'w' ) { |out| out.print file_contents }
+        File.open( yml_out, 'w' ) { |out| YAML.dump( test_data, out ) }
+        return file_gen
+      else
+        return nil
+      end
+    end
+
+    # Helper method to replace HTML file contents based on oats and test data mappings.
+    # Returns true if substitutions are made
+    def OatsData.map_file_contents(oats_data, test_data, file_contents)
+      return false unless test_data
+      changed = false
+      test_data.each do |key,val|
+        repVal = oats_data[key]
+        next if val.nil? or repVal.nil?
+        if val.class == Hash
+          changed = changed or map_file_contents( repVal, val, file_contents)
+        else
+          changed = changed or file_contents.sub!(val, repVal)
+          test_data[key] = repVal
+        end
+      end
+    end
+
+  end
+end

data/lib/oats/oats_exceptions.rb

@@ -0,0 +1,25 @@
+# Defines general exception classes used in OATS.
+
+# Not an error, but a request to exit gracefully from deep within OATS code.
+class OatsExit < StandardError ; end
+
+# Unclassified exceptions used by OATS framework
+class OatsError < StandardError ; end
+
+# Errors related to Oats Setup
+class OatsSetupError < OatsError ; end
+
+# Commandline or related oats-user.yml value errors
+class OatsBadInput < OatsError ; end
+
+# Assertion of failure of an individual OATS test
+class OatsTestError < OatsError ; end
+
+# Raised by Oats.assert_* methods
+class OatsAssertError < OatsTestError ; end
+
+# Assertion of failure during verification of test output
+class OatsVerifyError < OatsTestError ; end
+
+# Not an error, but a way to escape a OatsTest from the middle of it.
+class OatsTestExit < OatsTestError ; end

data/lib/oats/oats_lock.rb

@@ -0,0 +1,261 @@
+# Manages a lock file indicating a OATS session is in process
+require 'win32ole' if ENV['OS'] == 'Windows_NT'
+module Oats
+
+  module OatsLock
+    @@file_handle = nil
+    @@is_locked = false
+
+    # Returns true if able to set the lock.
+    def OatsLock.set(verbose = nil)
+      if OatsLock.locked?(true)
+        return false
+      else
+        @@file_handle = File.open(in_progress_file, 'w')
+        my_pid = Process.pid.to_s
+        @@file_handle.puts my_pid
+        if ENV['OS'] != 'Windows_NT' or ENV['TEMP'] =~ /^\/cygdrive/
+          # Leave file handle open for windows to detect and kill associated java, etc.
+          # processes using file handles.
+          @@file_handle.close
+          @@file_handle = nil
+        end
+        @@is_locked = true
+        return true
+      end
+    end
+
+    # Returns the locked state after the last check
+    # verify: true will verify the true state of the lock
+    def OatsLock.locked?(verify = nil)
+      return @@is_locked unless verify
+      @@is_locked = false
+      if ENV['OS'] != 'Windows_NT' or ENV['TEMP'] =~ /^\/cygdrive/
+        if File.exist?(in_progress_file)
+          pids = IO.readlines(in_progress_file)
+          ruby_pid = pids.shift
+          return @@is_locked unless ruby_pid
+          ps_line = `ps -p #{ruby_pid} `
+          if ps_line =~ /bin\/ruby/
+            @@is_locked = true
+            $log.error "Another oats session is possibly in progress:"
+            $log.error ">> #{ps_line}"
+            $log.error "Please kill locking processes or remove #{in_progress_file}."
+          else
+            pids.each { |pid| OatsLock.kill_pid(pid.chomp) }
+            FileUtils.rm(in_progress_file)
+          end
+        end
+      else
+        begin
+          FileUtils.rm(in_progress_file)
+        rescue Errno::ENOENT  # No such File or Directory
+        rescue Errno::EACCES  # unlink Permission denied
+          @@is_locked = true
+          return @@is_locked if verify == :handles_are_cleared
+          # Attempt to kill all dangling processes that prevent removal of the lock
+          proc_array = nil
+          hstring = lock_file
+          ok_to_kill = /(java)|(mysql)||(chromedriver)|(firefox)||(chrome)|(iexplore)\.exe/
+          pid, proc_name, handle_string, line = nil
+          matches = IO.popen("handle #{hstring}").readlines
+          oats_is_alive = false
+          matches.each do |lvar|
+            line = lvar.chomp
+            proc_array = parse_windows_handle_process_line(line)
+            pid, proc_name, handle_string = proc_array
+            next unless pid
+            if proc_name =~ /ruby/
+              #          if pid = $$.to_s
+              #            @@is_locked = false
+              #            return false
+              #          end
+              oats_is_alive = line
+              $log.error "Another oats session is possibly in progress:"
+              $log.error ">> #{line}"
+              $log.error "Please kill locking processes and remove this file if the oats session is defunct."
+              break
+            end
+          end
+          @@is_locked = oats_is_alive
+          unless oats_is_alive
+            matches.each do |lvar|
+              line = lvar.chomp
+              pid, proc_name, handle_string = parse_windows_handle_process_line(line)
+              next unless pid
+              raise "Handle error for [#{hstring}] Please notify OATS administrator." unless handle_string =~ /#{hstring}/
+              $log.warn "Likely locking process: [#{line}]"
+              if proc_name =~ ok_to_kill
+                $log.warn "Will attempt to kill [#{proc_name}] with PID #{pid}"
+                signal = 'KILL'
+                killed = Process.kill(signal,pid.to_i)
+                if RUBY_VERSION =~ /^1.9/
+                  if killed.empty?
+                    killed = 0
+                  else
+                    killed = 1
+                  end
+                end
+                if killed == 0
+                  $log.warn "Failed to kill the process"
+                else
+                  $log.warn "Successfully killed [#{proc_name}]"
+                end
+              else
+                $log.warn "Oats is configured not to auto-kill process [#{proc_name}]"
+              end
+            end
+            sleep 2  # Need time to clear the process handles
+            @@is_locked = OatsLock.locked?(:handles_are_cleared) # Still locked?
+          end
+          @@is_locked = proc_array if @@is_locked and proc_array
+        end
+      end
+      return @@is_locked
+    end
+
+    def OatsLock.kill_pid(pid,info_line=nil)
+      signal = 'KILL'
+      no_such_process = false
+      begin
+        killed = Process.kill(signal,pid.to_i)
+      rescue Errno::ESRCH # OK if the process is gone
+        no_such_process = true
+      end
+      if RUBY_VERSION =~ /^1.9/
+        if killed.empty?
+          killed = 0
+        else
+          killed = 1
+        end
+      end
+      if no_such_process
+        #      $log.debug "No such process #{info_line||pid}"
+      elsif killed == 0
+        $log.warn "Failed to kill [#{info_line||pid}]"
+      else
+        $log.warn "Successfully killed [#{info_line||pid}]"
+      end
+    end
+
+    def OatsLock.find_matching_processes(proc_names)
+      matched = []
+      if ENV['OS'] == 'Windows_NT'
+        processes = WIN32OLE.connect("winmgmts://").ExecQuery("select * from win32_process")
+        #      for process in processes do
+        #        for property in process.Properties_ do
+        #          puts property.Name
+        #        end
+        #        break
+        #      end
+        processes.each do |process|
+          if process.Commandline =~ proc_names
+            matched.push [process.ProcessId,process.Name,nil, process.CommandLine]
+          end
+        end
+      else
+        pscom = ENV['OS'] == 'Linux' ? 'ps lxww' : 'ps -ef'
+        `#{pscom}`.split("\n").each do |lvar|
+          line = lvar.chomp
+          case ENV['OS']
+          when 'Darwin' #  ps -ef output
+            pid = line[5..11]
+            next if pid.to_i == 0
+            ppid = line[12..16]
+            proc_name = line[50..-1]
+          when 'Linux' #  ps ww output
+            pid = line[7..12]
+            next if pid.to_i == 0
+            ppid = line[13..18]
+            proc_name = line[69..-1]
+          else
+            raise OatError, "Do not know how to parse ps output from #{ENV['OS']}"
+          end
+          next unless pid
+          matched.push [pid.strip, proc_name.strip, ppid.strip, line.strip] if proc_name =~ proc_names
+        end
+      end
+      return matched
+    end
+
+    def OatsLock.kill_webdriver_browsers
+      match = "ruby.*oats/lib/oats_main.rb"
+      # Not tested on agents on Windows_NT
+      if $oats_execution['agent']
+        nickname = $oats_execution['agent']['execution:occ:agent_nickname']
+        port = $oats_execution['agent']['execution:occ:agent_port']
+        match += " -p #{port} -n #{nickname}"
+      end
+
+      # Kill all selenium automation chrome jobs on MacOS. Assumes MacOS is for development only, not OCC.
+      # Will cause problems if multiple agents are run on MacOS
+      if ENV['OS'] == 'Darwin'
+        chrome_automation_procs = OatsLock.find_matching_processes(/ Chrome .* --dom-automation/)
+        chrome_automation_procs.each do |pid,proc_name,ppid|
+          OatsLock.kill_pid pid
+        end
+      end
+
+      oats_procs = OatsLock.find_matching_processes(/#{match}\z/)
+      chromedriver_procs = OatsLock.find_matching_processes(/IEXPLORE.EXE\" -noframemerging|(chromedriver|firefox(-bin|\.exe\") -no-remote)/)
+      webdriver_procs = OatsLock.find_matching_processes(/webdriver/)
+      oats_procs.each do |opid,oproc_name,oppid|
+        chromedriver_procs.each do |cpid,cproc_name,cppid|
+          if cppid == opid
+            webdriver_procs.each do |wpid,wproc_name,wppid|
+              OatsLock.kill_pid wpid if wppid == cpid
+            end
+            OatsLock.kill_pid cpid
+          end
+        end
+      end
+      # If parent ruby dies, ppid reverts to "1"
+      (chromedriver_procs + webdriver_procs).each do |pid,proc_name,ppid|
+        OatsLock.kill_pid pid if ppid == "1" and proc_name !~ /defunct/
+      end
+    end
+
+    # Removes lock
+    def OatsLock.reset
+      if @@file_handle  # Only for Windows
+        @@file_handle.close
+        @@file_handle = nil
+        @@is_locked = true
+      else # Doesn't return status properly for non-windows, just resets the lock
+        if $oats_execution['agent'].nil? and ENV['OS'] != 'Windows_NT' and File.exist?(in_progress_file)
+          pids = IO.readlines(in_progress_file)
+          current_pid = pids.shift
+          pids.each { |pid| OatsLock.kill_pid(pid.chomp) } # Legacy firefox
+        end
+        @@is_locked = false
+      end
+      FileUtils.rm_f in_progress_file
+      return @@is_locked
+    end
+
+    class << self
+      private
+      def lock_file
+        file =  'oats_in_progress.lock'
+        if $oats_execution['agent'] && $oats_execution['agent']['execution:occ:agent_nickname']
+          file = $oats_execution['agent']['execution:occ:agent_nickname'] + '_' + file
+        end
+        return file
+      end
+
+      def in_progress_file
+        return ENV['HOME'] + '/' + lock_file
+      end
+
+      def parse_windows_handle_process_line(line)
+        line =~ /(.*) pid:(.*) .*: (.*)/
+        return nil unless $1
+        proc_name = $1
+        pid = $2
+        handle_string = $3
+        return pid.strip, proc_name.strip, handle_string.strip
+      end
+    end
+
+  end
+end