repository.rb 26.9 KB
Newer Older
1 2
require 'securerandom'

3
class Repository
Lin Jen-Shin's avatar
Lin Jen-Shin committed
4 5 6
  REF_MERGE_REQUEST = 'merge-requests'.freeze
  REF_KEEP_AROUND = 'keep-around'.freeze
  REF_ENVIRONMENTS = 'environments'.freeze
7
  MAX_DIVERGING_COUNT = 1000
8 9 10 11

  RESERVED_REFS_NAMES = %W[
    heads
    tags
12
    replace
13 14 15 16 17
    #{REF_ENVIRONMENTS}
    #{REF_KEEP_AROUND}
    #{REF_ENVIRONMENTS}
  ].freeze

18
  include Gitlab::ShellAdapter
19
  include Gitlab::RepositoryCacheAdapter
20

21
  attr_accessor :full_path, :disk_path, :project, :is_wiki
22

23
  delegate :ref_name_for_sha, to: :raw_repository
24
  delegate :bundle_to_disk, to: :raw_repository
25

26
  CreateTreeError = Class.new(StandardError)
27

28 29 30 31 32 33
  # Methods that cache data from the Git repository.
  #
  # Each entry in this Array should have a corresponding method with the exact
  # same name. The cache key used by those methods must also match method's
  # name.
  #
34 35 36
  # For example, for entry `:commit_count` there's a method called `commit_count` which
  # stores its data in the `commit_count` cache key.
  CACHED_METHODS = %i(size commit_count rendered_readme contribution_guide
37 38
                      changelog license_blob license_key gitignore koding_yml
                      gitlab_ci_yml branch_names tag_names branch_count
39
                      tag_count avatar exists? root_ref has_visible_content?
40
                      issue_template_names merge_request_template_names xcode_project?).freeze
41 42

  # Methods that use cache_method but only memoize the value
43
  MEMOIZED_CACHED_METHODS = %i(license).freeze
44 45 46 47 48

  # Certain method caches should be refreshed when certain types of files are
  # changed. This Hash maps file types (as returned by Gitlab::FileDetector) to
  # the corresponding methods to call for refreshing caches.
  METHOD_CACHES_FOR_FILE_TYPES = {
49
    readme: :rendered_readme,
50
    changelog: :changelog,
51
    license: %i(license_blob license_key license),
52 53 54 55
    contributing: :contribution_guide,
    gitignore: :gitignore,
    koding: :koding_yml,
    gitlab_ci: :gitlab_ci_yml,
56 57
    avatar: :avatar,
    issue_template: :issue_template_names,
58 59
    merge_request_template: :merge_request_template_names,
    xcode_config: :xcode_project?
Douwe Maan's avatar
Douwe Maan committed
60
  }.freeze
61

62
  def initialize(full_path, project, disk_path: nil, is_wiki: false)
63
    @full_path = full_path
64
    @disk_path = disk_path || full_path
65
    @project = project
66
    @commit_cache = {}
67
    @is_wiki = is_wiki
68
  end
69

70
  def ==(other)
71 72 73
    @disk_path == other.disk_path
  end

74
  def raw_repository
75
    return nil unless full_path
76

77
    @raw_repository ||= initialize_raw_repository
78 79
  end

80 81
  alias_method :raw, :raw_repository

82 83 84 85
  def cleanup
    @raw_repository&.cleanup
  end

86
  # Return absolute path to repository
87
  def path_to_repo
88 89 90 91 92 93 94 95
    @path_to_repo ||=
      begin
        storage = Gitlab.config.repositories.storages[@project.repository_storage]

        File.expand_path(
          File.join(storage.legacy_disk_path, disk_path + '.git')
        )
      end
96 97
  end

98 99 100 101
  def inspect
    "#<#{self.class.name}:#{@disk_path}>"
  end

102
  def commit(ref = 'HEAD')
103
    return nil unless exists?
104
    return ref if ref.is_a?(::Commit)
105

106 107
    find_commit(ref)
  end
108

109 110 111 112 113 114
  # Finding a commit by the passed SHA
  # Also takes care of caching, based on the SHA
  def commit_by(oid:)
    return @commit_cache[oid] if @commit_cache.key?(oid)

    @commit_cache[oid] = find_commit(oid)
115 116
  end

117 118 119 120 121 122 123 124 125 126 127 128
  def commits_by(oids:)
    return [] unless oids.present?

    commits = Gitlab::Git::Commit.batch_by_oid(raw_repository, oids)

    if commits.present?
      Commit.decorate(commits, @project)
    else
      []
    end
  end

