rbbt-util 5.30.2 → 5.30.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 649eff7bb5d00dd4bf47e39c8e7aba41279f0318d97289aae42e2f404eee7969
-  data.tar.gz: cb215144a707557db37b8e160c860622676ef2f29aa395d15813d28b7c8ba233
+  metadata.gz: 3275cafa7bc74ca88f5d487287ff736113dad5ee6e607bb13f283bb4aa5e0562
+  data.tar.gz: 1a7642c60ce3f3828790599c2522ad1e083bd877c53de10401b93735e952934d
 SHA512:
-  metadata.gz: 34b782a247f1816cd57b6acfef861a84f1d0003376e048b1c441c841cee7abe09b2a7d9d858eaa99bef8f2dfdbdb88352d0c8b6bef5cfec4a72a79e75f24db61
-  data.tar.gz: 5a1bc971d33e35eb7e9b57e258d705393dfac17896ad68dabd58f0584ede460bcccbced20a68ac7a5250fc03932357ef185d1f9908b798691dde85d3cf173c35
+  metadata.gz: bc9717f6611646c099305587bdcf224243102a500ba68047e382df49e583a3c764489e09b7c9aa4993eab3953d72dc9ce206d5450213e1ae832b1622c96fd309
+  data.tar.gz: 791cdba47b74e1f1fd47c439bb3f2b025e540002ec2b1e18d846bab08c6fd858cc25a94f9c84056383c5125cca22c19f00d43ae0c53a8c77ef4de423c19f0d8c

data/lib/rbbt/hpc/orchestrate.rb

@@ -5,7 +5,10 @@ module HPC
     def self.job_rules(rules, job)
       workflow = job.workflow.to_s
       task_name = job.task_name.to_s
+      task_name = job.overriden.to_s if Symbol === job.overriden
+
       defaults = rules["defaults"] || {}
+      defaults = defaults.merge(rules[workflow]["defaults"] || {}) if rules[workflow]
 
       job_rules = IndiferentHash.setup(defaults.dup)
 
@@ -50,47 +53,88 @@ module HPC
       job_rules
     end
 
-    def self.get_job_dependencies(job, job_rules)
+    def self.get_job_dependencies(job, job_rules = nil)
       deps = job.dependencies || []
       deps += job.input_dependencies || []
       deps
     end
 
-    def self.orchestrate_job(job, options, skip = false, seen = {})
-      return if job.done?
-      return unless job.path.split("/")[-4] == "jobs"
-      seen[:orchestration_target_job] ||= job
-
-      options.delete "recursive_clean"
-      options.delete "clean_task"
-      options.delete "clean"
-      options.delete "tail"
-      options.delete "printfile"
-      options.delete "detach"
+    def self.get_recursive_job_dependencies(job)
+      deps = get_job_dependencies(job) 
+      (deps + deps.collect{|dep| get_recursive_job_dependencies(dep) }).flatten
+    end
 
-      rules = YAML.load(Open.read(options[:orchestration_rules])) if options[:orchestration_rules]
-      rules ||= {}
-      IndiferentHash.setup(rules)
+    def self.piggyback(job, job_rules, job_deps)
+      return false unless job_rules["skip"]
+      final_deps = job_deps - job_deps.collect{|dep| get_recursive_job_dependencies(dep)}.flatten.uniq
+      return final_deps.first if final_deps.length == 1
+      return false
+    end
 
+    def self.get_chains(job, rules, chains = {})
       job_rules = self.job_rules(rules, job)
+      job_deps = get_job_dependencies(job)
+
+      input_deps = []
+      job.rec_dependencies.each do |dep|
+        input_deps.concat dep.input_dependencies
+      end
 
-      deps = get_job_dependencies(job, job_rules)
+      job_deps.each do |dep|
+        input_deps.concat dep.input_dependencies
+        get_chains(dep, rules, chains)
+      end
 
