ood_core 0.5.1 → 0.6.0

data/lib/ood_core/job/adapters/helper.rb

@@ -0,0 +1,18 @@
+module OodCore
+  module Job
+    module Adapters
+      # @api private
+      class Helper
+        # Get the configured path to a command allowing overrides from bin_overrides
+        # @param cmd [String] the desired command
+        # @param bin_default [String] the default place to find cmd on the file system
+        # @param bin_overrides [Hash<String, String>] commands associated with the full path to their replacement
+        #   e.g. {'squeue' => '/usr/local/slurm/bin/squeue'}
+        # @return [String] path to the configured command
+        def self.bin_path(cmd, bin_default, bin_overrides)
+          bin_overrides.fetch(cmd.to_s) { Pathname.new(bin_default.to_s).join(cmd.to_s).to_s }
+        end
+      end
+    end
+  end
+end

data/lib/ood_core/job/adapters/lsf/batch.rb

@@ -2,20 +2,21 @@
 #
 # @api private
 class OodCore::Job::Adapters::Lsf::Batch
-  attr_reader :bindir, :libdir, :envdir, :serverdir, :cluster
+  attr_reader :bindir, :libdir, :envdir, :serverdir, :cluster, :bin_overrides
 
   # The root exception class that all LSF-specific exceptions inherit
   # from
   class Error < StandardError; end
 
   # @param bin [#to_s] path to LSF installation binaries
-  def initialize(bindir: "", envdir: "", libdir: "", serverdir: "", cluster: "", **_)
+  def initialize(bindir: "", envdir: "", libdir: "", serverdir: "", cluster: "", bin_overrides: {}, **_)
     @bindir = Pathname.new(bindir.to_s)
 
     @envdir = Pathname.new(envdir.to_s)
     @libdir = Pathname.new(libdir.to_s)
     @serverdir = Pathname.new(serverdir.to_s)
     @cluster = cluster.to_s
+    @bin_overrides = bin_overrides
   end
 
   def default_env
@@ -139,7 +140,7 @@ class OodCore::Job::Adapters::Lsf::Batch
   private
     # Call a forked Lsf command for a given cluster
     def call(cmd, *args, env: {}, stdin: "")
-      cmd = bindir.join(cmd.to_s).to_s
+      cmd = OodCore::Job::Adapters::Helper.bin_path(cmd, bindir, bin_overrides)
       args = cluster_args + args
       env = default_env.merge(env.to_h)
       o, e, s = Open3.capture3(env, cmd, *(args.map(&:to_s)), stdin_data: stdin.to_s)

data/lib/ood_core/job/adapters/lsf.rb

@@ -1,4 +1,5 @@
 require "ood_core/refinements/hash_extensions"
+require "ood_core/job/adapters/helper"
 
 module OodCore
   module Job
@@ -12,6 +13,7 @@ module OodCore
       # @option config [#to_s] :envdir ('') Path to lsf client conf dir
       # @option config [#to_s] :serverdir ('') Path to lsf client etc dir
       # @option config [#to_s] :cluster ('') name of cluster, if in multi-cluster mode
+      # @option config [#to_h] :bin_overrides ({}) Optional overrides to LSF client executables
       def self.build_lsf(config)
         batch = Adapters::Lsf::Batch.new(config.to_h.symbolize_keys)
         Adapters::Lsf.new(batch: batch)
@@ -123,8 +125,8 @@ module OodCore
           elsif owners.count == 0
             []
           else
-	    batch.get_jobs_for_user(owners.first).map { |v| info_for_batch_hash(v) }
-	  end
+            batch.get_jobs_for_user(owners.first).map { |v| info_for_batch_hash(v) }
+          end
         rescue Batch::Error => e
           raise JobAdapterError, e.message
         end

data/lib/ood_core/job/adapters/pbspro.rb

@@ -1,5 +1,6 @@
 require "time"
 require "ood_core/refinements/hash_extensions"
+require "ood_core/job/adapters/helper"
 
 module OodCore
   module Job
@@ -12,12 +13,14 @@ module OodCore
       # @option config [Object] :exec (nil) Path to PBS Pro executables
       # @option config [Object] :qstat_factor (nil) Deciding factor on how to
       #   call qstat for a user
+      # @option config [#to_h] :bin_overrides ({}) Optional overrides to PBS Pro client executables
       def self.build_pbspro(config)
         c = config.to_h.compact.symbolize_keys
         host = c.fetch(:host, nil)
