apps/workbench/app/controllers/pipeline_instances_controller.rb

   1 class PipelineInstancesController < ApplicationController
   2   skip_before_filter :find_object_by_uuid, only: :compare
   3   before_filter :find_objects_by_uuid, only: :compare
   4   include PipelineInstancesHelper
   5
   6   def copy
   7     @object = @object.dup
   8     @object.components.each do |cname, component|
   9       component.delete :job
  10     end
  11     @object.state = 'New'
  12     super
  13   end
  14
  15   def update
  16     @updates ||= params[@object.class.to_s.underscore.singularize.to_sym]
  17     if (components = @updates[:components])
  18       components.each do |cname, component|
  19         if component[:script_parameters]
  20           component[:script_parameters].each do |param, value_info|
  21             if value_info.is_a? Hash
  22               if resource_class_for_uuid(value_info[:value]) == Link
  23                 # Use the link target, not the link itself, as script
  24                 # parameter; but keep the link info around as well.
  25                 link = Link.find value_info[:value]
  26                 value_info[:value] = link.head_uuid
  27                 value_info[:link_uuid] = link.uuid
  28                 value_info[:link_name] = link.name
  29               else
  30                 # Delete stale link_uuid and link_name data.
  31                 value_info[:link_uuid] = nil
  32                 value_info[:link_name] = nil
  33               end
  34             end
  35           end
  36         end
  37       end
  38     end
  39     super
  40   end
  41
  42   def graph(pipelines)
  43     return nil, nil if params['tab_pane'] != "Graph"
  44
  45     count = {}
  46     provenance = {}
  47     pips = {}
  48     n = 1
  49
  50     pipelines.each do |p|
  51       collections = []
  52
  53       p.components.each do |k, v|
  54         j = v[:job] || next
  55
  56         # The graph is interested in whether the component is
  57         # indicated as persistent, more than whether the job
  58         # satisfying it (which could have been reused, or someone
  59         # else's) is.
  60         j[:output_is_persistent] = v[:output_is_persistent]
  61
  62         uuid = j[:uuid].intern
  63         provenance[uuid] = j
  64         pips[uuid] = 0 unless pips[uuid] != nil
  65         pips[uuid] |= n
  66
  67         collections << j[:output]
  68         ProvenanceHelper::find_collections(j[:script_parameters]).each do |k|
  69           collections << k
  70         end
  71
  72         uuid = j[:script_version].intern
  73         provenance[uuid] = {:uuid => uuid}
  74         pips[uuid] = 0 unless pips[uuid] != nil
  75         pips[uuid] |= n
  76       end
  77
  78       Collection.where(uuid: collections.compact).each do |c|
  79         uuid = c.uuid.intern
  80         provenance[uuid] = c
  81         pips[uuid] = 0 unless pips[uuid] != nil
  82         pips[uuid] |= n
  83       end
  84
  85       n = n << 1
  86     end
  87
  88     return provenance, pips
  89   end
  90
  91   def show
  92     @pipelines = [@object]
  93
  94     if params[:compare]
  95       PipelineInstance.where(uuid: params[:compare]).each do |p|
  96         @pipelines << p
  97       end
  98     end
  99
 100     provenance, pips = graph(@pipelines)
 101     if provenance
 102       @prov_svg = ProvenanceHelper::create_provenance_graph provenance, "provenance_svg", {
 103         :request => request,
 104         :all_script_parameters => true,
 105         :combine_jobs => :script_and_version,
 106         :script_version_nodes => true,
 107         :pips => pips }
 108     end
 109
 110     super
 111   end
 112
 113   def compare
 114     @breadcrumb_page_name = 'compare'
 115
 116     @rows = []          # each is {name: S, components: [...]}
 117
 118     if params['tab_pane'] == "Compare" or params['tab_pane'].nil?
 119       # Build a table: x=pipeline y=component
 120       @objects.each_with_index do |pi, pi_index|
 121         pipeline_jobs(pi).each do |component|
 122           # Find a cell with the same name as this component but no
 123           # entry for this pipeline
 124           target_row = nil
 125           @rows.each_with_index do |row, row_index|
 126             if row[:name] == component[:name] and !row[:components][pi_index]
 127               target_row = row
 128             end
 129           end
 130           if !target_row
 131             target_row = {name: component[:name], components: []}
 132             @rows << target_row
 133           end
 134           target_row[:components][pi_index] = component
 135         end
 136       end
 137
 138       @rows.each do |row|
 139         # Build a "normal" pseudo-component for this row by picking the
 140         # most common value for each attribute. If all values are
 141         # equally common, there is no "normal".
 142         normal = {}              # attr => most common value
 143         highscore = {}           # attr => how common "normal" is
 144         score = {}               # attr => { value => how common }
 145         row[:components].each do |pj|
 146           next if pj.nil?
 147           pj.each do |k,v|
 148             vstr = for_comparison v
 149             score[k] ||= {}
 150             score[k][vstr] = (score[k][vstr] || 0) + 1
 151             highscore[k] ||= 0
 152             if score[k][vstr] == highscore[k]
 153               # tie for first place = no "normal"
 154               normal.delete k
 155             elsif score[k][vstr] == highscore[k] + 1
 156               # more pipelines have v than anything else
 157               highscore[k] = score[k][vstr]
 158               normal[k] = vstr
 159             end
 160           end
 161         end
 162
 163         # Add a hash in component[:is_normal]: { attr => is_the_value_normal? }
 164         row[:components].each do |pj|
 165           next if pj.nil?
 166           pj[:is_normal] = {}
 167           pj.each do |k,v|
 168             pj[:is_normal][k] = (normal.has_key?(k) && normal[k] == for_comparison(v))
 169           end
 170         end
 171       end
 172     end
 173
 174     if params['tab_pane'] == "Graph"
 175       provenance, pips = graph(@objects)
 176
 177       @pipelines = @objects
 178
 179       if provenance
 180         @prov_svg = ProvenanceHelper::create_provenance_graph provenance, "provenance_svg", {
 181           :request => request,
 182           :all_script_parameters => true,
 183           :combine_jobs => :script_and_version,
 184           :script_version_nodes => true,
 185           :pips => pips }
 186       end
 187     end
 188
 189     @object = @objects.first
 190
 191     show
 192   end
 193
 194   def show_pane_list
 195     panes = %w(Components Graph Advanced)
 196     if @object and @object.state.in? ['New', 'Ready']
 197       panes = %w(Inputs) + panes
 198     end
 199     if not @object.components.values.collect { |x| x[:job] }.compact.any?
 200       panes -= ['Graph']
 201     end
 202     panes
 203   end
 204
 205   def compare_pane_list
 206     %w(Compare Graph)
 207   end
 208
 209   def index
 210     @limit = 20
 211     super
 212   end
 213
 214   protected
 215   def for_comparison v
 216     if v.is_a? Hash or v.is_a? Array
 217       v.to_json
 218     else
 219       v.to_s
 220     end
 221   end
 222
 223   def find_objects_by_uuid
 224     @objects = model_class.where(uuid: params[:uuids])
 225   end
 226
 227 end