apps/workbench/app/controllers/actions_controller.rb

   1 class ActionsController < ApplicationController
   2
   3   skip_filter :require_thread_api_token, only: [:report_issue_popup, :report_issue]
   4   skip_filter :check_user_agreements, only: [:report_issue_popup, :report_issue]
   5
   6   @@exposed_actions = {}
   7   def self.expose_action method, &block
   8     @@exposed_actions[method] = true
   9     define_method method, block
  10   end
  11
  12   def model_class
  13     ArvadosBase::resource_class_for_uuid(params[:uuid])
  14   end
  15
  16   def show
  17     @object = model_class.andand.find(params[:uuid])
  18     if @object.is_a? Link and
  19         @object.link_class == 'name' and
  20         ArvadosBase::resource_class_for_uuid(@object.head_uuid) == Collection
  21       redirect_to collection_path(id: @object.uuid)
  22     elsif @object
  23       redirect_to @object
  24     else
  25       raise ActiveRecord::RecordNotFound
  26     end
  27   end
  28
  29   def post
  30     params.keys.collect(&:to_sym).each do |param|
  31       if @@exposed_actions[param]
  32         return self.send(param)
  33       end
  34     end
  35     redirect_to :back
  36   end
  37
  38   expose_action :copy_selections_into_project do
  39     move_or_copy :copy
  40   end
  41
  42   expose_action :move_selections_into_project do
  43     move_or_copy :move
  44   end
  45
  46   def move_or_copy action
  47     uuids_to_add = params["selection"]
  48     uuids_to_add = [ uuids_to_add ] unless uuids_to_add.is_a? Array
  49     resource_classes = uuids_to_add.
  50       collect { |x| ArvadosBase::resource_class_for_uuid(x) }.
  51       uniq
  52     resource_classes.each do |resource_class|
  53       resource_class.filter([['uuid','in',uuids_to_add]]).each do |src|
  54         if resource_class == Collection and not Collection.attribute_info.include?(:name)
  55           dst = Link.new(owner_uuid: @object.uuid,
  56                          tail_uuid: @object.uuid,
  57                          head_uuid: src.uuid,
  58                          link_class: 'name',
  59                          name: src.uuid)
  60         else
  61           case action
  62           when :copy
  63             dst = src.dup
  64             if dst.respond_to? :'name='
  65               if dst.name
  66                 dst.name = "Copy of #{dst.name}"
  67               else
  68                 dst.name = "Copy of unnamed #{dst.class_for_display.downcase}"
  69               end
  70             end
  71             if resource_class == Collection
  72               dst.manifest_text = Collection.select([:manifest_text]).where(uuid: src.uuid).first.manifest_text
  73             end
  74           when :move
  75             dst = src
  76           else
  77             raise ArgumentError.new "Unsupported action #{action}"
  78           end
  79           dst.owner_uuid = @object.uuid
  80           dst.tail_uuid = @object.uuid if dst.class == Link
  81         end
  82         begin
  83           dst.save!
  84         rescue
  85           dst.name += " (#{Time.now.localtime})" if dst.respond_to? :name=
  86           dst.save!
  87         end
  88       end
  89     end
  90     if (resource_classes == [Collection] and
  91         @object.is_a? Group and
  92         @object.group_class == 'project')
  93       # In the common case where only collections are copied/moved
  94       # into a project, it's polite to land on the collections tab on
  95       # the destination project.
  96       redirect_to project_url(@object.uuid, anchor: 'Data_collections')
  97     else
  98       # Otherwise just land on the default (Description) tab.
  99       redirect_to @object
 100     end
 101   end
 102
 103   def arv_normalize mt, *opts
 104     r = ""
 105     env = Hash[ENV].
 106       merge({'ARVADOS_API_HOST' =>
 107               arvados_api_client.arvados_v1_base.
 108               sub(/\/arvados\/v1/, '').
 109               sub(/^https?:\/\//, ''),
 110               'ARVADOS_API_TOKEN' => 'x',
 111               'ARVADOS_API_HOST_INSECURE' =>
 112               Rails.configuration.arvados_insecure_https ? 'true' : 'false'
 113             })
 114     IO.popen([env, 'arv-normalize'] + opts, 'w+b') do |io|
 115       io.write mt
 116       io.close_write
 117       while buf = io.read(2**16)
 118         r += buf
 119       end
 120     end
 121     r
 122   end
 123
 124   expose_action :combine_selected_files_into_collection do
 125     uuids = []
 126     pdhs = []
 127     files = []
 128     params["selection"].each do |s|
 129       a = ArvadosBase::resource_class_for_uuid s
 130       if a == Link
 131         begin
 132           if (m = CollectionsHelper.match(Link.find(s).head_uuid))
 133             pdhs.append(m[1] + m[2])
 134             files.append(m)
 135           end
 136         rescue
 137         end
 138       elsif (m = CollectionsHelper.match(s))
 139         pdhs.append(m[1] + m[2])
 140         files.append(m)
 141       elsif (m = CollectionsHelper.match_uuid_with_optional_filepath(s))
 142         uuids.append(m[1])
 143         files.append(m)
 144       end
 145     end
 146
 147     pdhs = pdhs.uniq
 148     uuids = uuids.uniq
 149     chash = {}
 150
 151     Collection.select([:uuid, :manifest_text]).where(uuid: uuids).each do |c|
 152       chash[c.uuid] = c
 153     end
 154
 155     Collection.select([:portable_data_hash, :manifest_text]).where(portable_data_hash: pdhs).each do |c|
 156       chash[c.portable_data_hash] = c
 157     end
 158
 159     combined = ""
 160     files_in_dirs = {}
 161     files.each do |m|
 162       mt = chash[m[1]+m[2]].andand.manifest_text
 163       if not m[4].nil? and m[4].size > 1
 164         manifest_files = files_in_dirs['.']
 165         if !manifest_files
 166           manifest_files = []
 167           files_in_dirs['.'] = manifest_files
 168         end
 169         manifest_file = m[4].split('/')[-1]
 170         uniq_file = derive_unique_filename(manifest_file, manifest_files)
 171         normalized = arv_normalize mt, '--extract', ".#{m[4]}"
 172         index = normalized.rindex manifest_file
 173         part1 = normalized[0, index]
 174         part2 = normalized[index, normalized.length]
 175         part2 = part2.gsub(manifest_file) {|s| uniq_file}
 176         normalized = part1 + part2
 177         combined += normalized
 178         manifest_files << uniq_file
 179       else
 180         mt = arv_normalize mt
 181         manifest_streams = mt.split "\n"
 182         adjusted_streams = []
 183         manifest_streams.each do |stream|
 184           manifest_parts = stream.split
 185           adjusted_parts = []
 186           manifest_files = files_in_dirs[manifest_parts[0]]
 187           if !manifest_files
 188             manifest_files = []
 189             files_in_dirs[manifest_parts[0]] = manifest_files
 190           end
 191
 192           manifest_parts.each do |part|
 193             part_match = /\d*:\d*:(\S+)/.match(part)
 194             if part_match
 195               uniq_file = derive_unique_filename(part_match[1], manifest_files)
 196               adjusted_parts << (part.gsub(part_match[1]) {|s| uniq_file})
 197               manifest_files << uniq_file
 198             else
 199               adjusted_parts << part
 200             end
 201           end
 202           adjusted_streams << adjusted_parts.join(' ')
 203         end
 204         adjusted_streams.each do |stream|
 205           combined += (stream + "\n")
 206         end
 207       end
 208     end
 209
 210     normalized = arv_normalize combined
 211     newc = Collection.new({:manifest_text => normalized})
 212     newc.name = newc.name || "Collection created at #{Time.now.localtime}"
 213
 214     # set owner_uuid to current project, provided it is writable
 215     current_project_writable = false
 216     action_data = JSON.parse(params['action_data']) if params['action_data']
 217     if action_data && action_data['current_project_uuid']
 218       current_project = Group.find(action_data['current_project_uuid']) rescue nil
 219       if (current_project && current_project.writable_by.andand.include?(current_user.uuid))
 220         newc.owner_uuid = action_data['current_project_uuid']
 221         current_project_writable = true
 222       end
 223     end
 224
 225     newc.save!
 226
 227     chash.each do |k,v|
 228       l = Link.new({
 229                      tail_uuid: k,
 230                      head_uuid: newc.uuid,
 231                      link_class: "provenance",
 232                      name: "provided"
 233                    })
 234       l.save!
 235     end
 236
 237     msg = current_project_writable ?
 238               "Created new collection in the project #{current_project.name}." :
 239               "Created new collection in your Home project."
 240
 241     redirect_to newc, flash: {'message' => msg}
 242   end
 243
 244   def report_issue_popup
 245     respond_to do |format|
 246       format.js
 247       format.html
 248     end
 249   end
 250
 251   def report_issue
 252     logger.warn "report_issue: #{params.inspect}"
 253
 254     respond_to do |format|
 255       IssueReporter.send_report(current_user, params).deliver
 256       format.js {render nothing: true}
 257     end
 258   end
 259
 260   protected
 261
 262   def derive_unique_filename filename, manifest_files
 263     filename_parts = filename.split('.')
 264     filename_part = filename_parts[0]
 265     counter = 1
 266     while true
 267       return filename if !manifest_files.include? filename
 268       filename_parts[0] = filename_part + "(" + counter.to_s + ")"
 269       filename = filename_parts.join('.')
 270       counter += 1
 271     end
 272   end
 273
 274 end