129
  def commits(ref = nil, path: nil, limit: nil, offset: nil, skip_merges: false, after: nil, before: nil, all: nil)
130
    options = {
131 132 133 134 135
      repo: raw_repository,
      ref: ref,
      path: path,
      limit: limit,
      offset: offset,
136 137
      after: after,
      before: before,
138
      follow: Array(path).length == 1,
139 140
      skip_merges: skip_merges,
      all: all
141 142 143
    }

    commits = Gitlab::Git::Commit.where(options)
144
    commits = Commit.decorate(commits, @project) if commits.present?
145 146

    CommitCollection.new(project, commits, ref)
147 148
  end

149 150
  def commits_between(from, to)
    commits = Gitlab::Git::Commit.between(raw_repository, from, to)
151
    commits = Commit.decorate(commits, @project) if commits.present?
152 153 154
    commits
  end

155 156
  # Returns a list of commits that are not present in any reference
  def new_commits(newrev)
157 158 159 160
    # Gitaly migration: https://gitlab.com/gitlab-org/gitaly/issues/1233
    refs = Gitlab::GitalyClient::StorageSettings.allow_disk_access do
      ::Gitlab::Git::RevList.new(raw, newrev: newrev).new_refs
    end
161 162 163 164

    refs.map { |sha| commit(sha.strip) }
  end

Jacob Vosmaer's avatar
Jacob Vosmaer committed
165
  # Gitaly migration: https://gitlab.com/gitlab-org/gitaly/issues/384
166
  def find_commits_by_message(query, ref = nil, path = nil, limit = 1000, offset = 0)
167 168 169 170
    unless exists? && has_visible_content? && query.present?
      return []
    end

171 172
    commits = raw_repository.find_commits_by_message(query, ref, path, limit, offset).map do |c|
      commit(c)
173
    end
174
    CommitCollection.new(project, commits, ref)
175 176
  end

177
  def find_branch(name, fresh_repo: true)
178
    raw_repository.find_branch(name, fresh_repo)
179 180 181
  end

  def find_tag(name)
182
    tags.find { |tag| tag.name == name }
183 184
  end

185
  def add_branch(user, branch_name, ref)
186
    branch = raw_repository.add_branch(branch_name, user: user, target: ref)
187

188
    after_create_branch
189 190 191 192

    branch
  rescue Gitlab::Git::Repository::InvalidRef
    false
193 194
  end

195
  def add_tag(user, tag_name, target, message = nil)
196
    raw_repository.add_tag(tag_name, user: user, target: target, message: message)
197 198
  rescue Gitlab::Git::Repository::InvalidRef
    false
199 200
  end

201
  def rm_branch(user, branch_name)
202
    before_remove_branch
203

204
    raw_repository.rm_branch(branch_name, user: user)
205

206
    after_remove_branch
207
    true
208 209
  end

Lin Jen-Shin's avatar
Lin Jen-Shin committed
210
  def rm_tag(user, tag_name)
211
    before_remove_tag
212

213
    raw_repository.rm_tag(tag_name, user: user)
Lin Jen-Shin's avatar
Lin Jen-Shin committed
214 215 216

    after_remove_tag
    true
217 218
  end

219 220 221 222
  def ref_names
    branch_names + tag_names
  end

223
  def branch_exists?(branch_name)
224 225
    return false unless raw_repository

226
    branch_names.include?(branch_name)
227 228
  end

229 230 231 232 233 234
  def tag_exists?(tag_name)
    return false unless raw_repository

    tag_names.include?(tag_name)
  end

235
  def ref_exists?(ref)
236 237
    !!raw_repository&.ref_exists?(ref)
  rescue ArgumentError
238
    false
239 240
  end

241 242 243 244
  # Makes sure a commit is kept around when Git garbage collection runs.
  # Git GC will delete commits from the repository that are no longer in any
  # branches or tags, but we want to keep some of these commits around, for
  # example if they have comments or CI builds.
245
  def keep_around(sha)
246
    return unless sha.present? && commit_by(oid: sha)
247 248 249

    return if kept_around?(sha)

250
    # This will still fail if the file is corrupted (e.g. 0 bytes)
251
    raw_repository.write_ref(keep_around_ref_name(sha), sha, shell: false)
