ood_core 0.0.4 → 0.0.5

data/lib/ood_core/cluster.rb

@@ -33,8 +33,12 @@ module OodCore
     # @option cluster [#to_h] :metadata ({}) The cluster's metadata
     # @option cluster [#to_h] :login ({}) The cluster's SSH host
     # @option cluster [#to_h] :job ({}) The job adapter for this cluster
-    # @option cluster [#to_h] :custom ({}) Any custom resources for this cluster
-    # @option cluster [Array<#to_h>] :acls ([]) List of ACLs to validate against
+    # @option cluster [#to_h] :custom ({}) Any custom resources for this
+    #   cluster
+    # @option cluster [Array<#to_h>] :acls ([]) List of ACLs to validate
+    #   against
+    # @option cluster [#to_h] :batch_connect ({}) Configuration for batch
+    #   connect templates
     def initialize(cluster)
       c = cluster.to_h.symbolize_keys
 
@@ -47,6 +51,7 @@ module OodCore
       @job_config      = c.fetch(:job, {})     .to_h.symbolize_keys
       @custom_config   = c.fetch(:custom, {})  .to_h.symbolize_keys
       @acls_config     = c.fetch(:acls, [])    .map(&:to_h)
+      @batch_connect_config = c.fetch(:batch_connect, {}).to_h.symbolize_keys
     end
 
     # Metadata that provides extra information about this cluster
@@ -81,6 +86,25 @@ module OodCore
         build_acls(job_config.fetch(:acls, []).map(&:to_h)).all?(&:allow?)
     end
 
+    # The batch connect template configuration used for this cluster
+    # @param template [#to_sym, nil] the template type
+    # @return [Hash] the batch connect configuration
+    def batch_connect_config(template = nil)
+      if template
+        @batch_connect_config.fetch(template.to_sym, {}).to_h.symbolize_keys.merge(template: template.to_sym)
+      else
+        @batch_connect_config
+      end
+    end
+
+    # Build a batch connect template from the respective configuration
+    # @param context [#to_h] the context used for rendering the template
+    # @return [BatchConnect::Template] the batch connect template
+    def batch_connect_template(context = {})
+      context = context.to_h.symbolize_keys
+      BatchConnect::Factory.build batch_connect_config(context[:template] || :basic).merge(context)
+    end
+
     # The configuration for any custom features or resources for this cluster
     # @param feature [#to_sym, nil] the feature or resource
     # @return [Hash] configuration for custom feature or resource
@@ -125,12 +149,13 @@ module OodCore
     # @return [Hash] the hash describing this object
     def to_h
       {
-        id:        id,
-        metadata:  metadata_config,
-        login:     login_config,
-        job:       job_config,
-        custom:    custom_config,
-        acls:      acls_config
+        id: id,
+        metadata: metadata_config,
+        login: login_config,
+        job: job_config,
+        custom: custom_config,
+        acls: acls_config,
+        batch_connect:  batch_connect_config
       }
     end
 

data/lib/ood_core/errors.rb

@@ -16,4 +16,10 @@ module OodCore
 
   # Raised when a job state is set to an invalid option
   class UnknownStateAttribute < Error; end
+
+  # Raised when template not specified in configuration
+  class TemplateNotSpecified < Error; end
+
+  # Raised when cannot find template specified in configuration
+  class TemplateNotFound < Error; end
 end

data/lib/ood_core/job/adapter.rb

@@ -4,6 +4,8 @@ module OodCore
     # submitting/statusing/holding/deleting jobs
     # @abstract
     class Adapter
+      using Refinements::ArrayExtensions
+
       # Submit a job with the attributes defined in the job template instance
       # @abstract Subclass is expected to implement {#submit}
       # @raise [NotImplementedError] if subclass did not define {#submit}
@@ -39,6 +41,15 @@ module OodCore
         raise NotImplementedError, "subclass did not define #info_all"
       end
 
+      # Retrieve info for all jobs for a given owner or owners from the
+      # resource manager
+      # @param owner [#to_s, Array<#to_s>] the owner(s) of the jobs
+      # @return [Array<Info>] information describing submitted jobs
+      def info_where_owner(owner)
+        owner = Array.wrap(owner).map(&:to_s)
+        info_all.select { |info| owner.include? info.job_owner }
+      end
+
       # Retrieve job info from the resource manager
       # @abstract Subclass is expected to implement {#info}
       # @raise [NotImplementedError] if subclass did not define {#info}

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

