# SPDX-License-Identifier: AGPL-3.0
require 'safe_json'
+require 'request_error'
module ApiTemplateOverride
def allowed_to_render?(fieldset, field, model, options)
ERROR_ACTIONS = [:render_error, :render_not_found]
- around_filter :set_current_request_id
- before_filter :disable_api_methods
- before_filter :set_cors_headers
- before_filter :respond_with_json_by_default
- before_filter :remote_ip
- before_filter :load_read_auths
- before_filter :require_auth_scope, except: ERROR_ACTIONS
+ around_action :set_current_request_id
+ before_action :disable_api_methods
+ before_action :set_cors_headers
+ before_action :respond_with_json_by_default
+ before_action :remote_ip
+ before_action :load_read_auths
+ before_action :require_auth_scope, except: ERROR_ACTIONS
- before_filter :catch_redirect_hint
- before_filter(:find_object_by_uuid,
+ before_action :catch_redirect_hint
+ before_action(:find_object_by_uuid,
except: [:index, :create] + ERROR_ACTIONS)
- before_filter :load_required_parameters
- before_filter :load_limit_offset_order_params, only: [:index, :contents]
- before_filter :load_where_param, only: [:index, :contents]
- before_filter :load_filters_param, only: [:index, :contents]
- before_filter :find_objects_for_index, :only => :index
- before_filter :reload_object_before_update, :only => :update
- before_filter(:render_404_if_no_object,
+ before_action :load_required_parameters
+ before_action :load_limit_offset_order_params, only: [:index, :contents]
+ before_action :load_where_param, only: [:index, :contents]
+ before_action :load_filters_param, only: [:index, :contents]
+ before_action :find_objects_for_index, :only => :index
+ before_action :reload_object_before_update, :only => :update
+ before_action(:render_404_if_no_object,
except: [:index, :create] + ERROR_ACTIONS)
- theme Rails.configuration.arvados_theme
-
attr_writer :resource_attrs
begin
@distinct = nil
@response_resource_name = nil
@attrs = nil
+ @extra_included = nil
end
def default_url_options
- if Rails.configuration.host
- {:host => Rails.configuration.host}
- else
- {}
+ options = {}
+ if Rails.configuration.Services.Controller.ExternalURL != URI("")
+ exturl = Rails.configuration.Services.Controller.ExternalURL
+ options[:host] = exturl.host
+ options[:port] = exturl.port
+ options[:protocol] = exturl.scheme
end
+ options
end
def index
def render_error(e)
logger.error e.inspect
- if e.respond_to? :backtrace and e.backtrace
+ if !e.is_a? RequestError and (e.respond_to? :backtrace and e.backtrace)
logger.error e.backtrace.collect { |x| x + "\n" }.join('')
end
if (@object.respond_to? :errors and
send_error("Path not found", status: 404)
end
+ def render_accepted
+ send_json ({accepted: true}), status: 202
+ end
+
protected
def send_error(*args)
# The obvious render(json: ...) forces a slow JSON encoder. See
# #3021 and commit logs. Might be fixed in Rails 4.1.
render({
- text: SafeJSON.dump(response).html_safe,
+ plain: SafeJSON.dump(response).html_safe,
content_type: 'application/json'
}.merge opts)
end
def find_objects_for_index
- @objects ||= model_class.readable_by(*@read_users, {:include_trash => (params[:include_trash] || 'untrash' == action_name)})
+ @objects ||= model_class.readable_by(*@read_users, {
+ :include_trash => (params[:include_trash] || 'untrash' == action_name),
+ :include_old_versions => params[:include_old_versions]
+ })
apply_where_limit_order_params
end
conditions[0] << " and #{ar_table_name}.#{attr} in (?)"
conditions << value
end
- elsif value.is_a? String or value.is_a? Fixnum or value == true or value == false
+ elsif value.is_a? String or value.is_a? Integer or value == true or value == false
conditions[0] << " and #{ar_table_name}.#{attr}=?"
conditions << value
elsif value.is_a? Hash
@objects = @objects.order(@orders.join ", ") if @orders.any?
@objects = @objects.limit(@limit)
@objects = @objects.offset(@offset)
- @objects = @objects.uniq(@distinct) if not @distinct.nil?
+ @objects = @objects.distinct(@distinct) if not @distinct.nil?
end
# limit_database_read ensures @objects (which must be an
limit_query.each do |record|
new_limit += 1
read_total += record.read_length.to_i
- if read_total >= Rails.configuration.max_index_database_read
+ if read_total >= Rails.configuration.API.MaxIndexDatabaseRead
new_limit -= 1 if new_limit > 1
@limit = new_limit
break
def resource_attrs
return @attrs if @attrs
@attrs = params[resource_name]
- if @attrs.is_a? String
+ if @attrs.nil?
+ @attrs = {}
+ elsif @attrs.is_a? String
@attrs = Oj.strict_load @attrs, symbol_keys: true
end
- unless @attrs.is_a? Hash
+ unless [Hash, ActionController::Parameters].include? @attrs.class
message = "No #{resource_name}"
if resource_name.index('_')
message << " (or #{resource_name.camelcase(:lower)})"
# If there are too many reader tokens, assume the request is malicious
# and ignore it.
if request.get? and params[:reader_tokens] and
- params[:reader_tokens].size < 100
+ params[:reader_tokens].size < 100
+ secrets = params[:reader_tokens].map { |t|
+ if t.is_a? String and t.starts_with? "v2/"
+ t.split("/")[2]
+ else
+ t
+ end
+ }
@read_auths += ApiClientAuthorization
.includes(:user)
.where('api_token IN (?) AND
(expires_at IS NULL OR expires_at > CURRENT_TIMESTAMP)',
- params[:reader_tokens])
- .all
+ secrets)
+ .to_a
end
@read_auths.select! { |auth| auth.scopes_allow_request? request }
@read_users = @read_auths.map(&:user).uniq
req_id = "req-" + Random::DEFAULT.rand(2**128).to_s(36)[0..19]
end
response.headers['X-Request-Id'] = Thread.current[:request_id] = req_id
- yield
+ Rails.logger.tagged(req_id) do
+ yield
+ end
Thread.current[:request_id] = nil
end
end
def disable_api_methods
- if Rails.configuration.disable_api_methods.
- include?(controller_name + "." + action_name)
+ if Rails.configuration.API.DisabledAPIs.include?(controller_name + "." + action_name)
send_error("Disabled", status: 404)
end
end
def set_cors_headers
response.headers['Access-Control-Allow-Origin'] = '*'
response.headers['Access-Control-Allow-Methods'] = 'GET, HEAD, PUT, POST, DELETE'
- response.headers['Access-Control-Allow-Headers'] = 'Authorization'
+ response.headers['Access-Control-Allow-Headers'] = 'Authorization, Content-Type'
response.headers['Access-Control-Max-Age'] = '86486400'
end
def respond_with_json_by_default
- html_index = request.accepts.index(Mime::HTML)
- if html_index.nil? or request.accepts[0...html_index].include?(Mime::JSON)
+ html_index = request.accepts.index(Mime[:html])
+ if html_index.nil? or request.accepts[0...html_index].include?(Mime[:json])
request.format = :json
end
end
end
def load_json_value(hash, key, must_be_class=nil)
- if hash[key].is_a? String
- hash[key] = SafeJSON.load(hash[key])
- if must_be_class and !hash[key].is_a? must_be_class
- raise TypeError.new("parameter #{key.to_s} must be a #{must_be_class.to_s}")
- end
+ return if hash[key].nil?
+
+ val = hash[key]
+ if val.is_a? ActionController::Parameters
+ val = val.to_unsafe_hash
+ elsif val.is_a? String
+ val = SafeJSON.load(val)
+ hash[key] = val
+ end
+ # When assigning a Hash to an ActionController::Parameters and then
+ # retrieve it, we get another ActionController::Parameters instead of
+ # a Hash. This doesn't happen with other types. This is why 'val' is
+ # being used to do type checking below.
+ if must_be_class and !val.is_a? must_be_class
+ raise TypeError.new("parameter #{key.to_s} must be a #{must_be_class.to_s}")
end
end
def self.accept_attribute_as_json(attr, must_be_class=nil)
- before_filter lambda { accept_attribute_as_json attr, must_be_class }
+ before_action lambda { accept_attribute_as_json attr, must_be_class }
end
accept_attribute_as_json :properties, Hash
accept_attribute_as_json :info, Hash
def accept_attribute_as_json(attr, must_be_class)
- if params[resource_name] and resource_attrs.is_a? Hash
+ if params[resource_name] and [Hash, ActionController::Parameters].include?(resource_attrs.class)
if resource_attrs[attr].is_a? Hash
# Convert symbol keys to strings (in hashes provided by
# resource_attrs)
end
def self.accept_param_as_json(key, must_be_class=nil)
- prepend_before_filter lambda { load_json_value(params, key, must_be_class) }
+ prepend_before_action lambda { load_json_value(params, key, must_be_class) }
end
accept_param_as_json :reader_tokens, Array
:limit => @limit,
:items => @objects.as_api_response(nil, {select: @select})
}
+ if @extra_included
+ list[:included] = @extra_included.as_api_response(nil, {select: @select})
+ end
case params[:count]
when nil, '', 'exact'
if @objects.respond_to? :except
list[:items_available] = @objects.
except(:limit).except(:offset).
- count(:id, distinct: true)
+ distinct.count(:id)
end
when 'none'
else
location: "query",
required: false,
default: false
- }
+ },
+ cluster_id: {
+ type: 'string',
+ description: "Create object on a remote federated cluster instead of the current one.",
+ location: "query",
+ required: false,
+ },
}
end
+ def self._update_requires_parameters
+ {}
+ end
+
def self._index_requires_parameters
{
filters: { type: 'array', required: false },
limit: { type: 'integer', required: false, default: DEFAULT_LIMIT },
offset: { type: 'integer', required: false, default: 0 },
count: { type: 'string', required: false, default: 'exact' },
+ cluster_id: {
+ type: 'string',
+ description: "List objects on a remote federated cluster instead of the current one.",
+ location: "query",
+ required: false,
+ },
}
end