apps/workbench/app/helpers/provenance_helper.rb

   1 module ProvenanceHelper
   2
   3   class GenerateGraph
   4     def initialize(pdata, opts)
   5       @pdata = pdata
   6       @opts = opts
   7       @visited = {}
   8       @jobs = {}
   9       @node_extra = {}
  10     end
  11
  12     def self.collection_uuid(uuid)
  13       m = CollectionsHelper.match(uuid)
  14       if m
  15         if m[2]
  16           return m[1]+m[2]
  17         else
  18           return m[1]
  19         end
  20         #  Collection.where(uuid: ['contains', m[1]]).each do |u|
  21         #    puts "fixup #{uuid} to #{u.uuid}"
  22         #    return u.uuid
  23         #  end
  24         #end
  25       else
  26         nil
  27       end
  28     end
  29
  30     def url_for u
  31       p = { :host => @opts[:request].host,
  32         :port => @opts[:request].port,
  33         :protocol => @opts[:request].protocol }
  34       p.merge! u
  35       Rails.application.routes.url_helpers.url_for (p)
  36     end
  37
  38     def determine_fillcolor(n)
  39       fillcolor = %w(aaaaaa aaffaa aaaaff aaaaaa ffaaaa)[n || 0] || 'aaaaaa'
  40       "style=filled,fillcolor=\"##{fillcolor}\""
  41     end
  42
  43     def describe_node(uuid)
  44       uuid = uuid.to_sym
  45       bgcolor = determine_fillcolor @opts[:pips].andand[uuid]
  46
  47       rsc = ArvadosBase::resource_class_for_uuid uuid.to_s
  48       if rsc
  49         href = url_for ({:controller => rsc.to_s.tableize,
  50                           :action => :show,
  51                           :id => uuid.to_s })
  52
  53         #"\"#{uuid}\" [label=\"#{rsc}\\n#{uuid}\",href=\"#{href}\"];\n"
  54         if rsc == Collection
  55           #puts uuid
  56           if uuid == :"d41d8cd98f00b204e9800998ecf8427e+0"
  57             # special case
  58             #puts "empty!"
  59             return "\"#{uuid}\" [label=\"(empty collection)\"];\n"
  60           end
  61           #puts "#{uuid.class} #{@pdata[uuid]}"
  62           if @pdata[uuid]
  63             #puts @pdata[uuid]
  64             if @pdata[uuid][:name]
  65               return "\"#{uuid}\" [label=\"#{@pdata[uuid][:name]}\",href=\"#{href}\",shape=oval,#{bgcolor}];\n"
  66             else
  67               files = nil
  68               if @pdata[uuid].respond_to? :files
  69                 files = @pdata[uuid].files
  70               elsif @pdata[uuid][:files]
  71                 files = @pdata[uuid][:files]
  72               end
  73
  74               if files
  75                 i = 0
  76                 label = ""
  77                 while i < 3 and i < files.length
  78                   label += "\\n" unless label == ""
  79                   label += files[i][1]
  80                   i += 1
  81                 end
  82                 if i < files.length
  83                   label += "\\n&vellip;"
  84                 end
  85                 #puts "#{uuid} #{label} #{files}"
  86                 extra_s = @node_extra[uuid].andand.map { |k,v|
  87                   "#{k}=\"#{v}\""
  88                 }.andand.join ","
  89                 return "\"#{uuid}\" [label=\"#{label}\",href=\"#{href}\",shape=oval,#{bgcolor},#{extra_s}];\n"
  90               end
  91             end
  92           end
  93         end
  94         return "\"#{uuid}\" [label=\"#{rsc}\",href=\"#{href}\",#{bgcolor}];\n"
  95       end
  96       "\"#{uuid}\" [#{bgcolor}];\n"
  97     end
  98
  99     def job_uuid(job)
 100       if @opts[:combine_jobs] == :script_only
 101         uuid = "#{job[:script]}"
 102       elsif @opts[:combine_jobs] == :script_and_version
 103         uuid = "#{job[:script]}_#{job[:script_version]}"
 104       else
 105         uuid = "#{job[:uuid]}"
 106       end
 107
 108       @jobs[uuid] = [] unless @jobs[uuid]
 109       @jobs[uuid] << job unless @jobs[uuid].include? job
 110
 111       uuid
 112     end
 113
 114     def edge(tail, head, extra)
 115       if @opts[:direction] == :bottom_up
 116         gr = "\"#{tail}\" -> \"#{head}\""
 117       else
 118         gr = "\"#{head}\" -> \"#{tail}\""
 119       end
 120       if extra.length > 0
 121         gr += " ["
 122         extra.each do |k, v|
 123           gr += "#{k}=\"#{v}\","
 124         end
 125         gr += "]"
 126       end
 127       gr += ";\n"
 128       gr
 129     end
 130
 131     def script_param_edges(job, prefix, sp)
 132       gr = ""
 133       case sp
 134       when Hash
 135         sp.each do |k, v|
 136           if prefix.size > 0
 137             k = prefix + "::" + k.to_s
 138           end
 139           gr += script_param_edges(job, k.to_s, v)
 140         end
 141       when Array
 142         i = 0
 143         node = ""
 144         sp.each do |v|
 145           if GenerateGraph::collection_uuid(v)
 146             gr += script_param_edges(job, "#{prefix}[#{i}]", v)
 147           elsif @opts[:all_script_parameters]
 148             node += "', '" unless node == ""
 149             node = "['" if node == ""
 150             node += "#{v}"
 151           end
 152           i += 1
 153         end
 154         unless node == ""
 155           node += "']"
 156           #puts node
 157           #id = "#{job[:uuid]}_#{prefix}"
 158           gr += "\"#{node}\" [label=\"#{node}\"];\n"
 159           gr += edge(job_uuid(job), node, {:label => prefix})
 160         end
 161       when String
 162         return '' if sp.empty?
 163         m = GenerateGraph::collection_uuid(sp)
 164         #puts "#{m} pdata is #{@pdata[m.intern]}"
 165         if m and (@pdata[m.intern] or (not @opts[:pdata_only]))
 166           gr += edge(job_uuid(job), m, {:label => prefix})
 167           gr += generate_provenance_edges(m)
 168         elsif @opts[:all_script_parameters]
 169           #id = "#{job[:uuid]}_#{prefix}"
 170           gr += "\"#{sp}\" [label=\"#{sp}\"];\n"
 171           gr += edge(job_uuid(job), sp, {:label => prefix})
 172         end
 173       end
 174       gr
 175     end
 176
 177     def generate_provenance_edges(uuid)
 178       gr = ""
 179       m = GenerateGraph::collection_uuid(uuid)
 180       uuid = m if m
 181
 182       uuid = uuid.intern if uuid
 183
 184       if (not uuid) or uuid.empty? or @visited[uuid]
 185
 186         #puts "already @visited #{uuid}"
 187         return ""
 188       end
 189
 190       if not @pdata[uuid] then
 191         return describe_node(uuid)
 192       else
 193         @visited[uuid] = true
 194       end
 195
 196       #puts "visiting #{uuid.inspect}"
 197
 198       if m
 199         # uuid is a collection
 200         if uuid != :"d41d8cd98f00b204e9800998ecf8427e+0"
 201           # not the empty collection
 202
 203           @pdata.each do |k, job|
 204             if job[:output] == uuid.to_s
 205               extra = { label: 'output' }
 206               if job[:output_is_persistent]
 207                 extra[:label] += ' (persistent)'
 208                 @node_extra[uuid] ||= {}
 209                 @node_extra[uuid][:penwidth] = 4
 210               end
 211               gr += edge(uuid, job_uuid(job), extra)
 212               gr += generate_provenance_edges(job[:uuid])
 213             end
 214             if job[:log] == uuid.to_s
 215               gr += edge(uuid, job_uuid(job), {:label => "log"})
 216               gr += generate_provenance_edges(job[:uuid])
 217             end
 218           end
 219         end
 220         gr += describe_node(uuid)
 221       else
 222         # uuid is something else
 223         rsc = ArvadosBase::resource_class_for_uuid uuid.to_s
 224
 225         if rsc == Job
 226           job = @pdata[uuid]
 227           if job
 228             gr += script_param_edges(job, "", job[:script_parameters])
 229
 230             if @opts[:script_version_nodes]
 231               gr += describe_node(job[:script_version])
 232               gr += edge(job_uuid(job), job[:script_version], {:label => "script_version"})
 233             end
 234           end
 235         elsif rsc == Link
 236           # do nothing
 237         else
 238           gr += describe_node(uuid)
 239         end
 240       end
 241
 242       @pdata.each do |k, link|
 243         if link[:head_uuid] == uuid.to_s and link[:link_class] == "provenance"
 244           href = url_for ({:controller => Link.to_s.tableize,
 245                             :action => :show,
 246                             :id => link[:uuid] })
 247
 248           gr += describe_node(link[:tail_uuid])
 249           gr += edge(link[:head_uuid], link[:tail_uuid], {:label => link[:name], :href => href})
 250           gr += generate_provenance_edges(link[:tail_uuid])
 251         end
 252       end
 253
 254       #puts "finished #{uuid}"
 255
 256       gr
 257     end
 258
 259     def describe_jobs
 260       gr = ""
 261       @jobs.each do |k, v|
 262         href = url_for ({:controller => Job.to_s.tableize,
 263                           :action => :index })
 264
 265         gr += "\"#{k}\" [href=\"#{href}?"
 266
 267         n = 0
 268         v.each do |u|
 269           gr += "uuid%5b%5d=#{u[:uuid]}&"
 270           n |= @opts[:pips][u[:uuid].intern] if @opts[:pips] and @opts[:pips][u[:uuid].intern]
 271         end
 272
 273         gr += "\",label=\""
 274
 275         if @opts[:combine_jobs] == :script_only
 276           gr += "#{v[0][:script]}"
 277         elsif @opts[:combine_jobs] == :script_and_version
 278           gr += "#{v[0][:script]}" # Just show the name but the nodes will be distinct
 279         else
 280           gr += "#{v[0][:script]}\\n#{v[0][:finished_at]}"
 281         end
 282         gr += "\",#{determine_fillcolor n}];\n"
 283       end
 284       gr
 285     end
 286
 287   end
 288
 289   def self.create_provenance_graph(pdata, svgId, opts={})
 290     if pdata.is_a? Array or pdata.is_a? ArvadosResourceList
 291       p2 = {}
 292       pdata.each do |k|
 293         p2[k[:uuid].intern] = k if k[:uuid]
 294       end
 295       pdata = p2
 296     end
 297
 298     unless pdata.is_a? Hash
 299       raise "create_provenance_graph accepts Array or Hash for pdata only, pdata is #{pdata.class}"
 300     end
 301
 302     gr = """strict digraph {
 303 node [fontsize=10,shape=box];
 304 edge [fontsize=10];
 305 """
 306
 307     if opts[:direction] == :bottom_up
 308       gr += "edge [dir=back];"
 309     end
 310
 311     #puts "@pdata is #{pdata}"
 312
 313     g = GenerateGraph.new(pdata, opts)
 314
 315     pdata.each do |k, v|
 316       gr += g.generate_provenance_edges(k)
 317     end
 318
 319     gr += g.describe_jobs
 320
 321     gr += "}"
 322     svg = ""
 323
 324     #puts gr
 325
 326     require 'open3'
 327
 328     Open3.popen2("dot", "-Tsvg") do |stdin, stdout, wait_thr|
 329       stdin.print(gr)
 330       stdin.close
 331       svg = stdout.read()
 332       wait_thr.value
 333       stdout.close()
 334     end
 335
 336     svg = svg.sub(/<\?xml.*?\?>/m, "")
 337     svg = svg.sub(/<!DOCTYPE.*?>/m, "")
 338     svg = svg.sub(/<svg /, "<svg id=\"#{svgId}\" ")
 339   end
 340
 341   def self.find_collections(sp)
 342     c = []
 343     case sp
 344     when Hash
 345       sp.each do |k, v|
 346         c.concat(find_collections(v))
 347       end
 348     when Array
 349       sp.each do |v|
 350         c.concat(find_collections(v))
 351       end
 352     when String
 353       if !sp.empty?
 354         m = GenerateGraph::collection_uuid(sp)
 355         if m
 356           c << m
 357         end
 358       end
 359     end
 360     c
 361   end
 362 end