project_policy.rb 11.9 KB
Newer Older
1
class ProjectPolicy < BasePolicy
2 3
  extend ClassMethods

4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
  READONLY_FEATURES_WHEN_ARCHIVED = %i[
    issue
    list
    merge_request
    label
    milestone
    project_snippet
    wiki
    note
    pipeline
    pipeline_schedule
    build
    trigger
    environment
    deployment
    commit_status
    container_image
    pages
    cluster
  ].freeze

25 26
  desc "User is a project owner"
  condition :owner do
27 28
    (project.owner.present? && project.owner == @user) ||
      project.group&.has_owner?(@user)
29
  end
30

31
  desc "Project has public builds enabled"
32
  condition(:public_builds, scope: :subject, score: 0) { project.public_builds? }
33

34
  # For guest access we use #team_member? so we can use
35 36 37 38 39
  # project.members, which gets cached in subject scope.
  # This is safe because team_access_level is guaranteed
  # by ProjectAuthorization's validation to be at minimum
  # GUEST
  desc "User has guest access"
40
  condition(:guest) { team_member? }
41

42 43
  desc "User has reporter access"
  condition(:reporter) { team_access_level >= Gitlab::Access::REPORTER }
44

45 46 47
  desc "User has developer access"
  condition(:developer) { team_access_level >= Gitlab::Access::DEVELOPER }

Mark Chao's avatar
Mark Chao committed
48
  desc "User has maintainer access"
49 50 51
  condition(:master) { team_access_level >= Gitlab::Access::MASTER }

  desc "Project is public"
52
  condition(:public_project, scope: :subject, score: 0) { project.public? }
53 54 55 56

  desc "Project is visible to internal users"
  condition(:internal_access) do
    project.internal? && !user.external?
57 58
  end

59 60 61 62
  desc "User is a member of the group"
  condition(:group_member, scope: :subject) { project_group_member? }

  desc "Project is archived"
63
  condition(:archived, scope: :subject, score: 0) { project.archived? }
64 65 66 67 68 69

  condition(:default_issues_tracker, scope: :subject) { project.default_issues_tracker? }

  desc "Container registry is disabled"
  condition(:container_registry_disabled, scope: :subject) do
    !project.container_registry_enabled
70 71
  end

72
  desc "Project has an external wiki"
73
  condition(:has_external_wiki, scope: :subject, score: 0) { project.has_external_wiki? }
74 75

  desc "Project has request access enabled"
76
  condition(:request_access_enabled, scope: :subject, score: 0) { project.request_access_enabled }
77

78
  desc "Has merge requests allowing pushes to user"
79
  condition(:has_merge_requests_allowing_pushes) do
80
    project.merge_requests_allowing_push_to_user(user).any?
81 82
  end

83 84 85 86 87
  with_scope :global
  condition(:mirror_available, score: 0) do
    ::Gitlab::CurrentSettings.current_application_settings.mirror_available
  end

88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103
  # We aren't checking `:read_issue` or `:read_merge_request` in this case
  # because it could be possible for a user to see an issuable-iid
  # (`:read_issue_iid` or `:read_merge_request_iid`) but then wouldn't be
  # allowed to read the actual issue after a more expensive `:read_issue`
  # check. These checks are intended to be used alongside
  # `:read_project_for_iids`.
  #
  # `:read_issue` & `:read_issue_iid` could diverge in gitlab-ee.
  condition(:issues_visible_to_user, score: 4) do
    @subject.feature_available?(:issues, @user)
  end

  condition(:merge_requests_visible_to_user, score: 4) do
    @subject.feature_available?(:merge_requests, @user)
  end

104 105 106 107 108 109 110 111 112 113 114 115 116
  features = %w[
    merge_requests
    issues
    repository
    snippets
    wiki
    builds
  ]

  features.each do |f|
    # these are scored high because they are unlikely
    desc "Project has #{f} disabled"
    condition(:"#{f}_disabled", score: 32) { !feature_available?(f.to_sym) }
117 118
  end

119 120 121 122
  # `:read_project` may be prevented in EE, but `:read_project_for_iids` should
  # not.
  rule { guest | admin }.enable :read_project_for_iids

123 124 125 126
  rule { guest }.enable :guest_access
  rule { reporter }.enable :reporter_access
  rule { developer }.enable :developer_access
  rule { master }.enable :master_access
127
  rule { owner | admin }.enable :owner_access
128

129
  rule { can?(:owner_access) }.policy do
130 131 132 133 134 135 136 137 138 139 140 141 142 143 144
    enable :guest_access
    enable :reporter_access
    enable :developer_access
    enable :master_access

    enable :change_namespace
    enable :change_visibility_level
    enable :rename_project
    enable :remove_project
    enable :archive_project
    enable :remove_fork_project
    enable :destroy_merge_request
    enable :destroy_issue
    enable :remove_pages
  end
145

146 147
  rule { can?(:guest_access) }.policy do
    enable :read_project
148
    enable :create_merge_request_in
149 150 151 152 153 154 155 156 157 158 159 160 161 162
    enable :read_board
    enable :read_list
    enable :read_wiki
    enable :read_issue
    enable :read_label
    enable :read_milestone
    enable :read_project_snippet
    enable :read_project_member
    enable :read_note
    enable :create_project
    enable :create_issue
    enable :create_note
    enable :upload_file
    enable :read_cycle_analytics
163
    enable :award_emoji
164
  end
165

166
  # These abilities are not allowed to admins that are not members of the project,
167
  # that's why they are defined separately.
168
  rule { guest & can?(:download_code) }.enable :build_download_code
169
  rule { guest & can?(:read_container_image) }.enable :build_read_container_image
170

171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188
  rule { can?(:reporter_access) }.policy do
    enable :download_code
    enable :download_wiki_code
    enable :fork_project
    enable :create_project_snippet
    enable :update_issue
    enable :admin_issue
    enable :admin_label
    enable :admin_list
    enable :read_commit_status
    enable :read_build
    enable :read_container_image
    enable :read_pipeline
    enable :read_pipeline_schedule
    enable :read_environment
    enable :read_deployment
    enable :read_merge_request
  end
189

190 191
  # We define `:public_user_access` separately because there are cases in gitlab-ee
  # where we enable or prevent it based on other coditions.
192 193
  rule { (~anonymous & public_project) | internal_access }.policy do
    enable :public_user_access
194
    enable :read_project_for_iids
195
  end
196

197
  rule { can?(:public_user_access) }.policy do
198
    enable :public_access
199
    enable :guest_access
200 201 202

    enable :fork_project
    enable :build_download_code
203
    enable :build_read_container_image
204 205
    enable :request_access
  end
206

207 208 209 210 211
  rule { owner | admin | guest | group_member }.prevent :request_access
  rule { ~request_access_enabled }.prevent :request_access

  rule { can?(:developer_access) }.policy do
    enable :admin_merge_request
212
    enable :admin_milestone
213 214 215 216 217 218 219 220
    enable :update_merge_request
    enable :create_commit_status
    enable :update_commit_status
    enable :create_build
    enable :update_build
    enable :create_pipeline
    enable :update_pipeline
    enable :create_pipeline_schedule
221
    enable :create_merge_request_from
222 223 224 225 226 227 228
    enable :create_wiki
    enable :push_code
    enable :resolve_note
    enable :create_container_image
    enable :update_container_image
    enable :create_environment
    enable :create_deployment
229 230
  end

231
  rule { can?(:master_access) }.policy do
232
    enable :push_to_delete_protected_branch
233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249
    enable :update_project_snippet
    enable :update_environment
    enable :update_deployment
    enable :admin_project_snippet
    enable :admin_project_member
    enable :admin_note
    enable :admin_wiki
    enable :admin_project
    enable :admin_commit_status
    enable :admin_build
    enable :admin_container_image
    enable :admin_pipeline
    enable :admin_environment
    enable :admin_deployment
    enable :admin_pages
    enable :read_pages
    enable :update_pages
250 251
    enable :read_cluster
    enable :create_cluster
252
  end
253

254 255
  rule { (mirror_available & can?(:admin_project)) | admin }.enable :admin_remote_mirror

256 257
  rule { archived }.policy do
    prevent :push_code
258 259 260 261
    prevent :push_to_delete_protected_branch
    prevent :request_access
    prevent :upload_file
    prevent :resolve_note
262 263
    prevent :create_merge_request_from
    prevent :create_merge_request_in
264
    prevent :award_emoji
265 266 267 268 269 270 271 272

    READONLY_FEATURES_WHEN_ARCHIVED.each do |feature|
      prevent(*create_update_admin_destroy(feature))
    end
  end

  rule { issues_disabled }.policy do
    prevent(*create_read_update_admin_destroy(:issue))
273 274
  end

275
  rule { merge_requests_disabled | repository_disabled }.policy do
276 277
    prevent :create_merge_request_in
    prevent :create_merge_request_from
278
    prevent(*create_read_update_admin_destroy(:merge_request))
279 280
  end

281
  rule { issues_disabled & merge_requests_disabled }.policy do
282 283
    prevent(*create_read_update_admin_destroy(:label))
    prevent(*create_read_update_admin_destroy(:milestone))
284 285 286
  end

  rule { snippets_disabled }.policy do
287
    prevent(*create_read_update_admin_destroy(:project_snippet))
288 289 290
  end

  rule { wiki_disabled & ~has_external_wiki }.policy do
291
    prevent(*create_read_update_admin_destroy(:wiki))
292 293 294 295
    prevent(:download_wiki_code)
  end

  rule { builds_disabled | repository_disabled }.policy do
296 297 298 299
    prevent(*create_update_admin_destroy(:pipeline))
    prevent(*create_read_update_admin_destroy(:build))
    prevent(*create_read_update_admin_destroy(:pipeline_schedule))
    prevent(*create_read_update_admin_destroy(:environment))
300
    prevent(*create_read_update_admin_destroy(:cluster))
301
    prevent(*create_read_update_admin_destroy(:deployment))
302 303 304 305 306 307 308 309 310 311
  end

  rule { repository_disabled }.policy do
    prevent :push_code
    prevent :download_code
    prevent :fork_project
    prevent :read_commit_status
  end

  rule { container_registry_disabled }.policy do
312
    prevent(*create_read_update_admin_destroy(:container_image))
313 314 315
  end

  rule { anonymous & ~public_project }.prevent_all
316 317 318 319 320

  rule { public_project }.policy do
    enable :public_access
    enable :read_project_for_iids
  end
321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353

  rule { can?(:public_access) }.policy do
    enable :read_project
    enable :read_board
    enable :read_list
    enable :read_wiki
    enable :read_label
    enable :read_milestone
    enable :read_project_snippet
    enable :read_project_member
    enable :read_merge_request
    enable :read_note
    enable :read_pipeline
    enable :read_pipeline_schedule
    enable :read_commit_status
    enable :read_container_image
    enable :download_code
    enable :download_wiki_code
    enable :read_cycle_analytics

    # NOTE: may be overridden by IssuePolicy
    enable :read_issue
  end

  rule { public_builds }.policy do
    enable :read_build
  end

  rule { public_builds & can?(:guest_access) }.policy do
    enable :read_pipeline
    enable :read_pipeline_schedule
  end

354
  # These rules are included to allow maintainers of projects to push to certain
355 356
  # to run pipelines for the branches they have access to.
  rule { can?(:public_access) & has_merge_requests_allowing_pushes }.policy do
357 358 359 360
    enable :create_build
    enable :create_pipeline
  end

361 362 363 364 365 366 367 368
  rule do
    (can?(:read_project_for_iids) & issues_visible_to_user) | can?(:read_issue)
  end.enable :read_issue_iid

  rule do
    (can?(:read_project_for_iids) & merge_requests_visible_to_user) | can?(:read_merge_request)
  end.enable :read_merge_request_iid

369 370
  private

371
  def team_member?
372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395
    return false if @user.nil?

    greedy_load_subject = false

    # when scoping by subject, we want to be greedy
    # and load *all* the members with one query.
    greedy_load_subject ||= DeclarativePolicy.preferred_scope == :subject

    # in this case we're likely to have loaded #members already
    # anyways, and #member? would fail with an error
    greedy_load_subject ||= !@user.persisted?

    if greedy_load_subject
      project.team.members.include?(user)
    else
      # otherwise we just make a specific query for
      # this particular user.
      team_access_level >= Gitlab::Access::GUEST
    end
  end

  def project_group_member?
    return false if @user.nil?

396 397
    project.group &&
      (
398 399
        project.group.members_with_parents.exists?(user_id: @user.id) ||
        project.group.requesters.exists?(user_id: @user.id)
400 401 402
      )
  end

403 404
  def team_access_level
    return -1 if @user.nil?
405

406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422
    # NOTE: max_member_access has its own cache
    project.team.max_member_access(@user.id)
  end

  def feature_available?(feature)
    case project.project_feature.access_level(feature)
    when ProjectFeature::DISABLED
      false
    when ProjectFeature::PRIVATE
      guest? || admin?
    else
      true
    end
  end

  def project
    @subject
423
  end
424
end