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

3
class Repository
4
  include Gitlab::ShellAdapter
5
  include RepositoryMirroring
6

7
  attr_accessor :full_path, :disk_path, :project
8

9
10
  delegate :ref_name_for_sha, to: :raw_repository

11
  CommitError = Class.new(StandardError)
12
  CreateTreeError = Class.new(StandardError)
13

14
15
16
17
18
19
  # 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.
  #
20
21
22
  # 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
23
24
                      changelog license_blob license_key gitignore koding_yml
                      gitlab_ci_yml branch_names tag_names branch_count
Douwe Maan's avatar
Douwe Maan committed
25
                      tag_count avatar exists? empty? root_ref).freeze
26
27
28
29
30

  # 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 = {
31
    readme: :rendered_readme,
32
    changelog: :changelog,
33
    license: %i(license_blob license_key license),
34
35
36
37
38
    contributing: :contribution_guide,
    gitignore: :gitignore,
    koding: :koding_yml,
    gitlab_ci: :gitlab_ci_yml,
    avatar: :avatar
Douwe Maan's avatar
Douwe Maan committed
39
  }.freeze
40
41
42
43
44

  # Wraps around the given method and caches its output in Redis and an instance
  # variable.
  #
  # This only works for methods that do not take any arguments.
45
  def self.cache_method(name, fallback: nil, memoize_only: false)
46
    original = :"_uncached_#{name}"
47

48
    alias_method(original, name)
49

50
    define_method(name) do
51
      cache_method_output(name, fallback: fallback, memoize_only: memoize_only) { __send__(original) }
52
    end
53
  end
54

55
  def initialize(full_path, project, disk_path: nil)
56
    @full_path = full_path
57
    @disk_path = disk_path || full_path
58
    @project = project
59
  end
60

61
  def raw_repository
62
    return nil unless full_path
63

64
    @raw_repository ||= initialize_raw_repository
65
66
  end

67
68
  alias_method :raw, :raw_repository

69
  # Return absolute path to repository
70
  def path_to_repo
71
    @path_to_repo ||= File.expand_path(
72
      File.join(repository_storage_path, disk_path + '.git')
73
    )
74
75
  end

76
77
78
79
80
81
82
83
84
85
  #
  # Git repository can contains some hidden refs like:
  #   /refs/notes/*
  #   /refs/git-as-svn/*
  #   /refs/pulls/*
  # This refs by default not visible in project page and not cloned to client side.
  #
  # This method return true if repository contains some content visible in project page.
  #
  def has_visible_content?
86
    branch_count > 0
87
88
  end

89
  def commit(ref = 'HEAD')
90
    return nil unless exists?
91

92
93
94
95
96
97
    commit =
      if ref.is_a?(Gitlab::Git::Commit)
        ref
      else
        Gitlab::Git::Commit.find(raw_repository, ref)
      end
98

99
    commit = ::Commit.new(commit, @project) if commit
100
    commit
101
  rescue Rugged::OdbError, Rugged::TreeError
102
    nil
103
104
  end

105
  def commits(ref, path: nil, limit: nil, offset: nil, skip_merges: false, after: nil, before: nil)
106
    options = {
107
108
109
110
111
      repo: raw_repository,
      ref: ref,
      path: path,
      limit: limit,
      offset: offset,
112
113
      after: after,
      before: before,
114
      follow: Array(path).length == 1,
115
      skip_merges: skip_merges
116
117
118
    }

    commits = Gitlab::Git::Commit.where(options)
119
    commits = Commit.decorate(commits, @project) if commits.present?
120
121
122
    commits
  end

123
124
  def commits_between(from, to)
    commits = Gitlab::Git::Commit.between(raw_repository, from, to)
125
    commits = Commit.decorate(commits, @project) if commits.present?
126
127
128
    commits
  end

Jacob Vosmaer's avatar
Jacob Vosmaer committed
129
  # Gitaly migration: https://gitlab.com/gitlab-org/gitaly/issues/384
