# Methods that don't require login should
# skip_around_filter :require_thread_api_token
around_filter :require_thread_api_token, except: ERROR_ACTIONS
+ before_filter :set_cache_buster
before_filter :accept_uuid_as_id_param, except: ERROR_ACTIONS
before_filter :check_user_agreements, except: ERROR_ACTIONS
before_filter :check_user_profile, except: ERROR_ACTIONS
with: :render_exception)
end
+ def set_cache_buster
+ response.headers["Cache-Control"] = "no-cache, no-store, max-age=0, must-revalidate"
+ response.headers["Pragma"] = "no-cache"
+ response.headers["Expires"] = "Fri, 01 Jan 1990 00:00:00 GMT"
+ end
+
def unprocessable(message=nil)
@errors ||= []
end
end
+ # params[:order]:
+ #
+ # The order can be left empty to allow it to default.
+ # Or it can be a comma separated list of real database column names, one per model.
+ # Column names should always be qualified by a table name and a direction is optional, defaulting to asc
+ # (e.g. "collections.name" or "collections.name desc").
+ # If a column name is specified, that table will be sorted by that column.
+ # If there are objects from different models that will be shown (such as in Jobs and Pipelines tab),
+ # then a sort column name can optionally be specified for each model, passed as an comma-separated list (e.g. "jobs.script, pipeline_instances.name")
+ # Currently only one sort column name and direction can be specified for each model.
def load_filters_and_paging_params
- @order = params[:order] || 'created_at desc'
+ if params[:order].blank?
+ @order = 'created_at desc'
+ elsif params[:order].is_a? Array
+ @order = params[:order]
+ else
+ begin
+ @order = JSON.load(params[:order])
+ rescue
+ @order = params[:order].split(',')
+ end
+ end
@order = [@order] unless @order.is_a? Array
@limit ||= 200
end
end
end
+ # After this, params[:filters] can be trusted to be an array of arrays:
+ params[:filters] = filters
@filters += filters
end
end
return render_not_found("object not found")
end
respond_to do |f|
- f.json { render json: @object.attributes.merge(href: url_for(action: :show, id: @object)) }
+ f.json do
+ extra_attrs = { href: url_for(action: :show, id: @object) }
+ @object.textile_attributes.each do |textile_attr|
+ extra_attrs.merge!({ "#{textile_attr}Textile" => view_context.render_markup(@object.attributes[textile_attr]) })
+ end
+ render json: @object.attributes.merge(extra_attrs)
+ end
f.html {
if params['tab_pane']
- render_pane params['tab_pane']
+ render_pane(if params['tab_pane'].is_a? Hash then params['tab_pane']["name"] else params['tab_pane'] end)
elsif request.method.in? ['GET', 'HEAD']
render
else
false # For convenience to return from callbacks
end
- def using_specific_api_token(api_token)
+ def using_specific_api_token(api_token, opts={})
start_values = {}
[:arvados_api_token, :user].each do |key|
start_values[key] = Thread.current[key]
end
- load_api_token(api_token)
+ if opts.fetch(:load_user, true)
+ load_api_token(api_token)
+ else
+ Thread.current[:arvados_api_token] = api_token
+ Thread.current[:user] = nil
+ end
begin
yield
ensure
end.reverse
end
+ helper_method :running_pipelines
+ def running_pipelines
+ pi = PipelineInstance.order(["started_at asc", "created_at asc"]).filter([["state", "in", ["RunningOnServer", "RunningOnClient"]]])
+ jobs = {}
+ pi.each do |pl|
+ pl.components.each do |k,v|
+ if v.is_a? Hash and v[:job]
+ jobs[v[:job][:uuid]] = {}
+ end
+ end
+ end
+
+ if jobs.keys.any?
+ Job.filter([["uuid", "in", jobs.keys]]).each do |j|
+ jobs[j[:uuid]] = j
+ end
+
+ pi.each do |pl|
+ pl.components.each do |k,v|
+ if v.is_a? Hash and v[:job]
+ v[:job] = jobs[v[:job][:uuid]]
+ end
+ end
+ end
+ end
+
+ pi
+ end
+
+ helper_method :finished_pipelines
+ def finished_pipelines lim
+ PipelineInstance.limit(lim).order(["finished_at desc"]).filter([["state", "in", ["Complete", "Failed", "Paused"]], ["finished_at", "!=", nil]])
+ end
+
+ helper_method :recent_collections
+ def recent_collections lim
+ c = Collection.limit(lim).order(["modified_at desc"]).filter([["owner_uuid", "is_a", "arvados#group"]])
+ own = {}
+ Group.filter([["uuid", "in", c.map(&:owner_uuid)]]).each do |g|
+ own[g[:uuid]] = g
+ end
+ {collections: c, owners: own}
+ end
+
helper_method :my_project_tree
def my_project_tree
build_project_trees
@my_project_tree =
sorted_paths.call buildtree.call(children_of, 'me')
@shared_project_tree =
- sorted_paths.call({'Shared with me' =>
+ sorted_paths.call({'Projects shared with me' =>
buildtree.call(children_of, false)})
end
crumbs = []
current = @name_link || @object
while current
+ # Halt if a group ownership loop is detected. API should refuse
+ # to produce this state, but it could still arise from a race
+ # condition when group ownership changes between our find()
+ # queries.
+ break if crumbs.collect(&:uuid).include? current.uuid
+
if current.is_a?(Group) and current.group_class == 'project'
crumbs.prepend current
end
projects / arvados.git / blobdiff