scout-gear 7.3.0 → 8.1.0

data/lib/scout/workflow/deployment/orchestrator.rb

@@ -0,0 +1,245 @@
+module Workflow
+  class Orchestrator
+
+    def self.job_workload(job)
+      workload = {job => []}
+      return workload if job.done? && job.updated?
+
+      job.dependencies.each do |dep|
+        next if dep.done? && job.updated?
+        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? && job.updated?
+        workload.merge!(job_workload(dep))
+        workload[job] += workload[dep]
+        workload[job] << dep
+        workload[job].uniq!
+      end
+
+      workload
+    end
+
+    def self.workload(jobs)
+      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
+    end
+
+    def self.job_rules(rules, job)
+      workflow = job.workflow.to_s
+      task_name = job.task_name.to_s
+      defaults = rules["defaults"] || {}
+
+      return IndiferentHash.setup(defaults) unless rules[workflow]
+      return IndiferentHash.setup(defaults) unless rules[workflow][task_name]
+
+      job_rules = IndiferentHash.setup(rules[workflow][task_name])
+      defaults.each{|k,v| job_rules[k] = v if job_rules[k].nil? } if 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"] 
+      default_resources ||= rules["defaults"]["resources"] if rules["defaults"]
+      default_resources ||= {}
+
+      default_resources.each{|k,v| resources[k] ||= v } if default_resources
+
+      resources = {:cpus => 1} if resources.empty?
+      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
+
+    def self.process(*args)
+      self.new.process(*args)
+    end
+
+    attr_accessor :available_resources, :resources_requested, :resources_used, :timer
+
+    def initialize(timer = 5, available_resources = {})
+      available_resources  = {:cpus => Etc.nprocessors } if available_resources.nil?
+      @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)
+
+      Scout::Config.with_config do 
+        job_rules[:config_keys].each do |config|
+          Scout::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.fork
+        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 = nil)
+      jobs, rules = rules, {} if jobs.nil?
+      jobs = [jobs] if Step === jobs
+      begin
+
+        workload = Orchestrator.workload(jobs)
+        all_jobs = workload.keys
+
+        top_level_jobs = jobs.collect{|job| job.path }
+        while workload.any? 
+
+          candidates = resources_used.keys + Orchestrator.candidates(workload, rules)
+          candidates.uniq!
+          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? || k.error? || k.aborted?
+            #new_workload[k] = v.reject{|d| d.done? || ((d.error? || d.aborted?) && ! d.recoverable_error?)}
+            new_workload[k] = v.reject{|d| d.done? || d.error? || d.aborted?}
+          end
+          workload = new_workload
+          sleep timer
+        end
+      rescue TryAgain
+        retry
+      end
+    end
+  end
+end

data/lib/scout/workflow/deployment.rb

@@ -0,0 +1 @@
+require_relative 'deployment/orchestrator'

data/lib/scout/workflow/step/dependencies.rb

@@ -1,31 +1,46 @@
 class Step
+  def rec_dependencies
+    rec_dependencies = dependencies.dup
+    dependencies.inject(rec_dependencies){|acc,d| acc.concat d.rec_dependencies }
+  end
+
   def recursive_inputs
-    dependencies.inject(@inputs.annotate(@inputs.dup)) do |acc,dep|
-      acc.concat(dep.inputs) if dep.inputs
-      acc
+    recursive_inputs = @inputs.to_hash
+    dependencies.inject(recursive_inputs) do |acc,dep|
+      acc.merge(dep.recursive_inputs)
     end
   end
 
   def input_dependencies
     return [] unless inputs
-    inputs.select do |d|
-      Step === d
-    end
+    inputs.collect do |d|
+      if Step === d
+        d
+      elsif (Path === d) && (Step === d.pkgdir)
+        d.pkgdir
+      else
+        nil
+      end
+    end.compact.uniq
   end
 
   def prepare_dependencies
     inverse_dep = {}
