helpers.rb 10.9 KB
Newer Older
1 2
module API
  module Helpers
3
    include Gitlab::Utils
4
    include Helpers::Pagination
5

6
    SUDO_HEADER = "HTTP_SUDO".freeze
7 8
    SUDO_PARAM = :sudo

9 10 11 12 13
    def declared_params(options = {})
      options = { include_parent_namespaces: false }.merge(options)
      declared(params, options).to_h.symbolize_keys
    end

14
    def current_user
15
      return @current_user if defined?(@current_user)
16

17
      @current_user = initial_current_user
18

19
      sudo!
20 21 22 23

      @current_user
    end

24 25
    def sudo?
      initial_current_user != current_user
26 27 28
    end

    def user_project
29
      @project ||= find_project!(params[:id])
30 31
    end

32 33 34 35
    def available_labels
      @available_labels ||= LabelsFinder.new(current_user, project_id: user_project.id).execute
    end

36 37 38 39 40 41 42 43
    def find_user(id)
      if id =~ /^\d+$/
        User.find_by(id: id)
      else
        User.find_by(username: id)
      end
    end

44
    def find_project(id)
45 46 47
      if id =~ /^\d+$/
        Project.find_by(id: id)
      else
48
        Project.find_by_full_path(id)
49 50 51 52 53
      end
    end

    def find_project!(id)
      project = find_project(id)
54

55
      if can?(current_user, :read_project, project)
56 57
        project
      else
58
        not_found!('Project')
59 60 61 62
      end
    end

    def find_group(id)
63 64 65
      if id =~ /^\d+$/
        Group.find_by(id: id)
      else
66
        Group.find_by_full_path(id)
67 68 69 70 71
      end
    end

    def find_group!(id)
      group = find_group(id)
72 73 74 75 76 77 78 79

      if can?(current_user, :read_group, group)
        group
      else
        not_found!('Group')
      end
    end

80
    def find_project_label(id)
81
      label = available_labels.find_by_id(id) || available_labels.find_by_title(id)
82 83 84
      label || not_found!('Label')
    end

85 86
    def find_project_issue(iid)
      IssuesFinder.new(current_user, project_id: user_project.id).find_by!(iid: iid)
87 88
    end

89 90
    def find_project_merge_request(iid)
      MergeRequestsFinder.new(current_user, project_id: user_project.id).find_by!(iid: iid)
91 92
    end

93 94 95 96 97
    def find_project_snippet(id)
      finder_params = { filter: :by_project, project: user_project }
      SnippetsFinder.new.execute(current_user, finder_params).find(id)
    end

98 99
    def find_merge_request_with_access(iid, access_level = :read_merge_request)
      merge_request = user_project.merge_requests.find_by!(iid: iid)
100 101 102 103
      authorize! access_level, merge_request
      merge_request
    end

104
    def authenticate!
105
      unauthorized! unless current_user && can?(initial_current_user, :access_api)
106 107
    end

108
    def authenticate_non_get!
109
      authenticate! unless %w[GET HEAD].include?(route.request_method)
110 111
    end

112 113 114 115 116 117 118 119
    def authenticate_by_gitlab_shell_token!
      input = params['secret_token'].try(:chomp)
      unless Devise.secure_compare(secret_token, input)
        unauthorized!
      end
    end

    def authenticated_as_admin!
120
      authenticate!
121
      forbidden! unless current_user.admin?
122 123
    end

124
    def authorize!(action, subject = :global)
125
      forbidden! unless can?(current_user, action, subject)
126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141
    end

    def authorize_push_project
      authorize! :push_code, user_project
    end

    def authorize_admin_project
      authorize! :admin_project, user_project
    end

    def require_gitlab_workhorse!
      unless env['HTTP_GITLAB_WORKHORSE'].present?
        forbidden!('Request should be executed via GitLab Workhorse')
      end
    end

142
    def can?(object, action, subject = :global)
143
      Ability.allowed?(object, action, subject)
