rbbt-util 5.39.0 → 5.40.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 12c5401cf3ecb8495ba5c21d0f3d3f35c741c1c335ffa0d3a7d3ee498f6daae8
-  data.tar.gz: 344f30b6651a272f5e9665d3ec6383b4a1d62ba7c64c7889af5cfc573b2285ac
+  metadata.gz: f88968adb433164ce6c0180298f95bc1560c4260b7095660f8179bc0cafe1b1a
+  data.tar.gz: 92ab9d09861bb5569f70b13f1cc444158f87141c0024e5c3c623f06c1387745e
 SHA512:
-  metadata.gz: 6e8305e1f3e74eeff9e5892592bc66bfc9aac3baa505503942b266c3de996408a9210fcfaa2f6073800fc763bf3cdf5b8f39a50a920696402657d2928a9add8f
-  data.tar.gz: 511c72833b4a8ef747e574376d44a3b4799f96f6a922301d3f405df1cd7aac79a2d2de388075aaab4fc3ef6962ee66ded3de8684227912399f41f7ad00006148
+  metadata.gz: 6f64d85276194d276312b128dad1a62caf3b1500317429f4be288f4b1d617c105e07552c8fd8d0ea79660fa4b9ff7430a26329b5abfae7656abc6d432931ecf5
+  data.tar.gz: c228bea1369c1ec574d98cc33dadd1845ddb9f65f69e0e334935ef2f25ddfa0ecf2cf0a040e097d32d3472df2a7d5b2509541914170b1f59c33610fa39d0fd96

data/lib/rbbt/hpc/batch.rb

@@ -1,5 +1,5 @@
 module HPC
-  class SBATCH < Exception; 
+  class BATCH_DRY_RUN < Exception; 
     attr_accessor :directory
     def initialize(directory)
       @directory = directory
@@ -12,24 +12,32 @@ module HPC
       HPC::SLURM
     when 'lsf'
       HPC::LSF
+    when 'pbs'
+      HPC::PBS
     when 'auto'
       case $previous_commands.last
       when 'slurm'
         HPC::SLURM
       when 'lsf'
         HPC::LSF
+      when 'pbs'
+        HPC::PBS
       else
         case Rbbt::Config.get(:batch_system, :batch, :batch_system, :hpc, :HPC, :BATCH).to_s.downcase
         when 'slurm'
           HPC::SLURM
         when 'lsf'
           HPC::LSF
+        when 'pbd'
+          HPC::PBS
         else
           case ENV["BATCH_SYSTEM"].to_s.downcase
           when 'slurm'
             HPC::SLURM
           when 'lsf'
             HPC::LSF
+          when 'pbs'
+            HPC::PBS
           end
         end
       end
@@ -564,8 +572,8 @@ env > #{batch_options[:fenv]}
     def run_job(job, options = {})
       system = self.to_s.split("::").last
 
-      batch_base_dir, clean_batch_job, remove_batch_dir, procpath, tail, batch_dependencies, dry_run = Misc.process_options options, 
-        :batch_base_dir, :clean_batch_job, :remove_batch_dir, :batch_procpath, :tail, :batch_dependencies, :dry_run,
+      batch_base_dir, clean_batch_job, remove_batch_dir, procpath, tail, batch_dependencies, dry_run, orchestration_rules_file = Misc.process_options options, 
+        :batch_base_dir, :clean_batch_job, :remove_batch_dir, :batch_procpath, :tail, :batch_dependencies, :dry_run, :orchestration_rules,
         :batch_base_dir => File.expand_path(File.join('~/rbbt-batch')) 
 
       if (batch_job = job.info[:batch_job]) && job_queued(batch_job)
@@ -586,6 +594,8 @@ env > #{batch_options[:fenv]}
       workflow = job.original_workflow ||job.workflow
       task_name = job.original_task_name || job.task_name
 