-      dep_ids = deps.collect do |dep|
-        skip_dep = job_rules["chain_tasks"] &&
+      job_deps.select do |dep|
+        chained = job_rules["chain_tasks"] &&
           job_rules["chain_tasks"][job.workflow.to_s] && job_rules["chain_tasks"][job.workflow.to_s].include?(job.task_name.to_s)  &&
           job_rules["chain_tasks"][dep.workflow.to_s] && job_rules["chain_tasks"][dep.workflow.to_s].include?(dep.task_name.to_s) 
 
-        deps = seen[dep.path] ||= self.orchestrate_job(dep, options, skip_dep, seen)
-        if job.canfail_paths.include? dep.path
-          [deps].flatten.compact.collect{|id| ['canfail', id] * ":"}
+        dep_skip = dep.done? && ! input_deps.include?(dep) && self.job_rules(rules, dep)["skip"] 
+        chained || dep_skip
+      end.each do |dep|
+        chains[job] ||= [] 
+        chains[job] << dep 
+        chains[job].concat chains[dep] if chains[dep]
+      end
+
+      chains
+    end
+
+    def self.workload(job, rules, chains, options, seen = nil)
+      return [] if job.done?
+      if seen.nil?
+        seen = {} 
+        target_job = true
+      end
+
+      job_rules = self.job_rules(rules, job)
+      job_deps = get_job_dependencies(job)
+
+
+      chain = chains[job]
+      chain -= seen.keys if chain
+      piggyback = piggyback(job, job_rules, job_deps)
+      dep_ids = job_deps.collect do |dep|
+        seen[dep] = nil if chain && chain.include?(dep) #&& ! job.input_dependencies.include?(dep) 
+        next_options = IndiferentHash.setup(options.dup)
+        if piggyback and piggyback == dep
+          next_options[:piggyback] ||= []
+          next_options[:piggyback].push job
+          ids = workload(dep, rules, chains, next_options, seen)
         else
-          deps
+          next_options.delete :piggyback
+          ids = workload(dep, rules, chains, next_options, seen)
         end
-      end.flatten.compact.uniq
 
-      skip = true if job_rules[:skip]
-      return dep_ids if skip and seen[:orchestration_target_job] != job
+        ids = [ids].flatten.compact.collect{|id| ['canfail', id] * ":"} if job.canfail_paths.include? dep.path
+
+        seen[dep] = ids
+        ids
+      end.compact.flatten.uniq
+
+      return seen[job] || dep_ids if seen.include?(job) 
+      return seen[piggyback] if piggyback
 
       job_rules.delete :chain_tasks
       job_rules.delete :tasks
@@ -105,7 +149,48 @@ module HPC
         job_options[:config_keys] = job_options[:config_keys] ? config_keys + "," + job_options[:config_keys] : config_keys
       end
 
-      run_job(job, job_options)
+
+      if options[:piggyback]
+        manifest = options[:piggyback].uniq
+        manifest += [job]
+        manifest.concat chain if chain
+        job = options[:piggyback].first
+        job_options.delete :piggyback
+      else
+        manifest = [job]
+        manifest.concat chain if chain
+      end
+
+      manifest.uniq!
+
+      job_options[:manifest] = manifest.collect{|j| j.workflow_short_path }
+
+      if options[:dry_run]
+        puts Log.color(:magenta, "Manifest: ") + Log.color(:blue, job_options[:manifest] * ", ") + " - tasks: #{job_options[:task_cpus] || 1} - time: #{job_options[:time]} - config: #{job_options[:config_keys]}"
+        puts Log.color(:yellow, "Deps: ") + Log.color(:blue, job_options[:slurm_dependencies]*", ")
+        job_options[:manifest].first
+      else
+        run_job(job, job_options)
+      end
     end
+
+
+    def self.orchestrate_job(job, options)
+      options.delete "recursive_clean"
+      options.delete "clean_task"
+      options.delete "clean"
+      options.delete "tail"
+      options.delete "printfile"
+      options.delete "detach"
+
+      rules = YAML.load(Open.read(options[:orchestration_rules])) if options[:orchestration_rules]
+      rules ||= {}
+      IndiferentHash.setup(rules)
+
+      chains = get_chains(job, rules)
+
+      workload(job, rules, chains, options)
+    end
+
   end
 end