-        exec = c.fetch(:exec, nil)
+        pbs_exec = c.fetch(:exec, nil)
         qstat_factor = c.fetch(:qstat_factor, nil)
-        pbspro = Adapters::PBSPro::Batch.new(host: host, exec: exec)
+        bin_overrides = c.fetch(:bin_overrides, {})
+        pbspro = Adapters::PBSPro::Batch.new(host: host, pbs_exec: pbs_exec, bin_overrides: bin_overrides)
         Adapters::PBSPro.new(pbspro: pbspro, qstat_factor: qstat_factor)
       end
     end
@@ -40,9 +43,15 @@ module OodCore
 
           # The path containing the PBS executables
           # @example
-          #   my_batch.exec.to_s #=> "/usr/local/pbspro/10.0.0
+          #   my_batch.pbs_exec.to_s #=> "/usr/local/pbspro/10.0.0
           # @return [Pathname, nil] path to pbs executables
-          attr_reader :exec
+          attr_reader :pbs_exec
+
+          # Optional overrides for PBS Pro client executables
+          # @example
+          #  {'qsub' => '/usr/local/bin/qsub'}
+          # @return Hash<String, String>
+          attr_reader :bin_overrides
 
           # The root exception class that all PBS Pro-specific exceptions
           # inherit from
@@ -50,9 +59,10 @@ module OodCore
 
           # @param host [#to_s, nil] the batch server host
           # @param exec [#to_s, nil] path to pbs executables
-          def initialize(host: nil, exec: nil)
+          def initialize(host: nil, pbs_exec: nil, bin_overrides: {})
             @host = host && host.to_s
-            @exec = exec && Pathname.new(exec.to_s)
+            @pbs_exec = pbs_exec && Pathname.new(pbs_exec.to_s)
+            @bin_overrides = bin_overrides
           end
 
           # Get a list of hashes detailing each of the jobs on the batch server
@@ -147,11 +157,12 @@ module OodCore
             # Call a forked PBS Pro command for a given batch server
             def call(cmd, *args, env: {}, stdin: "", chdir: nil)
               cmd = cmd.to_s
-              cmd = exec.join("bin", cmd).to_s if exec
+              bindir = (!!pbs_exec) ? pbs_exec.join("bin").to_s : ''
+              cmd = OodCore::Job::Adapters::Helper.bin_path(cmd, bindir, bin_overrides)
               args = args.map(&:to_s)
               env = env.to_h.each_with_object({}) { |(k, v), h| h[k.to_s] = v.to_s }
               env["PBS_DEFAULT"] = host.to_s if host
-              env["PBS_EXEC"]    = exec.to_s if exec
+              env["PBS_EXEC"]    = pbs_exec.to_s if pbs_exec
               chdir ||= "."
               o, e, s = Open3.capture3(env, cmd, *args, stdin_data: stdin.to_s, chdir: chdir.to_s)
               s.success? ? o : raise(Error, e)

data/lib/ood_core/job/adapters/sge/batch.rb

