rbbt-util 5.28.5 → 5.28.10

data/lib/rbbt/workflow/definition.rb

@@ -44,6 +44,7 @@ module Workflow
 
   def dep(*dependency, &block)
     @dependencies ||= []
+    dependency = [tasks.keys.last] if dependency.empty? && ! block_given?
     if block_given?
       if dependency.any?
 
@@ -81,9 +82,10 @@ module Workflow
       if forget
         remove = config :remove_dep_tasks, :remove_dep_tasks, :default => REMOVE_DEP_TASKS
         self.archive_deps
+        self.copy_files_dir
         self.dependencies = self.dependencies - [dep]
         Open.rm_rf self.files_dir if Open.exist? self.files_dir
-        FileUtils.cp_r dep.files_dir, self.files_dir if Open.exist? dep.files_dir
+        FileUtils.cp_r dep.files_dir, self.files_dir if Open.exist?(dep.files_dir)
         Open.ln_h dep.path, self.tmp_path
         case remove.to_s
         when 'true'
@@ -92,8 +94,10 @@ module Workflow
           dep.recursive_clean
         end
       else
-        Open.rm_rf self.files_dir 
-        Open.link dep.files_dir, self.files_dir
+        if Open.exists?(dep.files_dir)
+          Open.rm_rf self.files_dir 
+          Open.link dep.files_dir, self.files_dir
+        end
         Open.link dep.path, self.path
       end
       nil
@@ -126,7 +130,7 @@ module Workflow
       :resumable          => consume_resumable,
       :input_options      => consume_input_options
     }
-
+     
     task_info[:extension] = case task_info[:result_type].to_s
                             when "tsv"
                               "tsv"

data/lib/rbbt/workflow/integration/ansible.rb

@@ -0,0 +1,53 @@
+require_relative 'ansible/workflow'
+require 'rbbt/workflow/usage'
+
+module Ansible
+  def self.play(playbook, inventory = nil)
+    inventory = Rbbt.etc.ansible_inventory.find
+    Log.with_severity 0 do
+      TmpFile.with_file do |tmp|
+        if Hash === playbook
+          Open.write(tmp, [playbook].to_yaml)
+          playbook = tmp
+        end
+        CMD.cmd_log("ansible-playbook -i #{inventory} #{playbook}")
+      end
+    end
+  end
+
+  def self.clean_symbols(hash)
+    new = {}
+    hash.each do |key,value|
+      key = key.to_s
+      value = case value
+              when Symbol
+                value.to_s
+              when Hash
+                self.clean_symbols(value)
+              else
+                value
+              end
+      new[key] = value
+    end
+    new
+  end
+
+  def self.workflow2playbook(workflow, task, options = {})
+    job_options = workflow.get_SOPT(workflow.tasks[task])
+
+    tasks = workflow.job(task, nil, job_options).exec
+
+    hosts = options[:hosts] || 'localhost'
+
+    clean_tasks = tasks.collect{|task| self.clean_symbols task }
+    {"hosts" => hosts, "tasks" => clean_tasks}
+  end
+
+  def self.playbook(file, task = nil, options = {})
+    task = 'default' if task.nil?
+
+    workflow = Workflow.require_workflow file
+    task = workflow.tasks.keys.last if workflow.tasks[task].nil?
+    workflow2playbook workflow, task, options
+  end
+end

data/lib/rbbt/workflow/integration/ansible/workflow.rb

@@ -0,0 +1,60 @@
+require 'rbbt/workflow'
+
+module Ansible
+  module AnsibleWorkflow
+    def self.extended(object)
+      class << object
+        attr_accessor :ans_tasks
+      end
+
+      object.helper :register do |task_info|
+        desc = task.description if task
+        name ||= desc || short_path
+        task_info = {"name" => name}.merge(task_info)
+        @ans_tasks ||= []
+        @ans_tasks << task_info
+        task
+      end
+
+      object.helper :ans do |name, info|
+        register({ name => info})
+      end
+
+      object.helper :add do |name, info|
+        @ans_tasks.last[name.to_s] = info
+      end
+
+      object.helper :shell do |cmd|
+        register({"shell" => cmd.strip})
+      end
+
+      object.helper :sudo do |cmd|
+        register({"shell" => cmd.strip, "become" => 'yes'})
+      end
+
+      object.helper :singularity do |scmd|
+        img = config :singularity_img, :build, :test, :small, :default => '/data/img/singularity/rbbt/rbbt.simg'
+        container = config :singularity_container, :build, :test, :small, :default => '/data/img/sandbox/mvazque2/'
+        cmd = <<-EOF
+singularity exec -C -H '#{container}' '#{img}' #{scmd}
+        EOF
+        register({"shell" => cmd.strip, "name" => short_path})
+      end
+
+
+      object.helper :produce_task do
+        @ans_tasks
+      end
+    end
+
+    def play(name = nil, &block)
+      name = Misc.snake_case(@description) if name.nil?
+      task name => :yaml do |*args|
+        self.instance_exec *args, &block
+        dependencies.inject([]){|acc,dep| acc += dep.load } + produce_task
+      end
+    end
+
+  end
+end
+