144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160
    end

    # Checks the occurrences of required attributes, each attribute must be present in the params hash
    # or a Bad Request error is invoked.
    #
    # Parameters:
    #   keys (required) - A hash consisting of keys that must be present
    def required_attributes!(keys)
      keys.each do |key|
        bad_request!(key) unless params[key].present?
      end
    end

    def attributes_for_keys(keys, custom_params = nil)
      params_hash = custom_params || params
      attrs = {}
      keys.each do |key|
Douwe Maan's avatar
Douwe Maan committed
161
        if params_hash[key].present? || (params_hash.has_key?(key) && params_hash[key] == false)
162 163 164 165 166 167 168 169 170 171
          attrs[key] = params_hash[key]
        end
      end
      ActionController::Parameters.new(attrs).permit!
    end

    def filter_by_iid(items, iid)
      items.where(iid: iid)
    end

172 173 174 175
    def filter_by_search(items, text)
      items.search(text)
    end

176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216
    # error helpers

    def forbidden!(reason = nil)
      message = ['403 Forbidden']
      message << " - #{reason}" if reason
      render_api_error!(message.join(' '), 403)
    end

    def bad_request!(attribute)
      message = ["400 (Bad request)"]
      message << "\"" + attribute.to_s + "\" not given"
      render_api_error!(message.join(' '), 400)
    end

    def not_found!(resource = nil)
      message = ["404"]
      message << resource if resource
      message << "Not Found"
      render_api_error!(message.join(' '), 404)
    end

    def unauthorized!
      render_api_error!('401 Unauthorized', 401)
    end

    def not_allowed!
      render_api_error!('405 Method Not Allowed', 405)
    end

    def conflict!(message = nil)
      render_api_error!(message || '409 Conflict', 409)
    end

    def file_to_large!
      render_api_error!('413 Request Entity Too Large', 413)
    end

    def not_modified!
      render_api_error!('304 Not Modified', 304)
    end

217 218 219 220
    def no_content!
      render_api_error!('204 No Content', 204)
    end

221 222 223 224
    def accepted!
      render_api_error!('202 Accepted', 202)
    end

225 226 227 228 229 230
    def render_validation_error!(model)
      if model.errors.any?
        render_api_error!(model.errors.messages || '400 Bad Request', 400)
      end
    end

231 232 233 234
    def render_spam_error!
      render_api_error!({ error: 'Spam detected' }, 400)
    end

235
    def render_api_error!(message, status)
Kamil Trzcinski's avatar
Kamil Trzcinski committed
236
      error!({ 'message' => message }, status, header)
237 238
    end

239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256
    def handle_api_exception(exception)
      if sentry_enabled? && report_exception?(exception)
        define_params_for_grape_middleware
        sentry_context
        Raven.capture_exception(exception)
      end

      # lifted from https://github.com/rails/rails/blob/master/actionpack/lib/action_dispatch/middleware/debug_exceptions.rb#L60
      trace = exception.backtrace

      message = "\n#{exception.class} (#{exception.message}):\n"
      message << exception.annoted_source_code.to_s if exception.respond_to?(:annoted_source_code)
      message << "  " << trace.join("\n  ")

      API.logger.add Logger::FATAL, message
      rack_response({ 'message' => '500 Internal Server Error' }.to_json, 500)
    end

257
    # project helpers
258 259

    def filter_projects(projects)
260
      if params[:membership]
261 262 263
        projects = projects.merge(current_user.authorized_projects)
      end

264 265 266 267 268 269 270 271
      if params[:owned]
        projects = projects.merge(current_user.owned_projects)
      end

      if params[:starred]
        projects = projects.merge(current_user.starred_projects)
      end

272 273 274 275 276 277 278 279
      if params[:search].present?
        projects = projects.search(params[:search])
      end

      if params[:visibility].present?
        projects = projects.search_by_visibility(params[:visibility])
      end

280 281
      projects = projects.where(archived: params[:archived])
      projects.reorder(params[:order_by] => params[:sort])