@@ -0,0 +1,203 @@
+# Patch to allow runtime setting of the libdrmaa path
+module FFI_DRMAA
+  def self.libdrmaa_path
+    @libdrmaa_path || 'libdrmaa.so'
+  end
+  
+  def self.libdrmaa_path=(path)
+    @libdrmaa_path = path
+  end
+end
+
+# Object used for simplified communication with a SGE batch server
+#
+# @api private
+class OodCore::Job::Adapters::Sge::Batch
+  using OodCore::Refinements::HashExtensions
+
+  attr_reader :bin, :bin_overrides, :conf, :cluster, :sge_root, :helper
+  
+  require "ood_core/job/adapters/sge/qstat_xml_j_r_listener"
+  require "ood_core/job/adapters/sge/qstat_xml_r_listener"
+  require "ood_core/job/adapters/sge/helper"
+  require "ood_core/job/adapters/helper"
+  require 'time'
+
+  class Error < StandardError; end
+
+  # @param opts [#to_h] the options defining this adapter
+  # @option opts [Batch] :batch The Sge batch object
+  #
+  # @api private
+  # @see Factory.build_sge
+  def initialize(config)
+    @cluster          = config.fetch(:cluster, nil)
+    @conf             = Pathname.new(config.fetch(:conf, nil))
+    @bin              = Pathname.new(config.fetch(:bin, nil))
+    @sge_root         = config.key?(:sge_root) && config[:sge_root] ? Pathname.new(config[:sge_root]) : nil
+    @bin_overrides    = config.fetch(:bin_overrides, {})
+
+    load_drmaa(config[:libdrmaa_path]) if sge_root
+
+    @helper = OodCore::Job::Adapters::Sge::Helper.new
+  end
+
+  def load_drmaa(libdrmaa_path)
+    FFI_DRMAA.libdrmaa_path = libdrmaa_path if libdrmaa_path
+    require "ood_core/job/adapters/drmaa"
+    require "ood_core/refinements/drmaa_extensions"
+  end
+
+  # Get OodCore::Job::Info for every enqueued job, optionally filtering on owner
+  # @param owner [#to_s] the owner or owner list
+  # @return [Array<OodCore::Job::Info>]
+  def get_all(owner: nil)
+    listener = QstatXmlRListener.new
+    argv = ['qstat', '-r', '-xml']
+    argv += ['-u', owner] unless owner.nil?
+    REXML::Parsers::StreamParser.new(call(*argv), listener).parse
+
+    listener.parsed_jobs.map{|job_hash| OodCore::Job::Info.new(**post_process_qstat_job_hash(job_hash))}
+  end
+
+  # Get OodCore::Job::Info for a job_id that may still be in the queue
+  # 
+  # If @sge_root is nil or libdrmaa is not loaded then we cannot use DRMAA. Using
+  # DRMAA provides better job status and should always be chosen if it is possible.
+  # 
+  # When qstat is called in XML mode for a job id that is not in the queue invalid XML
+  # is returned. The second line of the invalid XML contains the string '<unknown_jobs'
+  # which will be used to recognize this case.
+  # 
+  # @param job_id [#to_s]
+  # @return [OodCore::Job::Info]
+  def get_info_enqueued_job(job_id)
+    job_info = OodCore::Job::Info.new(id: job_id.to_s, status: :completed)
+    argv = ['qstat', '-r', '-xml', '-j', job_id.to_s]
+    
+    begin
+      results = call(*argv)
+      listener = QstatXmlJRListener.new
+      REXML::Parsers::StreamParser.new(results, listener).parse
+
+      job_hash = listener.parsed_job
+      job_hash[:status] = get_status_from_drmma(job_id) if can_use_drmaa?
+        
+      job_info = OodCore::Job::Info.new(**job_hash)
+    rescue REXML::ParseException => e
+      # If the error is something other than a job not being found by qstat re-raise the error
+      unless results =~ /unknown_jobs/
+        raise e, "REXML::ParseException error and command '#{argv.join(' ')}' produced results that didn't contain string 'unknown_jobs'. ParseException: #{e.message}"
+      end
+    rescue DRMAA::DRMAAInvalidArgumentError => e
+      raise Error, e.message
+    end
+
+    job_info
+  end
+
+  def can_use_drmaa?
+    sge_root && Object.const_defined?('DRMAA')
+  end
+
+  # Call qhold
+  # @param job_id [#to_s]
+  # @return [void]
+  def hold(job_id)
+    call('qhold', job_id)
+  end
+
+  # Call qrls
+  # @param job_id [#to_s]
+  # @return [void]
+  def release(job_id)
+    call('qrls', job_id)
+  end
+
+  # Call qdel
+  # @param job_id [#to_s]
+  # @return [void]
+  def delete(job_id)
+    call('qdel', job_id)
+  end
+
+  # Call qsub with arguments and the scripts content
+  # @param job_id [#to_s]
+  # @return job_id [String]
+  def submit(content, args)
+      cmd = ['qsub'] + args
+      @helper.parse_job_id_from_qsub(call(*cmd, :stdin => content))
+  end
+
+  # Call a forked SGE command for a given batch server
+  def call(cmd, *args, env: {}, stdin: "", chdir: nil)
+    cmd = OodCore::Job::Adapters::Helper.bin_path(cmd, bin, bin_overrides)
+    args = args.map(&:to_s)
+
+    env = env.to_h.each_with_object({}) { |(k, v), h| h[k.to_s] = v.to_s }
+    chdir ||= "."
+    o, e, s = Open3.capture3(env, cmd, *args, stdin_data: stdin.to_s, chdir: chdir.to_s)
+    s.success? ? o : raise(Error, e)
+  end
+
+  # Adapted from http://www.softpanorama.org/HPC/Grid_engine/Queues/queue_states.shtml
+  STATE_MAP = {
+    'EhRqw'   => :undetermined, # all pending states with error
+    'Ehqw'    => :undetermined, # all pending states with error
+    'Eqw'     => :undetermined, # all pending states with error
+    'RS'      => :suspended,    # all suspended with re-submit
+    'RT'      => :suspended,    # all suspended with re-submit
+    'Rr'      => :running,      # running, re-submit
+    'Rs'      => :suspended,    # all suspended with re-submit
+    'Rt'      => :running,      # transferring, re-submit
+    'RtS'     => :suspended,    # all suspended with re-submit
+    'RtT'     => :suspended,    # all suspended with re-submit
+    'Rts'     => :suspended,    # all suspended with re-submit
+    'S'       => :suspended,    # queue suspended
+    'T'       => :suspended,    # queue suspended by alarm
+    'dRS'     => :completed,    # all running and suspended states with deletion
+    'dRT'     => :completed,    # all running and suspended states with deletion
+    'dRr'     => :completed,    # all running and suspended states with deletion
+    'dRs'     => :completed,    # all running and suspended states with deletion
+    'dRt'     => :completed,    # all running and suspended states with deletion
+    'dS'      => :completed,    # all running and suspended states with deletion
+    'dT'      => :completed,    # all running and suspended states with deletion
+    'dr'      => :completed,    # all running and suspended states with deletion
+    'ds'      => :completed,    # all running and suspended states with deletion
+    'dt'      => :completed,    # all running and suspended states with deletion
+    'hRwq'    => :queued_held,  # pending, system hold, re-queue
+    'hqw'     => :queued_held,  # pending, system hold
+    'qw'      => :queued,       # pending
+    'r'       => :running,      # running
+    's'       => :suspended,    # suspended
+    't'       => :running,      # transferring
+    'tS'      => :suspended,    # queue suspended
+    'tT'      => :suspended,    # queue suspended by alarm
+    'ts'      => :suspended,    # obsuspended
+  }
+
+  def translate_sge_state(sge_state_code)
+    STATE_MAP.fetch(sge_state_code, :undetermined)
+  end
+
+  def translate_drmaa_state(drmaa_state_code)
+    DRMAA::DRMMA_TO_OOD_STATE_MAP.fetch(drmaa_state_code, :undetermined)
+  end
+
+  def post_process_qstat_job_hash(job_hash)
+    # dispatch is not set if the job is not running
+    if ! job_hash.key?(:wallclock_time)
+      job_hash[:wallclock_time] = job_hash.key?(:dispatch_time) ? Time.now.to_i - job_hash[:dispatch_time] : 0
+    end
+
+    job_hash[:status] = translate_sge_state(job_hash[:status])
+
+    job_hash
+  end
+
+  # Get the job status using DRMAA
+  def get_status_from_drmma(job_id)
+    ENV['SGE_ROOT'] = sge_root.to_s
+    translate_drmaa_state(DRMAA::SessionSingleton.instance.job_ps(job_id.to_s))
+  end
+end