data/lib/rbbt/hpc/slurm.rb

@@ -21,10 +21,12 @@ module HPC
       exclusive        = options.delete :exclusive
       highmem          = options.delete :highmem
 
-      queue            = options.delete(:queue) || 'bsc_ls'
+      manifest         = options.delete :manifest
+
+      queue            = options.delete(:queue) || Rbbt::Config.get('queue', :slurm_queue, :slurm, :SLURM, :default => 'bsc_ls')
       task_cpus        = options.delete(:task_cpus) || 1
       nodes            = options.delete(:nodes) || 1
-      time             = options.delete(:time) || "0:00:10"
+      time             = options.delete(:time) || "0:02:00"
 
       inputs_dir       = options.delete :inputs_dir
       config_keys      = options.delete :config_keys
@@ -258,6 +260,10 @@ EOF
 workflow write_info --recursive --force=false --check_pid "$step_path" slurm_job $SLURM_JOB_ID 
 EOF
 
+      header +=<<-EOF if manifest
+#MANIFEST: #{manifest * ", "}
+      EOF
+
       header +=<<-EOF
 #CMD: #{rbbt_cmd}
       EOF
@@ -301,11 +307,15 @@ EOF
         coda +=<<-EOF
 
 # Sync data to target location
-mkdir -p "$(dirname '#{target}')"
-rsync -avztAXHP --copy-unsafe-links "#{source}/" "#{target}/" &>> #{fsync} 
-sync_es="$?" 
-echo $sync_es > #{fsyncexit}
-find '#{target}' -type l -ls | awk '$13 ~ /^#{target.gsub('/','\/')}/ { sub("#{source}", "#{target}", $13); print $11, $13 }' | while read A B; do rm $A; ln -s $B $A; done
+if [ $exit_status == '0' ]; then 
+  mkdir -p "$(dirname '#{target}')"
+  rsync -avztAXHP --copy-unsafe-links "#{source}/" "#{target}/" &>> #{fsync} 
+  sync_es="$?" 
+  echo $sync_es > #{fsyncexit}
+  find '#{target}' -type l -ls | awk '$13 ~ /^#{target.gsub('/','\/')}/ { sub("#{source}", "#{target}", $13); print $11, $13 }' | while read A B; do rm $A; ln -s $B $A; done
+else
+  sync_es="$exit_status" 
+fi
 EOF
 
         if  contain && (wipe_container == "post" || wipe_container == "both")
@@ -331,11 +341,11 @@ EOF
           else
             coda +=<<-EOF
 ##{exec_cmd} system clean
-if [ $exit_status == '0' -a $sync_es == '0' ]; then 
+#if [ $exit_status == '0' -a $sync_es == '0' ]; then 
     rm -Rfv #{contain} &>> #{fsync}
-else
-    echo "ERROR: Process failed or results could not sync correctly. Contain directory not purged" &>> #{fsync}
-fi
+#else
+#    echo "ERROR: Process failed or results could not sync correctly. Contain directory not purged" &>> #{fsync}
+#fi
 EOF
 
           end

data/lib/rbbt/persist.rb

@@ -349,7 +349,7 @@ module Persist
 
         Open.notify_write(path)
 
-        return path if persist_options[:no_load]
+        return path if persist_options[:no_load] || type == :path
 
         res
       end

data/lib/rbbt/resource/path.rb

@@ -218,7 +218,14 @@ module Path
 
                      else
                        where = where.to_sym
-                       raise "Did not recognize the 'where' tag: #{where}. Options: #{paths.keys}" unless paths.include? where
+
+                       if paths.include? where
+                         path = paths[where]
+                       elsif where.to_s.include?("/")
+                         path = where.to_s
+                       else
+                         raise "Did not recognize the 'where' tag: #{where}. Options: #{paths.keys}" unless paths.include? where
+                       end
 
                        if where == :lib 
                          libdir = @libdir || Path.caller_lib_dir(caller_lib) || "NOLIBDIR" 