+      options = options.merge(HPC::Orchestration.job_rules(HPC::Orchestration.orchestration_rules(orchestration_rules_file), job)) if orchestration_rules_file
+
       workflows_to_load = job.rec_dependencies.select{|d| Step === d}.collect{|d| d.workflow }.compact.collect(&:to_s) - [workflow.to_s]
 
       TmpFile.with_file(nil, remove_batch_dir, :tmpdir => batch_base_dir, :prefix => "#{system}_rbbt_job-#{workflow.to_s}-#{task_name}-") do |batch_dir|

data/lib/rbbt/hpc/lsf.rb

@@ -99,7 +99,7 @@ export BATCH_SYSTEM=#{batch_system}
         elsif dry_run
           STDERR.puts Log.color(:magenta, "To execute run: ") + Log.color(:blue, cmd)
           STDERR.puts Log.color(:magenta, "To monitor progress run (needs local rbbt): ") + Log.color(:blue, "rbbt lsf tail '#{batch_dir}'")
-          raise HPC::SBATCH, batch_dir
+          raise HPC::BATCH_DRY_RUN, batch_dir
         else
           Open.rm fsync
           Open.rm fexit

data/lib/rbbt/hpc/orchestrate/rules.rb

@@ -65,6 +65,13 @@ module HPC
       merge_rules(rules[workflow][task], workflow_rules)
     end
 
-
+    def self.job_rules(rules, job)
+      return {} if job.done? or job.error?
+      job_rules = task_specific_rules(rules, job.workflow.to_s, job.task_name.to_s)
+      job.dependencies.each do |dep|
+        job_rules = accumulate_rules(job_rules, job_rules(rules, dep))
+      end
+      job_rules
+    end
   end
 end

data/lib/rbbt/hpc/orchestrate.rb

@@ -22,6 +22,25 @@ module HPC
 
     end
 
+    def self.orchestration_rules(orchestration_rules_file = nil)
+      rules = {}
+      if orchestration_rules_file
+        if Open.exists?(orchestration_rules_file)
+          rules = Misc.load_yaml(orchestration_rules_file)
+        elsif Rbbt.etc.batch[orchestration_rules_file].exists?
+          rules = Misc.load_yaml(Rbbt.etc.batch[orchestration_rules_file])
+        elsif Rbbt.etc.batch[orchestration_rules_file + '.yaml'].exists?
+          rules = Misc.load_yaml(Rbbt.etc.batch[orchestration_rules_file + '.yaml'])
+        else
+          raise "Orchestration rules file not found: #{orchestration_rules_file}"
+        end
+      elsif Rbbt.etc.batch["default.yaml"].exists?
+        rules = Misc.load_yaml(Rbbt.etc.batch["default.yaml"])
+      end
+
+      IndiferentHash.setup(rules)
+    end
+
     def orchestrate_job(job, options)
       options.delete "recursive_clean"
       options.delete "clean_task"
@@ -33,26 +52,11 @@ module HPC
       options.delete "load_inputs"
       options.delete "provenance"
 
+
       Log.high "Prepare for exec"
       prepare_for_execution(job)
 
-      if orchestration_rules_file = options[:orchestration_rules]
-        if Open.exists?(orchestration_rules_file)
-          rules = Misc.load_yaml(orchestration_rules_file)
-        elsif Rbbt.etc.slurm(orchestration_rules_file).exists?
-          rules = Misc.load_yaml(Rbbt.etc.slurm(orchestration_rules_file))
-        elsif Rbbt.etc.slurm(orchestration_rules_file + '.yaml').exists?
-          rules = Misc.load_yaml(Rbbt.etc.slurm(orchestration_rules_file + '.yaml'))
-        else
-          raise "Orchestration rules file not found: #{options[:orchestration_rules]}"
-        end
-      elsif Rbbt.etc.slurm["default.yaml"].exists?
-        rules = Misc.load_yaml(Rbbt.etc.slurm["default.yaml"])
-      else
-        rules = {}
-      end
-
-      IndiferentHash.setup(rules)
+      rules = HPC::Orchestration.orchestration_rules(options[:orchestration_rules])
 
       batches = HPC::Orchestration.job_batches(rules, job)
       Log.high "Compute #{batches.length} batches"