data/lib/rbbt/workflow/remote_workflow/driver/rest.rb

@@ -85,7 +85,11 @@ class RemoteWorkflow
 
       RemoteWorkflow::REST.__prepare_inputs_for_restclient(params)
       name = RemoteWorkflow.capture_exception do
-        RestClient.post(self.encode(url), params)
+        begin
+          RestClient.post(self.encode(url), params)
+        rescue RestClient::MovedPermanently, RestClient::Found, RestClient::TemporaryRedirect
+          raise RbbtException, "REST end-point moved to: #{$!.response.headers[:location]}"
+        end
       end
 
       Log.debug{ "RestClient jobname returned for #{ url } - #{Misc.fingerprint params}: #{name}" }

data/lib/rbbt/workflow/step.rb

@@ -84,6 +84,7 @@ class Step
   end
 
   def load_dependencies_from_info
+    relocated = nil
     @dependencies = (self.info[:dependencies] || []).collect do |task,name,dep_path|
       if Open.exists?(dep_path) || Open.exists?(dep_path + '.info')
         Workflow._load_step dep_path
@@ -108,6 +109,14 @@ class Step
     @inputs || []
   end
 
+  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
+    end
+  end
+
   def archive_deps
     self.set_info :archived_info, archived_info
     self.set_info :archived_dependencies, info[:dependencies]
@@ -145,6 +154,11 @@ class Step
     all_inputs
   end
 
+  def dependencies=(dependencies)
+    @dependencies = dependencies
+    set_info :dependencies, dependencies.collect{|dep| [dep.task_name, dep.name, dep.path]}
+  end
+
   def recursive_inputs
     if NamedArray === inputs
       i = {}
@@ -411,7 +425,7 @@ class Step
       return 
     end
 
-    if (Open.exists?(path) or Open.broken_link?(path)) or Open.exists?(pid_file) or Open.exists?(info_file) or Open.exists?(files_dir)
+    if (Open.exists?(path) or Open.broken_link?(path)) or Open.exists?(pid_file) or Open.exists?(info_file) or Open.exists?(files_dir) or Open.broken_link?(files_dir)
 
       @result = nil
       @pid = nil
@@ -419,8 +433,8 @@ class Step
       Misc.insist do
         Open.rm info_file if Open.exists?(info_file)
         Open.rm md5_file if Open.exists?(md5_file)
-        Open.rm path if (Open.exists?(path) or Open.broken_link?(path))
-        Open.rm_rf files_dir if Open.exists?(files_dir)
+        Open.rm path if (Open.exists?(path) || Open.broken_link?(path))
+        Open.rm_rf files_dir if Open.exists?(files_dir) || Open.broken_link?(files_dir)
         Open.rm pid_file if Open.exists?(pid_file)
         Open.rm tmp_path if Open.exists?(tmp_path)
       end
@@ -454,12 +468,15 @@ class Step
     return [] if dependencies.nil? or dependencies.empty?
 
     new_dependencies = []
+    archived_deps = self.info[:archived_info] ? self.info[:archived_info].keys : []
+
     dependencies.each{|step| 
       #next if self.done? && Open.exists?(info_file) && info[:dependencies] && info[:dependencies].select{|task,name,path| path == step.path }.empty?
-      next if seen.include? step
+      next if archived_deps.include? step.path
+      next if seen.include? step.path
       next if self.done? && need_run && ! updatable?
 
-      r = step.rec_dependencies(need_run, new_dependencies)
+      r = step.rec_dependencies(need_run, new_dependencies.collect{|d| d.path})
       new_dependencies.concat r
       new_dependencies << step
     }

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

@@ -93,8 +93,8 @@ class Step
         else
           Open.write(path + '.read', value.to_s)
         end
-      when Step === v
-        v = v.produce.load 
+      when Step === value
+        value = value.produce.load 
       else
         Open.write(path, value.to_s)
       end
@@ -110,22 +110,24 @@ class Step
     task_info = workflow.task_info(task_name)
     input_types = task_info[:input_types]
     task_inputs = task_info[:inputs]