@@ -72,24 +72,9 @@ module OodCore
           afternotok = Array(afternotok).map(&:to_s)
           afterany   = Array(afterany).map(&:to_s)
 
-          args = []
-          args += ["-P", script.accounting_id] unless script.accounting_id.nil?
-          args += ["-cwd", script.workdir.to_s] unless script.workdir.nil?
-          args += ["-J", script.job_name] unless script.job_name.nil?
-
-          # TODO: dependencies
-
-          env = {
-            #TODO:
-            #LSB_HOSTS?
-            #LSB_MCPU_HOSTS?
-            #SNDJOBS_TO?
-            #
-          }
-
-          # Submit job
-          batch.submit_string(script.content, args: args, env: env)
+          kwargs = helper.batch_submit_args(script, after: after, afterok: afterok, afternotok: afternotok, afterany: afterany)
 
+          batch.submit_string(script.content, **kwargs)
         rescue Batch::Error => e
           raise JobAdapterError, e.message
         end
@@ -170,20 +155,29 @@ module OodCore
           end
 
           def info_for_batch_hash(v)
+            nodes = helper.parse_exec_host(v[:exec_host]).map do |host|
+              NodeInfo.new(name: host[:host], procs: host[:slots])
+            end
+
+            # FIXME: estimated_runtime should be set by batch object instead of
+            dispatch_time = helper.parse_past_time(v[:start_time], ignore_errors: true)
+            finish_time = helper.parse_past_time(v[:finish_time], ignore_errors: true)
+
             Info.new(
               id: v[:id],
               status: get_state(v[:status]),
-              allocated_nodes: [],
+              allocated_nodes: nodes,
               submit_host: v[:from_host],
               job_name: v[:name],
               job_owner: v[:user],
               accounting_id: v[:project],
-              procs: nil,
+              procs: nodes.any? ? nodes.map(&:procs).reduce(&:+) : 0,
               queue_name: v[:queue],
-              wallclock_time: nil,
-              cpu_time: nil,
+              wallclock_time: helper.estimate_runtime(current_time: Time.now, start_time: dispatch_time, finish_time: finish_time),
+              cpu_time: helper.parse_cpu_used(v[:cpu_used]),
+              # cpu_time: nil,
               submission_time: helper.parse_past_time(v[:submit_time], ignore_errors: true),
-              dispatch_time: helper.parse_past_time(v[:start_time], ignore_errors: true),
+              dispatch_time: dispatch_time,
               native: v
             )
           end

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

@@ -49,21 +49,24 @@ class OodCore::Job::Adapters::Lsf::Batch
     %w( -u all -a -w -W )
   end
 
-    # status fields available from bjobs
-    def fields
-      %i(id user status queue from_host exec_host name submit_time
-          project cpu_used mem swap pids start_time finish_time)
-    end
+  # status fields available from bjobs
+  def fields
+    %i(id user status queue from_host exec_host name submit_time
+        project cpu_used mem swap pids start_time finish_time)
+  end
 
   # helper method
   def parse_bjobs_output(response)
     return [] if response =~ /No job found/ || response.nil?
 
     lines = response.split("\n")
-    validate_bjobs_output_columns(lines.first.split)
+    columns = lines.shift.split
+
+    validate_bjobs_output_columns(columns)
+    jobname_column_idx = columns.find_index("JOB_NAME")
 
