services/api/app/controllers/application_controller.rb

   1 # Copyright (C) The Arvados Authors. All rights reserved.
   2 #
   3 # SPDX-License-Identifier: AGPL-3.0
   4
   5 require 'safe_json'
   6
   7 module ApiTemplateOverride
   8   def allowed_to_render?(fieldset, field, model, options)
   9     return false if !super
  10     if options[:select]
  11       options[:select].include? field.to_s
  12     else
  13       true
  14     end
  15   end
  16 end
  17
  18 class ActsAsApi::ApiTemplate
  19   prepend ApiTemplateOverride
  20 end
  21
  22 require 'load_param'
  23
  24 class ApplicationController < ActionController::Base
  25   include ThemesForRails::ActionController
  26   include CurrentApiClient
  27   include LoadParam
  28   include DbCurrentTime
  29
  30   respond_to :json
  31   protect_from_forgery
  32
  33   ERROR_ACTIONS = [:render_error, :render_not_found]
  34
  35   before_filter :disable_api_methods
  36   before_filter :set_cors_headers
  37   before_filter :respond_with_json_by_default
  38   before_filter :remote_ip
  39   before_filter :load_read_auths
  40   before_filter :require_auth_scope, except: ERROR_ACTIONS
  41
  42   before_filter :catch_redirect_hint
  43   before_filter(:find_object_by_uuid,
  44                 except: [:index, :create] + ERROR_ACTIONS)
  45   before_filter :load_required_parameters
  46   before_filter :load_limit_offset_order_params, only: [:index, :contents]
  47   before_filter :load_where_param, only: [:index, :contents]
  48   before_filter :load_filters_param, only: [:index, :contents]
  49   before_filter :find_objects_for_index, :only => :index
  50   before_filter :reload_object_before_update, :only => :update
  51   before_filter(:render_404_if_no_object,
  52                 except: [:index, :create] + ERROR_ACTIONS)
  53
  54   theme Rails.configuration.arvados_theme
  55
  56   attr_writer :resource_attrs
  57
  58   begin
  59     rescue_from(Exception,
  60                 ArvadosModel::PermissionDeniedError,
  61                 :with => :render_error)
  62     rescue_from(ActiveRecord::RecordNotFound,
  63                 ActionController::RoutingError,
  64                 ActionController::UnknownController,
  65                 AbstractController::ActionNotFound,
  66                 :with => :render_not_found)
  67   end
  68
  69   def initialize *args
  70     super
  71     @object = nil
  72     @objects = nil
  73     @offset = nil
  74     @limit = nil
  75     @select = nil
  76     @distinct = nil
  77     @response_resource_name = nil
  78     @attrs = nil
  79   end
  80
  81   def default_url_options
  82     if Rails.configuration.host
  83       {:host => Rails.configuration.host}
  84     else
  85       {}
  86     end
  87   end
  88
  89   def index
  90     if params[:eager] and params[:eager] != '0' and params[:eager] != 0 and params[:eager] != ''
  91       @objects.each(&:eager_load_associations)
  92     end
  93     render_list
  94   end
  95
  96   def show
  97     send_json @object.as_api_response(nil, select: @select)
  98   end
  99
 100   def create
 101     @object = model_class.new resource_attrs
 102
 103     if @object.respond_to?(:name) && params[:ensure_unique_name]
 104       @object.save_with_unique_name!
 105     else
 106       @object.save!
 107     end
 108
 109     show
 110   end
 111
 112   def update
 113     attrs_to_update = resource_attrs.reject { |k,v|
 114       [:kind, :etag, :href].index k
 115     }
 116     @object.update_attributes! attrs_to_update
 117     show
 118   end
 119
 120   def destroy
 121     @object.destroy
 122     show
 123   end
 124
 125   def catch_redirect_hint
 126     if !current_user
 127       if params.has_key?('redirect_to') then
 128         session[:redirect_to] = params[:redirect_to]
 129       end
 130     end
 131   end
 132
 133   def render_404_if_no_object
 134     render_not_found "Object not found" if !@object
 135   end
 136
 137   def render_error(e)
 138     logger.error e.inspect
 139     if e.respond_to? :backtrace and e.backtrace
 140       logger.error e.backtrace.collect { |x| x + "\n" }.join('')
 141     end
 142     if (@object.respond_to? :errors and
 143         @object.errors.andand.full_messages.andand.any?)
 144       errors = @object.errors.full_messages
 145       logger.error errors.inspect
 146     else
 147       errors = [e.inspect]
 148     end
 149     status = e.respond_to?(:http_status) ? e.http_status : 422
 150     send_error(*errors, status: status)
 151   end
 152
 153   def render_not_found(e=ActionController::RoutingError.new("Path not found"))
 154     logger.error e.inspect
 155     send_error("Path not found", status: 404)
 156   end
 157
 158   protected
 159
 160   def send_error(*args)
 161     if args.last.is_a? Hash
 162       err = args.pop
 163     else
 164       err = {}
 165     end
 166     err[:errors] ||= args
 167     err[:error_token] = [Time.now.utc.to_i, "%08x" % rand(16 ** 8)].join("+")
 168     status = err.delete(:status) || 422
 169     logger.error "Error #{err[:error_token]}: #{status}"
 170     send_json err, status: status
 171   end
 172
 173   def send_json response, opts={}
 174     # The obvious render(json: ...) forces a slow JSON encoder. See
 175     # #3021 and commit logs. Might be fixed in Rails 4.1.
 176     render({
 177              text: SafeJSON.dump(response).html_safe,
 178              content_type: 'application/json'
 179            }.merge opts)
 180   end
 181
 182   def find_objects_for_index
 183     @objects ||= model_class.readable_by(*@read_users)
 184     apply_where_limit_order_params
 185   end
 186
 187   def apply_filters model_class=nil
 188     model_class ||= self.model_class
 189     @objects = model_class.apply_filters(@objects, @filters)
 190   end
 191
 192   def apply_where_limit_order_params model_class=nil
 193     model_class ||= self.model_class
 194     apply_filters model_class
 195
 196     ar_table_name = @objects.table_name
 197     if @where.is_a? Hash and @where.any?
 198       conditions = ['1=1']
 199       @where.each do |attr,value|
 200         if attr.to_s == 'any'
 201           if value.is_a?(Array) and
 202               value.length == 2 and
 203               value[0] == 'contains' then
 204             ilikes = []
 205             model_class.searchable_columns('ilike').each do |column|
 206               # Including owner_uuid in an "any column" search will
 207               # probably just return a lot of false positives.
 208               next if column == 'owner_uuid'
 209               ilikes << "#{ar_table_name}.#{column} ilike ?"
 210               conditions << "%#{value[1]}%"
 211             end
 212             if ilikes.any?
 213               conditions[0] << ' and (' + ilikes.join(' or ') + ')'
 214             end
 215           end
 216         elsif attr.to_s.match(/^[a-z][_a-z0-9]+$/) and
 217             model_class.columns.collect(&:name).index(attr.to_s)
 218           if value.nil?
 219             conditions[0] << " and #{ar_table_name}.#{attr} is ?"
 220             conditions << nil
 221           elsif value.is_a? Array
 222             if value[0] == 'contains' and value.length == 2
 223               conditions[0] << " and #{ar_table_name}.#{attr} like ?"
 224               conditions << "%#{value[1]}%"
 225             else
 226               conditions[0] << " and #{ar_table_name}.#{attr} in (?)"
 227               conditions << value
 228             end
 229           elsif value.is_a? String or value.is_a? Fixnum or value == true or value == false
 230             conditions[0] << " and #{ar_table_name}.#{attr}=?"
 231             conditions << value
 232           elsif value.is_a? Hash
 233             # Not quite the same thing as "equal?" but better than nothing?
 234             value.each do |k,v|
 235               if v.is_a? String
 236                 conditions[0] << " and #{ar_table_name}.#{attr} ilike ?"
 237                 conditions << "%#{k}%#{v}%"
 238               end
 239             end
 240           end
 241         end
 242       end
 243       if conditions.length > 1
 244         conditions[0].sub!(/^1=1 and /, '')
 245         @objects = @objects.
 246           where(*conditions)
 247       end
 248     end
 249
 250     if @select
 251       unless action_name.in? %w(create update destroy)
 252         # Map attribute names in @select to real column names, resolve
 253         # those to fully-qualified SQL column names, and pass the
 254         # resulting string to the select method.
 255         columns_list = model_class.columns_for_attributes(@select).
 256           map { |s| "#{ar_table_name}.#{ActiveRecord::Base.connection.quote_column_name s}" }
 257         @objects = @objects.select(columns_list.join(", "))
 258       end
 259
 260       # This information helps clients understand what they're seeing
 261       # (Workbench always expects it), but they can't select it explicitly
 262       # because it's not an SQL column.  Always add it.
 263       # (This is harmless, given that clients can deduce what they're
 264       # looking at by the returned UUID anyway.)
 265       @select |= ["kind"]
 266     end
 267     @objects = @objects.order(@orders.join ", ") if @orders.any?
 268     @objects = @objects.limit(@limit)
 269     @objects = @objects.offset(@offset)
 270     @objects = @objects.uniq(@distinct) if not @distinct.nil?
 271   end
 272
 273   # limit_database_read ensures @objects (which must be an
 274   # ActiveRelation) does not return too many results to fit in memory,
 275   # by previewing the results and calling @objects.limit() if
 276   # necessary.
 277   def limit_database_read(model_class:)
 278     return if @limit == 0 || @limit == 1
 279     model_class ||= self.model_class
 280     limit_columns = model_class.limit_index_columns_read
 281     limit_columns &= model_class.columns_for_attributes(@select) if @select
 282     return if limit_columns.empty?
 283     model_class.transaction do
 284       limit_query = @objects.
 285         except(:select, :distinct).
 286         select("(%s) as read_length" %
 287                limit_columns.map { |s| "octet_length(#{model_class.table_name}.#{s})" }.join(" + "))
 288       new_limit = 0
 289       read_total = 0
 290       limit_query.each do |record|
 291         new_limit += 1
 292         read_total += record.read_length.to_i
 293         if read_total >= Rails.configuration.max_index_database_read
 294           new_limit -= 1 if new_limit > 1
 295           @limit = new_limit
 296           break
 297         elsif new_limit >= @limit
 298           break
 299         end
 300       end
 301       @objects = @objects.limit(@limit)
 302       # Force @objects to run its query inside this transaction.
 303       @objects.each { |_| break }
 304     end
 305   end
 306
 307   def resource_attrs
 308     return @attrs if @attrs
 309     @attrs = params[resource_name]
 310     if @attrs.is_a? String
 311       @attrs = Oj.strict_load @attrs, symbol_keys: true
 312     end
 313     unless @attrs.is_a? Hash
 314       message = "No #{resource_name}"
 315       if resource_name.index('_')
 316         message << " (or #{resource_name.camelcase(:lower)})"
 317       end
 318       message << " hash provided with request"
 319       raise ArgumentError.new(message)
 320     end
 321     %w(created_at modified_by_client_uuid modified_by_user_uuid modified_at).each do |x|
 322       @attrs.delete x.to_sym
 323     end
 324     @attrs = @attrs.symbolize_keys if @attrs.is_a? HashWithIndifferentAccess
 325     @attrs
 326   end
 327
 328   # Authentication
 329   def load_read_auths
 330     @read_auths = []
 331     if current_api_client_authorization
 332       @read_auths << current_api_client_authorization
 333     end
 334     # Load reader tokens if this is a read request.
 335     # If there are too many reader tokens, assume the request is malicious
 336     # and ignore it.
 337     if request.get? and params[:reader_tokens] and
 338         params[:reader_tokens].size < 100
 339       @read_auths += ApiClientAuthorization
 340         .includes(:user)
 341         .where('api_token IN (?) AND
 342                 (expires_at IS NULL OR expires_at > CURRENT_TIMESTAMP)',
 343                params[:reader_tokens])
 344         .all
 345     end
 346     @read_auths.select! { |auth| auth.scopes_allow_request? request }
 347     @read_users = @read_auths.map { |auth| auth.user }.uniq
 348   end
 349
 350   def require_login
 351     if not current_user
 352       respond_to do |format|
 353         format.json { send_error("Not logged in", status: 401) }
 354         format.html { redirect_to '/auth/joshid' }
 355       end
 356       false
 357     end
 358   end
 359
 360   def admin_required
 361     unless current_user and current_user.is_admin
 362       send_error("Forbidden", status: 403)
 363     end
 364   end
 365
 366   def require_auth_scope
 367     if @read_auths.empty?
 368       if require_login != false
 369         send_error("Forbidden", status: 403)
 370       end
 371       false
 372     end
 373   end
 374
 375   def disable_api_methods
 376     if Rails.configuration.disable_api_methods.
 377         include?(controller_name + "." + action_name)
 378       send_error("Disabled", status: 404)
 379     end
 380   end
 381
 382   def set_cors_headers
 383     response.headers['Access-Control-Allow-Origin'] = '*'
 384     response.headers['Access-Control-Allow-Methods'] = 'GET, HEAD, PUT, POST, DELETE'
 385     response.headers['Access-Control-Allow-Headers'] = 'Authorization'
 386     response.headers['Access-Control-Max-Age'] = '86486400'
 387   end
 388
 389   def respond_with_json_by_default
 390     html_index = request.accepts.index(Mime::HTML)
 391     if html_index.nil? or request.accepts[0...html_index].include?(Mime::JSON)
 392       request.format = :json
 393     end
 394   end
 395
 396   def model_class
 397     controller_name.classify.constantize
 398   end
 399
 400   def resource_name             # params[] key used by client
 401     controller_name.singularize
 402   end
 403
 404   def table_name
 405     controller_name
 406   end
 407
 408   def find_object_by_uuid
 409     if params[:id] and params[:id].match(/\D/)
 410       params[:uuid] = params.delete :id
 411     end
 412     @where = { uuid: params[:uuid] }
 413     @offset = 0
 414     @limit = 1
 415     @orders = []
 416     @filters = []
 417     @objects = nil
 418     find_objects_for_index
 419     @object = @objects.first
 420   end
 421
 422   def reload_object_before_update
 423     # This is necessary to prevent an ActiveRecord::ReadOnlyRecord
 424     # error when updating an object which was retrieved using a join.
 425     if @object.andand.readonly?
 426       @object = model_class.find_by_uuid(@objects.first.uuid)
 427     end
 428   end
 429
 430   def load_json_value(hash, key, must_be_class=nil)
 431     if hash[key].is_a? String
 432       hash[key] = SafeJSON.load(hash[key])
 433       if must_be_class and !hash[key].is_a? must_be_class
 434         raise TypeError.new("parameter #{key.to_s} must be a #{must_be_class.to_s}")
 435       end
 436     end
 437   end
 438
 439   def self.accept_attribute_as_json(attr, must_be_class=nil)
 440     before_filter lambda { accept_attribute_as_json attr, must_be_class }
 441   end
 442   accept_attribute_as_json :properties, Hash
 443   accept_attribute_as_json :info, Hash
 444   def accept_attribute_as_json(attr, must_be_class)
 445     if params[resource_name] and resource_attrs.is_a? Hash
 446       if resource_attrs[attr].is_a? Hash
 447         # Convert symbol keys to strings (in hashes provided by
 448         # resource_attrs)
 449         resource_attrs[attr] = resource_attrs[attr].
 450           with_indifferent_access.to_hash
 451       else
 452         load_json_value(resource_attrs, attr, must_be_class)
 453       end
 454     end
 455   end
 456
 457   def self.accept_param_as_json(key, must_be_class=nil)
 458     prepend_before_filter lambda { load_json_value(params, key, must_be_class) }
 459   end
 460   accept_param_as_json :reader_tokens, Array
 461
 462   def object_list(model_class:)
 463     if @objects.respond_to?(:except)
 464       limit_database_read(model_class: model_class)
 465     end
 466     list = {
 467       :kind  => "arvados##{(@response_resource_name || resource_name).camelize(:lower)}List",
 468       :etag => "",
 469       :self_link => "",
 470       :offset => @offset,
 471       :limit => @limit,
 472       :items => @objects.as_api_response(nil, {select: @select})
 473     }
 474     case params[:count]
 475     when nil, '', 'exact'
 476       if @objects.respond_to? :except
 477         list[:items_available] = @objects.
 478           except(:limit).except(:offset).
 479           count(:id, distinct: true)
 480       end
 481     when 'none'
 482     else
 483       raise ArgumentError.new("count parameter must be 'exact' or 'none'")
 484     end
 485     list
 486   end
 487
 488   def render_list
 489     send_json object_list(model_class: self.model_class)
 490   end
 491
 492   def remote_ip
 493     # Caveat: this is highly dependent on the proxy setup. YMMV.
 494     if request.headers.key?('HTTP_X_REAL_IP') then
 495       # We're behind a reverse proxy
 496       @remote_ip = request.headers['HTTP_X_REAL_IP']
 497     else
 498       # Hopefully, we are not!
 499       @remote_ip = request.env['REMOTE_ADDR']
 500     end
 501   end
 502
 503   def load_required_parameters
 504     (self.class.send "_#{params[:action]}_requires_parameters" rescue {}).
 505       each do |key, info|
 506       if info[:required] and not params.include?(key)
 507         raise ArgumentError.new("#{key} parameter is required")
 508       elsif info[:type] == 'boolean'
 509         # Make sure params[key] is either true or false -- not a
 510         # string, not nil, etc.
 511         if not params.include?(key)
 512           params[key] = info[:default]
 513         elsif [false, 'false', '0', 0].include? params[key]
 514           params[key] = false
 515         elsif [true, 'true', '1', 1].include? params[key]
 516           params[key] = true
 517         else
 518           raise TypeError.new("#{key} parameter must be a boolean, true or false")
 519         end
 520       end
 521     end
 522     true
 523   end
 524
 525   def self._create_requires_parameters
 526     {
 527       ensure_unique_name: {
 528         type: "boolean",
 529         description: "Adjust name to ensure uniqueness instead of returning an error on (owner_uuid, name) collision.",
 530         location: "query",
 531         required: false,
 532         default: false
 533       }
 534     }
 535   end
 536
 537   def self._index_requires_parameters
 538     {
 539       filters: { type: 'array', required: false },
 540       where: { type: 'object', required: false },
 541       order: { type: 'array', required: false },
 542       select: { type: 'array', required: false },
 543       distinct: { type: 'boolean', required: false },
 544       limit: { type: 'integer', required: false, default: DEFAULT_LIMIT },
 545       offset: { type: 'integer', required: false, default: 0 },
 546       count: { type: 'string', required: false, default: 'exact' },
 547     }
 548   end
 549
 550   def client_accepts_plain_text_stream
 551     (request.headers['Accept'].split(' ') &
 552      ['text/plain', '*/*']).count > 0
 553   end
 554
 555   def render *opts
 556     if opts.first
 557       response = opts.first[:json]
 558       if response.is_a?(Hash) &&
 559           params[:_profile] &&
 560           Thread.current[:request_starttime]
 561         response[:_profile] = {
 562           request_time: Time.now - Thread.current[:request_starttime]
 563         }
 564       end
 565     end
 566     super(*opts)
 567   end
 568 end