130
  def find_commits_by_message(query, ref = nil, path = nil, limit = 1000, offset = 0)
131
132
133
134
    unless exists? && has_visible_content? && query.present?
      return []
    end

135
136
137
138
139
140
141
    raw_repository.gitaly_migrate(:commits_by_message) do |is_enabled|
      if is_enabled
        find_commits_by_message_by_gitaly(query, ref, path, limit, offset)
      else
        find_commits_by_message_by_shelling_out(query, ref, path, limit, offset)
      end
    end
142
143
  end

144
145
146
147
148
149
150
  def find_branch(name, fresh_repo: true)
    # Since the Repository object may have in-memory index changes, invalidating the memoized Repository object may
    # cause unintended side effects. Because finding a branch is a read-only operation, we can safely instantiate
    # a new repo here to ensure a consistent state to avoid a libgit2 bug where concurrent access (e.g. via git gc)
    # may cause the branch to "disappear" erroneously or have the wrong SHA.
    #
    # See: https://github.com/libgit2/libgit2/issues/1534 and https://gitlab.com/gitlab-org/gitlab-ce/issues/15392
151
    raw_repo = fresh_repo ? initialize_raw_repository : raw_repository
152
153

    raw_repo.find_branch(name)
154
155
156
  end

  def find_tag(name)
157
    tags.find { |tag| tag.name == name }
158
159
  end

160
161
  def add_branch(user, branch_name, ref)
    newrev = commit(ref).try(:sha)
162

163
    return false unless newrev
164

165
    GitOperationService.new(user, self).add_branch(branch_name, newrev)
166

167
    after_create_branch
168
    find_branch(branch_name)
169
170
  end

171
  def add_tag(user, tag_name, target, message = nil)
172
    newrev = commit(target).try(:id)
173
174
    options = { message: message, tagger: user_to_committer(user) } if message

175
176
177
    return false unless newrev

    GitOperationService.new(user, self).add_tag(tag_name, newrev, options)
178

179
    find_tag(tag_name)
180
181
  end

182
  def rm_branch(user, branch_name)
183
    before_remove_branch
184
185
    branch = find_branch(branch_name)

186
    GitOperationService.new(user, self).rm_branch(branch)
187

188
    after_remove_branch
189
    true
190
191
  end

Lin Jen-Shin's avatar
Lin Jen-Shin committed
192
  def rm_tag(user, tag_name)
193
    before_remove_tag
Lin Jen-Shin's avatar
Lin Jen-Shin committed
194
    tag = find_tag(tag_name)
195

Lin Jen-Shin's avatar
Lin Jen-Shin committed
196
197
198
199
    GitOperationService.new(user, self).rm_tag(tag)

    after_remove_tag
    true
200
201
  end

202
203
204
205
  def ref_names
    branch_names + tag_names
  end

206
207
208
209
  def branch_exists?(branch_name)
    branch_names.include?(branch_name)
  end

210
211
  def ref_exists?(ref)
    rugged.references.exist?(ref)
212
213
  rescue Rugged::ReferenceError
    false
214
215
  end

Douwe Maan's avatar
Douwe Maan committed
216
217
218
219
  # 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.
220
221
222
223
224
  def keep_around(sha)
    return unless sha && commit(sha)

    return if kept_around?(sha)

225
226
227
228
229
    # This will still fail if the file is corrupted (e.g. 0 bytes)
    begin
      rugged.references.create(keep_around_ref_name(sha), sha, force: true)
    rescue Rugged::ReferenceError => ex
      Rails.logger.error "Unable to create keep-around reference for repository #{path}: #{ex}"
230
231
232
    rescue Rugged::OSError => ex
      raise unless ex.message =~ /Failed to create locked file/ && ex.message =~ /File exists/
      Rails.logger.error "Unable to create keep-around reference for repository #{path}: #{ex}"
233
    end
234
235
236
  end

  def kept_around?(sha)
237
    ref_exists?(keep_around_ref_name(sha))
238
  end