data/lib/ood_core/job/adapters/sge/helper.rb

@@ -0,0 +1,65 @@
+class OodCore::Job::Adapters::Sge::Helper
+  require 'ood_core/job/adapters/sge'
+
+  using OodCore::Refinements::ArrayExtensions
+
+  # Convert seconds to duration
+  # @param time [#to_i]
+  # @return [String] an SGE qsub compatible wallclock limit
+  def seconds_to_duration(time)
+    time = time.to_i
+    "%02d:%02d:%02d" % [time/3600, time/60%60, time%60]
+  end
+
+  # Convert script and job dependencies to qsub argument vector
+  # @return args [Array<String>]
+  def batch_submit_args(script, after: [], afterok: [], afternotok: [], afterany: [])
+    raise_error_on_unsupported_args(script, after: after, afterok: afterok, afternotok: afternotok, afterany: afterany)
+
+    args = []
+    args += ['-h'] if script.submit_as_hold
+    args += ['-r', 'yes'] if script.rerunnable
+    script.job_environment.each_pair {|k, v| args += ['-v', "#{k.to_s}=#{v.to_s}"]} unless script.job_environment.nil?
+    args += ['-wd', script.workdir] unless script.workdir.nil?
+
+    on_event_email = []
+    on_event_email << 'b' if script.email_on_started  # beginning
+    on_event_email << 'ea' if script.email_on_terminated  # end, aborted
+
+    args += ['-M', script.email.first, '-m', on_event_email.join] if script.email && ! on_event_email.empty?
+
+    afterok  = Array(afterok).map(&:to_s)
+    args += ['-hold_jid_ad', afterok.join(',')] unless afterok.empty?
+
+    # ignoring email_on_started
+    args += ['-N', script.job_name] unless script.job_name.nil?
+    args += ['-e', script.error_path] unless script.error_path.nil?
+    args += ['-o', script.output_path] unless script.output_path.nil?
+    args += ['-ar', script.reservation_id] unless script.reservation_id.nil?
+    args += ['-q', script.queue_name] unless script.queue_name.nil?
+    args += ['-p', script.priority] unless script.priority.nil?
+    args += ['-a', script.start_time.strftime('%C%y%m%d%H%M.%S')] unless script.start_time.nil?
+    args += ['-l', "h_rt=" + seconds_to_duration(script.wall_time)] unless script.wall_time.nil?
+    args += ['-P', script.accounting_id] unless script.accounting_id.nil?
+    args += Array.wrap(script.native) if script.native
+
+    args
+  end
+
+  # Raise exceptions when adapter is asked to perform an action that SGE does not support
+  # @raise [Error] when an incompatible action is requested
+  def raise_error_on_unsupported_args(script, after:, afterok:, afternotok:, afterany:)
+    # SGE job dependencies only supports one kind of event: completion
+    raise OodCore::Job::Adapters::Sge::Error.new('SGE does not support job dependencies on after start') if after && ! after.empty?
+    raise OodCore::Job::Adapters::Sge::Error.new('SGE does not support job dependencies on after not ok') if afternotok && ! afternotok.empty?
+    raise OodCore::Job::Adapters::Sge::Error.new('SGE does not support job dependencies on after any') if afterany && ! afterany.empty?
+  end
+
+  # Extract the job id from qsub's output
+  # e.g. Your job 1043 ("job_16") has been submitted
+  # @param qsub_output [#to_s]
+  # @return job_id [String]
+  def parse_job_id_from_qsub(qsub_output)
+    /Your job(?:-array)? (?<job_id>[0-9]+)/.match(qsub_output)[:job_id]
+  end
+end