data/lib/rbbt/hpc/pbs.rb

@@ -0,0 +1,179 @@
+require 'rbbt/hpc/batch'
+require 'rbbt/hpc/orchestrate'
+
+module HPC
+  module PBS 
+    extend HPC::TemplateGeneration
+    extend HPC::Orchestration
+
+    def self.batch_system
+      "PBS"
+    end
+
+    def self.batch_system_variables
+      <<-EOF
+let TOTAL_PROCESORS="$(cat /proc/cpuinfo|grep ^processor |wc -l)"
+let MAX_MEMORY_DEFAULT="$(grep MemTotal /proc/meminfo|grep -o "[[:digit:]]*") / ( (1024 * $TOTAL_PROCESORS) / $PBS_CPUS_PER_TASK )"
+MAX_MEMORY="$MAX_MEMORY_DEFAULT"
+[ ! -z $PBS_MEM_PER_CPU ] && let MAX_MEMORY="$PBS_MEM_PER_CPU * $PBS_CPUS_PER_TASK" 
+[ ! -z $PBS_MEM_PER_NODE ] && MAX_MEMORY="$PBS_MEM_PER_NODE"
+export MAX_MEMORY_DEFAULT
+export MAX_MEMORY
+export BATCH_JOB_ID=$PBS_JOBID
+export BATCH_SYSTEM=#{batch_system}
+
+cd ${PBS_O_WORKDIR}
+      EOF
+    end
+
+    def self.header(options = {})
+      options = options.dup
+
+      workdir    = Misc.process_options options, :workdir
+      batch_dir  = Misc.process_options options, :batch_dir
+      batch_name = Misc.process_options options, :batch_name
+
+      queue      = Misc.process_options options, :queue
+      account    = Misc.process_options options, :account
+      time       = Misc.process_options options, :time
+      nodes      = Misc.process_options options, :nodes
+
+      # PBS 
+      place      = Misc.process_options options, :place, :place => 'scatter'
+      system     = Misc.process_options options, :partition
+      filesystems = Misc.process_options options, :filesystems
+
+      filesystems = "home" if filesystems.nil?
+
+      filesystems = filesystems * "," if Array === filesystems
+
+      # NOT USED 
+      partition  = Misc.process_options options, :partition
+      task_cpus  = Misc.process_options options, :task_cpus
+      exclusive  = Misc.process_options options, :exclusive
+      highmem    = Misc.process_options options, :highmem
+      licenses   = Misc.process_options options, :licenses
+      constraint = Misc.process_options options, :constraint
+      gres       = Misc.process_options options, :gres
+
+      constraint     = [constraint, "highmem"].compact * "&" if highmem
+
+      mem            = Misc.process_options options, :mem
+      mem_per_cpu    = Misc.process_options options, :mem_per_cpu
+
+      fout       = File.join(batch_dir, 'std.out')
+      ferr       = File.join(batch_dir, 'std.err')
+
+      time = Misc.format_seconds Misc.timespan(time) unless time.include? ":"
+
+      qsub_params = {  "-l filesystems=" => filesystems,
+                       "-l system=" => system,
+                       "-l select=" => nodes,
+                       "-l place=" => place,
+                       "-l walltime=" => time,
+                       "-q " => queue,
+                       "-A " => account,
+                       "-o " => fout,
+                       "-e " => ferr,
+                       "-k doe" => true,
+                       # "cpus-per-task" => task_cpus,
+                       # "nodes" => nodes,
+                       # "time" => time,
+                       # "constraint" => constraint,
+                       # "exclusive" => exclusive,
+                       # "licenses" => licenses,
+                       # "gres" => gres,
+                       # "mem" => mem,
+                       # "mem-per-cpu" => mem_per_cpu,
+      }
+
+
+      header =<<-EOF
+#!/bin/bash
+      EOF
+
+      qsub_params.each do |name,value|
+        next if value.nil? || value == ""
+        if TrueClass === value
+          header << "#PBS #{name}" << "\n"
+        elsif Array === value
+          value.each do |v|
+            header << "#PBS #{name}\"#{v}\"" << "\n"
+          end
+        else
+          header << "#PBS #{name}\"#{value}\"" << "\n"
+        end
+      end
+
+      header
+    end
+
+    def self.run_template(batch_dir, dry_run)
+
+      fout   = File.join(batch_dir, 'std.out')
+      ferr   = File.join(batch_dir, 'std.err')
+      fjob   = File.join(batch_dir, 'job.id')
+      fdep   = File.join(batch_dir, 'dependencies.list')
+      fcfdep = File.join(batch_dir, 'canfail_dependencies.list')
+      fexit  = File.join(batch_dir, 'exit.status')
+      fsync  = File.join(batch_dir, 'sync.log')
+      fcmd   = File.join(batch_dir, 'command.batch')
+
+      return if Open.exists?(fexit)
+
+      Log.info "Issuing PBS file: #{fcmd}"
+      Log.debug Open.read(fcmd)
+
+      if File.exist?(fjob)
+        job = Open.read(fjob).to_i
+      else
+
+        dependencies = Open.read(fdep).split("\n") if File.exist? fdep
+        canfail_dependencies = Open.read(fcfdep).split("\n") if File.exist? fcfdep
+
+        normal_dep_str = dependencies && dependencies.any? ? "afterok:" + dependencies * ":" : nil
+        canfail_dep_str = canfail_dependencies && canfail_dependencies.any? ? "afterany:" + canfail_dependencies * ":" : nil
+
+        if normal_dep_str.nil? && canfail_dep_str.nil?
+          dep_str = ""
+        else
+          dep_str = '-W depend=' + [normal_dep_str, canfail_dep_str].compact * ","
+        end
+
+        cmd = "qsub #{dep_str} '#{fcmd}'"
+
+        if File.exist?(fout)
+          return
+        elsif dry_run
+          STDERR.puts Log.color(:magenta, "To execute run: ") + Log.color(:blue, "squb '#{fcmd}'")
+          STDERR.puts Log.color(:magenta, "To monitor progress run (needs local rbbt): ") + Log.color(:blue, "rbbt pbs tail '#{batch_dir}'")
+          raise HPC::BATCH_DRY_RUN, batch_dir
+        else
+          Open.rm fsync
+          Open.rm fexit
+          Open.rm fout
+          Open.rm ferr
+
+          job = CMD.cmd(cmd).read.scan(/\d+/).first.to_i
+          Log.debug "SBATCH job id: #{job}"
+          Open.write(fjob, job.to_s)
+          job
+        end
+      end
+    end
+
+    def self.job_status(job = nil)
+      if job.nil?
+        CMD.cmd("qstat").read
+      else
+        begin
+          CMD.cmd("qstat #{job}").read
+        rescue
+          ""
+        end
+      end
+    end
+
+  end
+end
+