239

240
  def diverging_commit_counts(branch)
241
    root_ref_hash = raw_repository.rev_parse_target(root_ref).oid
Jeff Stubler's avatar
Jeff Stubler committed
242
    cache.fetch(:"diverging_commit_counts_#{branch.name}") do
243
244
      # Rugged seems to throw a `ReferenceError` when given branch_names rather
      # than SHA-1 hashes
245
246
      number_commits_behind = raw_repository
        .count_commits_between(branch.dereferenced_target.sha, root_ref_hash)
247

248
249
      number_commits_ahead = raw_repository
        .count_commits_between(root_ref_hash, branch.dereferenced_target.sha)
250

251
252
253
      { behind: number_commits_behind, ahead: number_commits_ahead }
    end
  end
254

255
256
257
  def expire_tags_cache
    expire_method_caches(%i(tag_names tag_count))
    @tags = nil
258
  end
259

260
261
262
  def expire_branches_cache
    expire_method_caches(%i(branch_names branch_count))
    @local_branches = nil
263
264
  end

265
266
  def expire_statistics_caches
    expire_method_caches(%i(size commit_count))
267
268
  end

269
270
  def expire_all_method_caches
    expire_method_caches(CACHED_METHODS)
Douwe Maan's avatar
Douwe Maan committed
271
272
  end

273
274
275
276
277
278
279
280
281
  # Expires the caches of a specific set of methods
  def expire_method_caches(methods)
    methods.each do |key|
      cache.expire(key)

      ivar = cache_instance_variable_name(key)

      remove_instance_variable(ivar) if instance_variable_defined?(ivar)
    end
Douwe Maan's avatar
Douwe Maan committed
282
283
  end

284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
  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
299
    end
300

301
    expire_method_caches(to_refresh)
302

303
    to_refresh.each { |method| send(method) } # rubocop:disable GitlabSecurity/PublicSend
304
  end
305

306
307
308
309
310
311
312
  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}")
313
        cache.expire(:"commit_count_#{branch.name}")
314
315
316
317
318
      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}")
319
      cache.expire(:"commit_count_#{branch_name}")
320
    end
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
321
322
  end

323
  def expire_root_ref_cache
324
    expire_method_caches(%i(root_ref))
325
326
  end

327
328
  # Expires the cache(s) used to determine if a repository is empty or not.
  def expire_emptiness_caches
329
    return unless empty?
330

331
    expire_method_caches(%i(empty?))
332
333
  end

334
335
336
337
  def lookup_cache
    @lookup_cache ||= {}
  end

338
  def expire_exists_cache
339
    expire_method_caches(%i(exists?))
340
341
  end

342
343
344
345
346
347
348
  # 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
349
    expire_statistics_caches
350
351
352
353
354
  end

  # Runs code after a repository has been created.
  def after_create
    expire_exists_cache
355
356
    expire_root_ref_cache
    expire_emptiness_caches
Yorick Peterse's avatar
Yorick Peterse committed
357
358

    repository_event(:create_repository)
359
360
  end

361
362
  # Runs code just before a repository is deleted.
  def before_delete
363
    expire_exists_cache
364
365
    expire_all_method_caches
    expire_branch_cache if exists?
366
    expire_content_cache
Yorick Peterse's avatar
Yorick Peterse committed
367
368

    repository_event(:remove_repository)
369
370
371
372
373
374
375
  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
376
377

    repository_event(:change_default_branch)
378
379
  end

380
381
  # Runs code before pushing (= creating or removing) a tag.
  def before_push_tag
382
383
    expire_statistics_caches
    expire_emptiness_caches
384
    expire_tags_cache
Yorick Peterse's avatar
Yorick Peterse committed
385
386

    repository_event(:push_tag)
387
388
389
390
391
  end

  # Runs code before removing a tag.
  def before_remove_tag
    expire_tags_cache
392
    expire_statistics_caches
Yorick Peterse's avatar
Yorick Peterse committed
393
394

    repository_event(:remove_tag)