-    dependencies.each{|dep| 
+    dependencies.each{|dep|
+      if dep.present? && ! dep.updated?
+        Log.debug "Clean outdated #{dep.path}"
+        dep.clean
+      end
       next if dep.done?
       if dep.dependencies
         dep.dependencies.each do |d|
           inverse_dep[d] ||= []
-          inverse_dep[d] << dep 
+          inverse_dep[d] << dep
         end
       end
       input_dependencies.each do |d|
         inverse_dep[d] ||= []
-        inverse_dep[d] << dep 
+        inverse_dep[d] << dep
       end
     }
     inverse_dep.each do |dep,list|
@@ -34,7 +49,38 @@ class Step
   end
 
   def run_dependencies
-    dependencies.each{|dep| dep.run unless dep.running? || dep.done? }
+    dependencies.each{|dep| 
+      next if dep.running? || dep.done?
+      compute_options = compute[dep.path] if compute
+      compute_options = [] if compute_options.nil?
+
+      stream = compute_options.include?(:stream)
+      stream = true unless ENV["SCOUT_EXPLICIT_STREAMING"] == 'true'
+      stream = false if compute_options.include?(:produce)
+
+      begin
+        dep.run(stream)
+      rescue ScoutException
+        if compute_options.include?(:canfail)
+          Log.medium "Allow failing of #{dep.path}"
+        else
+          raise $!
+        end
+      end
+    }
+  end
+
+  def abort_dependencies
+    dependencies.each{|dep| dep.abort if dep.running? }
   end
 
+  def self.wait_for_jobs(jobs)
+    threads = []
+    jobs.each do |job|
+      threads << Thread.new{ job.join }
+    end
+    threads.each do |t|
+      t.join
+    end
+  end
 end

data/lib/scout/workflow/step/file.rb

@@ -3,6 +3,7 @@ class Step
     @files_dir ||= begin
                      dir = @path + ".files"
                      @path.annotate(dir) if Path === @path
+                     dir.pkgdir = self
                      dir
                    end
   end
@@ -12,4 +13,8 @@ class Step
     Path.setup(dir) unless Path === dir
     dir[file]
   end
+
+  def bundle_files
+    [path, info_file, Dir.glob(File.join(files_dir,"**/*"))].flatten.select{|f| Open.exist?(f) }
+  end
 end

data/lib/scout/workflow/step/info.rb

@@ -1,6 +1,7 @@
 class Step
   SERIALIZER = :marshal
   def info_file
+    return nil if @path.nil?
     @info_file ||= begin
                      info_file = @path + ".info"
                      @path.annotate info_file if Path === @path
@@ -19,6 +20,10 @@ class Step
     @info_load_time = Time.now
   end
 
+  def clear_info
+    save_info(@info = {})
+  end
+
   def info
     outdated = begin
                  @info_load_time && (mtime = Open.mtime(info_file)) && mtime > @info_load_time
@@ -36,7 +41,20 @@ class Step
   def merge_info(new_info)
     info = self.info
     new_info.each do |key,value|
-      report_status new_info[:status], new_info[:message] if key == :status
+      if key == :status
+        message = new_info[:messages]
+        if message.nil? && (value == :done || value == :error || value == :aborted)
+          start = info[:start]
+          eend = new_info[:end]
+          if start && eend
+            time = eend - start
+            time_str = Misc.format_seconds_short(time)
+            message = Log.color(:time, time_str)
+          end
+        end
+        report_status value, message 
+      end
+
       if Exception === value
         begin
           Marshal.dump(value)
@@ -50,6 +68,7 @@ class Step
           value = new
         end
       end
+
       if info.include?(key)
         case info[key]
         when Array
@@ -72,15 +91,21 @@ class Step
   
   def report_status(status, message = nil)
     if message.nil?
-      Log.info Log.color(:status, status, true) + " " + Log.color(:path, path)
+      Log.info [Log.color(:status, status, true), Log.color(:task, task_name, true), Log.color(:path, path)] * " "
     else
-      Log.info Log.color(:status, status, true) + " " + Log.color(:path, path) + " " + message
+      Log.info [Log.color(:status, status, true), Log.color(:task, task_name, true), message, Log.color(:path, path)] * " "
     end
   end
 
-  def log(status, message = nil)
+  def log(status, message = nil, &block)
+    if block_given?
+      time = Misc.exec_time &block
+      time_str = Misc.format_seconds_short time
+      message = message.nil? ? Log.color(:time, time_str) : "#{Log.color :time, time_str} - #{ message }"
+    end
+
     if message
-      merge_info :status => status, :messages => [message]
+      merge_info :status => status, :messages => message
     else
       merge_info :status => status
     end
@@ -91,11 +116,11 @@ class Step
   end
 
   def error?
-    status == :error
+    status == :error || status == 'error'
   end
 
   def aborted?
-    status == :aborted
+    status == :aborted || status == 'aborted'
   end
 
   def running?
@@ -105,4 +130,12 @@ class Step
   def exception
     info[:exception]
   end
+
+  def marshal_dump
+    @path
+  end
+
+  def marshal_load(path)
+    Step.new path
+  end
 end

data/lib/scout/workflow/step/load.rb

@@ -12,7 +12,7 @@ class Step
 
   def self.load(path)
     path = relocate(path) unless Open.exists?(path)
-    raise "Could not load #{path}" unless Open.exists?(path)
+    #raise "Could not load #{path}" unless Open.exists?(path)
     s = Step.new path
   end
 end

data/lib/scout/workflow/step/provenance.rb

@@ -5,7 +5,7 @@ class Step
 
   def self.status_color(status)
     case status.to_sym
-    when :error, :aborted, :missing, :dead, :unsync
+    when :error, :aborted, :dead, :unsync
       :red
     when :streaming, :started
       :cyan
@@ -13,7 +13,7 @@ class Step
       :green
     when :dependencies, :waiting, :setup
       :yellow
-    when :notfound, :cleaned
+    when :notfound, :cleaned, :missing
       :blue
     else
       if status.to_s.index ">"
@@ -91,6 +91,8 @@ class Step
     info[:task_name] = task
     path  = step.path
     status = info[:status] || :missing
+    status = status.to_sym if String === status
+    status = :noinfo if status == :missing && Open.exist?(path)
     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)