-    lines.drop(1).map{ |job|
-      values = split_bjobs_output_line(job)
+    lines.map{ |job|
+      values = split_bjobs_output_line(job, num_columns: columns.count, jobname_column_idx: jobname_column_idx)
 
       # make a hash of { field: "value", etc. }
       Hash[fields.zip(values)].each_with_object({}) { |(k,v),o|
@@ -135,13 +138,21 @@ class OodCore::Job::Adapters::Lsf::Batch
     end
 
     # split a line of output from bjobs into field values
-    def split_bjobs_output_line(line)
+    def split_bjobs_output_line(line, num_columns:, jobname_column_idx:)
       values = line.strip.split
 
-      if(values.count > 15)
-        # FIXME: hack assumes 15 fields & only job name may have spaces
-        # collapse >15 fields into 15, assumes 7th field is JOB_NAME
-        values = values[0..5] + [values[6..-9].join(" ")] + values[-8..-1]
+      if(values.count > num_columns)
+        # if the line has more fields than the number of columns, that means one
+        # field value has spaces, so it was erroneously split into
+        # multiple fields; we assume that is the jobname field, and we will
+        # collapse the fields into a single field
+        #
+        # FIXME: assumes jobname_column_idx is not first or last item
+        j = jobname_column_idx
+
+        # e.g. if 15 fields and jobname is 7th field
+        # values = values[0..5] + [values[6..-9].join(" ")] + values[-8..-1]
+        values = values[0..(j-1)] + [values[j..(j-num_columns)].join(" ")] + values[(j+1-num_columns)..-1]
       end
 
       values
@@ -151,9 +162,11 @@ class OodCore::Job::Adapters::Lsf::Batch
     def validate_bjobs_output_columns(columns)
       expected = %w(JOBID USER STAT QUEUE FROM_HOST EXEC_HOST JOB_NAME
                     SUBMIT_TIME PROJ_NAME CPU_USED MEM SWAP PIDS START_TIME FINISH_TIME)
-      if columns != expected
+      # (expected & columns) will return the columns that are the same
+      # so if there are extra columns we can just ignore those (like SLOTS in LSF 9.1)
+      if columns && ((expected & columns) != expected)
         raise Error, "bjobs output in different format than expected: " \
-          "#{columns.inspect} instead of #{expected.inspect}"
+          "#{columns.inspect} did not include all columns: #{expected.inspect}"
       end
     end
 

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

@@ -23,4 +23,83 @@ class OodCore::Job::Adapters::Lsf::Helper
 
     nil
   end
+
+  # convert exec_host string format from bjobs to a hash
+  # i.e. "c012" => [{host: "c012", slots: 1}]
+  # i.e. "4*c012:8*c013" => [{host: "c012", slots: 4}, {host: "c013", slots: 8}]
+  def parse_exec_host(exec_host_str)
+    return [] if exec_host_str.nil? || exec_host_str.empty?
+
+    exec_host_str.scan(exec_host_regex).map do |match|
+      {host: match[2], slots: match[1] ? match[1].to_i : 1}
+    end
+  end
+
+  def exec_host_regex
+    @exec_host_regex ||= Regexp.new(/((\d+)\*)?([^:]+)/)
+  end
+
+  # given current time, dispatch time, and finish time values, estimate the
+  # runtime for a job; this estimate will be accurate if the job never enters a
+  # suspended state during its execution
+  def estimate_runtime(current_time:, start_time:, finish_time:)
+    return nil if start_time.nil?
+
+    (finish_time || current_time) - start_time
+  end
+
+  # Convert CPU_USED string to seconds
+  #
+  # example strings of cpu_used in LSF 8.3:
+  #
+  # 060:24:00.00
+  # 046:19:37.00
+  # 1118:59:09.00
+  # 000:00:00.00
+  # 000:48:18.39
+  # 003:11:36.67
+  # 003:24:40.95
+  # 50769:48:00.-48
+  # 50835:48:48.-48
+  #
+  # my guess is: hours:minutes:seconds.????
+  #
+  # @return [Fixnum, nil] cpu used as seconds
+  def parse_cpu_used(cpu_used)
+    if cpu_used =~ /^(\d+):(\d+):(\d+)\..*$/
+      $1.to_i*3600 + $2.to_i*60 + $3.to_i
+    end
+  end
+
+  def batch_submit_args(script, after: [], afterok: [], afternotok: [], afterany: [])
+    args = []
+
+    args += ["-P", script.accounting_id] unless script.accounting_id.nil?
+    args += ["-cwd", script.workdir.to_s] unless script.workdir.nil?
+    args += ["-J", script.job_name] unless script.job_name.nil?
+    args += ["-q", script.queue_name] unless script.queue_name.nil?
+    args += ["-U", script.reservation_id] unless script.reservation_id.nil?
+    args += ["-sp", script.priority] unless script.priority.nil?
+    args += ["-H"] if script.submit_as_hold
+    args += (script.rerunnable ? ["-r"] : ["-rn"]) unless script.rerunnable.nil?
+    args += ["-b", script.start_time.localtime.strftime("%Y:%m:%d:%H:%M")] unless script.start_time.nil?
+    args += ["-W", (script.wall_time / 60).to_i] unless script.wall_time.nil?
+
+    # input and output files
+    args += ["-i", script.input_path] unless script.input_path.nil?
+    args += ["-o", script.output_path] unless script.output_path.nil?
+    args += ["-e", script.error_path] unless script.error_path.nil?
+
+    # email
+    args += ["-B"] if script.email_on_started
+    args += ["-N"] if script.email_on_terminated
+    args += ["-u", script.email.join(",")] unless script.email.nil? || script.email.empty?
+
+    args += script.native unless script.native.nil?
+
+    # environment
+    env = script.job_environment || {}
+
+    {args: args, env: env}
+  end
 end

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

@@ -0,0 +1,424 @@
+require "time"
+require "ood_core/refinements/hash_extensions"
+
+module OodCore
+  module Job
+    class Factory
+      using Refinements::HashExtensions
+
+      # Build the PBS Pro adapter from a configuration
+      # @param config [#to_h] the configuration for job adapter
+      # @option config [Object] :host (nil) The batch server host
+      # @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
+      def self.build_pbspro(config)
+        c = config.to_h.compact.symbolize_keys
+        host = c.fetch(:host, nil)
+        exec = c.fetch(:exec, nil)
+        qstat_factor = c.fetch(:qstat_factor, nil)
+        pbspro = Adapters::PBSPro::Batch.new(host: host, exec: exec)
+        Adapters::PBSPro.new(pbspro: pbspro, qstat_factor: qstat_factor)
+      end
+    end
+
+    module Adapters
+      # An adapter object that describes the communication with a PBS Pro
+      # resource manager for job management.
+      class PBSPro < Adapter
+        using Refinements::ArrayExtensions
+        using Refinements::HashExtensions
+
+        # Object used for simplified communication with a PBS Pro batch server
+        # @api private
+        class Batch
+          # The host of the PBS Pro batch server
+          # @example
+          #   my_batch.host #=> "my_batch.server.edu"
+          # @return [String, nil] the batch server host
+          attr_reader :host
+
+          # The path containing the PBS executables
+          # @example
+          #   my_batch.exec.to_s #=> "/usr/local/pbspro/10.0.0
+          # @return [Pathname, nil] path to pbs executables
+          attr_reader :exec
+
+          # The root exception class that all PBS Pro-specific exceptions
+          # inherit from
+          class Error < StandardError; end
+
+          # @param host [#to_s, nil] the batch server host
+          # @param exec [#to_s, nil] path to pbs executables
+          def initialize(host: nil, exec: nil)
+            @host = host && host.to_s
+            @exec = exec && Pathname.new(exec.to_s)
+          end
+
+          # Get a list of hashes detailing each of the jobs on the batch server
+          # @example Status info for all jobs
+          #   my_batch.get_jobs
+          #   #=>
+          #   #[
+          #   #  {
+          #   #    :account => "account",
+          #   #    :job_id => "my_job",
+          #   #    ...
+          #   #  },
+          #   #  {
+          #   #    :account => "account",
+          #   #    :job_id => "my_other_job",
+          #   #    ...
+          #   #  },
+          #   #  ...
+          #   #]
+          # @param id [#to_s] the id of the job
+          # @raise [Error] if `qstat` command exited unsuccessfully
+          # @return [Array<Hash>] list of details for jobs
+          def get_jobs(id: "")
+            args = ["-f"]   # display all information
+            args += ["-t"]  # list subjobs
+            args += [id.to_s] unless id.to_s.empty?
+            lines = call("qstat", *args).gsub("\n\t", "").split("\n").map(&:strip)
+
+            jobs = []
+            lines.each do |line|
+              if /^Job Id: (?<job_id>.+)$/ =~ line
+                jobs << { job_id: job_id }
+              elsif /^(?<key>[^\s]+) = (?<value>.+)$/ =~ line
+                hsh = jobs.last
+                k1, k2 = key.split(".").map(&:to_sym)
+                k2 ? ( hsh[k1] ||= {} and hsh[k1][k2] = value ) : ( hsh[k1] = value )
+              end
+            end
+            jobs.reject { |j| /\[\]/ =~ j[:job_id] } # drop main job array jobs
+          end
+
+          # Select batch jobs from the batch server
+          # @param args [Array<#to_s>] arguments passed to `qselect` command
+          # @raise [Error] if `qselect` command exited unsuccessfully
+          # @return [Array<String>] list of job ids that match selection
+          #   criteria
+          def select_jobs(args: [])
+            call("qselect", *args).split("\n").map(&:strip)
+          end
+
+          # Put a specified job on hold
+          # @example Put job "1234" on hold
+          #   my_batch.hold_job("1234")
+          # @param id [#to_s] the id of the job
+          # @raise [Error] if `qhold` command exited unsuccessfully
+          # @return [void]
+          def hold_job(id)
+            call("qhold", id.to_s)
+          end
+
+          # Release a specified job that is on hold
+          # @example Release job "1234" from on hold
+          #   my_batch.release_job("1234")
+          # @param id [#to_s] the id of the job
+          # @raise [Error] if `qrls` command exited unsuccessfully
+          # @return [void]
+          def release_job(id)
+            call("qrls", id.to_s)
+          end
+
+          # Delete a specified job from batch server
+          # @example Delete job "1234"
+          #   my_batch.delete_job("1234")
+          # @param id [#to_s] the id of the job
+          # @raise [Error] if `qdel` command exited unsuccessfully
+          # @return [void]
+          def delete_job(id)
+            call("qdel", id.to_s)
+          end
+
+          # Submit a script expanded as a string to the batch server
+          # @param str [#to_s] script as a string
+          # @param args [Array<#to_s>] arguments passed to `qsub` command
+          # @param chdir [#to_s, nil] working directory where `qsub` is called
+          # @raise [Error] if `qsub` command exited unsuccessfully
+          # @return [String] the id of the job that was created
+          def submit_string(str, args: [], chdir: nil)
+            call("qsub", *args, stdin: str.to_s, chdir: chdir).strip
+          end
+
+          private
+            # 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
+              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
+              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
+        end
+
+        # Mapping of state codes for PBSPro
+        STATE_MAP = {
+          'Q' => :queued,
+          'W' => :queued,         # job is waiting for its submitter-assigned start time to be reached
+          'H' => :queued_held,
+          'T' => :queued_held,    # job is being moved to a new location
+          'M' => :completed,      # job was moved to another server
+          'R' => :running,
+          'S' => :suspended,
+          'U' => :suspended,      # cycle-harvesting job is suspended due to keyboard activity
+          'E' => :running,        # job is exiting after having run
+          'F' => :completed,      # job is finished
+          'X' => :completed       # subjob has completed execution or has been deleted
+          # ignore B as it signifies a job array
+        }
+
+        # What percentage of jobs a user owns out of all jobs, used to decide
+        # whether we filter the owner's jobs from a `qstat` of all jobs or call
+        # `qstat` on each of the owner's individual jobs
+        # @return [Float] ratio of owner's jobs to all jobs
+        attr_reader :qstat_factor
+
+        # @api private
+        # @param opts [#to_h] the options defining this adapter
+        # @option opts [Batch] :pbspro The PBS Pro batch object
+        # @option opts [#to_f] :qstat_factor (0.10) The qstat deciding factor
+        # @see Factory.build_pbspro
+        def initialize(opts = {})
+          o = opts.to_h.compact.symbolize_keys
+
+          @pbspro = o.fetch(:pbspro) { raise ArgumentError, "No pbspro object specified. Missing argument: pbspro" }
+          @qstat_factor = o.fetch(:qstat_factor, 0.10).to_f
+        end
+
+        # Submit a job with the attributes defined in the job template instance
+        # @param script [Script] script object that describes the script and
+        #   attributes for the submitted job
+        # @param after [#to_s, Array<#to_s>] this job may be scheduled for
+        #   execution at any point after dependent jobs have started execution
+        # @param afterok [#to_s, Array<#to_s>] this job may be scheduled for
+        #   execution only after dependent jobs have terminated with no errors
+        # @param afternotok [#to_s, Array<#to_s>] this job may be scheduled for
+        #   execution only after dependent jobs have terminated with errors
+        # @param afterany [#to_s, Array<#to_s>] this job may be scheduled for
+        #   execution after dependent jobs have terminated
+        # @raise [JobAdapterError] if something goes wrong submitting a job
+        # @return [String] the job id returned after successfully submitting a
+        #   job
+        # @see Adapter#submit
+        def submit(script, after: [], afterok: [], afternotok: [], afterany: [])
+          after      = Array(after).map(&:to_s)
+          afterok    = Array(afterok).map(&:to_s)
+          afternotok = Array(afternotok).map(&:to_s)
+          afterany   = Array(afterany).map(&:to_s)
+
+          # Set qsub options
+          args = []
+          # ignore args, can't use these if submitting from STDIN
+          args += ["-h"] if script.submit_as_hold
+          args += ["-r", script.rerunnable ? "y" : "n"] unless script.rerunnable.nil?
+          args += ["-M", script.email.join(",")] unless script.email.nil?
+          if script.email_on_started && script.email_on_terminated
+            args += ["-m", "be"]
+          elsif script.email_on_started
+            args += ["-m", "b"]
+          elsif script.email_on_terminated
+            args += ["-m", "e"]
+          end
+          args += ["-N", script.job_name] unless script.job_name.nil?
+          # ignore input_path (not defined in PBS Pro)
+          args += ["-o", script.output_path] unless script.output_path.nil?
+          args += ["-e", script.error_path] unless script.error_path.nil?
+          # Reservations are actually just queues in PBS Pro
+          args += ["-q", script.reservation_id] if !script.reservation_id.nil? && script.queue_name.nil?
+          args += ["-q", script.queue_name] unless script.queue_name.nil?
+          args += ["-p", script.priority] unless script.priority.nil?
+          args += ["-a", script.start_time.localtime.strftime("%C%y%m%d%H%M.%S")] unless script.start_time.nil?
+          args += ["-A", script.accounting_id] unless script.accounting_id.nil?
+          args += ["-l", "walltime=#{seconds_to_duration(script.wall_time)}"] unless script.wall_time.nil?
+
+          # Set dependencies
+          depend = []
+          depend << "after:#{after.join(":")}"           unless after.empty?
+          depend << "afterok:#{afterok.join(":")}"       unless afterok.empty?
+          depend << "afternotok:#{afternotok.join(":")}" unless afternotok.empty?
+          depend << "afterany:#{afterany.join(":")}"     unless afterany.empty?
+          args += ["-W", "depend=#{depend.join(",")}"]   unless depend.empty?
+
+          # Set environment variables
+          envvars = script.job_environment.to_h
+          args += ["-v", envvars.map{|k,v| "#{k}=#{v}"}.join(",")] unless envvars.empty?
+
+          # If error_path is not specified we join stdout & stderr (as this
+          # mimics what the other resource managers do)
+          args += ["-j", "oe"] if script.error_path.nil?
+
+          # Set native options
+          args += script.native if script.native
+
+          # Submit job
+          @pbspro.submit_string(script.content, args: args, chdir: script.workdir)
+        rescue Batch::Error => e
+          raise JobAdapterError, e.message
+        end
+
+        # Retrieve info for all jobs from the resource manager
+        # @raise [JobAdapterError] if something goes wrong getting job info
+        # @return [Array<Info>] information describing submitted jobs
+        # @see Adapter#info_all
+        def info_all
+          @pbspro.get_jobs.map do |v|
+            parse_job_info(v)
+          end
+        rescue Batch::Error => e
+          raise JobAdapterError, e.message
+        end
+
+      # Retrieve info for all jobs for a given owner or owners from the
+      # resource manager
+      # @param owner [#to_s, Array<#to_s>] the owner(s) of the jobs
+      # @raise [JobAdapterError] if something goes wrong getting job info
+      # @return [Array<Info>] information describing submitted jobs
+      def info_where_owner(owner)
+        owner = Array.wrap(owner).map(&:to_s)
+
+        usr_jobs = @pbspro.select_jobs(args: ["-u", owner.join(",")])
+        all_jobs = @pbspro.select_jobs(args: ["-T"])
+
+        # `qstat` all jobs if user has too many jobs, otherwise `qstat` each
+        # individual job (default factor is 10%)
+        if usr_jobs.size > (qstat_factor * all_jobs.size)
+          super
+        else
+          usr_jobs.map { |id| info(id) }
+        end
+      end
+
+        # Retrieve job info from the resource manager
+        # @param id [#to_s] the id of the job
+        # @raise [JobAdapterError] if something goes wrong getting job info
+        # @return [Info] information describing submitted job
+        # @see Adapter#info
+        def info(id)
+          id = id.to_s
+          @pbspro.get_jobs(id: id).map do |v|
+            parse_job_info(v)
+          end.first || Info.new(id: id, status: :completed)
+        rescue Batch::Error => e
+          # set completed status if can't find job id
+          if /Unknown Job Id/ =~ e.message || /Job has finished/ =~ e.message
+            Info.new(
+              id: id,
+              status: :completed
+            )
+          else
+            raise JobAdapterError, e.message
+          end
+        end
+
+        # Retrieve job status from resource manager
+        # @param id [#to_s] the id of the job
+        # @raise [JobAdapterError] if something goes wrong getting job status
+        # @return [Status] status of job
+        # @see Adapter#status
+        def status(id)
+          info(id.to_s).status
+        end
+
+        # Put the submitted job on hold
+        # @param id [#to_s] the id of the job
+        # @raise [JobAdapterError] if something goes wrong holding a job
+        # @return [void]
+        # @see Adapter#hold
+        def hold(id)
+          @pbspro.hold_job(id.to_s)
+        rescue Batch::Error => e
+          # assume successful job hold if can't find job id
+          raise JobAdapterError, e.message unless /Unknown Job Id/ =~ e.message || /Job has finished/ =~ e.message
+        end
+
+        # Release the job that is on hold
+        # @param id [#to_s] the id of the job
+        # @raise [JobAdapterError] if something goes wrong releasing a job
+        # @return [void]
+        # @see Adapter#release
+        def release(id)
+          @pbspro.release_job(id.to_s)
+        rescue Batch::Error => e
+          # assume successful job release if can't find job id
+          raise JobAdapterError, e.message unless /Unknown Job Id/ =~ e.message || /Job has finished/ =~ e.message
+        end
+
+        # Delete the submitted job
+        # @param id [#to_s] the id of the job
+        # @raise [JobAdapterError] if something goes wrong deleting a job
+        # @return [void]
+        # @see Adapter#delete
+        def delete(id)
+          @pbspro.delete_job(id.to_s)
+        rescue Batch::Error => e
+          # assume successful job deletion if can't find job id
+          raise JobAdapterError, e.message unless /Unknown Job Id/ =~ e.message || /Job has finished/ =~ e.message
+        end
+
+        private
+          # Convert duration to seconds
+          def duration_in_seconds(time)
+            time.nil? ? nil : time.split(':').map { |v| v.to_i }.inject(0) { |total, v| total * 60 + v }
+          end
+
+          # Convert seconds to duration
+          def seconds_to_duration(time)
+            "%02d:%02d:%02d" % [time/3600, time/60%60, time%60]
+          end
+
+          # Convert host list string to individual nodes
+          # "hosta/J1+hostb/J2*P+..."
+          # where J1 and J2 are an index of the job on the named host and P is the number of
+          # processors allocated from that host to this job. P does not appear if it is 1.
+          # Example: "i5n14/2*7" uses 7 procs on node "i5n14"
+          def parse_nodes(node_list)
+            node_list.split('+').map do |n|
+              name, procs_list = n.split('/')
+              procs = (procs_list.split('*')[1] || 1).to_i
+              {name: name, procs: procs}
+            end
+          end
+
+          # Determine state from PBS Pro state code
+          def get_state(st)
+            STATE_MAP.fetch(st, :undetermined)
+          end
+
+          # Parse hash describing PBS Pro job status
+          def parse_job_info(v)
+            /^(?<job_owner>[\w-]+)@(?<submit_host>.+)$/ =~ v[:Job_Owner]
+            allocated_nodes = parse_nodes(v[:exec_host] || "")
+            procs = allocated_nodes.inject(0) { |sum, x| sum + x[:procs] }
+            if allocated_nodes.empty? # fill in with requested resources
+              allocated_nodes = [ { name: nil } ] * v.fetch(:Resource_List, {})[:nodect].to_i
+              procs = v.fetch(:Resource_List, {})[:ncpus].to_i
+            end
+            Info.new(
+              id: v[:job_id],
+              status: get_state(v[:job_state]),
+              allocated_nodes: allocated_nodes,
+              submit_host: submit_host,
+              job_name: v[:Job_Name],
+              job_owner: job_owner,
+              accounting_id: v[:Account_Name],
+              procs: procs,
+              queue_name: v[:queue],
+              wallclock_time: duration_in_seconds(v.fetch(:resources_used, {})[:walltime]),
+              wallclock_limit: duration_in_seconds(v.fetch(:Resource_List, {})[:walltime]),
+              cpu_time: duration_in_seconds(v.fetch(:resources_used, {})[:cput]),
+              submission_time: v[:ctime] ? Time.parse(v[:ctime]) : nil,
+              dispatch_time: v[:stime] ? Time.parse(v[:stime]) : nil,
+              native: v
+            )
+          end
+      end
+    end
+  end
+end