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 ::AbstractController::ActionNotFound,
  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     if params[:uuid].is_a? String
 127       @object = model_class.find(params[:uuid])
 128     else
 129       @object = model_class.where(uuid: params[:uuid]).first
 130     end
 131   end
 132
 133   def thread_clear
 134     Thread.current[:arvados_api_token] = nil
 135     Thread.current[:user] = nil
 136     yield
 137   end
 138
 139   def thread_with_api_token(login_optional = false)
 140     begin
 141       try_redirect_to_login = true
 142       if params[:api_token]
 143         try_redirect_to_login = false
 144         Thread.current[:arvados_api_token] = params[:api_token]
 145         # Before copying the token into session[], do a simple API
 146         # call to verify its authenticity.
 147         if verify_api_token
 148           session[:arvados_api_token] = params[:api_token]
 149           if !request.format.json? and request.method == 'GET'
 150             # Repeat this request with api_token in the (new) session
 151             # cookie instead of the query string.  This prevents API
 152             # tokens from appearing in (and being inadvisedly copied
 153             # and pasted from) browser Location bars.
 154             redirect_to request.fullpath.sub(%r{([&\?]api_token=)[^&\?]*}, '')
 155           else
 156             yield
 157           end
 158         else
 159           @errors = ['Invalid API token']
 160           self.render_error status: 401
 161         end
 162       elsif session[:arvados_api_token]
 163         # In this case, the token must have already verified at some
 164         # point, but it might have been revoked since.  We'll try
 165         # using it, and catch the exception if it doesn't work.
 166         try_redirect_to_login = false
 167         Thread.current[:arvados_api_token] = session[:arvados_api_token]
 168         begin
 169           yield
 170         rescue ArvadosApiClient::NotLoggedInException
 171           try_redirect_to_login = true
 172         end
 173       else
 174         logger.debug "No token received, session is #{session.inspect}"
 175       end
 176       if try_redirect_to_login
 177         unless login_optional
 178           respond_to do |f|
 179             f.html {
 180               if request.method == 'GET'
 181                 redirect_to $arvados_api_client.arvados_login_url(return_to: request.url)
 182               else
 183                 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."
 184                 redirect_to :back
 185               end
 186             }
 187             f.json {
 188               @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.']
 189               self.render_error status: 422
 190             }
 191           end
 192         else
 193           # login is optional for this route so go on to the regular controller
 194           Thread.current[:arvados_api_token] = nil
 195           yield
 196         end
 197       end
 198     ensure
 199       # Remove token in case this Thread is used for anything else.
 200       Thread.current[:arvados_api_token] = nil
 201     end
 202   end
 203
 204   def thread_with_optional_api_token
 205     thread_with_api_token(true) do
 206       yield
 207     end
 208   end
 209
 210   def verify_api_token
 211     begin
 212       Link.where(uuid: 'just-verifying-my-api-token')
 213       true
 214     rescue ArvadosApiClient::NotLoggedInException
 215       false
 216     end
 217   end
 218
 219   def ensure_current_user_is_admin
 220     unless current_user and current_user.is_admin
 221       @errors = ['Permission denied']
 222       self.render_error status: 401
 223     end
 224   end
 225 end