395
396
  end

Lin Jen-Shin's avatar
Lin Jen-Shin committed
397
398
399
400
401
  # Runs code after removing a tag.
  def after_remove_tag
    expire_tags_cache
  end

402
403
404
  # Runs code after the HEAD of a repository is changed.
  def after_change_head
    expire_method_caches(METHOD_CACHES_FOR_FILE_TYPES.keys)
405
406
  end

407
408
  # Runs code after a repository has been forked/imported.
  def after_import
409
    expire_content_cache
410
411
412
  end

  # Runs code after a new commit has been pushed.
413
414
415
  def after_push_commit(branch_name)
    expire_statistics_caches
    expire_branch_cache(branch_name)
Yorick Peterse's avatar
Yorick Peterse committed
416
417

    repository_event(:push_commit, branch: branch_name)
418
419
420
421
  end

  # Runs code after a new branch has been created.
  def after_create_branch
422
    expire_branches_cache
Yorick Peterse's avatar
Yorick Peterse committed
423
424

    repository_event(:push_branch)
425
426
  end

427
428
429
  # Runs code before removing an existing branch.
  def before_remove_branch
    expire_branches_cache
Yorick Peterse's avatar
Yorick Peterse committed
430
431

    repository_event(:remove_branch)
432
433
  end

434
435
  # Runs code after an existing branch has been removed.
  def after_remove_branch
436
    expire_branches_cache
437
438
  end

439
  def method_missing(m, *args, &block)
440
441
442
443
444
445
    if m == :lookup && !block_given?
      lookup_cache[m] ||= {}
      lookup_cache[m][args.join(":")] ||= raw_repository.send(m, *args, &block)
    else
      raw_repository.send(m, *args, &block)
    end
446
447
  end

448
449
  def respond_to_missing?(method, include_private = false)
    raw_repository.respond_to?(method, include_private) || super
450
  end
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
451
452

  def blob_at(sha, path)
453
    unless Gitlab::Git.blank_ref?(sha)
Douwe Maan's avatar
Douwe Maan committed
454
      Blob.decorate(Gitlab::Git::Blob.find(self, sha, path), project)
455
    end
Douwe Maan's avatar
Douwe Maan committed
456
457
  rescue Gitlab::Git::Repository::NoRepository
    nil
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
458
  end
459

460
461
462
463
464
465
466
  def root_ref
    if raw_repository
      raw_repository.root_ref
    else
      # When the repo does not exist we raise this error so no data is cached.
      raise Rugged::ReferenceError
    end
467
  end
468
  cache_method :root_ref
469

470
  # Gitaly migration: https://gitlab.com/gitlab-org/gitaly/issues/314
471
  def exists?
472
    return false unless full_path
473
474
475
476
477
478
479
480

    Gitlab::GitalyClient.migrate(:repository_exists) do |enabled|
      if enabled
        raw_repository.exists?
      else
        refs_directory_exists?
      end
    end
481
482
483
  end
  cache_method :exists?

Douwe Maan's avatar
Douwe Maan committed
484
  delegate :empty?, to: :raw_repository
485
486
487
488
489
490
491
492
493
494
495
496
497
  cache_method :empty?

  # 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

498
  def commit_count_for_ref(ref)
499
    return 0 unless exists?
500

501
502
503
504
    begin
      cache.fetch(:"commit_count_#{ref}") { raw_repository.commit_count(ref) }
    rescue Rugged::ReferenceError
      0
505
506
507
    end
  end

508
  delegate :branch_names, to: :raw_repository
509
510
  cache_method :branch_names, fallback: []

Douwe Maan's avatar
Douwe Maan committed
511
  delegate :tag_names, to: :raw_repository
512
513
  cache_method :tag_names, fallback: []

Kim "BKC" Carlbäcker's avatar
Cleanup    
Kim "BKC" Carlbäcker committed
514
  delegate :branch_count, :tag_count, to: :raw_repository