252 253
  rescue Gitlab::Git::CommandError => ex
    Rails.logger.error "Unable to create keep-around reference for repository #{path}: #{ex}"
254 255 256
  end

  def kept_around?(sha)
257
    ref_exists?(keep_around_ref_name(sha))
258
  end
259

260
  def diverging_commit_counts(branch)
261
    @root_ref_hash ||= raw_repository.commit(root_ref).id
Jeff Stubler's avatar
Jeff Stubler committed
262
    cache.fetch(:"diverging_commit_counts_#{branch.name}") do
263 264
      # Rugged seems to throw a `ReferenceError` when given branch_names rather
      # than SHA-1 hashes
265 266
      number_commits_behind, number_commits_ahead =
        raw_repository.count_commits_between(
267
          @root_ref_hash,
268 269 270
          branch.dereferenced_target.sha,
          left_right: true,
          max_count: MAX_DIVERGING_COUNT)
271

272 273 274
      { behind: number_commits_behind, ahead: number_commits_ahead }
    end
  end
275

276 277 278 279 280 281 282 283 284 285
  def archive_metadata(ref, storage_path, format = "tar.gz", append_sha:)
    raw_repository.archive_metadata(
      ref,
      storage_path,
      project.path,
      format,
      append_sha: append_sha
    )
  end

286 287 288
  def expire_tags_cache
    expire_method_caches(%i(tag_names tag_count))
    @tags = nil
289
  end
290

291
  def expire_branches_cache
292
    expire_method_caches(%i(branch_names branch_count has_visible_content?))
293
    @local_branches = nil
294
    @branch_exists_memo = nil
295 296
  end

297 298
  def expire_statistics_caches
    expire_method_caches(%i(size commit_count))
299 300
  end

301 302
  def expire_all_method_caches
    expire_method_caches(CACHED_METHODS)
303 304
  end

305 306 307 308 309 310 311 312 313 314 315 316 317 318 319
  def expire_avatar_cache
    expire_method_caches(%i(avatar))
  end

  # Refreshes the method caches of this repository.
  #
  # types - An Array of file types (e.g. `:readme`) used to refresh extra
  #         caches.
  def refresh_method_caches(types)
    to_refresh = []

    types.each do |type|
      methods = METHOD_CACHES_FOR_FILE_TYPES[type.to_sym]

      to_refresh.concat(Array(methods)) if methods
320
    end
321

322
    expire_method_caches(to_refresh)
323

324
    to_refresh.each { |method| send(method) } # rubocop:disable GitlabSecurity/PublicSend
325
  end
326

327 328 329 330 331 332 333
  def expire_branch_cache(branch_name = nil)
    # When we push to the root branch we have to flush the cache for all other
    # branches as their statistics are based on the commits relative to the
    # root branch.
    if !branch_name || branch_name == root_ref
      branches.each do |branch|
        cache.expire(:"diverging_commit_counts_#{branch.name}")
334
        cache.expire(:"commit_count_#{branch.name}")
335 336 337 338 339
      end
    # In case a commit is pushed to a non-root branch we only have to flush the
    # cache for said branch.
    else
      cache.expire(:"diverging_commit_counts_#{branch_name}")
340
      cache.expire(:"commit_count_#{branch_name}")
341
    end
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
342 343
  end

344
  def expire_root_ref_cache
345
    expire_method_caches(%i(root_ref))
346 347
  end

348 349
  # Expires the cache(s) used to determine if a repository is empty or not.
  def expire_emptiness_caches
350
    return unless empty?
351

352
    expire_method_caches(%i(has_visible_content?))
353
    raw_repository.expire_has_local_branches_cache
354 355
  end

356 357 358 359
  def lookup_cache
    @lookup_cache ||= {}
  end

360
  def expire_exists_cache
361
    expire_method_caches(%i(exists?))
362 363
  end

364 365 366 367 368 369 370
  # expire cache that doesn't depend on repository data (when expiring)
  def expire_content_cache
    expire_tags_cache
    expire_branches_cache
    expire_root_ref_cache
    expire_emptiness_caches
    expire_exists_cache
371
    expire_statistics_caches
372 373 374 375 376
  end

  # Runs code after a repository has been created.
  def after_create
    expire_exists_cache
377 378
    expire_root_ref_cache
    expire_emptiness_caches
Yorick Peterse's avatar
Yorick Peterse committed
379 380

    repository_event(:create_repository)
381 382
  end

383 384
  # Runs code just before a repository is deleted.
  def before_delete