+    input_defaults = task_info[:input_defaults]
 
     inputs = {}
     job.recursive_inputs.zip(job.recursive_inputs.fields).each do |value,name|
       next unless task_inputs.include? name.to_sym
       next if options and ! options.include?(name)
       next if value.nil?
+      next if input_defaults[name] == value
       inputs[name] = value
     end
 
-    if options.include? 'override_dependencies'
+    if options && options.include?('override_dependencies')
       inputs.merge!(:override_dependencies => open[:override_dependencies])
       input_types = IndiferentHash.setup(input_types.merge(:override_dependencies => :array))
     end
     save_inputs(inputs, input_types, dir)
 
-    inputs.any?
+    inputs.keys
   end
 
   def name
@@ -437,7 +439,7 @@ class Step
     rec_dependencies = self.rec_dependencies
     return [] if rec_dependencies.empty?
     canfail_paths = self.canfail_paths
-    dep = rec_dependencies.select{|d| d.task_name.to_s == 'contamination'}.first
+
     dirty_files = rec_dependencies.reject{|dep|
       (defined?(WorkflowRemoteClient) && WorkflowRemoteClient::RemoteStep === dep) || 
         ! Open.exists?(dep.info_file) ||

data/lib/rbbt/workflow/usage.rb

@@ -240,7 +240,7 @@ module Workflow
 
           inputs.each do |input, type, file|
             case type
-            when :tsv, :array, :text
+            when :tsv, :array, :text, :file
               lines = file.read.split("\n")
               head = lines[0..5].compact * "\n\n"
               head = head[0..500]

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

@@ -67,8 +67,10 @@ class Step
       next unless File.exists?(step.path)
       job_files << step.path
       job_files << step.info_file if File.exists?(step.info_file)
+      job_files << Step.md5_file(step.path) if File.exists?(Step.md5_file step.path)
       job_file_dir_content = Dir.glob(step.files_dir + '/**/*')
       job_files += job_file_dir_content
+      job_files << step.files_dir if File.exists?(step.files_dir)
       rec_dependencies = Set.new
 
       next unless recursive
@@ -262,6 +264,7 @@ puts resource[path].find(search_path)
 
     job_files.each do |file|
       begin
+        Log.debug "Purging #{file}"
         Open.rm_rf file if Open.exists?(file)
       rescue
         Log.warn "Could not erase '#{file}': #{$!.message}"

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

@@ -0,0 +1,228 @@
+require 'rbbt/workflow'
+
+module Workflow
+  class Orchestrator
+
+    def self.job_workload(job)
+      workload = {job => []}
+      return workload if job.done?
+
+      job.dependencies.each do |dep|
+        next if dep.done?
+        workload.merge!(job_workload(dep))
+        workload[job] += workload[dep]
+        workload[job] << dep
+        workload[job].uniq!
+      end
+
+      job.input_dependencies.each do |dep|
+        next if dep.done?
+        workload.merge!(job_workload(dep))
+        workload[job] += workload[dep]
+        workload[job] << dep
+        workload[job].uniq!
+      end
+
+      workload
+    end
+
+    def self.job_rules(rules, job)
+      workflow = job.workflow.to_s
+      task_name = job.task_name.to_s
+
+      return IndiferentHash.setup(rules["defaults"]) unless rules[workflow]
+      return IndiferentHash.setup(rules["defaults"]) unless rules[workflow][task_name]
+
+      job_rules = IndiferentHash.setup(rules[workflow][task_name])
+      rules["defaults"].each{|k,v| job_rules[k] = v if job_rules[k].nil? } if rules["defaults"]
+      job_rules
+    end
+
+    def self.purge_duplicates(candidates)
+      seen = Set.new
+      candidates.select do |job|
+        if seen.include? job.path
+          false
+        else
+          seen << job.path
+          true
+        end
+      end
+    end
+
+    def self.job_resources(rules, job)
+      resources = (job_rules(rules, job) || {})["resources"] || {}
+
+      IndiferentHash.setup(resources)
+
+      default_resources = rules["default_resources"] || rules["defaults"]["resources"]
+      default_resources.each{|k,v| resources[k] ||= v } if default_resources
+
+      resources
+    end
+
+    def self.sort_candidates(candidates, rules)
+      seen = Set.new
+      candidates.sort_by do |job|
+        - job_resources(rules, job).values.inject(0){|acc,e| acc += e}
+      end
+    end
+
+    def self.candidates(workload, rules)
+      if rules.empty?
+        candidates = workload.select{|k,v| v.empty? }.
+          collect{|k,v| k}.
+          reject{|k| k.done? }
+      else
+        candidates = workload. #select{|k,v| Orchestrator.job_rules(rules, k) }.
+          select{|k,v| v.empty? }.
+          collect{|k,v| k }.
+          reject{|k| k.done? }
+      end
+
+      top_level = workload.keys - workload.values.flatten
+
+      candidates = purge_duplicates candidates
+      candidates = sort_candidates candidates, rules
+
+      candidates
+    end
+
+    attr_accessor :available_resources, :resources_requested, :resources_used, :timer
+
+    def initialize(timer = 5, available_resources = {})
+      @timer               = timer
+      @available_resources = IndiferentHash.setup(available_resources)
+      @resources_requested = IndiferentHash.setup({})
+      @resources_used      = IndiferentHash.setup({})
+    end
+
+    def release_resources(job)
+      if resources_used[job]
+        Log.debug "Orchestrator releasing resouces from #{job.path}"
+        resources_used[job].each do |resource,value| 
+          next if resource == 'size'
+          resources_requested[resource] -= value.to_i
+        end
+        resources_used.delete job
+      end
+    end
+
+    def check_resources(rules, job)
+      resources = Orchestrator.job_resources(rules, job)
+
+      limit_resources = resources.select{|resource,value| available_resources[resource] && ((resources_requested[resource] || 0) + value) > available_resources[resource]  }.collect{|resource,v| resource }
+      if limit_resources.any?
+        Log.debug "Orchestrator waiting on #{job.path} due to #{limit_resources * ", "}"
+      else
+
+        resources_used[job] = resources
+        resources.each do |resource,value| 
+          resources_requested[resource] ||= 0
+          resources_requested[resource] += value.to_i
+        end
+        Log.low "Orchestrator producing #{job.path} with resources #{resources}"
+
+        return yield
+      end
+    end
+
+    def run_with_rules(rules, job)
+      job_rules = Orchestrator.job_rules(rules, job)
+
+      Rbbt::Config.with_config do 
+        job_rules[:config_keys].each do |config|
+          Rbbt::Config.process_config config
+        end if job_rules && job_rules[:config_keys]
+
+        log = job_rules[:log] if job_rules 
+        log = Log.severity if log.nil?
+        Log.with_severity log do
+          job.produce(false, true)
+        end
+      end
+    end
+
+    def erase_job_dependencies(job, rules, all_jobs, top_level_jobs)
+      job.dependencies.each do |dep|
+        next if top_level_jobs.include? dep.path
+        next unless Orchestrator.job_rules(rules, dep)["erase"].to_s == 'true'
+
+        dep_path = dep.path
+        parents = all_jobs.select do |parent| 
+          paths = parent.info[:dependencies].nil? ? parent.dependencies.collect{|d| d.path } : parent.info[:dependencies].collect{|d| d.last }
+          paths.include? dep_path
+        end
+
+        next unless parents.reject{|parent| parent.done? }.empty?
+
+        parents.each do |parent|
+          Log.high "Erasing #{dep.path} from #{parent.path}"
+          parent.archive_deps
+          parent.copy_files_dir
+          parent.dependencies = parent.dependencies - [dep]
+        end
+        dep.clean
+      end
+    end
+
+    def process(rules, jobs)
+      begin
+
+        workload = jobs.inject({}) do |acc,job| 
+          Orchestrator.job_workload(job).each do |j,d|
+            acc[j] = d unless acc.keys.collect{|k| k.path }.include? j.path
+          end
+          acc
+        end
+        all_jobs = workload.keys
+
+        top_level_jobs = jobs.collect{|job| job.path }
+        while workload.any? 
+
+          candidates = resources_used.keys + Orchestrator.candidates(workload, rules)
+          raise "No candidates and no running jobs" if candidates.empty?
+
+          candidates.each do |job|
+            case 
+            when (job.error? || job.aborted?)
+              begin
+                if job.recoverable_error?
+                  job.clean
+                  raise TryAgain
+                else
+                  next
+                end
+              ensure
+                Log.warn "Releases resources from failed job: #{job.path}"
+                release_resources(job)
+              end
+            when job.done?
+              Log.debug "Orchestrator done #{job.path}"
+              release_resources(job)
+              erase_job_dependencies(job, rules, all_jobs, top_level_jobs)
+
+            when job.running?
+              next
+
+            else
+              check_resources(rules, job) do
+                run_with_rules(rules, job)
+              end
+            end
+          end
+
+          new_workload = {}
+          workload.each do |k,v|
+            next if k.done?
+            new_workload[k] = v.reject{|d| d.done? || (d.error? && ! d.recoverable_error?)}
+          end
+          workload = new_workload
+          sleep timer
+        end
+      rescue TryAgain
+        retry
+      end
+    end
+  end
+end