data/lib/rbbt/hpc/slurm.rb

@@ -130,7 +130,7 @@ export BATCH_SYSTEM=#{batch_system}
         elsif dry_run
           STDERR.puts Log.color(:magenta, "To execute run: ") + Log.color(:blue, "sbatch '#{fcmd}'")
           STDERR.puts Log.color(:magenta, "To monitor progress run (needs local rbbt): ") + Log.color(:blue, "rbbt slurm tail '#{batch_dir}'")
-          raise HPC::SBATCH, batch_dir
+          raise HPC::BATCH_DRY_RUN, batch_dir
         else
           Open.rm fsync
           Open.rm fexit

data/lib/rbbt/hpc.rb

@@ -4,3 +4,4 @@ require 'rbbt/hpc/batch'
 require 'rbbt/hpc/orchestrate'
 require 'rbbt/hpc/slurm'
 require 'rbbt/hpc/lsf'
+require 'rbbt/hpc/pbs'

data/lib/rbbt/resource/util.rb

@@ -1,6 +1,6 @@
 module Path
 
-  def self.caller_lib_dir(file = nil, relative_to = ['lib', 'bin'])
+  def self.caller_lib_dir(file = nil, relative_to = ['lib', 'bin', 'LICENSE'])
     #file = caller.reject{|l| 
     #  l =~ /rbbt\/(?:resource\.rb|workflow\.rb)/ or
     #  l =~ /rbbt\/resource\/path\.rb/ or