385
    expire_exists_cache
386 387
    expire_all_method_caches
    expire_branch_cache if exists?
388
    expire_content_cache
Yorick Peterse's avatar
Yorick Peterse committed
389 390

    repository_event(:remove_repository)
391 392 393 394 395 396 397
  end

  # Runs code just before the HEAD of a repository is changed.
  def before_change_head
    # Cached divergent commit counts are based on repository head
    expire_branch_cache
    expire_root_ref_cache
Yorick Peterse's avatar
Yorick Peterse committed
398 399

    repository_event(:change_default_branch)
400 401
  end

402 403
  # Runs code before pushing (= creating or removing) a tag.
  def before_push_tag
404 405
    expire_statistics_caches
    expire_emptiness_caches
406
    expire_tags_cache
Yorick Peterse's avatar
Yorick Peterse committed
407 408

    repository_event(:push_tag)
409 410 411 412 413
  end

  # Runs code before removing a tag.
  def before_remove_tag
    expire_tags_cache
414
    expire_statistics_caches
Yorick Peterse's avatar
Yorick Peterse committed
415 416

    repository_event(:remove_tag)
417 418
  end

Lin Jen-Shin's avatar
Lin Jen-Shin committed
419 420 421 422 423
  # Runs code after removing a tag.
  def after_remove_tag
    expire_tags_cache
  end

424 425 426
  # Runs code after the HEAD of a repository is changed.
  def after_change_head
    expire_method_caches(METHOD_CACHES_FOR_FILE_TYPES.keys)
427 428
  end

429 430
  # Runs code after a repository has been forked/imported.
  def after_import
431
    expire_content_cache
432 433 434
  end

  # Runs code after a new commit has been pushed.
435 436 437
  def after_push_commit(branch_name)
    expire_statistics_caches
    expire_branch_cache(branch_name)
Yorick Peterse's avatar
Yorick Peterse committed
438 439

    repository_event(:push_commit, branch: branch_name)
440 441 442 443
  end

  # Runs code after a new branch has been created.
  def after_create_branch
444
    expire_branches_cache
Yorick Peterse's avatar
Yorick Peterse committed
445 446

    repository_event(:push_branch)
447 448
  end

449 450 451
  # Runs code before removing an existing branch.
  def before_remove_branch
    expire_branches_cache
Yorick Peterse's avatar
Yorick Peterse committed
452 453

    repository_event(:remove_branch)
454 455
  end

456 457
  # Runs code after an existing branch has been removed.
  def after_remove_branch
458
    expire_branches_cache
459 460
  end

461
  def method_missing(m, *args, &block)
462 463
    if m == :lookup && !block_given?
      lookup_cache[m] ||= {}
464
      lookup_cache[m][args.join(":")] ||= raw_repository.__send__(m, *args, &block) # rubocop:disable GitlabSecurity/PublicSend
465
    else
466
      raw_repository.__send__(m, *args, &block) # rubocop:disable GitlabSecurity/PublicSend
467
    end
468 469
  end

470 471
  def respond_to_missing?(method, include_private = false)
    raw_repository.respond_to?(method, include_private) || super
472
  end
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
473 474

  def blob_at(sha, path)
475
    Blob.decorate(raw_repository.blob_at(sha, path), project)
Douwe Maan's avatar
Douwe Maan committed
476 477
  rescue Gitlab::Git::Repository::NoRepository
    nil
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
478
  end
479

480 481 482 483 484
  # items is an Array like: [[oid, path], [oid1, path1]]
  def blobs_at(items)
    raw_repository.batch_blobs(items).map { |blob| Blob.decorate(blob, project) }
  end

485
  def root_ref
486 487
    # When the repo does not exist, or there is no root ref, we raise this error so no data is cached.
    raw_repository&.root_ref or raise Gitlab::Git::Repository::NoRepository # rubocop:disable Style/AndOr
488
  end
489
  cache_method :root_ref
490

491
  # Gitaly migration: https://gitlab.com/gitlab-org/gitaly/issues/314
492
  def exists?
493
    return false unless full_path
494

495
    raw_repository.exists?
496 497 498
  end
  cache_method :exists?

499 500 501
  # We don't need to cache the output of this method because both exists? and
  # has_visible_content? are already memoized and cached. There's no guarantee
  # that the values are expired and loaded atomically.
502 503 504 505 506
  def empty?
    return true unless exists?

    !has_visible_content?
  end