data/lib/ood_core/job/adapters/sge/qstat_xml_j_r_listener.rb

@@ -0,0 +1,116 @@
+require 'rexml/document'
+require 'rexml/streamlistener'
+require 'date'
+
+# An XML stream listener to build an array of OodCore::Job::Info from qstat output
+#
+# Handles parsing `qstat -xml -r -j` which provides:
+# :accounting_id
+# :id
+# :job_name
+# :job_owner
+# :procs
+# :queue_name
+# :status
+# :wallclock_limit
+
+
+# :wallclock_time  # HOW LONG HAS IT BEEN RUNNING?
+
+class QstatXmlJRListener
+  # [Hash]
+  attr_reader :parsed_job
+
+  include REXML::StreamListener
+
+  def initialize
+    @parsed_job = {
+      :status => :queued,
+      :procs => 1,  # un-knowable from SGE qstat output
+      :native => {}  # TODO: improve native attribute reporting
+    }
+    @current_text = nil
+    @current_request = nil
+  end
+
+  def tag_end(name)
+    case name
+    when 'JB_ja_tasks'
+      end_JB_ja_tasks
+    when 'JB_job_number'
+      end_JB_job_number
+    when 'JB_job_name'
+      end_JB_job_name
+    when 'JB_owner'
+      end_JB_owner
+    when 'JB_project'
+      end_JB_project
+    when 'JB_submission_time'
+      end_JB_submission_time
+    when 'hard_request'
+      end_hard_request
+    when 'JAT_start_time'
+      end_JAT_start_time
+    when 'CE_name'
+      end_CE_name
+    when 'CE_stringval'
+      end_CE_stringval
+    when 'QR_name'
+      end_QR_name
+    end
+  end
+
+  # Always store text nodes temporarily
+  def text(text)
+    @current_text = text
+  end
+
+  # Attributes we need
+  def end_JB_job_number
+    @parsed_job[:id] = @current_text
+  end
+
+  def end_JB_owner
+    @parsed_job[:job_owner] = @current_text
+  end
+
+  def end_JB_project
+    @parsed_job[:accounting_id] = @current_text
+  end
+
+  def end_JB_job_name
+    @parsed_job[:job_name] = @current_text
+  end
+
+  def end_JB_submission_time
+    @parsed_job[:submission_time] = @current_text.to_i
+  end
+
+  def end_JB_ja_tasks
+    @parsed_job[:status] = :running
+  end
+
+  def end_JAT_start_time
+    @parsed_job[:status] = :running
+    @parsed_job[:dispatch_time] = @current_text.to_i
+    @parsed_job[:wallclock_time] = Time.now.to_i - @parsed_job[:dispatch_time]
+  end
+
+  def end_CE_name
+    @current_request = @current_text
+  end
+
+  def end_CE_stringval
+    return nil if @current_request.nil?
+
+    case @current_request
+    when 'h_rt'  # hard run time limit
+      @parsed_job[:wallclock_limit] = @current_text.to_i
+    end
+  end
+
+  def end_QR_name
+    @parsed_job[:queue_name] = @current_text
+  end
+end
+