@@ -227,7 +234,6 @@ module Path
                        end
 
                        pwd = FileUtils.pwd
-                       path = paths[where]
                        path = File.join(path, "{PATH}") unless path.include? "PATH}" or path.include? "{BASENAME}"
                        path = path.
                          sub('{PKGDIR}', pkgdir).

data/lib/rbbt/tsv.rb

@@ -118,16 +118,13 @@ module TSV
     end
 
     if data.respond_to? :persistence_path
+      data.read
       data
     else
       h = data.dup
       data.clear
       data.annotate h
     end
-
-    data.read if data.respond_to? :persistence_path
-
-    data
   end
 
   def self.parse_header(stream, options = {})

data/lib/rbbt/tsv/manipulate.rb

@@ -717,7 +717,7 @@ module TSV
   def transpose(key_field = "Unkown ID")
     case type
     when :single, :flat
-      transpose_list self.to_list, key_field
+      self.to_list.transpose_list key_field
     when :list
       transpose_list key_field
     when :double

data/lib/rbbt/util/open.rb

@@ -748,7 +748,9 @@ module Open
     if (dir_sub_path = find_repo_dir(path))
       writable_repo?(*dir_sub_path)
     else
-      if File.exist?(path)
+      if File.symlink?(path)
+        File.writable?(File.dirname(path))
+      elsif File.exist?(path)
         File.writable?(path)
       else
         File.writable?(File.dirname(File.expand_path(path)))

data/lib/rbbt/workflow.rb

@@ -190,7 +190,7 @@ module Workflow
       return Misc.string2const Misc.camel_case(wf_name)
     end
 
-    Log.info{"Loading workflow #{wf_name}"}
+    Log.high{"Loading workflow #{wf_name}"}
     require_local_workflow(wf_name) or 
     (Workflow.autoinstall and `rbbt workflow install #{Misc.snake_case(wf_name)} || rbbt workflow install #{wf_name}` and require_local_workflow(wf_name)) or raise("Workflow not found or could not be loaded: #{ wf_name }")
     begin
@@ -379,7 +379,7 @@ module Workflow
     has_overriden_inputs = false
 
     inputs.each do |k,v|
-      has_overriden_inputs = true if String === k and k.include? "#"
+      #has_overriden_inputs = true if String === k and k.include? "#"
       next unless (task_inputs.include?(k.to_sym) or task_inputs.include?(k.to_s))
       default = all_defaults[k]
       next if default == v 

data/lib/rbbt/workflow/accessor.rb

@@ -382,8 +382,8 @@ module Workflow
                              else
                                task_info = d[:workflow].task_info(d[:task])
 
-                               inputs = assign_dep_inputs({}, options.merge(d[:inputs] || {}), real_dependencies, task_info) 
-                               d[:workflow]._job(d[:task], d[:jobname], inputs) 
+                               _inputs = assign_dep_inputs({}, options.merge(d[:inputs] || {}), real_dependencies, task_info) 
+                               d[:workflow]._job(d[:task], d[:jobname], _inputs) 
                              end
                        end
                        ComputeDependency.setup(d, compute) if compute
@@ -400,8 +400,8 @@ module Workflow
                          setup_override_dependency(value, dep[:workflow], dep[:task])
                        else
                          task_info = (dep[:task] && dep[:workflow]) ? dep[:workflow].task_info(dep[:task]) : nil
-                         inputs = assign_dep_inputs({}, dep[:inputs], real_dependencies, task_info)
-                         dep = dep[:workflow]._job(dep[:task], dep[:jobname], inputs)
+                         _inputs = assign_dep_inputs({}, dep[:inputs], real_dependencies, task_info)
+                         dep = dep[:workflow]._job(dep[:task], dep[:jobname], _inputs)
                        end
                      end
                    end

data/lib/rbbt/workflow/examples.rb

@@ -53,7 +53,11 @@ module Workflow
           if file =~ /\.yaml/
             inputs[input.to_sym]  = YAML.load(Open.read(file))
           else