507 508 509 510 511 512 513 514 515 516 517 518

  # The size of this repository in megabytes.
  def size
    exists? ? raw_repository.size : 0.0
  end
  cache_method :size, fallback: 0.0

  def commit_count
    root_ref ? raw_repository.commit_count(root_ref) : 0
  end
  cache_method :commit_count, fallback: 0

519
  def commit_count_for_ref(ref)
520
    return 0 unless exists?
521

522
    cache.fetch(:"commit_count_#{ref}") { raw_repository.commit_count(ref) }
523 524
  end

525
  delegate :branch_names, to: :raw_repository
526 527
  cache_method :branch_names, fallback: []

Douwe Maan's avatar
Douwe Maan committed
528
  delegate :tag_names, to: :raw_repository
529 530
  cache_method :tag_names, fallback: []

531
  delegate :branch_count, :tag_count, :has_visible_content?, to: :raw_repository
532 533
  cache_method :branch_count, fallback: 0
  cache_method :tag_count, fallback: 0
534
  cache_method :has_visible_content?, fallback: false
535 536

  def avatar
537 538 539 540 541
    # n+1: https://gitlab.com/gitlab-org/gitlab-ce/issues/38327
    Gitlab::GitalyClient.allow_n_plus_1_calls do
      if tree = file_on_head(:avatar)
        tree.path
      end
542 543
    end
  end
544
  cache_method :avatar
545

546 547 548 549 550 551 552 553 554 555
  def issue_template_names
    Gitlab::Template::IssueTemplate.dropdown_names(project)
  end
  cache_method :issue_template_names, fallback: []

  def merge_request_template_names
    Gitlab::Template::MergeRequestTemplate.dropdown_names(project)
  end
  cache_method :merge_request_template_names, fallback: []

556
  def readme
557 558
    if readme = tree(:head)&.readme
      ReadmeBlob.new(readme, self)
559
    end
560 561
  end

562
  def rendered_readme
563
    MarkupHelper.markup_unsafe(readme.name, readme.data, project: project) if readme
564 565
  end
  cache_method :rendered_readme
566

567
  def contribution_guide
568
    file_on_head(:contributing)
569
  end
570
  cache_method :contribution_guide
571 572

  def changelog
573
    file_on_head(:changelog)
574
  end
575
  cache_method :changelog
576

577
  def license_blob
578
    file_on_head(:license)
579
  end
580
  cache_method :license_blob
581

582
  def license_key
583
    return unless exists?
584

585
    raw_repository.license_short_name
586
  end
587
  cache_method :license_key
588

589 590
  def license
    return unless license_key
591

592
    Licensee::License.new(license_key)
593
  end
594
  cache_method :license, memoize_only: true
595 596

  def gitignore
597
    file_on_head(:gitignore)
598
  end
599
  cache_method :gitignore
600 601

  def koding_yml
602
    file_on_head(:koding)
603
  end
604
  cache_method :koding_yml
605

606
  def gitlab_ci_yml
607
    file_on_head(:gitlab_ci)
608
  end
609
  cache_method :gitlab_ci_yml
610

611
  def xcode_project?
612
    file_on_head(:xcode_config, :tree).present?
613 614 615
  end
  cache_method :xcode_project?

616
  def head_commit
617 618 619 620
    @head_commit ||= commit(self.root_ref)
  end

  def head_tree
621 622 623
    if head_commit
      @head_tree ||= Tree.new(self, head_commit.sha, nil)
    end
624 625
  end

626
  def tree(sha = :head, path = nil, recursive: false)
627
    if sha == :head
628 629
      return unless head_commit

630 631 632 633 634
      if path.nil?
        return head_tree
      else
        sha = head_commit.sha
      end
635 636
    end

637
    Tree.new(self, sha, path, recursive: recursive)
638
  end
639 640

  def blob_at_branch(branch_name, path)
641
    last_commit = commit(branch_name)
642

643 644 645 646 647
    if last_commit
      blob_at(last_commit.sha, path)
    else
      nil
    end
648
  end
649

650
  def last_commit_for_path(sha, path)
651 652
    commit = raw_repository.last_commit_for_path(sha, path)
    ::Commit.new(commit, @project) if commit
653
  end
654

Hiroyuki Sato's avatar
Hiroyuki Sato committed
655 656
  def last_commit_id_for_path(sha, path)
    key = path.blank? ? "last_commit_id_for_path:#{sha}" : "last_commit_id_for_path:#{sha}:#{Digest::SHA1.hexdigest(path)}"
