apps/workbench/app/controllers/application_controller.rb

   1 class ApplicationController < ActionController::Base
   2   protect_from_forgery
   3   around_filter :thread_clear
   4   around_filter :thread_with_api_token, :except => [:render_exception, :render_not_found]
   5   before_filter :find_object_by_uuid, :except => [:index, :render_exception, :render_not_found]
   6
   7   begin
   8     rescue_from Exception,
   9     :with => :render_exception
  10     rescue_from ActiveRecord::RecordNotFound,
  11     :with => :render_not_found
  12     rescue_from ActionController::RoutingError,
  13     :with => :render_not_found
  14     rescue_from ActionController::UnknownController,
  15     :with => :render_not_found
  16     rescue_from ActionController::UnknownAction,
  17     :with => :render_not_found
  18   end
  19
  20   def unprocessable(message=nil)
  21     @errors ||= []
  22     @errors << message if message
  23     render_error status: 422
  24   end
  25
  26   def render_error(opts)
  27     respond_to do |f|
  28       f.html { render opts.merge(controller: 'application', action: 'error') }
  29       f.json { render opts.merge(json: {success: false, errors: @errors}) }
  30     end
  31   end
  32
  33   def render_exception(e)
  34     logger.error e.inspect
  35     logger.error e.backtrace.collect { |x| x + "\n" }.join('') if e.backtrace
  36     if @object.andand.errors.andand.full_messages.andand.any?
  37       @errors = @object.errors.full_messages
  38     else
  39       @errors = [e.inspect]
  40     end
  41     self.render_error status: 422
  42   end
  43
  44   def render_not_found(e=ActionController::RoutingError.new("Path not found"))
  45     logger.error e.inspect
  46     @errors = ["Path not found"]
  47     self.render_error status: 404
  48   end
  49
  50
  51   def index
  52     @objects ||= model_class.all
  53     respond_to do |f|
  54       f.json { render json: @objects }
  55       f.html { render }
  56     end
  57   end
  58
  59   def show
  60     if !@object
  61       return render_not_found("object not found")
  62     end
  63     respond_to do |f|
  64       f.json { render json: @object }
  65       f.html { render }
  66     end
  67   end
  68
  69   def render_content
  70     if !@object
  71       return render_not_found("object not found")
  72     end
  73   end
  74
  75   def new
  76     @object = model_class.new
  77   end
  78
  79   def update
  80     updates = params[@object.class.to_s.underscore.singularize.to_sym]
  81     updates.keys.each do |attr|
  82       if @object.send(attr).is_a? Hash and updates[attr].is_a? String
  83         updates[attr] = Oj.load updates[attr]
  84       end
  85     end
  86     if @object.update_attributes updates
  87       show
  88     else
  89       self.render_error status: 422
  90     end
  91   end
  92
  93   def create
  94     @object ||= model_class.new params[model_class.to_s.singularize.to_sym]
  95     @object.save!
  96     redirect_to @object
  97   end
  98
  99   def destroy
 100     if @object.destroy
 101       redirect_to(params[:return_to] || :back)
 102     else
 103       self.render_error status: 422
 104     end
 105   end
 106
 107   def current_user
 108     if Thread.current[:arvados_api_token]
 109       Thread.current[:user] ||= User.current
 110     else
 111       logger.error "No API token in Thread"
 112       return nil
 113     end
 114   end
 115
 116   def model_class
 117     controller_name.classify.constantize
 118   end
 119
 120   protected
 121
 122   def find_object_by_uuid
 123     if params[:id] and params[:id].match /\D/
 124       params[:uuid] = params.delete :id
 125     end
 126     @object = model_class.where(uuid: params[:uuid]).first
 127   end
 128
 129   def thread_clear
 130     Thread.current[:arvados_api_token] = nil
 131     Thread.current[:user] = nil
 132     yield
 133   end
 134
 135   def thread_with_api_token
 136     begin
 137       try_redirect_to_login = true
 138       if params[:api_token]
 139         try_redirect_to_login = false
 140         Thread.current[:arvados_api_token] = params[:api_token]
 141         # Before copying the token into session[], do a simple API
 142         # call to verify its authenticity.
 143         if verify_api_token
 144           session[:arvados_api_token] = params[:api_token]
 145           if !request.format.json? and request.method == 'GET'
 146             # Repeat this request with api_token in the (new) session
 147             # cookie instead of the query string.  This prevents API
 148             # tokens from appearing in (and being inadvisedly copied
 149             # and pasted from) browser Location bars.
 150             redirect_to request.fullpath.sub(%r{([&\?]api_token=)[^&\?]*}, '')
 151           else
 152             yield
 153           end
 154         else
 155           @errors = ['Invalid API token']
 156           self.render_error status: 401
 157         end
 158       elsif session[:arvados_api_token]
 159         # In this case, the token must have already verified at some
 160         # point, but it might have been revoked since.  We'll try
 161         # using it, and catch the exception if it doesn't work.
 162         try_redirect_to_login = false
 163         Thread.current[:arvados_api_token] = session[:arvados_api_token]
 164         begin
 165           yield
 166         rescue ArvadosApiClient::NotLoggedInException
 167           try_redirect_to_login = true
 168         end
 169       else
 170         logger.debug "No token received, session is #{session.inspect}"
 171       end
 172       if try_redirect_to_login
 173         respond_to do |f|
 174           f.html {
 175             if request.method == 'GET'
 176               redirect_to $arvados_api_client.arvados_login_url(return_to: request.url)
 177             else
 178               flash[:error] = "Either you are not logged in, or your session has timed out. I can't automatically log you in and re-attempt this request."
 179               redirect_to :back
 180             end
 181           }
 182           f.json {
 183             @errors = ['You do not seem to be logged in. You did not supply an API token with this request, and your session (if any) has timed out.']
 184             self.render_error status: 422
 185           }
 186         end
 187       end
 188     ensure
 189       # Remove token in case this Thread is used for anything else.
 190       Thread.current[:arvados_api_token] = nil
 191     end
 192   end
 193
 194   def verify_api_token
 195     begin
 196       Link.where(uuid: 'just-verifying-my-api-token')
 197       true
 198     rescue ArvadosApiClient::NotLoggedInException
 199       false
 200     end
 201   end
 202
 203   def ensure_current_user_is_admin
 204     unless current_user and current_user.is_admin
 205       @errors = ['Permission denied']
 206       self.render_error status: 401
 207     end
 208   end
 209 end