-            inputs[input.to_sym]  = Open.realpath(file)
+            if File.symlink?(file)
+              inputs[input.to_sym]  = File.readlink(file)
+            else
+              inputs[input.to_sym]  = Open.realpath(file)
+            end
           end
         when :text
           Log.debug "Reading #{ input } from #{file}"

data/lib/rbbt/workflow/remote_workflow/remote_step.rb

@@ -315,6 +315,11 @@ class RemoteStep < Step
     end
   end
 
+  def workflow_short_path
+    init_job unless @url
+    [@base_url, @task, @name] * "/"
+  end
+
   def short_path
     init_job unless @url
     [@task, @name] * "/"

data/lib/rbbt/workflow/step.rb

@@ -114,9 +114,13 @@ class Step
 
   def copy_files_dir
     if File.symlink?(self.files_dir)
-      realpath = Open.realpath(self.files_dir)
-      Open.rm self.files_dir
-      Open.cp realpath, self.files_dir
+      begin
+        realpath = Open.realpath(self.files_dir)
+        Open.rm self.files_dir
+        Open.cp realpath, self.files_dir
+      rescue
+        Log.warn "Copy files_dir for #{self.workflow_short_path}: " + $!.message
+      end
     end
   end
 
@@ -465,7 +469,10 @@ class Step
     self
   end
 
-  def rec_dependencies(need_run = false, seen = [])
+  #connected = true means that dependency searching ends when a result is done
+  #but dependencies are absent, meanining that the file could have been dropped
+  #in
+  def rec_dependencies(connected = false, seen = [])
 
     # A step result with no info_file means that it was manually
     # placed. In that case, do not consider its dependencies
@@ -480,9 +487,9 @@ class Step
       #next if self.done? && Open.exists?(info_file) && info[:dependencies] && info[:dependencies].select{|task,name,path| path == step.path }.empty?
       next if archived_deps.include? step.path
       next if seen.include? step.path
-      next if self.done? && need_run && ! updatable?
+      next if self.done? && connected && ! updatable?
 
-      r = step.rec_dependencies(need_run, new_dependencies.collect{|d| d.path})
+      r = step.rec_dependencies(connected, new_dependencies.collect{|d| d.path})
       new_dependencies.concat r
       new_dependencies << step
     }

data/lib/rbbt/workflow/step/accessor.rb