Hiroyuki Sato's avatar
Hiroyuki Sato committed
657

658
    cache.fetch(key) do
659
      last_commit_for_path(sha, path)&.id
660 661 662
    end
  end

663
  def next_branch(name, opts = {})
664 665
    branch_ids = self.branch_names.map do |n|
      next 1 if n == name
666

667
      result = n.match(/\A#{name}-([0-9]+)\z/)
668 669 670
      result[1].to_i if result
    end.compact

671
    highest_branch_id = branch_ids.max || 0
672

673 674 675
    return name if opts[:mild] && 0 == highest_branch_id

    "#{name}-#{highest_branch_id + 1}"
676 677
  end

678
  def branches_sorted_by(value)
679
    raw_repository.local_branches(sort_by: value)
680
  end
681

682 683
  def tags_sorted_by(value)
    case value
haseeb's avatar
haseeb committed
684 685 686
    when 'name_asc'
      VersionSorter.sort(tags) { |tag| tag.name }
    when 'name_desc'
687
      VersionSorter.rsort(tags) { |tag| tag.name }
688 689 690 691 692 693 694 695 696
    when 'updated_desc'
      tags_sorted_by_committed_date.reverse
    when 'updated_asc'
      tags_sorted_by_committed_date
    else
      tags
    end
  end

697 698 699 700 701
  # Params:
  #
  # order_by: name|email|commits
  # sort: asc|desc default: 'asc'
  def contributors(order_by: nil, sort: 'asc')
702
    commits = self.commits(nil, limit: 2000, offset: 0, skip_merges: true)
703

704
    commits = commits.group_by(&:author_email).map do |email, commits|
705 706
      contributor = Gitlab::Contributor.new
      contributor.email = email
707

Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
708
      commits.each do |commit|
709
        if contributor.name.blank?
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
710
          contributor.name = commit.author_name
711 712
        end

713
        contributor.commits += 1
714 715
      end

716 717
      contributor
    end
718
    Commit.order_by(collection: commits, order_by: order_by, sort: sort)
719
  end
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
720

721
  def branch_names_contains(sha)
722
    raw_repository.branch_names_contains_sha(sha)
723
  end
724

725
  def tag_names_contains(sha)
726
    raw_repository.tag_names_contains_sha(sha)
727
  end
728

729
  def local_branches
730
    @local_branches ||= raw_repository.local_branches
731 732
  end

733 734
  alias_method :branches, :local_branches

735 736 737 738
  def tags
    @tags ||= raw_repository.tags
  end

Douwe Maan's avatar
Douwe Maan committed
739 740
  def create_dir(user, path, **options)
    options[:actions] = [{ action: :create_dir, file_path: path }]
741

742
    multi_action(user, **options)
Stan Hu's avatar
Stan Hu committed
743 744
  end

Douwe Maan's avatar
Douwe Maan committed
745 746
  def create_file(user, path, content, **options)
    options[:actions] = [{ action: :create, file_path: path, content: content }]
747

748
    multi_action(user, **options)
Stan Hu's avatar
Stan Hu committed
749
  end
750

Douwe Maan's avatar
Douwe Maan committed
751 752 753
  def update_file(user, path, content, **options)
    previous_path = options.delete(:previous_path)
    action = previous_path && previous_path != path ? :move : :update
754

Douwe Maan's avatar
Douwe Maan committed
755
    options[:actions] = [{ action: action, file_path: path, previous_path: previous_path, content: content }]
756

757
    multi_action(user, **options)
758 759
  end

Douwe Maan's avatar
Douwe Maan committed
760 761
  def delete_file(user, path, **options)
    options[:actions] = [{ action: :delete, file_path: path }]
762

763
    multi_action(user, **options)
764 765
  end

766 767
  def with_cache_hooks
    result = yield
768

769
    return unless result
770

771 772
    after_create if result.repo_created?
    after_create_branch if result.branch_created?
773

774 775 776
    result.newrev
  end

777 778
  def multi_action(user, **options)
    start_project = options.delete(:start_project)
Marc Siegfriedt's avatar
Marc Siegfriedt committed
779

780 781
    if start_project
      options[:start_repository] = start_project.repository.raw_repository
Marc Siegfriedt's avatar
Marc Siegfriedt committed
782 783
    end

784
    with_cache_hooks { raw.multi_action(user, **options) }
785 786
  end

787 788 789 790 791 792
  def merge(user, source_sha, merge_request, message)
    with_cache_hooks do
      raw_repository.merge(user, source_sha, merge_request.target_branch, message) do |commit_id|
        merge_request.update(in_progress_merge_commit_sha: commit_id)
        nil # Return value does not matter.
      end
793
    end
794 795
  end

796
  def ff_merge(user, source, target_branch, merge_request: nil)
797 798
    their_commit_id = commit(source)&.id
    raise 'Invalid merge source' if their_commit_id.nil?
799

800
    merge_request&.update(in_progress_merge_commit_sha: their_commit_id)
801

802
    with_cache_hooks { raw.ff_merge(user, their_commit_id, target_branch) }
803 804
  end

805
  def revert(
806
    user, commit, branch_name, message,
807
    start_branch_name: nil, start_project: project)
808

809 810 811 812 813 814 815 816 817
    with_cache_hooks do
      raw_repository.revert(
        user: user,
        commit: commit.raw,
        branch_name: branch_name,
        message: message,
        start_branch_name: start_branch_name,
        start_repository: start_project.repository.raw_repository
      )
818
    end
819 820
  end

821
  def cherry_pick(
822
    user, commit, branch_name, message,
823
    start_branch_name: nil, start_project: project)
824

825 826 827 828 829 830 831 832 833
    with_cache_hooks do
      raw_repository.cherry_pick(
        user: user,
        commit: commit.raw,
        branch_name: branch_name,
        message: message,
        start_branch_name: start_branch_name,
        start_repository: start_project.repository.raw_repository
      )
834 835 836
    end
  end

837
  def merged_to_root_ref?(branch_or_name)
838 839 840
    branch = Gitlab::Git::Branch.find(self, branch_or_name)

    if branch
841 842
      same_head = branch.target == root_ref_sha
      merged = ancestor?(branch.target, root_ref_sha)
843
      !same_head && merged
844 845 846 847 848
    else
      nil
    end
  end

849 850 851 852
  def root_ref_sha
    @root_ref_sha ||= commit(root_ref).sha
  end

853
  delegate :merged_branch_names, to: :raw_repository
854

855
  def merge_base(first_commit_id, second_commit_id)
856 857
    first_commit_id = commit(first_commit_id).try(:id) || first_commit_id
    second_commit_id = commit(second_commit_id).try(:id) || second_commit_id
858
    raw_repository.merge_base(first_commit_id, second_commit_id)
859 860
  end

861
  def ancestor?(ancestor_id, descendant_id)
862
    return false if ancestor_id.nil? || descendant_id.nil?
863

864
    raw_repository.ancestor?(ancestor_id, descendant_id)
865 866
  end

867
  def fetch_as_mirror(url, forced: false, refmap: :all_refs, remote_name: nil, prune: true)
868 869 870 871 872
    unless remote_name
      remote_name = "tmp-#{SecureRandom.hex}"
      tmp_remote_name = true
    end

873
    add_remote(remote_name, url, mirror_refmap: refmap)
874
    fetch_remote(remote_name, forced: forced, prune: prune)
875
  ensure
876
    async_remove_remote(remote_name) if tmp_remote_name
877 878
  end

879 880
  def fetch_remote(remote, forced: false, ssh_auth: nil, no_tags: false, prune: true)
    gitlab_shell.fetch_remote(raw_repository, remote, ssh_auth: ssh_auth, forced: forced, no_tags: no_tags, prune: prune)
881 882
  end

883 884 885 886 887 888 889 890 891 892 893 894 895 896
  def async_remove_remote(remote_name)
    return unless remote_name

    job_id = RepositoryRemoveRemoteWorker.perform_async(project.id, remote_name)

    if job_id
      Rails.logger.info("Remove remote job scheduled for #{project.id} with remote name: #{remote_name} job ID #{job_id}.")
    else
      Rails.logger.info("Remove remote job failed to create for #{project.id} with remote name #{remote_name}.")
    end

    job_id
  end

897 898
  def fetch_source_branch!(source_repository, source_branch, local_ref)
    raw_repository.fetch_source_branch!(source_repository.raw_repository, source_branch, local_ref)
899
  end
900

901 902
  def compare_source_branch(target_branch_name, source_repository, source_branch_name, straight:)
    raw_repository.compare_source_branch(target_branch_name, source_repository.raw_repository, source_branch_name, straight: straight)
903
  end
904

905
  def create_ref(ref, ref_path)
906
    raw_repository.write_ref(ref_path, ref)
907 908
  end

909 910 911 912 913
  def ls_files(ref)
    actual_ref = ref || root_ref
    raw_repository.ls_files(actual_ref)
  end

914 915 916 917 918 919 920 921 922 923 924 925
  def search_files_by_content(query, ref)
    return [] if empty? || query.blank?

    raw_repository.search_files_by_content(query, ref)
  end

  def search_files_by_name(query, ref)
    return [] if empty?

    raw_repository.search_files_by_name(query, ref)
  end

926 927 928 929 930 931 932 933 934 935
  def copy_gitattributes(ref)
    actual_ref = ref || root_ref
    begin
      raw_repository.copy_gitattributes(actual_ref)
      true
    rescue Gitlab::Git::Repository::InvalidRef
      false
    end
  end

936 937 938 939 940 941 942 943 944 945 946
  def file_on_head(type, object_type = :blob)
    return unless head = tree(:head)

    objects =
      case object_type
      when :blob
        head.blobs
      when :tree
        head.trees
      else
        raise ArgumentError, "Object type #{object_type} is not supported"
947
      end
948 949 950

    objects.find do |object|
      Gitlab::FileDetector.type_of(object.path) == type
951 952 953
    end
  end

Douwe Maan's avatar
Douwe Maan committed
954 955 956 957
  def route_map_for(sha)
    blob_data_at(sha, '.gitlab/route-map.yml')
  end

958 959
  def gitlab_ci_yml_for(sha, path = '.gitlab-ci.yml')
    blob_data_at(sha, path)
Douwe Maan's avatar
Douwe Maan committed
960 961
  end

962 963 964 965
  def lfsconfig_for(sha)
    blob_data_at(sha, '.lfsconfig')
  end

966 967 968 969
  def fetch_ref(source_repository, source_ref:, target_ref:)
    raw_repository.fetch_ref(source_repository.raw_repository, source_ref: source_ref, target_ref: target_ref)
  end

970 971 972 973 974 975 976
  def rebase(user, merge_request)
    raw.rebase(user, merge_request.id, branch: merge_request.source_branch,
                                       branch_sha: merge_request.source_branch_sha,
                                       remote_repository: merge_request.target_project.repository.raw,
                                       remote_branch: merge_request.target_branch)
  end

977 978 979 980 981 982 983 984
  def blob_data_at(sha, path)
    blob = blob_at(sha, path)
    return unless blob

    blob.load_all_data!
    blob.data
  end

985 986 987 988 989 990 991 992
  def squash(user, merge_request)
    raw.squash(user, merge_request.id, branch: merge_request.target_branch,
                                       start_sha: merge_request.diff_start_sha,
                                       end_sha: merge_request.diff_head_sha,
                                       author: merge_request.author,
                                       message: merge_request.title)
  end

993 994
  private

995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006
  # TODO Generice finder, later split this on finders by Ref or Oid
  # gitlab-org/gitlab-ce#39239
  def find_commit(oid_or_ref)
    commit = if oid_or_ref.is_a?(Gitlab::Git::Commit)
               oid_or_ref
             else
               Gitlab::Git::Commit.find(raw_repository, oid_or_ref)
             end

    ::Commit.new(commit, @project) if commit
  end

1007
  def cache
1008
    @cache ||= Gitlab::RepositoryCache.new(self)
1009
  end
1010 1011

  def tags_sorted_by_committed_date
1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023
    tags.sort_by do |tag|
      # Annotated tags can point to any object (e.g. a blob), but generally
      # tags point to a commit. If we don't have a commit, then just default
      # to putting the tag at the end of the list.
      target = tag.dereferenced_target

      if target
        target.committed_date
      else
        Time.now
      end
    end
1024
  end
1025 1026

  def keep_around_ref_name(sha)
1027
    "refs/#{REF_KEEP_AROUND}/#{sha}"
1028
  end
Yorick Peterse's avatar
Yorick Peterse committed
1029 1030

  def repository_event(event, tags = {})
1031
    Gitlab::Metrics.add_event(event, { path: full_path }.merge(tags))
Yorick Peterse's avatar
Yorick Peterse committed
1032
  end
1033

1034
  def initialize_raw_repository
1035
    Gitlab::Git::Repository.new(project.repository_storage, disk_path + '.git', Gitlab::GlRepository.gl_repository(project, is_wiki))
1036
  end
1037
end