data/lib/ood_core/job/adapters/sge/qstat_xml_r_listener.rb

@@ -0,0 +1,138 @@
+require 'rexml/document'
+require 'rexml/streamlistener'
+require 'date'
+
+# An XML stream listener to build an array of OodCore::Job::Info from qstat output
+#
+# Handles parsing `qstat -xml -r` which provides:
+# :accounting_id
+# :id
+# :job_name
+# :job_owner
+# :procs
+# :queue_name
+# :status
+# :wallclock_limit
+
+class QstatXmlRListener
+  # [Array<Hash>]
+  attr_reader :parsed_jobs
+
+  include REXML::StreamListener
+
+  def initialize
+    @parsed_jobs = []
+    @current_job = {
+      :native => {}  # TODO: improve native reporting
+    }
+    @current_text = nil
+
+    @current_request = nil
+  end
+
+  def tag_start(name, attributes)
+    case name
+    when 'hard_request'
+      start_hard_request(attributes)
+    end
+  end
+
+  def tag_end(name)
+    case name
+    when 'job_list'
+      end_job_list
+    when 'JB_job_number'
+      end_JB_job_number
+    when 'JB_name'
+      end_JB_name
+    when 'JB_owner'
+      end_JB_owner
+    when 'JB_project'
+      end_JB_project
+    when 'state'
+      end_state
+    when 'slots'
+      end_slots
+    when 'JB_submission_time'
+      end_JB_submission_time
+    when 'hard_req_queue'
+      end_hard_req_queue
+    when 'JAT_start_time'
+      end_JAT_start_time
+    when 'hard_request'
+      end_hard_request
+    end
+  end
+
+  # Always store text nodes temporarily
+  def text(text)
+    @current_text = text
+  end
+
+  # Handle hard_request tags
+  #
+  # Multiple hard_request tags may be present and will be differentiated using their name attribute
+  def start_hard_request(attributes)
+    if attributes.key?('name')
+      @current_request = attributes['name']
+    else
+      @current_request = nil
+    end
+  end
+
+  # Attributes we need
+  def end_JB_job_number
+    @current_job[:id] = @current_text
+  end
+
+  def end_JB_owner
+    @current_job[:job_owner] = @current_text
+  end
+
+  def end_JB_project
+    @current_job[:accounting_id] = @current_text
+  end
+
+  def end_JB_name
+    @current_job[:job_name] = @current_text
+  end
+
+  # Note that this is the native SGE type
+  def end_state
+    @current_job[:status] = @current_text
+  end
+
+  def end_slots
+    @current_job[:procs] = @current_text.to_i
+  end
+
+  def end_hard_req_queue
+    @current_job[:queue_name] = @current_text
+  end
+
+  def end_JB_submission_time
+    @current_job[:submission_time] = DateTime.parse(@current_text).to_time.to_i
+  end
+
+  def end_JAT_start_time
+    @current_job[:dispatch_time] = DateTime.parse(@current_text).to_time.to_i
+  end
+
+  def end_hard_request
+    return nil if @current_request.nil?
+
+    case @current_request
+    when 'h_rt'  # hard run time limit
+      @current_job[:wallclock_limit] = @current_text.to_i
+    end
+  end
+
+  # Store a completed job and reset current_job for the next pass
+  def end_job_list
+    @parsed_jobs << @current_job
+    @current_job = {
+      :native => {}
+    }
+  end
+end
+