282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303
    end

    # file helpers

    def uploaded_file(field, uploads_path)
      if params[field]
        bad_request!("#{field} is not a file") unless params[field].respond_to?(:filename)
        return params[field]
      end

      return nil unless params["#{field}.path"] && params["#{field}.name"]

      # sanitize file paths
      # this requires all paths to exist
      required_attributes! %W(#{field}.path)
      uploads_path = File.realpath(uploads_path)
      file_path = File.realpath(params["#{field}.path"])
      bad_request!('Bad file path') unless file_path.start_with?(uploads_path)

      UploadedFile.new(
        file_path,
        params["#{field}.name"],
304
        params["#{field}.type"] || 'application/octet-stream'
305 306 307 308 309 310 311 312 313 314 315 316 317 318 319
      )
    end

    def present_file!(path, filename, content_type = 'application/octet-stream')
      filename ||= File.basename(path)
      header['Content-Disposition'] = "attachment; filename=#{filename}"
      header['Content-Transfer-Encoding'] = 'binary'
      content_type content_type

      # Support download acceleration
      case headers['X-Sendfile-Type']
      when 'X-Sendfile'
        header['X-Sendfile'] = path
        body
      else
320
        file path
321 322 323 324 325
      end
    end

    private

326
    def private_token
327
      params[APIGuard::PRIVATE_TOKEN_PARAM] || env[APIGuard::PRIVATE_TOKEN_HEADER]
328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343
    end

    def warden
      env['warden']
    end

    # Check the Rails session for valid authentication details
    #
    # Until CSRF protection is added to the API, disallow this method for
    # state-changing endpoints
    def find_user_from_warden
      warden.try(:authenticate) if %w[GET HEAD].include?(env['REQUEST_METHOD'])
    end

    def initial_current_user
      return @initial_current_user if defined?(@initial_current_user)
344 345 346 347
      Gitlab::Auth::UniqueIpsLimiter.limit_user! do
        @initial_current_user ||= find_user_by_private_token(scopes: @scopes)
        @initial_current_user ||= doorkeeper_guard(scopes: @scopes)
        @initial_current_user ||= find_user_from_warden
348

349 350 351
        unless @initial_current_user && Gitlab::UserAccess.new(@initial_current_user).allowed?
          @initial_current_user = nil
        end
352

353
        @initial_current_user
354 355 356 357 358
      end
    end

    def sudo!
      return unless sudo_identifier
359
      return unless initial_current_user
360

361
      unless initial_current_user.admin?
362 363 364 365 366 367 368 369
        forbidden!('Must be admin to use sudo')
      end

      # Only private tokens should be used for the SUDO feature
      unless private_token == initial_current_user.private_token
        forbidden!('Private token must be specified in order to use sudo')
      end

370
      sudoed_user = find_user(sudo_identifier)
371 372 373 374 375 376 377 378 379

      if sudoed_user
        @current_user = sudoed_user
      else
        not_found!("No user id or username for: #{sudo_identifier}")
      end
    end

    def sudo_identifier
380
      @sudo_identifier ||= params[SUDO_PARAM] || env[SUDO_HEADER]
381 382
    end

383
    def secret_token
384
      Gitlab::Shell.secret_token
385 386
    end

387 388 389
    def send_git_blob(repository, blob)
      env['api.format'] = :txt
      content_type 'text/plain'
Douwe Maan's avatar
Douwe Maan committed
390
      header(*Gitlab::Workhorse.send_git_blob(repository, blob))
391 392 393
    end

    def send_git_archive(repository, ref:, format:)
Douwe Maan's avatar
Douwe Maan committed
394
      header(*Gitlab::Workhorse.send_git_archive(repository, ref: ref, format: format))
395
    end
396

397 398 399 400 401 402 403 404 405 406 407 408 409
    # The Grape Error Middleware only has access to env but no params. We workaround this by
    # defining a method that returns the right value.
    def define_params_for_grape_middleware
      self.define_singleton_method(:params) { Rack::Request.new(env).params.symbolize_keys }
    end

    # We could get a Grape or a standard Ruby exception. We should only report anything that
    # is clearly an error.
    def report_exception?(exception)
      return true unless exception.respond_to?(:status)

      exception.status == 500
    end
410 411
  end
end