515
516
517
518
519
520
  cache_method :branch_count, fallback: 0
  cache_method :tag_count, fallback: 0

  def avatar
    if tree = file_on_head(:avatar)
      tree.path
521
522
    end
  end
523
  cache_method :avatar
524

525
  def readme
526
527
    if readme = tree(:head)&.readme
      ReadmeBlob.new(readme, self)
528
    end
529
530
  end

531
  def rendered_readme
Toon Claes's avatar
Toon Claes committed
532
    MarkupHelper.markup_unsafe(readme.name, readme.data, project: project) if readme
533
534
  end
  cache_method :rendered_readme
535

536
  def contribution_guide
537
    file_on_head(:contributing)
538
  end
539
  cache_method :contribution_guide
540
541

  def changelog
542
    file_on_head(:changelog)
543
  end
544
  cache_method :changelog
545

546
  def license_blob
547
    file_on_head(:license)
548
  end
549
  cache_method :license_blob
Zeger-Jan van de Weg's avatar
Zeger-Jan van de Weg committed
550

551
  def license_key
552
    return unless exists?
553

554
    Licensee.license(path).try(:key)
555
  end
556
  cache_method :license_key
557

Douwe Maan's avatar
Douwe Maan committed
558
559
  def license
    return unless license_key
560

561
    Licensee::License.new(license_key)
562
  end
563
  cache_method :license, memoize_only: true
564
565

  def gitignore
566
    file_on_head(:gitignore)
567
  end
568
  cache_method :gitignore
569
570

  def koding_yml
571
    file_on_head(:koding)
572
  end
573
  cache_method :koding_yml
574

575
  def gitlab_ci_yml
576
    file_on_head(:gitlab_ci)
577
  end
578
  cache_method :gitlab_ci_yml
579

580
  def head_commit
581
582
583
584
    @head_commit ||= commit(self.root_ref)
  end

  def head_tree
585
586
587
    if head_commit
      @head_tree ||= Tree.new(self, head_commit.sha, nil)
    end
588
589
  end

590
  def tree(sha = :head, path = nil, recursive: false)
591
    if sha == :head
592
593
      return unless head_commit

594
595
596
597
598
      if path.nil?
        return head_tree
      else
        sha = head_commit.sha
      end
599
600
    end

601
    Tree.new(self, sha, path, recursive: recursive)
602
  end
603
604

  def blob_at_branch(branch_name, path)
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
605
    last_commit = commit(branch_name)
606

Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
607
608
609
610
611
    if last_commit
      blob_at(last_commit.sha, path)
    else
      nil
    end
612
  end
613

614
  def last_commit_for_path(sha, path)
615
616
617
618
619
620
621
    raw_repository.gitaly_migrate(:last_commit_for_path) do |is_enabled|
      if is_enabled
        last_commit_for_path_by_gitaly(sha, path)
      else
        last_commit_for_path_by_rugged(sha, path)
      end
    end
622
  end
623

Hiroyuki Sato's avatar
Hiroyuki Sato committed
624
625
  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
626

Hiroyuki Sato's avatar
Hiroyuki Sato committed
627
    cache.fetch(key) do
628
629
630
631
632
633
634
      raw_repository.gitaly_migrate(:last_commit_for_path) do |is_enabled|
        if is_enabled
          last_commit_for_path_by_gitaly(sha, path).id
        else
          last_commit_id_for_path_by_shelling_out(sha, path)
        end
      end
Hiroyuki Sato's avatar
Hiroyuki Sato committed
635
636
637
    end
  end

638
  def next_branch(name, opts = {})