@@ -154,14 +154,24 @@ class Step
     @name ||= path.sub(/.*\/#{Regexp.quote task_name.to_s}\/(.*)/, '\1')
   end
 
+
   def short_path
     [task_name, name] * "/"
   end
 
+  def workflow_short_path
+    return short_path unless workflow
+    workflow.to_s + "#" + short_path
+  end
+
   def task_name
     @task_name ||= task.name
   end
 
+  def task_signature
+    [workflow.to_s, task_name] * "#"
+  end
+
   # {{{ INFO
 
   def info_file
@@ -456,7 +466,7 @@ class Step
   end
 
   def dirty_files
-    rec_dependencies = self.rec_dependencies
+    rec_dependencies = self.rec_dependencies(true)
     return [] if rec_dependencies.empty?
     canfail_paths = self.canfail_paths
 

data/lib/rbbt/workflow/step/run.rb

@@ -112,23 +112,27 @@ class Step
   end
 
   def updatable?
-    (ENV["RBBT_UPDATE_ALL_JOBS"] == 'true' || ( ENV["RBBT_UPDATE"] == "true" && Open.exists?(info_file)) && status != :noinfo && ! (relocated? && done?)) || (ENV["RBBT_UPDATE"] && ! (done? && ! Open.exists?(info_file)))
+    return true if ENV["RBBT_UPDATE_ALL_JOBS"] == 'true'
+    return false unless ENV["RBBT_UPDATE"] == "true"
+    return false unless Open.exists?(info_file)
+    return true if status != :noinfo && ! (relocated? && done?)
+    false
   end
 
   def dependency_checks
     return [] if ENV["RBBT_UPDATE"] != "true"
 
-    rec_dependencies.
+    rec_dependencies(true).
       reject{|dependency| (defined?(WorkflowRemoteClient) && WorkflowRemoteClient::RemoteStep === dependency) || Open.remote?(dependency.path) }.
       reject{|dependency| dependency.error? }.
       #select{|dependency| Open.exists?(dependency.path) || ((Open.exists?(dependency.info_file) && (dependency.status == :cleaned) || dependency.status == :waiting)) }.
-      select{|dependency| dependency.updatable? }.
+      #select{|dependency| dependency.updatable? }.
       collect{|dependency| Workflow.relocate_dependency(self, dependency)}
   end
 
   def input_checks
-    (inputs.select{|i| Step === i } + inputs.select{|i| Path === i && Step === i.resource}.collect{|i| i.resource}).
-      select{|dependency| dependency.updatable? }
+    (inputs.select{|i| Step === i } + inputs.select{|i| Path === i && Step === i.resource}.collect{|i| i.resource})
+      #select{|dependency| dependency.updatable? }
   end
 
   def checks
@@ -153,7 +157,8 @@ class Step
     canfail_paths = self.canfail_paths
     this_mtime = Open.mtime(self.path) if Open.exists?(self.path)
 
-    outdated_time = checks.select{|dep| dep.updatable? && dep.done? && Persist.newer?(path, dep.path) }
+    #outdated_time = checks.select{|dep| dep.updatable? && dep.done? && Persist.newer?(path, dep.path) }
+    outdated_time = checks.select{|dep| dep.done? && Persist.newer?(path, dep.path) }
     outdated_dep = checks.reject{|dep| dep.done? || (dep.error? && ! dep.recoverable_error? && canfail_paths.include?(dep.path)) }
 
     #checks.each do |dep| 

data/lib/rbbt/workflow/usage.rb

@@ -21,7 +21,7 @@ module Task
 
     selects = []
     if inputs.any?
-      inputs.zip(input_types.values_at(*inputs)).select{|i,t| t.to_sym == :select and input_options[i][:select_options] }.each{|i,t| selects << [i, input_options[i][:select_options]]  }
+      inputs.zip(input_types.values_at(*inputs)).select{|i,t| t.to_sym == :select && input_options[i] && input_options[i][:select_options] }.each{|i,t| selects << [i, input_options[i][:select_options]]  }
       puts SOPT.input_doc(inputs, input_types, input_descriptions, input_defaults, true)
       puts
     end

data/lib/rbbt/workflow/util/archive.rb

@@ -232,7 +232,7 @@ puts resource[path].find(search_path)
           ppp Open.read(tmp_include_file)
           puts cmd 
         else
-          CMD.cmd_log(cmd)
+          CMD.cmd_log(cmd, :log => Log::INFO)
         end
       end
     end

data/lib/rbbt/workflow/util/provenance.rb

@@ -78,6 +78,7 @@ class Step
     name = info[:name] || File.basename(path)
     status = :unsync if status == :done and not Open.exist?(path)
     status = :notfound if status == :noinfo and not Open.exist?(path)
+
     str = " " * offset
     str << prov_report_msg(status, name, path, info)
     step.dependencies.reverse.each do |dep|
@@ -90,7 +91,14 @@ class Step
         if expand_repeats
           str << Log.color(:green, Log.uncolor(prov_report(dep, offset+1, task)))
         else
-          str << Log.color(:green, " " * (offset + 1) + Log.uncolor(prov_report_msg(status, name, path, info)))
+          info = dep.info  || {}
+          status = info[:status] || :missing
+          status = "remote" if Open.remote?(path) || Open.ssh?(path)
+          name = info[:name] || File.basename(path)
+          status = :unsync if status == :done and not Open.exist?(path)
+          status = :notfound if status == :noinfo and not Open.exist?(path)
+
+          str << Log.color(status == :notfound ? :blue : :green, " " * (offset + 1) + Log.uncolor(prov_report_msg(status, name, path, info)))
         end
       end
     end if step.dependencies

data/share/Rlib/util.R

@@ -484,7 +484,7 @@ rbbt.model.inpute <- function(data, formula, ...){
     data
 }
 
-rbbt.tsv.melt <- function(tsv, variable = NULL, value = NULL, key.field = NULL){
+rbbt.tsv.melt <- function(tsv, variable = NULL, value = NULL, key.field = NULL, ...){
     rbbt.require('reshape2')
     if (is.null(key.field)){ key.field = attributes(data)$key.field;}
     if (is.null(key.field)){ key.field = "ID" }
@@ -494,7 +494,7 @@ rbbt.tsv.melt <- function(tsv, variable = NULL, value = NULL, key.field = NULL){
 
     tsv[key.field] = rownames(tsv)
 
-    m <- melt(tsv)
+    m <- melt(tsv, id.vars=c(key.field), ...)
 
     names(m) <- c(key.field, variable, value)
 
@@ -784,6 +784,12 @@ rbbt.plot.venn <- function(data, a=NULL, category=NULL, fill=NULL, ...) {
     return(out)
 }
 
+rbbt.plot.upset <- function(data, variable = NULL, ...){
+  rbbt.require('UpSetR')
+  data[data == TRUE] = 1
+  return(upset(data, ...))
+}
+
 rbbt.plot.pca <- function(data, center = TRUE, scale. = TRUE, ...) {
   rbbt.require('vqv/ggbiplot')
   data <- rbbt.impute(data)

data/share/rbbt_commands/migrate

@@ -107,6 +107,6 @@ real_paths.each do |source|
     puts cmd 
     exit 0
   else
-    CMD.cmd_log(cmd)
+    CMD.cmd_log(cmd, :log => Log::INFO)
   end
 end

data/share/rbbt_commands/slurm/list

@@ -70,6 +70,13 @@ workdir.glob("**/command.slurm").sort_by{|f| File.mtime(f)}.each do |fcmd|
   cmd = nil
  end
 
+ if m = Open.read(fcmd).match(/#MANIFEST: (.*)/)
+  manifest = m[1]
+ else
+  manifest = nil
+ end
+
+
  if m = Open.read(fcmd).match(/# Run command\n(.*?)\n/im)
   exe = m[1].sub('step_path=$(','')
  else
@@ -98,15 +105,24 @@ workdir.glob("**/command.slurm").sort_by{|f| File.mtime(f)}.each do |fcmd|
  if File.exists?(fstatus = File.join(dir, 'job.status'))
   nodes = Open.read(fstatus).split("\n").last.split(/\s+/).last.split(",")
  elsif job_nodes[id]
-  nodes = job_nodes[id]
+  nodes = job_nodes[id].reject{|n| n.include? "("}
  else
   nodes = []
  end
 
+ if File.exists?(File.join(dir, 'exit.status'))
+   now = File.ctime(File.join(dir, 'exit.status'))
+ else
+   now = Time.now
+ end
+
  if File.exists?(File.join(dir, 'std.out'))
+  cerrt = File.ctime File.join(dir, 'std.err')
+  coutt = File.ctime File.join(dir, 'std.out')
   outt = File.mtime File.join(dir, 'std.out')
   errt = File.mtime File.join(dir, 'std.err')
-  time_diff = Time.now - [outt, errt].max
+  time_diff = now - [outt, errt].max
+  time_elapsed = now - [cerrt, coutt].min
  end
 
  fdep = File.join(dir, 'dependencies.list')
@@ -115,14 +131,19 @@ workdir.glob("**/command.slurm").sort_by{|f| File.mtime(f)}.each do |fcmd|
  fcadep = File.join(dir, 'canfail_dependencies.list')
  cadeps = Open.read(fcadep).split("\n") if File.exists?(fcadep)
 
- if done || error || aborted || running || queued || jobid || search
+ if done || error || aborted || running || queued || jobid 
    select = false
    select = true if done && exit_status == 0
    select = true if error && exit_status && exit_status != 0 
    select = true if aborted && (exit_status.nil? && ! running_jobs.include?(id))
-   select = true if queued && deps && (running_jobs & deps).any?
-   select = true if running && (exit_status.nil? && running_jobs.include?(id)) && (!deps || (running_jobs & deps).empty?)
+   is_running =  exit_status.nil? && running_jobs.include?(id) && (!deps || (running_jobs & deps).empty?)
+   select = true if queued && deps && (running_jobs & deps).any? || queued && is_running && nodes.empty?
+   select = true if running && nodes.any? && (exit_status.nil? && running_jobs.include?(id)) && (!deps || (running_jobs & deps).empty?)
    select = true if jobid && jobid.split(",").include?(id)
+   select = select && cmd.match(/#{search}/) if search
+   next unless select 
+ elsif search
+   select = false
    select = true if search && cmd.match(/#{search}/)
    next unless select 
  end
@@ -130,6 +151,8 @@ workdir.glob("**/command.slurm").sort_by{|f| File.mtime(f)}.each do |fcmd|
 
  puts Log.color :blue, dir
  puts Log.color(:magenta, "Creation: ") << File.mtime(File.join(dir, 'command.slurm')).to_s
+ puts Log.color(:magenta, "Started: ") << File.ctime(File.join(dir, 'std.err')).to_s if File.exist?(File.join(dir, 'std.err'))
+ puts Log.color(:magenta, "Manifest: ") << Log.color(:yellow, manifest) 
  puts Log.color(:magenta, "Done: ") << File.mtime(File.join(dir, 'exit.status')).to_s if File.exist?(File.join(dir, 'exit.status'))
  puts Log.color(:magenta, "Exec: ") << (exe || "Missing")
  puts Log.color(:magenta, "CMD: ") << (Log.color(:yellow, cmd) || "Missing")
@@ -138,7 +161,8 @@ workdir.glob("**/command.slurm").sort_by{|f| File.mtime(f)}.each do |fcmd|
  puts Log.color(:magenta, "Dependencies: ") << deps * ", " if deps
  puts Log.color(:magenta, "Dependencies (can fail): ") << cadeps * ", " if cadeps
  puts Log.color(:magenta, "Nodes: ") << nodes * ", "
- puts Log.color(:magenta, "Output: ") << File.exists?(File.join(dir, 'std.out')).to_s << (id.nil? ? "" : " (last update " + Misc.format_seconds(time_diff) + " ago)")
+ puts Log.color(:magenta, "Time elapsed: ") << Misc.format_seconds(time_elapsed) if time_elapsed
+ puts Log.color(:magenta, "Output: ") << File.exists?(File.join(dir, 'std.out')).to_s << (id.nil? || File.exists?(File.join(dir, 'exit.status')) ? "" : " (last update " + Misc.format_seconds(time_diff) + " ago)")
 
  if options[:sbatch_parameters]
    puts Log.color(:magenta, "SBATCH parameters: ")
@@ -180,8 +204,11 @@ workdir.glob("**/command.slurm").sort_by{|f| File.mtime(f)}.each do |fcmd|
    start = rss_average.keys.sort.first
    eend = rss_average.keys.sort.last
    time_elapsed = eend - start
+   ticks = 1 if ticks == 0
+   time_elapsed = 1 if time_elapsed == 0
    puts Log.color(:yellow, "CPU average: ") + "%.2f" % ( ticks / clock_ticks / time_elapsed * 100).to_s
    puts Log.color(:yellow, "RSS average: ") + "%.2f GB" % Misc.mean(rss_average.collect{|t,l| Misc.sum(l) / (1024 * 1024 * 1024)}).to_s 
+   puts Log.color(:yellow, "Time: ") + Misc.format_seconds((eend - start))
 
  end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rbbt-util
 version: !ruby/object:Gem::Version
-  version: 5.30.2
+  version: 5.30.7
 platform: ruby
 authors:
 - Miguel Vazquez
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-02-02 00:00:00.000000000 Z
+date: 2021-02-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake