merge_request.rb 17.8 KB
Newer Older
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
1
class MergeRequest < ActiveRecord::Base
2
  include InternalId
3 4
  include Issuable
  include Referable
5
  include Sortable
6
  include Taskable
7
  include Importable
8

9 10
  belongs_to :target_project, foreign_key: :target_project_id, class_name: "Project"
  belongs_to :source_project, foreign_key: :source_project_id, class_name: "Project"
11
  belongs_to :merge_user, class_name: "User"
12

13
  has_one :merge_request_diff, dependent: :destroy
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
14

15 16
  has_many :events, as: :target, dependent: :destroy

17 18
  serialize :merge_params, Hash

19
  after_create :create_merge_request_diff, unless: :importing?
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
20
  after_update :update_merge_request_diff
21

22
  delegate :commits, :real_size, to: :merge_request_diff, prefix: nil
23

Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
24 25 26 27
  # When this attribute is true some MR validation is ignored
  # It allows us to close or modify broken merge requests
  attr_accessor :allow_broken

28 29
  # Temporary fields to store compare vars
  # when creating new merge request
30
  attr_accessor :can_be_created, :compare_commits, :compare
31

Andrew8xx8's avatar
Andrew8xx8 committed
32
  state_machine :state, initial: :opened do
33 34 35 36
    event :close do
      transition [:reopened, :opened] => :closed
    end

37
    event :mark_as_merged do
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
38
      transition [:reopened, :opened, :locked] => :merged
39 40 41
    end

    event :reopen do
Andrew8xx8's avatar
Andrew8xx8 committed
42
      transition closed: :reopened
43 44
    end

45
    event :lock_mr do
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
46 47 48
      transition [:reopened, :opened] => :locked
    end

49
    event :unlock_mr do
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
50 51 52
      transition locked: :reopened
    end

53 54 55 56 57
    after_transition any => :locked do |merge_request, transition|
      merge_request.locked_at = Time.now
      merge_request.save
    end

58
    after_transition locked: (any - :locked) do |merge_request, transition|
59 60 61 62
      merge_request.locked_at = nil
      merge_request.save
    end

63 64 65 66
    state :opened
    state :reopened
    state :closed
    state :merged
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
67
    state :locked
68 69
  end

70 71 72 73 74 75
  state_machine :merge_status, initial: :unchecked do
    event :mark_as_unchecked do
      transition [:can_be_merged, :cannot_be_merged] => :unchecked
    end

    event :mark_as_mergeable do
76
      transition [:unchecked, :cannot_be_merged] => :can_be_merged
77 78 79
    end

    event :mark_as_unmergeable do
80
      transition [:unchecked, :can_be_merged] => :cannot_be_merged
81 82
    end

83
    state :unchecked
84 85
    state :can_be_merged
    state :cannot_be_merged
86 87

    around_transition do |merge_request, transition, block|
88
      Gitlab::Timeless.timeless(merge_request, &block)
89
    end
90
  end
91

92
  validates :source_project, presence: true, unless: [:allow_broken, :importing?]
Andrey Kumanyaev's avatar
Andrey Kumanyaev committed
93
  validates :source_branch, presence: true
94
  validates :target_project, presence: true
Andrey Kumanyaev's avatar
Andrey Kumanyaev committed
95
  validates :target_branch, presence: true
Zeger-Jan van de Weg's avatar
Zeger-Jan van de Weg committed
96
  validates :merge_user, presence: true, if: :merge_when_build_succeeds?
97
  validate :validate_branches, unless: [:allow_broken, :importing?]
98
  validate :validate_fork
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
99

100
  scope :by_branch, ->(branch_name) { where("(source_branch LIKE :branch) OR (target_branch LIKE :branch)", branch: branch_name) }
101
  scope :cared, ->(user) { where('assignee_id = :user OR author_id = :user', user: user.id) }
102
  scope :by_milestone, ->(milestone) { where(milestone_id: milestone) }
103
  scope :of_projects, ->(ids) { where(target_project_id: ids) }
104
  scope :from_project, ->(project) { where(source_project_id: project.id) }
105 106
  scope :merged, -> { with_state(:merged) }
  scope :closed_and_merged, -> { with_states(:closed, :merged) }
107

108 109 110
  scope :join_project, -> { joins(:target_project) }
  scope :references_project, -> { references(:target_project) }

111 112
  after_save :keep_around_commit

113 114 115 116
  def self.reference_prefix
    '!'
  end

117 118 119 120
  # Pattern used to extract `!123` merge request references from text
  #
  # This pattern supports cross-project references.
  def self.reference_pattern
121
    @reference_pattern ||= %r{
122
      (#{Project.reference_pattern})?
123 124 125 126
      #{Regexp.escape(reference_prefix)}(?<merge_request>\d+)
    }x
  end

127
  def self.link_reference_pattern
128
    @link_reference_pattern ||= super("merge_requests", /(?<merge_request>\d+)/)
129 130
  end

131 132 133 134
  def self.reference_valid?(reference)
    reference.to_i > 0 && reference.to_i <= Gitlab::Database::MAX_INT_VALUE
  end

135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152
  # Returns all the merge requests from an ActiveRecord:Relation.
  #
  # This method uses a UNION as it usually operates on the result of
  # ProjectsFinder#execute. PostgreSQL in particular doesn't always like queries
  # using multiple sub-queries especially when combined with an OR statement.
  # UNIONs on the other hand perform much better in these cases.
  #
  # relation - An ActiveRecord::Relation that returns a list of Projects.
  #
  # Returns an ActiveRecord::Relation.
  def self.in_projects(relation)
    source = where(source_project_id: relation).select(:id)
    target = where(target_project_id: relation).select(:id)
    union  = Gitlab::SQL::Union.new([source, target])

    where("merge_requests.id IN (#{union.to_sql})")
  end

153 154 155 156 157 158 159 160 161 162
  def to_reference(from_project = nil)
    reference = "#{self.class.reference_prefix}#{iid}"

    if cross_project_reference?(from_project)
      reference = project.to_reference + reference
    end

    reference
  end

163 164
  def first_commit
    merge_request_diff ? merge_request_diff.first_commit : compare_commits.first
165
  end
166

167 168 169 170
  def diffs(*args)
    merge_request_diff ? merge_request_diff.diffs(*args) : compare.diffs(*args)
  end

171 172 173 174
  def diff_size
    merge_request_diff.size
  end

175
  def diff_base_commit
176
    if persisted?
177
      merge_request_diff.base_commit
178 179 180 181 182 183 184 185 186 187 188
    elsif diff_start_commit && diff_head_commit
      self.target_project.merge_base_commit(diff_start_sha, diff_head_sha)
    end
  end

  # MRs created before 8.4 don't store a MergeRequestDiff#base_commit_sha,
  # but we need to get a commit for the "View file @ ..." link by deleted files,
  # so we find the likely one if we can't get the actual one.
  # This will not be the actual base commit if the target branch was merged into
  # the source branch after the merge request was created, but it is good enough
  # for the specific purpose of linking to a commit.
Douwe Maan's avatar
Douwe Maan committed
189 190 191
  # It is not good enough for use in `Gitlab::Git::DiffRefs`, which needs the
  # true base commit, so we can't simply have `#diff_base_commit` fall back on
  # this method.
192 193 194 195 196 197 198 199 200
  def likely_diff_base_commit
    first_commit.parent || first_commit
  end

  def diff_start_commit
    if persisted?
      merge_request_diff.start_commit
    else
      target_branch_head
201 202 203
    end
  end

204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245
  def diff_head_commit
    if persisted?
      merge_request_diff.head_commit
    else
      source_branch_head
    end
  end

  def diff_start_sha
    diff_start_commit.try(:sha)
  end

  def diff_base_sha
    diff_base_commit.try(:sha)
  end

  def diff_head_sha
    diff_head_commit.try(:sha)
  end

  # When importing a pull request from GitHub, the old and new branches may no
  # longer actually exist by those names, but we need to recreate the merge
  # request diff with the right source and target shas.
  # We use these attributes to force these to the intended values.
  attr_writer :target_branch_sha, :source_branch_sha

  def source_branch_head
    source_branch_ref = @source_branch_sha || source_branch
    source_project.repository.commit(source_branch) if source_branch_ref
  end

  def target_branch_head
    target_branch_ref = @target_branch_sha || target_branch
    target_project.repository.commit(target_branch) if target_branch_ref
  end

  def target_branch_sha
    target_branch_head.try(:sha)
  end

  def source_branch_sha
    source_branch_head.try(:sha)
246 247
  end

248
  def diff_refs
249
    return unless diff_start_commit || diff_base_commit
250 251 252 253 254 255 256 257

    Gitlab::Diff::DiffRefs.new(
      base_sha:  diff_base_sha,
      start_sha: diff_start_sha,
      head_sha:  diff_head_sha
    )
  end

258
  def validate_branches
259
    if target_project == source_project && target_branch == source_branch
260
      errors.add :branch_conflict, "You can not use same project/branch for source and target"
261
    end
262

263
    if opened? || reopened?
264
      similar_mrs = self.target_project.merge_requests.where(source_branch: source_branch, target_branch: target_branch, source_project_id: source_project.try(:id)).opened
265 266
      similar_mrs = similar_mrs.where('id not in (?)', self.id) if self.id
      if similar_mrs.any?
267
        errors.add :validate_branches,
Gabriel Mazetto's avatar
Gabriel Mazetto committed
268
                   "Cannot Create: This merge request already exists: #{similar_mrs.pluck(:title)}"
269
      end
270
    end
271 272
  end

273
  def validate_fork
274 275 276
    return true unless target_project && source_project

    if target_project == source_project
277 278 279 280 281 282 283
      true
    else
      # If source and target projects are different
      # we should check if source project is actually a fork of target project
      if source_project.forked_from?(target_project)
        true
      else
284 285
        errors.add :validate_fork,
                   'Source project is not a fork of target project'
286 287 288 289
      end
    end
  end

Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
290 291
  def update_merge_request_diff
    if source_branch_changed? || target_branch_changed?
292
      reload_diff
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
293 294 295
    end
  end

296 297 298 299 300 301 302 303 304 305 306 307 308
  def reload_diff
    return unless merge_request_diff && open?

    old_diff_refs = self.diff_refs

    merge_request_diff.reload_content

    new_diff_refs = self.diff_refs

    update_diff_notes_positions(
      old_diff_refs: old_diff_refs,
      new_diff_refs: new_diff_refs
    )
309 310
  end

311
  def check_if_can_be_merged
312 313
    return unless unchecked?

314
    can_be_merged =
315
      !broken? && project.repository.can_be_merged?(diff_head_sha, target_branch)
316 317

    if can_be_merged
318 319 320 321
      mark_as_mergeable
    else
      mark_as_unmergeable
    end
322 323
  end

Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
324
  def merge_event
325
    @merge_event ||= target_project.events.where(target_id: self.id, target_type: "MergeRequest", action: Event::MERGED).last
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
326 327
  end

328
  def closed_event
329
    @closed_event ||= target_project.events.where(target_id: self.id, target_type: "MergeRequest", action: Event::CLOSED).last
330 331
  end

332
  WIP_REGEX = /\A\s*(\[WIP\]\s*|WIP:\s*|WIP\s+)+\s*/i.freeze
333

334
  def work_in_progress?
335
    !!(title =~ WIP_REGEX)
336 337 338 339
  end

  def wipless_title
    self.title.sub(WIP_REGEX, "")
340 341
  end

342 343
  def mergeable?(skip_ci_check: false)
    return false unless mergeable_state?(skip_ci_check: skip_ci_check)
344 345 346 347

    check_if_can_be_merged

    can_be_merged?
348 349
  end

350
  def mergeable_state?(skip_ci_check: false)
351 352 353
    return false unless open?
    return false if work_in_progress?
    return false if broken?
354
    return false unless skip_ci_check || mergeable_ci_state?
355 356

    true
357 358
  end

359 360
  def can_cancel_merge_when_build_succeeds?(current_user)
    can_be_merged_by?(current_user) || self.author == current_user
361 362
  end

363 364 365
  def can_remove_source_branch?(current_user)
    !source_project.protected_branch?(source_branch) &&
      !source_project.root_ref?(source_branch) &&
366
      Ability.abilities.allowed?(current_user, :push_code, source_project) &&
367
      diff_head_commit == source_branch_head
368 369
  end

370 371 372 373 374 375 376 377 378 379 380 381
  def should_remove_source_branch?
    merge_params['should_remove_source_branch'].present?
  end

  def force_remove_source_branch?
    merge_params['force_remove_source_branch'].present?
  end

  def remove_source_branch?
    should_remove_source_branch? || force_remove_source_branch?
  end

382
  def mr_and_commit_notes
383 384 385 386
    # Fetch comments only from last 100 commits
    commits_for_notes_limit = 100
    commit_ids = commits.last(commits_for_notes_limit).map(&:id)

387 388
    Note.where(
      "(project_id = :target_project_id AND noteable_type = 'MergeRequest' AND noteable_id = :mr_id) OR" +
389
      "((project_id = :source_project_id OR project_id = :target_project_id) AND noteable_type = 'Commit' AND commit_id IN (:commit_ids))",
390
      mr_id: id,
391 392 393
      commit_ids: commit_ids,
      target_project_id: target_project_id,
      source_project_id: source_project_id
394
    )
395
  end
396

Kirill Zaitsev's avatar
Kirill Zaitsev committed
397 398
  def hook_attrs
    attrs = {
399
      source: source_project.try(:hook_attrs),
Kirill Zaitsev's avatar
Kirill Zaitsev committed
400
      target: target_project.hook_attrs,
401 402
      last_commit: nil,
      work_in_progress: work_in_progress?
Kirill Zaitsev's avatar
Kirill Zaitsev committed
403 404
    }

405 406
    if diff_head_commit
      attrs.merge!(last_commit: diff_head_commit.hook_attrs)
Kirill Zaitsev's avatar
Kirill Zaitsev committed
407 408 409 410 411
    end

    attributes.merge!(attrs)
  end

412 413 414 415
  def for_fork?
    target_project != source_project
  end

416 417 418 419
  def project
    target_project
  end

420 421 422 423
  def closes_issue?(issue)
    closes_issues.include?(issue)
  end

424
  # Return the set of issues that will be closed if this merge request is accepted.
425
  def closes_issues(current_user = self.author)
426
    if target_branch == project.default_branch
427 428 429 430
      messages = commits.map(&:safe_message) << description

      Gitlab::ClosingIssueExtractor.new(project, current_user).
        closed_by_message(messages.join("\n"))
431 432 433 434 435
    else
      []
    end
  end

436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451
  def target_project_path
    if target_project
      target_project.path_with_namespace
    else
      "(removed)"
    end
  end

  def source_project_path
    if source_project
      source_project.path_with_namespace
    else
      "(removed)"
    end
  end

452 453 454 455 456 457 458 459
  def source_project_namespace
    if source_project && source_project.namespace
      source_project.namespace.path
    else
      "(removed)"
    end
  end

460 461 462 463 464 465 466 467
  def target_project_namespace
    if target_project && target_project.namespace
      target_project.namespace.path
    else
      "(removed)"
    end
  end

468 469 470 471 472 473 474 475 476 477 478 479
  def source_branch_exists?
    return false unless self.source_project

    self.source_project.repository.branch_names.include?(self.source_branch)
  end

  def target_branch_exists?
    return false unless self.target_project

    self.target_project.repository.branch_names.include?(self.target_branch)
  end

Drew Blessing's avatar
Drew Blessing committed
480 481 482 483 484 485 486 487 488
  # Reset merge request events cache
  #
  # Since we do cache @event we need to reset cache in special cases:
  # * when a merge request is updated
  # Events cache stored like  events/23-20130109142513.
  # The cache key includes updated_at timestamp.
  # Thus it will automatically generate a new fragment
  # when the event is updated because the key changes.
  def reset_events_cache
489
    Event.reset_event_cache_for(self)
Drew Blessing's avatar
Drew Blessing committed
490 491
  end

492 493 494
  def merge_commit_message
    message = "Merge branch '#{source_branch}' into '#{target_branch}'"
    message << "\n\n"
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
495
    message << title.to_s
496
    message << "\n\n"
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
497
    message << description.to_s
498 499
    message << "\n\n"
    message << "See merge request !#{iid}"
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
500
    message
501
  end
502

503 504
  def reset_merge_when_build_succeeds
    return unless merge_when_build_succeeds?
505

506 507
    self.merge_when_build_succeeds = false
    self.merge_user = nil
508 509 510 511
    if merge_params
      merge_params.delete('should_remove_source_branch')
      merge_params.delete('commit_message')
    end
512 513 514 515

    self.save
  end

516
  # Return array of possible target branches
Steven Burgart's avatar
Steven Burgart committed
517
  # depends on target project of MR
518 519 520 521 522 523 524 525 526
  def target_branches
    if target_project.nil?
      []
    else
      target_project.repository.branch_names
    end
  end

  # Return array of possible source branches
Steven Burgart's avatar
Steven Burgart committed
527
  # depends on source project of MR
528 529 530 531 532 533 534
  def source_branches
    if source_project.nil?
      []
    else
      source_project.repository.branch_names
    end
  end
535 536

  def locked_long_ago?
Ben Bodenmiller's avatar
Ben Bodenmiller committed
537 538 539
    return false unless locked?

    locked_at.nil? || locked_at < (Time.now - 1.day)
540
  end
541 542 543 544 545 546 547 548

  def has_ci?
    source_project.ci_service && commits.any?
  end

  def branch_missing?
    !source_branch_exists? || !target_branch_exists?
  end
549

550 551 552 553
  def broken?
    self.commits.blank? || branch_missing? || cannot_be_merged?
  end

554
  def can_be_merged_by?(user)
555
    ::Gitlab::GitAccess.new(user, project, 'web').can_push_to_branch?(target_branch)
556 557
  end

558 559
  def mergeable_ci_state?
    return true unless project.only_allow_merge_if_build_succeeds?
560

Rémy Coutable's avatar
Rémy Coutable committed
561
    !pipeline || pipeline.success?
562 563
  end

564 565 566 567 568 569 570 571 572
  def state_human_name
    if merged?
      "Merged"
    elsif closed?
      "Closed"
    else
      "Open"
    end
  end
573

574 575 576 577 578 579 580 581 582 583
  def state_icon_name
    if merged?
      "check"
    elsif closed?
      "times"
    else
      "circle-o"
    end
  end

584 585 586 587
  def fetch_ref
    target_project.repository.fetch_ref(
      source_project.repository.path_to_repo,
      "refs/heads/#{source_branch}",
588
      ref_path
589 590 591
    )
  end

592 593 594 595
  def ref_path
    "refs/merge-requests/#{iid}/head"
  end

596 597
  def ref_fetched?
    project.repository.ref_exists?(ref_path)
598 599 600
  end

  def ensure_ref_fetched
601
    fetch_ref unless ref_fetched?
602 603
  end

604 605 606 607 608 609 610 611
  def in_locked_state
    begin
      lock_mr
      yield
    ensure
      unlock_mr if locked?
    end
  end
612

613 614 615
  def diverged_commits_count
    cache = Rails.cache.read(:"merge_request_#{id}_diverged_commits")

616
    if cache.blank? || cache[:source_sha] != source_branch_sha || cache[:target_sha] != target_branch_sha
617
      cache = {
618 619
        source_sha: source_branch_sha,
        target_sha: target_branch_sha,
620 621 622 623 624 625 626 627 628
        diverged_commits_count: compute_diverged_commits_count
      }
      Rails.cache.write(:"merge_request_#{id}_diverged_commits", cache)
    end

    cache[:diverged_commits_count]
  end

  def compute_diverged_commits_count
629
    return 0 unless source_branch_sha && target_branch_sha
630

631
    Gitlab::Git::Commit.between(target_project.repository.raw_repository, source_branch_sha, target_branch_sha).size
632
  end
633
  private :compute_diverged_commits_count
634 635 636 637 638

  def diverged_from_target_branch?
    diverged_commits_count > 0
  end

639
  def pipeline
640
    @pipeline ||= source_project.pipeline(diff_head_sha, source_branch) if diff_head_sha && source_project
641
  end
642 643 644 645 646

  def merge_commit
    @merge_commit ||= project.commit(merge_commit_sha) if merge_commit_sha
  end

647 648
  def can_be_reverted?(current_user = nil)
    merge_commit && !merge_commit.has_been_reverted?(current_user, self)
649
  end
650 651 652 653

  def can_be_cherry_picked?
    merge_commit
  end
654

655 656 657 658
  def support_new_diff_notes?
    diff_refs && diff_refs.complete?
  end

659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684
  def update_diff_notes_positions(old_diff_refs:, new_diff_refs:)
    return unless support_new_diff_notes?
    return if new_diff_refs == old_diff_refs

    active_diff_notes = self.notes.diff_notes.select do |note|
      note.new_diff_note? && note.active?(old_diff_refs)
    end

    return if active_diff_notes.empty?

    paths = active_diff_notes.flat_map { |n| n.diff_file.paths }.uniq

    service = Notes::DiffPositionUpdateService.new(
      self.project,
      nil,
      old_diff_refs: old_diff_refs,
      new_diff_refs: new_diff_refs,
      paths: paths
    )

    active_diff_notes.each do |note|
      service.execute(note)
      Gitlab::Timeless.timeless(note, &:save)
    end
  end

685 686 687
  def keep_around_commit
    project.repository.keep_around(self.merge_commit_sha)
  end
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
688
end