639
640
641
    branch_ids = self.branch_names.map do |n|
      next 1 if n == name
      result = n.match(/\A#{name}-([0-9]+)\z/)
642
643
644
      result[1].to_i if result
    end.compact

645
    highest_branch_id = branch_ids.max || 0
646

647
648
649
    return name if opts[:mild] && 0 == highest_branch_id

    "#{name}-#{highest_branch_id + 1}"
650
651
  end

652
  def branches_sorted_by(value)
653
    raw_repository.local_branches(sort_by: value)
654
  end
655

656
657
658
  def tags_sorted_by(value)
    case value
    when 'name'
659
      VersionSorter.rsort(tags) { |tag| tag.name }
660
661
662
663
664
665
666
667
668
    when 'updated_desc'
      tags_sorted_by_committed_date.reverse
    when 'updated_asc'
      tags_sorted_by_committed_date
    else
      tags
    end
  end

669
  def contributors
670
    commits = self.commits(nil, limit: 2000, offset: 0, skip_merges: true)
671

Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
672
    commits.group_by(&:author_email).map do |email, commits|
673
674
      contributor = Gitlab::Contributor.new
      contributor.email = email
675

Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
676
      commits.each do |commit|
677
        if contributor.name.blank?
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
678
          contributor.name = commit.author_name
679
680
        end

681
        contributor.commits += 1
682
683
      end

684
685
      contributor
    end
686
  end
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
687

688
  def refs_contains_sha(ref_type, sha)
689
690
    args = %W(#{ref_type} --contains #{sha})
    names = run_git(args).first
691
692
693
694
695
696
697
698
699
700
701
702
703

    if names.respond_to?(:split)
      names = names.split("\n").map(&:strip)

      names.each do |name|
        name.slice! '* '
      end

      names
    else
      []
    end
  end
Hannes Rosenögger's avatar
Hannes Rosenögger committed
704

705
706
707
  def branch_names_contains(sha)
    refs_contains_sha('branch', sha)
  end
Hannes Rosenögger's avatar
Hannes Rosenögger committed
708

709
710
  def tag_names_contains(sha)
    refs_contains_sha('tag', sha)
Hannes Rosenögger's avatar
Hannes Rosenögger committed
711
  end
712

713
  def local_branches
714
    @local_branches ||= raw_repository.local_branches
715
716
  end

717
718
  alias_method :branches, :local_branches

719
720
721
722
  def tags
    @tags ||= raw_repository.tags
  end

Douwe Maan's avatar
Douwe Maan committed
723
724
725
  def create_dir(user, path, **options)
    options[:user] = user
    options[:actions] = [{ action: :create_dir, file_path: path }]
726

Douwe Maan's avatar
Douwe Maan committed
727
    multi_action(**options)
Stan Hu's avatar
Stan Hu committed
728
729
  end

Douwe Maan's avatar
Douwe Maan committed
730
731
732
  def create_file(user, path, content, **options)
    options[:user] = user
    options[:actions] = [{ action: :create, file_path: path, content: content }]
733

Douwe Maan's avatar
Douwe Maan committed
734
    multi_action(**options)
Stan Hu's avatar
Stan Hu committed
735
  end
736

Douwe Maan's avatar
Douwe Maan committed
737
738
739
  def update_file(user, path, content, **options)
    previous_path = options.delete(:previous_path)
    action = previous_path && previous_path != path ? :move : :update
740

Douwe Maan's avatar
Douwe Maan committed
741
742
    options[:user] = user
    options[:actions] = [{ action: action, file_path: path, previous_path: previous_path, content: content }]
743

Douwe Maan's avatar
Douwe Maan committed
744
    multi_action(**options)
745
746
  end

Douwe Maan's avatar
Douwe Maan committed
747
748
749
  def delete_file(user, path, **options)
    options[:user] = user
    options[:actions] = [{ action: :delete, file_path: path }]
750

Douwe Maan's avatar
Douwe Maan committed
751
    multi_action(**options)
752
753
  end

754
  # rubocop:disable Metrics/ParameterLists
Lin Jen-Shin's avatar
Lin Jen-Shin committed
755
  def multi_action(
756
    user:, branch_name:, message:, actions:,
757
    author_email: nil, author_name: nil,
758
    start_branch_name: nil, start_project: project)
759

760
    GitOperationService.new(user, self).with_branch(
761
      branch_name,
762
763
      start_branch_name: start_branch_name,
      start_project: start_project) do |start_commit|
764

765
      index = Gitlab::Git::Index.new(raw_repository)
766

767
      if start_commit
768
        index.read_tree(start_commit.rugged_commit.tree)
769
770
771
        parents = [start_commit.sha]
      else
        parents = []
Marc Siegfriedt's avatar
Marc Siegfriedt committed
772
773
      end

774
      actions.each do |options|
Douwe Maan's avatar
Douwe Maan committed
775
        index.public_send(options.delete(:action), options)
Marc Siegfriedt's avatar
Marc Siegfriedt committed
776
777
778
      end

      options = {
779
        tree: index.write_tree,
Marc Siegfriedt's avatar
Marc Siegfriedt committed
780
781
782
783
784
        message: message,
        parents: parents
      }
      options.merge!(get_committer_and_author(user, email: author_email, name: author_name))

785
      create_commit(options)
Marc Siegfriedt's avatar
Marc Siegfriedt committed
786
787
    end
  end
788
  # rubocop:enable Metrics/ParameterLists
Marc Siegfriedt's avatar
Marc Siegfriedt committed
789

790
791
  def get_committer_and_author(user, email: nil, name: nil)
    committer = user_to_committer(user)
Douwe Maan's avatar
Douwe Maan committed
792
    author = Gitlab::Git.committer_hash(email: email, name: name) || committer
793

794
    {
795
796
      author: author,
      committer: committer
797
798
799
    }
  end

800
  def user_to_committer(user)
801
    Gitlab::Git.committer_hash(email: user.email, name: user.name)
802
803
  end

804
805
806
807
808
809
810
811
812
813
814
  def can_be_merged?(source_sha, target_branch)
    our_commit = rugged.branches[target_branch].target
    their_commit = rugged.lookup(source_sha)

    if our_commit && their_commit
      !rugged.merge_commits(our_commit, their_commit).conflicts?
    else
      false
    end
  end

815
  def merge(user, source, merge_request, options = {})
816
    GitOperationService.new(user, self).with_branch(
817
818
      merge_request.target_branch) do |start_commit|
      our_commit = start_commit.sha
819
      their_commit = source
820

821
822
      raise 'Invalid merge target' unless our_commit
      raise 'Invalid merge source' unless their_commit
823

824
825
      merge_index = rugged.merge_commits(our_commit, their_commit)
      break if merge_index.conflicts?
826

827
828
      actual_options = options.merge(
        parents: [our_commit, their_commit],
829
        tree: merge_index.write_tree(rugged)
830
      )
831

832
      commit_id = create_commit(actual_options)
833
834
      merge_request.update(in_progress_merge_commit_sha: commit_id)
      commit_id
835
    end
836
837
  rescue Repository::CommitError # when merge_index.conflicts?
    false
838
839
  end

840
  def revert(
841
    user, commit, branch_name,
842
    start_branch_name: nil, start_project: project)
843
    GitOperationService.new(user, self).with_branch(
844
      branch_name,
845
846
      start_branch_name: start_branch_name,
      start_project: start_project) do |start_commit|
847

848
849
      revert_tree_id = check_revert_content(commit, start_commit.sha)
      unless revert_tree_id
850
        raise Repository::CreateTreeError.new('Failed to revert commit')
851
      end
852
853

      committer = user_to_committer(user)
854

855
856
857
858
859
      create_commit(message: commit.revert_message(user),
                    author: committer,
                    committer: committer,
                    tree: revert_tree_id,
                    parents: [start_commit.sha])
860
    end
861
862
  end

863
  def cherry_pick(
864
    user, commit, branch_name,
865
    start_branch_name: nil, start_project: project)
866
    GitOperationService.new(user, self).with_branch(
867
      branch_name,
868
869
      start_branch_name: start_branch_name,
      start_project: start_project) do |start_commit|
870

871
872
      cherry_pick_tree_id = check_cherry_pick_content(commit, start_commit.sha)
      unless cherry_pick_tree_id