16470: File updates & additions from 'rake rails:update'
[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         include_old_versions: {
19           type: 'boolean', required: false, description: "Include past collection versions."
20         },
21       })
22   end
23
24   def self._show_requires_parameters
25     (super rescue {}).
26       merge({
27         include_trash: {
28           type: 'boolean', required: false, description: "Show collection even if its is_trashed attribute is true."
29         },
30         include_old_versions: {
31           type: 'boolean', required: false, description: "Include past collection versions."
32         },
33       })
34   end
35
36   def create
37     if resource_attrs[:uuid] and (loc = Keep::Locator.parse(resource_attrs[:uuid]))
38       resource_attrs[:portable_data_hash] = loc.to_s
39       resource_attrs.delete :uuid
40     end
41     resource_attrs.delete :version
42     resource_attrs.delete :current_version_uuid
43     super
44   end
45
46   def find_objects_for_index
47     opts = {}
48     if params[:include_trash] || ['destroy', 'trash', 'untrash'].include?(action_name)
49       opts.update({include_trash: true})
50     end
51     if params[:include_old_versions] || @include_old_versions
52       opts.update({include_old_versions: true})
53     end
54     @objects = Collection.readable_by(*@read_users, opts) if !opts.empty?
55     super
56   end
57
58   def find_object_by_uuid
59     @include_old_versions = true
60
61     if loc = Keep::Locator.parse(params[:id])
62       loc.strip_hints!
63
64       # It matters which Collection object we pick because we use it to get signed_manifest_text,
65       # the value of which is affected by the value of trash_at.
66       #
67       # From postgres doc: "By default, null values sort as if larger than any non-null
68       # value; that is, NULLS FIRST is the default for DESC order, and
69       # NULLS LAST otherwise."
70       #
71       # "trash_at desc" sorts null first, then latest to earliest, so
72       # it will select the Collection object with the longest
73       # available lifetime.
74
75       if c = Collection.readable_by(*@read_users).where({ portable_data_hash: loc.to_s }).order("trash_at desc").limit(1).first
76         @object = {
77           uuid: c.portable_data_hash,
78           portable_data_hash: c.portable_data_hash,
79           manifest_text: c.signed_manifest_text,
80         }
81       end
82       true
83     else
84       super
85     end
86   end
87
88   def show
89     if @object.is_a? Collection
90       # Omit unsigned_manifest_text
91       @select ||= model_class.selectable_attributes - ["unsigned_manifest_text"]
92       super
93     else
94       send_json @object
95     end
96   end
97
98
99   def find_collections(visited, sp, ignore_columns=[], &b)
100     case sp
101     when ArvadosModel
102       sp.class.columns.each do |c|
103         find_collections(visited, sp[c.name.to_sym], &b) if !ignore_columns.include?(c.name)
104       end
105     when Hash
106       sp.each do |k, v|
107         find_collections(visited, v, &b)
108       end
109     when Array
110       sp.each do |v|
111         find_collections(visited, v, &b)
112       end
113     when String
114       if m = /[a-f0-9]{32}\+\d+/.match(sp)
115         yield m[0], nil
116       elsif m = Collection.uuid_regex.match(sp)
117         yield nil, m[0]
118       end
119     end
120   end
121
122   def search_edges(visited, uuid, direction)
123     if uuid.nil? or uuid.empty? or visited[uuid]
124       return
125     end
126
127     if loc = Keep::Locator.parse(uuid)
128       loc.strip_hints!
129       return if visited[loc.to_s]
130     end
131
132     if loc
133       # uuid is a portable_data_hash
134       collections = Collection.readable_by(*@read_users).where(portable_data_hash: loc.to_s)
135       c = collections.limit(2).all
136       if c.size == 1
137         visited[loc.to_s] = c[0]
138       elsif c.size > 1
139         name = collections.limit(1).where("name <> ''").first
140         if name
141           visited[loc.to_s] = {
142             portable_data_hash: c[0].portable_data_hash,
143             name: "#{name.name} + #{collections.count-1} more"
144           }
145         else
146           visited[loc.to_s] = {
147             portable_data_hash: c[0].portable_data_hash,
148             name: loc.to_s
149           }
150         end
151       end
152
153       if direction == :search_up
154         # Search upstream for jobs where this locator is the output of some job
155         if !Rails.configuration.API.DisabledAPIs["jobs.list"]
156           Job.readable_by(*@read_users).where(output: loc.to_s).each do |job|
157             search_edges(visited, job.uuid, :search_up)
158           end
159
160           Job.readable_by(*@read_users).where(log: loc.to_s).each do |job|
161             search_edges(visited, job.uuid, :search_up)
162           end
163         end
164
165         Container.readable_by(*@read_users).where(output: loc.to_s).each do |c|
166           search_edges(visited, c.uuid, :search_up)
167         end
168
169         Container.readable_by(*@read_users).where(log: loc.to_s).each do |c|
170           search_edges(visited, c.uuid, :search_up)
171         end
172       elsif direction == :search_down
173         if loc.to_s == "d41d8cd98f00b204e9800998ecf8427e+0"
174           # Special case, don't follow the empty collection.
175           return
176         end
177
178         # Search downstream for jobs where this locator is in script_parameters
179         if !Rails.configuration.API.DisabledAPIs["jobs.list"]
180           Job.readable_by(*@read_users).where(["jobs.script_parameters like ?", "%#{loc.to_s}%"]).each do |job|
181             search_edges(visited, job.uuid, :search_down)
182           end
183
184           Job.readable_by(*@read_users).where(["jobs.docker_image_locator = ?", "#{loc.to_s}"]).each do |job|
185             search_edges(visited, job.uuid, :search_down)
186           end
187         end
188
189         Container.readable_by(*@read_users).where([Container.full_text_trgm + " like ?", "%#{loc.to_s}%"]).each do |c|
190           if c.output != loc.to_s && c.log != loc.to_s
191             search_edges(visited, c.uuid, :search_down)
192           end
193         end
194       end
195     else
196       # uuid is a regular Arvados UUID
197       rsc = ArvadosModel::resource_class_for_uuid uuid
198       if rsc == Job
199         Job.readable_by(*@read_users).where(uuid: uuid).each do |job|
200           visited[uuid] = job.as_api_response
201           if direction == :search_up
202             # Follow upstream collections referenced in the script parameters
203             find_collections(visited, job) do |hash, col_uuid|
204               search_edges(visited, hash, :search_up) if hash
205               search_edges(visited, col_uuid, :search_up) if col_uuid
206             end
207           elsif direction == :search_down
208             # Follow downstream job output
209             search_edges(visited, job.output, direction)
210           end
211         end
212       elsif rsc == Container
213         c = Container.readable_by(*@read_users).where(uuid: uuid).limit(1).first
214         if c
215           visited[uuid] = c.as_api_response
216           if direction == :search_up
217             # Follow upstream collections referenced in the script parameters
218             find_collections(visited, c, ignore_columns=["log", "output"]) do |hash, col_uuid|
219               search_edges(visited, hash, :search_up) if hash
220               search_edges(visited, col_uuid, :search_up) if col_uuid
221             end
222           elsif direction == :search_down
223             # Follow downstream job output
224             search_edges(visited, c.output, :search_down)
225           end
226         end
227       elsif rsc == ContainerRequest
228         c = ContainerRequest.readable_by(*@read_users).where(uuid: uuid).limit(1).first
229         if c
230           visited[uuid] = c.as_api_response
231           if direction == :search_up
232             # Follow upstream collections
233             find_collections(visited, c, ignore_columns=["log_uuid", "output_uuid"]) do |hash, col_uuid|
234               search_edges(visited, hash, :search_up) if hash
235               search_edges(visited, col_uuid, :search_up) if col_uuid
236             end
237           elsif direction == :search_down
238             # Follow downstream job output
239             search_edges(visited, c.output_uuid, :search_down)
240           end
241         end
242       elsif rsc == Collection
243         c = Collection.readable_by(*@read_users).where(uuid: uuid).limit(1).first
244         if c
245           if direction == :search_up
246             visited[c.uuid] = c.as_api_response
247
248             if !Rails.configuration.API.DisabledAPIs["jobs.list"]
249               Job.readable_by(*@read_users).where(output: c.portable_data_hash).each do |job|
250                 search_edges(visited, job.uuid, :search_up)
251               end
252
253               Job.readable_by(*@read_users).where(log: c.portable_data_hash).each do |job|
254                 search_edges(visited, job.uuid, :search_up)
255               end
256             end
257
258             ContainerRequest.readable_by(*@read_users).where(output_uuid: uuid).each do |cr|
259               search_edges(visited, cr.uuid, :search_up)
260             end
261
262             ContainerRequest.readable_by(*@read_users).where(log_uuid: uuid).each do |cr|
263               search_edges(visited, cr.uuid, :search_up)
264             end
265           elsif direction == :search_down
266             search_edges(visited, c.portable_data_hash, :search_down)
267           end
268         end
269       elsif rsc != nil
270         rsc.where(uuid: uuid).each do |r|
271           visited[uuid] = r.as_api_response
272         end
273       end
274     end
275
276     if direction == :search_up
277       # Search for provenance links pointing to the current uuid
278       Link.readable_by(*@read_users).
279         where(head_uuid: uuid, link_class: "provenance").
280         each do |link|
281         visited[link.uuid] = link.as_api_response
282         search_edges(visited, link.tail_uuid, direction)
283       end
284     elsif direction == :search_down
285       # Search for provenance links emanating from the current uuid
286       Link.readable_by(current_user).
287         where(tail_uuid: uuid, link_class: "provenance").
288         each do |link|
289         visited[link.uuid] = link.as_api_response
290         search_edges(visited, link.head_uuid, direction)
291       end
292     end
293   end
294
295   def provenance
296     visited = {}
297     if @object[:uuid]
298       search_edges(visited, @object[:uuid], :search_up)
299     else
300       search_edges(visited, @object[:portable_data_hash], :search_up)
301     end
302     send_json visited
303   end
304
305   def used_by
306     visited = {}
307     if @object[:uuid]
308       search_edges(visited, @object[:uuid], :search_down)
309     else
310       search_edges(visited, @object[:portable_data_hash], :search_down)
311     end
312     send_json visited
313   end
314
315   protected
316
317   def load_limit_offset_order_params *args
318     super
319     if action_name == 'index'
320       # Omit manifest_text and unsigned_manifest_text from index results unless expressly selected.
321       @select ||= model_class.selectable_attributes - ["manifest_text", "unsigned_manifest_text"]
322     end
323   end
324 end