Merge branch 'master' of git.curoverse.com:arvados into 11876-r-sdk
[arvados.git] / services / api / app / controllers / arvados / v1 / collections_controller.rb
1 # Copyright (C) The Arvados Authors. All rights reserved.
2 #
3 # SPDX-License-Identifier: AGPL-3.0
4
5 require "arvados/keep"
6 require "trashable"
7
8 class Arvados::V1::CollectionsController < ApplicationController
9   include DbCurrentTime
10   include TrashableController
11
12   def self._index_requires_parameters
13     (super rescue {}).
14       merge({
15         include_trash: {
16           type: 'boolean', required: false, description: "Include collections whose is_trashed attribute is true."
17         },
18       })
19   end
20
21   def create
22     if resource_attrs[:uuid] and (loc = Keep::Locator.parse(resource_attrs[:uuid]))
23       resource_attrs[:portable_data_hash] = loc.to_s
24       resource_attrs.delete :uuid
25     end
26     super
27   end
28
29   def find_objects_for_index
30     if params[:include_trash] || ['destroy', 'trash', 'untrash'].include?(action_name)
31       @objects = Collection.readable_by(*@read_users, {include_trash: true, query_on: Collection.unscoped})
32     end
33     super
34   end
35
36   def find_object_by_uuid
37     if loc = Keep::Locator.parse(params[:id])
38       loc.strip_hints!
39       if c = Collection.readable_by(*@read_users).where({ portable_data_hash: loc.to_s }).limit(1).first
40         @object = {
41           uuid: c.portable_data_hash,
42           portable_data_hash: c.portable_data_hash,
43           manifest_text: c.signed_manifest_text,
44         }
45       end
46       true
47     else
48       super
49     end
50   end
51
52   def show
53     if @object.is_a? Collection
54       # Omit unsigned_manifest_text
55       @select ||= model_class.selectable_attributes - ["unsigned_manifest_text"]
56       super
57     else
58       send_json @object
59     end
60   end
61
62
63   def find_collections(visited, sp, &b)
64     case sp
65     when ArvadosModel
66       sp.class.columns.each do |c|
67         find_collections(visited, sp[c.name.to_sym], &b) if c.name != "log"
68       end
69     when Hash
70       sp.each do |k, v|
71         find_collections(visited, v, &b)
72       end
73     when Array
74       sp.each do |v|
75         find_collections(visited, v, &b)
76       end
77     when String
78       if m = /[a-f0-9]{32}\+\d+/.match(sp)
79         yield m[0], nil
80       elsif m = Collection.uuid_regex.match(sp)
81         yield nil, m[0]
82       end
83     end
84   end
85
86   def search_edges(visited, uuid, direction)
87     if uuid.nil? or uuid.empty? or visited[uuid]
88       return
89     end
90
91     if loc = Keep::Locator.parse(uuid)
92       loc.strip_hints!
93       return if visited[loc.to_s]
94     end
95
96     logger.debug "visiting #{uuid}"
97
98     if loc
99       # uuid is a portable_data_hash
100       collections = Collection.readable_by(*@read_users).where(portable_data_hash: loc.to_s)
101       c = collections.limit(2).all
102       if c.size == 1
103         visited[loc.to_s] = c[0]
104       elsif c.size > 1
105         name = collections.limit(1).where("name <> ''").first
106         if name
107           visited[loc.to_s] = {
108             portable_data_hash: c[0].portable_data_hash,
109             name: "#{name.name} + #{collections.count-1} more"
110           }
111         else
112           visited[loc.to_s] = {
113             portable_data_hash: c[0].portable_data_hash,
114             name: loc.to_s
115           }
116         end
117       end
118
119       if direction == :search_up
120         # Search upstream for jobs where this locator is the output of some job
121         Job.readable_by(*@read_users).where(output: loc.to_s).each do |job|
122           search_edges(visited, job.uuid, :search_up)
123         end
124
125         Job.readable_by(*@read_users).where(log: loc.to_s).each do |job|
126           search_edges(visited, job.uuid, :search_up)
127         end
128       elsif direction == :search_down
129         if loc.to_s == "d41d8cd98f00b204e9800998ecf8427e+0"
130           # Special case, don't follow the empty collection.
131           return
132         end
133
134         # Search downstream for jobs where this locator is in script_parameters
135         Job.readable_by(*@read_users).where(["jobs.script_parameters like ?", "%#{loc.to_s}%"]).each do |job|
136           search_edges(visited, job.uuid, :search_down)
137         end
138
139         Job.readable_by(*@read_users).where(["jobs.docker_image_locator = ?", "#{loc.to_s}"]).each do |job|
140           search_edges(visited, job.uuid, :search_down)
141         end
142       end
143     else
144       # uuid is a regular Arvados UUID
145       rsc = ArvadosModel::resource_class_for_uuid uuid
146       if rsc == Job
147         Job.readable_by(*@read_users).where(uuid: uuid).each do |job|
148           visited[uuid] = job.as_api_response
149           if direction == :search_up
150             # Follow upstream collections referenced in the script parameters
151             find_collections(visited, job) do |hash, col_uuid|
152               search_edges(visited, hash, :search_up) if hash
153               search_edges(visited, col_uuid, :search_up) if col_uuid
154             end
155           elsif direction == :search_down
156             # Follow downstream job output
157             search_edges(visited, job.output, direction)
158           end
159         end
160       elsif rsc == Collection
161         if c = Collection.readable_by(*@read_users).where(uuid: uuid).limit(1).first
162           search_edges(visited, c.portable_data_hash, direction)
163           visited[c.portable_data_hash] = c.as_api_response
164         end
165       elsif rsc != nil
166         rsc.where(uuid: uuid).each do |r|
167           visited[uuid] = r.as_api_response
168         end
169       end
170     end
171
172     if direction == :search_up
173       # Search for provenance links pointing to the current uuid
174       Link.readable_by(*@read_users).
175         where(head_uuid: uuid, link_class: "provenance").
176         each do |link|
177         visited[link.uuid] = link.as_api_response
178         search_edges(visited, link.tail_uuid, direction)
179       end
180     elsif direction == :search_down
181       # Search for provenance links emanating from the current uuid
182       Link.readable_by(current_user).
183         where(tail_uuid: uuid, link_class: "provenance").
184         each do |link|
185         visited[link.uuid] = link.as_api_response
186         search_edges(visited, link.head_uuid, direction)
187       end
188     end
189   end
190
191   def provenance
192     visited = {}
193     search_edges(visited, @object[:portable_data_hash], :search_up)
194     search_edges(visited, @object[:uuid], :search_up)
195     send_json visited
196   end
197
198   def used_by
199     visited = {}
200     search_edges(visited, @object[:uuid], :search_down)
201     search_edges(visited, @object[:portable_data_hash], :search_down)
202     send_json visited
203   end
204
205   protected
206
207   def load_limit_offset_order_params *args
208     super
209     if action_name == 'index'
210       # Omit manifest_text and unsigned_manifest_text from index results unless expressly selected.
211       @select ||= model_class.selectable_attributes - ["manifest_text", "unsigned_manifest_text"]
212     end
213   end
214 end