data/lib/rbbt/util/R/plot.rb

@@ -1,6 +1,91 @@
 module R
   module SVG
 
+    def self.plot(filename, data = nil, script = nil, width = nil, height = nil, options = {}, &block)
+      width ||= 600
+      height ||= 600
+      values = []
+
+      script ||= ""
+      if block_given?
+        s = StringIO.new
+        class << s
+          def method_missing(name, *args)
+            name = name.to_s
+            if name[-1] == '='
+              arg = args.first
+              value = if String === arg
+                        arg
+                      else
+                        R.ruby2R arg
+                      end
+              add("" << name[0..-2] << "=" << value)
+            else
+              args_strs = []
+              args.each do |arg|
+                value = if String === arg
+                          arg
+                        else
+                          R.ruby2R arg
+                        end
+                args_strs << value
+              end
+              add("" << name << "(" << args_strs * ", " << ")")
+            end
+          end
+
+          def add(line)
+            self.write line << "\n"
+          end
+        end
+        block.call(s)
+        s.rewind
+        script << "\n" << s.read
+      end
+      sources = [:plot, options[:source]].flatten.compact
+      
+      if data
+        data.each do |k,v|
+          v = Array === v ? v : [v]
+          next if v == "NA" or v.nil? or v.include? "NA" or v.include? nil
+          values = v
+          break
+        end 
+
+        values = [values] unless values.nil? or Array === values
+
+        field_classes = values.collect do |v| 
+          case v
+          when FalseClass, TrueClass
+            "'logical'"
+          when Numeric
+            "'numeric'"
+          when String
+            if v.strip =~ /^[-+]?[\d\.]+$/
+              "'numeric'"
+            else
+              "'character'"
+            end
+          when Symbol
+            "'factor'"
+          else
+            ":NA"
+          end
+        end
+
+        options[:R_open] ||= "colClasses=c('character'," + field_classes * ", " + ')' if field_classes.any?
+
+        data.R <<-EOF, :plot, options
+  rbbt.svg_plot("#{ filename }", width=#{ width }, height = #{ height }, function(){ #{script} })
+  data = NULL
+        EOF
+      else
+        R.run <<-EOF, :plot, options
+  rbbt.svg_plot("#{ filename }", width=#{ width }, height = #{ height }, function(){ #{script} })
+        EOF
+      end
+    end
+
     def self.ggplotSVG(*args)
       ggplot(*args)
     end

data/lib/rbbt/util/misc/development.rb

@@ -1,6 +1,6 @@
 module Misc
 
-def self.add_libdir(dir=nil)
+  def self.add_libdir(dir=nil)
     dir ||= File.join(Path.caller_lib_dir(caller.first), 'lib')
     $LOAD_PATH.unshift(dir) unless $LOAD_PATH.include? dir
   end

data/lib/rbbt/util/python/step.rb

@@ -0,0 +1,41 @@
+require 'rbbt/workflow/step'
+
+class Step
+  def python_file(file, options = {})
+    CMD.cmd_log(:python, file, options)
+  end
+
+  def python_block(options = {}, &block)
+    RbbtPython.run options, &block
+  end
+
+  def python(python = nil, options = {}, &block)
+    begin
+      RbbtPython.add_path self.workflow.libdir.python.find
+    rescue
+      Log.warn "Error loading libdir python for workflow '#{Misc.fingerprint self.workflow}'"
+    end
+    case python
+    when Path
+      python_file python.find, options
+    when String
+      if Open.exists?(python)
+        python_file python
+      else
+        TmpFile.with_file do |dir|
+          pkg = "pkg#{rand(100)}"
+          Open.write File.join(dir, "#{pkg}/__init__.py"), code
+
+          RbbtPython.add_path dir
+
+          Misc.in_dir dir do
+            yield pkg
+          end
+        end
+      end
+    else
+      python_block(python, &block)
+    end
+  end
+end
+

data/lib/rbbt/util/python/util.rb

@@ -49,5 +49,5 @@ module RbbtPython
     end
     hash
   end
-
 end
+

data/python/rbbt.py

@@ -29,6 +29,7 @@ def tsv_preamble(line, comment_char="#"):
     entries = re.sub(f"^{comment_char}:", '', line)
     entries = re.sub(f"^{comment_char}:", '', line).split("#")
     for entry in entries:
+        entry = entry.strip()
         key, value = entry.split("=")
         key = re.sub("^:","",key)
         value = re.sub("^:","",value)
@@ -75,7 +76,13 @@ def tsv_pandas(filename, sep="\t", comment_char="#", index_col=0, **kwargs):
         header = tsv_header(filename, sep=sep, comment_char="#")
 
         if ("type" in header and header["type"] == "flat"):
-            return None
+            if ("sep" in header):
+                sep=header["sep"]
+
+            tsv = pandas.read_table(filename, sep=sep, index_col=index_col, header=None, skiprows=[0,1], **kwargs)
+
+            if ("key_field" in header):
+                tsv.index.name = header["key_field"]
         else:
             if ("sep" in header):
                 sep=header["sep"]

data/share/Rlib/util.R

@@ -577,6 +577,16 @@ rbbt.get.modes <- function(x,bw = NULL,spar = NULL) {
 
 #{{{ PLOTS
 
+rbbt.svg_plot <- function(filename, p, width=500, height=500, ...){
+    svg(filename=filename, width=width, height=height, ...);
+    if (is.function(p)) {
+      p()
+    }else{
+      eval(parse(text=p));
+    }
+    dev.off()
+}
+
 rbbt.png_plot <- function(filename, p, width=500, height=500, ...){
     png(filename=filename, width=width, height=height, type='cairo', ...);
     if (is.function(p)) {
@@ -751,6 +761,8 @@ rbbt.plot.venn <- function(data, a=NULL, category=NULL, fill=NULL, ...) {
       fill=rbbt.plot.set_colors(dim(data)[2], "Set3")
     }
 
+    fill=fill[0:dim(data)[2]]
+
     group.matches <- function(data, fields) {
         sub = data
         for (i in 1:length(fields)) {

data/share/rbbt_commands/hpc/list

@@ -253,6 +253,8 @@ workdir.glob("**/command.batch").sort_by{|f| File.mtime(f)}.each do |fcmd|
       text = CMD.cmd('grep "^#SBATCH" ', :in => Open.read(fcmd)).read.strip
     when 'lsf'
       text = CMD.cmd('grep "^#BSUB" ', :in => Open.read(fcmd)).read.strip
+    when 'pbs'
+      text = CMD.cmd('grep "^#PBS" ', :in => Open.read(fcmd)).read.strip
     else
       text = ""
     end

data/share/rbbt_commands/hpc/orchestrate

@@ -73,7 +73,7 @@ class Step
           join
           self.load
         end
-      rescue HPC::SBATCH
+      rescue HPC::BATCH_DRY_RUN
       end
     end
   end

data/share/rbbt_commands/hpc/task

@@ -32,16 +32,17 @@ $slurm_options = SOPT.get <<EOF
 -p--partition* Partition
 -t--task_cpus* Tasks
 -tm--time* Time
--m--mem* SLURM minimum memory
---gres* SLURM Generic resources
--mcpu--mem_per_cpu* SLURM minimum memory per CPU
--lin--licenses* SLURM licenses
--cons--constraint* SLURM constraint
+-m--mem* minimum memory
+--gres* Generic resources
+-mcpu--mem_per_cpu* minimum memory per CPU
+-lin--licenses* licenses
+-cons--constraint* constraint
 -W--workflows* Additional workflows
 -rmb--remove_batch_dir Remove the batch working directory (command, STDIN, exit status, ...)
 -bs--batch_system* Batch system to use: auto, lsf, slurm (default is auto-detect)
 -lmod--lua_modules* Lua Modules to load 
 -co--conda* Conda environment to use
+-OR--orchestration_rules* Orchestration rules
 EOF
 
 batch_system = $slurm_options.delete :batch_system
@@ -58,9 +59,9 @@ class Step
       self.load
     else
       begin
-        Log.debug "Issuing SLURM job for #{self.path}"
+        Log.debug "Issuing BATCH job for #{self.path}"
         HPC::BATCH_MODULE.run_job(self, $slurm_options) 
-      rescue HPC::SBATCH
+      rescue HPC::BATCH_DRY_RUN
       end
     end
   end

data/share/rbbt_commands/lsf/list

@@ -253,6 +253,8 @@ workdir.glob("**/command.batch").sort_by{|f| File.mtime(f)}.each do |fcmd|
       text = CMD.cmd('grep "^#SBATCH" ', :in => Open.read(fcmd)).read.strip
     when 'lsf'
       text = CMD.cmd('grep "^#BSUB" ', :in => Open.read(fcmd)).read.strip
+    when 'pbs'
+      text = CMD.cmd('grep "^#PBS" ', :in => Open.read(fcmd)).read.strip
     else
       text = ""
     end

data/share/rbbt_commands/lsf/orchestrate

@@ -73,7 +73,7 @@ class Step
           join
           self.load
         end
-      rescue HPC::SBATCH
+      rescue HPC::BATCH_DRY_RUN
       end
     end
   end

data/share/rbbt_commands/lsf/task

@@ -32,16 +32,17 @@ $slurm_options = SOPT.get <<EOF
 -p--partition* Partition
 -t--task_cpus* Tasks
 -tm--time* Time
--m--mem* SLURM minimum memory
---gres* SLURM Generic resources
--mcpu--mem_per_cpu* SLURM minimum memory per CPU
--lin--licenses* SLURM licenses
--cons--constraint* SLURM constraint
+-m--mem* minimum memory
+--gres* Generic resources
+-mcpu--mem_per_cpu* minimum memory per CPU
+-lin--licenses* licenses
+-cons--constraint* constraint
 -W--workflows* Additional workflows
 -rmb--remove_batch_dir Remove the batch working directory (command, STDIN, exit status, ...)
 -bs--batch_system* Batch system to use: auto, lsf, slurm (default is auto-detect)
 -lmod--lua_modules* Lua Modules to load 
 -co--conda* Conda environment to use
+-OR--orchestration_rules* Orchestration rules
 EOF
 
 batch_system = $slurm_options.delete :batch_system
@@ -58,9 +59,9 @@ class Step
       self.load
     else
       begin
-        Log.debug "Issuing SLURM job for #{self.path}"
+        Log.debug "Issuing BATCH job for #{self.path}"
         HPC::BATCH_MODULE.run_job(self, $slurm_options) 
-      rescue HPC::SBATCH
+      rescue HPC::BATCH_DRY_RUN
       end
     end
   end