@@ -103,9 +105,9 @@ class Step
     step.dependencies.each do |dep|
       if dep.input_dependencies.any?
         dep.input_dependencies.each do |id|
-          input_name, _dep = dep.recursive_inputs.fields.zip(dep.recursive_inputs).select{|f,d| 
+          input_name, _dep = dep.recursive_inputs.select{|f,d| 
             d == id || (String === d && d.start_with?(id.files_dir)) || (Array === d && d.include?(id))
-          }.last
+          }.keys.last
           if input_name
             input_dependencies[id] ||= []
             input_dependencies[id] << [dep, input_name]
@@ -115,10 +117,10 @@ class Step
     end if step.dependencies
 
     str = ""
-    str = " " * offset + this_step_msg if ENV["RBBT_ORIGINAL_STACK"] == 'true'
+    str = " " * offset + this_step_msg if ENV["SCOUT_ORIGINAL_STACK"] == 'true'
 
     step.dependencies.dup.tap{|l| 
-      l.reverse! if ENV["RBBT_ORIGINAL_STACK"] == 'true'
+      l.reverse! if ENV["SCOUT_ORIGINAL_STACK"] == 'true'
     }.each do |dep|
       path = dep.path
       new = ! seen.include?(path)
@@ -141,7 +143,7 @@ class Step
       end
     end if step.dependencies
 
-    str += (" " * offset) + this_step_msg unless ENV["RBBT_ORIGINAL_STACK"] == 'true'
+    str += (" " * offset) + this_step_msg unless ENV["SCOUT_ORIGINAL_STACK"] == 'true'
 
     str
   end

data/lib/scout/workflow/step/status.rb

@@ -0,0 +1,43 @@
+class Step
+  def abort(exception = nil)
+    if info[:pid] != Process.pid && Misc.alive?(pid)
+      Process.kill pid
+    else
+      while @result && streaming? && stream = self.stream
+        stream.abort(exception)
+      end
+    end
+  end
+
+  def recoverable_error?
+    self.error? && ! (ScoutException === self.exception)
+  end
+
+  def updated?
+    return false if self.error? && self.recoverable_error?
+    return true unless ENV["SCOUT_UPDATE"]
+    newer = rec_dependencies.select{|dep| Path.newer?(self.path, dep.path) }
+    newer += input_dependencies.select{|dep| Path.newer?(self.path, dep.path) }
+
+    newer.empty?
+  end
+
+  def clean
+    @take_stream = nil 
+    @result = nil
+    @info = nil
+    @info_load_time = nil
+    Open.rm path if Open.exist?(path)
+    Open.rm info_file if Open.exist?(info_file)
+    Open.rm_rf files_dir if Open.exist?(files_dir)
+  end
+
+
+  def recursive_clean
+    dependencies.each do |dep|
+      dep.recursive_clean
+    end
+    clean
+  end
+
+end