Class: Repository

Inherits:
Object
  • Object
show all
Includes:
Gitlab::RepositoryCacheAdapter
Defined in:
app/models/repository.rb

Direct Known Subclasses

DesignManagement::Repository

Constant Summary collapse

REF_MERGE_REQUEST =
'merge-requests'
REF_KEEP_AROUND =
'keep-around'
REF_ENVIRONMENTS =
'environments'
REF_PIPELINES =
'pipelines'
ARCHIVE_CACHE_TIME =

Cache archives referred to by a (mutable) ref for 1 minute

60
ARCHIVE_CACHE_TIME_IMMUTABLE =

Cache archives referred to by an immutable reference for 1 hour

3600
RESERVED_REFS_NAMES =
%W[
  heads
  tags
  replace
  #{REF_ENVIRONMENTS}
  #{REF_KEEP_AROUND}
  #{REF_PIPELINES}
].freeze
CreateTreeError =
Class.new(StandardError)
AmbiguousRefError =
Class.new(StandardError)
CACHED_METHODS =

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.

For example, for entry `:commit_count` there's a method called `commit_count` which stores its data in the `commit_count` cache key.

%i(size commit_count rendered_readme readme_path contribution_guide
changelog license_blob license_key gitignore
gitlab_ci_yml branch_names tag_names branch_count
tag_count avatar exists? root_ref merged_branch_names
has_visible_content? issue_template_names merge_request_template_names
user_defined_metrics_dashboard_paths xcode_project? has_ambiguous_refs?).freeze
MEMOIZED_CACHED_METHODS =

Methods that use cache_method but only memoize the value

%i(license).freeze
METHOD_CACHES_FOR_FILE_TYPES =

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.

{
  readme: %i(rendered_readme readme_path),
  changelog: :changelog,
  license: %i(license_blob license_key license),
  contributing: :contribution_guide,
  gitignore: :gitignore,
  gitlab_ci: :gitlab_ci_yml,
  avatar: :avatar,
  issue_template: :issue_template_names,
  merge_request_template: :merge_request_template_names,
  metrics_dashboard: :user_defined_metrics_dashboard_paths,
  xcode_config: :xcode_project?
}.freeze

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Gitlab::RepositoryCacheAdapter

#cache_method_output, #cache_method_output_as_redis_set, #cache_method_output_asymmetrically, #expire_method_caches, #memoize_method_output, #no_repository_fallback

Methods included from Gitlab::Utils::StrongMemoize

#clear_memoization, #strong_memoize, #strong_memoized?

Constructor Details

#initialize(full_path, container, shard:, disk_path: nil, repo_type: Gitlab::GlRepository::PROJECT) ⇒ Repository

Returns a new instance of Repository.


69
70
71
72
73
74
75
76
# File 'app/models/repository.rb', line 69

def initialize(full_path, container, shard:, disk_path: nil, repo_type: Gitlab::GlRepository::PROJECT)
  @full_path = full_path
  @shard = shard
  @disk_path = disk_path || full_path
  @container = container
  @commit_cache = {}
  @repo_type = repo_type
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(msg, *args, &block) ⇒ Object


497
498
499
500
501
502
503
504
# File 'app/models/repository.rb', line 497

def method_missing(msg, *args, &block)
  if msg == :lookup && !block_given?
    lookup_cache[msg] ||= {}
    lookup_cache[msg][args.join(":")] ||= raw_repository.__send__(msg, *args, &block) # rubocop:disable GitlabSecurity/PublicSend
  else
    raw_repository.__send__(msg, *args, &block) # rubocop:disable GitlabSecurity/PublicSend
  end
end

Instance Attribute Details

#containerObject

Returns the value of attribute container


25
26
27
# File 'app/models/repository.rb', line 25

def container
  @container
end

#disk_pathObject

Returns the value of attribute disk_path


25
26
27
# File 'app/models/repository.rb', line 25

def disk_path
  @disk_path
end

#full_pathObject

Returns the value of attribute full_path


25
26
27
# File 'app/models/repository.rb', line 25

def full_path
  @full_path
end

#repo_typeObject

Returns the value of attribute repo_type


25
26
27
# File 'app/models/repository.rb', line 25

def repo_type
  @repo_type
end

#shardObject

Returns the value of attribute shard


25
26
27
# File 'app/models/repository.rb', line 25

def shard
  @shard
end

Instance Method Details

#==(other) ⇒ Object Also known as: eql?


78
79
80
# File 'app/models/repository.rb', line 78

def ==(other)
  other.is_a?(self.class) && @disk_path == other.disk_path
end

#add_branch(user, branch_name, ref) ⇒ Object


234
235
236
237
238
239
240
241
242
# File 'app/models/repository.rb', line 234

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

  after_create_branch

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

#add_tag(user, tag_name, target, message = nil) ⇒ Object


244
245
246
247
248
# File 'app/models/repository.rb', line 244

def add_tag(user, tag_name, target, message = nil)
  raw_repository.add_tag(tag_name, user: user, target: target, message: message)
rescue Gitlab::Git::Repository::InvalidRef
  false
end

#after_change_headObject

Runs code after the HEAD of a repository is changed.


466
467
468
# File 'app/models/repository.rb', line 466

def after_change_head
  expire_all_method_caches
end

#after_createObject

Runs code after a repository has been created.


414
415
416
417
418
# File 'app/models/repository.rb', line 414

def after_create
  expire_status_cache

  repository_event(:create_repository)
end

#after_create_branch(expire_cache: true) ⇒ Object

Runs code after a new branch has been created.


479
480
481
482
483
# File 'app/models/repository.rb', line 479

def after_create_branch(expire_cache: true)
  expire_branches_cache if expire_cache

  repository_event(:push_branch)
end

#after_push_commit(branch_name) ⇒ Object

Runs code after a new commit has been pushed.


471
472
473
474
475
476
# File 'app/models/repository.rb', line 471

def after_push_commit(branch_name)
  expire_statistics_caches
  expire_branch_cache(branch_name)

  repository_event(:push_commit, branch: branch_name)
end

#after_remove_branch(expire_cache: true) ⇒ Object

Runs code after an existing branch has been removed.


493
494
495
# File 'app/models/repository.rb', line 493

def after_remove_branch(expire_cache: true)
  expire_branches_cache if expire_cache
end

#after_remove_tagObject

Runs code after removing a tag.


461
462
463
# File 'app/models/repository.rb', line 461

def after_remove_tag
  expire_caches_for_tags
end

#ambiguous_ref?(ref) ⇒ Boolean

Returns:

  • (Boolean)

196
197
198
# File 'app/models/repository.rb', line 196

def ambiguous_ref?(ref)
  tag_exists?(ref) && branch_exists?(ref)
end

#ancestor?(ancestor_id, descendant_id) ⇒ Boolean

Returns:

  • (Boolean)

965
966
967
968
969
970
971
972
973
974
# File 'app/models/repository.rb', line 965

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

  cache_key = "ancestor:#{ancestor_id}:#{descendant_id}"
  request_store_cache.fetch(cache_key) do
    cache.fetch(cache_key) do
      raw_repository.ancestor?(ancestor_id, descendant_id)
    end
  end
end

#archive_metadata(ref, storage_path, format = "tar.gz", append_sha:, path: nil) ⇒ Object


300
301
302
303
304
305
306
307
308
309
# File 'app/models/repository.rb', line 300

def (ref, storage_path, format = "tar.gz", append_sha:, path: nil)
  raw_repository.(
    ref,
    storage_path,
    project&.path,
    format,
    append_sha: append_sha,
    path: path
  )
end

#async_remove_remote(remote_name) ⇒ Object


988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
# File 'app/models/repository.rb', line 988

def async_remove_remote(remote_name)
  return unless remote_name
  return unless project

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

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

  job_id
end

#avatarObject


591
592
593
594
595
596
597
598
# File 'app/models/repository.rb', line 591

def avatar
  # n+1: https://gitlab.com/gitlab-org/gitlab-foss/issues/38327
  Gitlab::GitalyClient.allow_n_plus_1_calls do
    if tree = file_on_head(:avatar)
      tree.path
    end
  end
end

#before_change_headObject

Runs code just before the HEAD of a repository is changed.


431
432
433
434
435
436
437
# File 'app/models/repository.rb', line 431

def before_change_head
  # Cached divergent commit counts are based on repository head
  expire_branch_cache
  expire_root_ref_cache

  repository_event(:change_default_branch)
end

#before_deleteObject

Runs code just before a repository is deleted.


421
422
423
424
425
426
427
428
# File 'app/models/repository.rb', line 421

def before_delete
  expire_exists_cache
  expire_all_method_caches
  expire_branch_cache if exists?
  expire_content_cache

  repository_event(:remove_repository)
end

#before_push_tagObject

Runs code before pushing (= creating or removing) a tag.

Note that this doesn't expire the tags. You may need to call expire_caches_for_tags or expire_tags_cache.


443
444
445
# File 'app/models/repository.rb', line 443

def before_push_tag
  repository_event(:push_tag)
end

#before_remove_branchObject

Runs code before removing an existing branch.


486
487
488
489
490
# File 'app/models/repository.rb', line 486

def before_remove_branch
  expire_branches_cache

  repository_event(:remove_branch)
end

#before_remove_tagObject

Runs code before removing a tag.


454
455
456
457
458
# File 'app/models/repository.rb', line 454

def before_remove_tag
  expire_caches_for_tags

  repository_event(:remove_tag)
end

#blob_at(sha, path) ⇒ Object


510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
# File 'app/models/repository.rb', line 510

def blob_at(sha, path)
  blob = Blob.decorate(raw_repository.blob_at(sha, path), container)

  # Don't attempt to return a special result if there is no blob at all
  return unless blob

  # Don't attempt to return a special result if this can't be a README
  return blob unless Gitlab::FileDetector.type_of(blob.name) == :readme

  # Don't attempt to return a special result unless we're looking at HEAD
  return blob unless head_commit&.sha == sha

  case path
  when head_tree&.readme_path
    ReadmeBlob.new(blob, self)
  else
    blob
  end
rescue Gitlab::Git::Repository::NoRepository
  nil
end

#blob_at_branch(branch_name, path) ⇒ Object


702
703
704
705
706
707
708
709
710
# File 'app/models/repository.rb', line 702

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

  if last_commit
    blob_at(last_commit.sha, path)
  else
    nil
  end
end

#blob_data_at(sha, path) ⇒ Object


1119
1120
1121
1122
1123
1124
1125
# File 'app/models/repository.rb', line 1119

def blob_data_at(sha, path)
  blob = blob_at(sha, path)
  return unless blob

  blob.load_all_data!
  blob.data
end

#blobs_at(items, blob_size_limit: Gitlab::Git::Blob::MAX_DATA_DISPLAY_SIZE) ⇒ Object

items is an Array like: [[oid, path], [oid1, path1]]


533
534
535
536
537
538
539
# File 'app/models/repository.rb', line 533

def blobs_at(items, blob_size_limit: Gitlab::Git::Blob::MAX_DATA_DISPLAY_SIZE)
  return [] unless exists?

  raw_repository.batch_blobs(items, blob_size_limit: blob_size_limit).map do |blob|
    Blob.decorate(blob, container)
  end
end

#blobs_metadata(paths, ref = 'HEAD') ⇒ Object


1142
1143
1144
1145
1146
# File 'app/models/repository.rb', line 1142

def (paths, ref = 'HEAD')
  references = Array.wrap(paths).map { |path| [ref, path] }

  Gitlab::Git::Blob.(raw, references).map { |raw_blob| Blob.decorate(raw_blob) }
end

#branch_exists?(branch_name) ⇒ Boolean

Returns:

  • (Boolean)

272
273
274
275
276
# File 'app/models/repository.rb', line 272

def branch_exists?(branch_name)
  return false unless raw_repository

  branch_names_include?(branch_name)
end

#branch_names_contains(sha) ⇒ Object


791
792
793
# File 'app/models/repository.rb', line 791

def branch_names_contains(sha)
  raw_repository.branch_names_contains_sha(sha)
end

#branches_sorted_by(sort_by, pagination_params = nil) ⇒ Object


748
749
750
# File 'app/models/repository.rb', line 748

def branches_sorted_by(sort_by, pagination_params = nil)
  raw_repository.local_branches(sort_by: sort_by, pagination_params: pagination_params)
end

#cached_methodsObject


311
312
313
# File 'app/models/repository.rb', line 311

def cached_methods
  CACHED_METHODS
end

#changelogObject


639
640
641
# File 'app/models/repository.rb', line 639

def changelog
  file_on_head(:changelog)
end

#cherry_pick(user, commit, branch_name, message, start_branch_name: nil, start_project: project, dry_run: false) ⇒ Object


902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
# File 'app/models/repository.rb', line 902

def cherry_pick(
  user, commit, branch_name, message,
  start_branch_name: nil, start_project: project, dry_run: false)

  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,
      dry_run: dry_run
    )
  end
end

#commit(ref = nil) ⇒ Object


112
113
114
115
116
117
# File 'app/models/repository.rb', line 112

def commit(ref = nil)
  return unless exists?
  return ref if ref.is_a?(::Commit)

  find_commit(ref || root_ref)
end

#commit_by(oid:) ⇒ Object

Finding a commit by the passed SHA Also takes care of caching, based on the SHA


121
122
123
124
125
# File 'app/models/repository.rb', line 121

def commit_by(oid:)
  return @commit_cache[oid] if @commit_cache.key?(oid)

  @commit_cache[oid] = find_commit(oid)
end

#commit_countObject


569
570
571
# File 'app/models/repository.rb', line 569

def commit_count
  root_ref ? raw_repository.commit_count(root_ref) : 0
end

#commit_count_for_ref(ref) ⇒ Object


574
575
576
577
578
# File 'app/models/repository.rb', line 574

def commit_count_for_ref(ref)
  return 0 unless exists?

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

#commits(ref = nil, opts = {}) ⇒ Object


139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
# File 'app/models/repository.rb', line 139

def commits(ref = nil, opts = {})
  options = {
    repo: raw_repository,
    ref: ref,
    path: opts[:path],
    author: opts[:author],
    follow: Array(opts[:path]).length == 1,
    limit: opts[:limit],
    offset: opts[:offset],
    skip_merges: !!opts[:skip_merges],
    after: opts[:after],
    before: opts[:before],
    all: !!opts[:all],
    first_parent: !!opts[:first_parent],
    order: opts[:order],
    literal_pathspec: opts.fetch(:literal_pathspec, true)
  }

  commits = Gitlab::Git::Commit.where(options)
  commits = Commit.decorate(commits, container) if commits.present?

  CommitCollection.new(container, commits, ref)
end

#commits_between(from, to) ⇒ Object


163
164
165
166
167
# File 'app/models/repository.rb', line 163

def commits_between(from, to)
  commits = Gitlab::Git::Commit.between(raw_repository, from, to)
  commits = Commit.decorate(commits, container) if commits.present?
  commits
end

#commits_by(oids:) ⇒ Object


127
128
129
130
131
132
133
134
135
136
137
# File 'app/models/repository.rb', line 127

def commits_by(oids:)
  return [] unless oids.present?

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

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

#compare_source_branch(target_branch_name, source_repository, source_branch_name, straight:) ⇒ Object


1007
1008
1009
# File 'app/models/repository.rb', line 1007

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)
end

#contribution_guideObject


634
635
636
# File 'app/models/repository.rb', line 634

def contribution_guide
  file_on_head(:contributing)
end

#contributors(order_by: nil, sort: 'asc') ⇒ Object

Params:

order_by: name|email|commits sort: asc|desc default: 'asc'


771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
# File 'app/models/repository.rb', line 771

def contributors(order_by: nil, sort: 'asc')
  commits = self.commits(nil, limit: 2000, offset: 0, skip_merges: true)

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

    commits.each do |commit|
      if contributor.name.blank?
        contributor.name = commit.author_name
      end

      contributor.commits += 1
    end

    contributor
  end
  Commit.order_by(collection: commits, order_by: order_by, sort: sort)
end

#copy_gitattributes(ref) ⇒ Object


1032
1033
1034
1035
1036
1037
1038
1039
1040
# File 'app/models/repository.rb', line 1032

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

#create_dir(user, path, **options) ⇒ Object


809
810
811
812
813
# File 'app/models/repository.rb', line 809

def create_dir(user, path, **options)
  options[:actions] = [{ action: :create_dir, file_path: path }]

  multi_action(user, **options)
end

#create_file(user, path, content, **options) ⇒ Object


815
816
817
818
819
# File 'app/models/repository.rb', line 815

def create_file(user, path, content, **options)
  options[:actions] = [{ action: :create, file_path: path, content: content }]

  multi_action(user, **options)
end

#create_from_bundle(bundle_path) ⇒ Object


1136
1137
1138
1139
1140
# File 'app/models/repository.rb', line 1136

def create_from_bundle(bundle_path)
  raw.create_from_bundle(bundle_path).tap do |result|
    after_create if result
  end
end

#create_if_not_existsObject


1127
1128
1129
1130
1131
1132
1133
1134
# File 'app/models/repository.rb', line 1127

def create_if_not_exists
  return if exists?

  raw.create_repository
  after_create

  true
end

#create_ref(ref, ref_path) ⇒ Object


1011
1012
1013
# File 'app/models/repository.rb', line 1011

def create_ref(ref, ref_path)
  raw_repository.write_ref(ref_path, ref)
end

#delete_file(user, path, **options) ⇒ Object


830
831
832
833
834
# File 'app/models/repository.rb', line 830

def delete_file(user, path, **options)
  options[:actions] = [{ action: :delete, file_path: path }]

  multi_action(user, **options)
end

#delete_refs(*ref_names) ⇒ Object


872
873
874
# File 'app/models/repository.rb', line 872

def delete_refs(*ref_names)
  raw.delete_refs(*ref_names)
end

#empty?Boolean

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.

Returns:

  • (Boolean)

557
558
559
560
561
# File 'app/models/repository.rb', line 557

def empty?
  return true unless exists?

  !has_visible_content?
end

#exists?Boolean

Returns:

  • (Boolean)

547
548
549
550
551
# File 'app/models/repository.rb', line 547

def exists?
  return false unless full_path

  raw_repository.exists?
end

#expand_ref(ref) ⇒ Object


226
227
228
229
230
231
232
# File 'app/models/repository.rb', line 226

def expand_ref(ref)
  if tag_exists?(ref)
    Gitlab::Git::TAG_REF_PREFIX + ref
  elsif branch_exists?(ref)
    Gitlab::Git::BRANCH_REF_PREFIX + ref
  end
end

#expire_all_method_cachesObject


332
333
334
# File 'app/models/repository.rb', line 332

def expire_all_method_caches
  expire_method_caches(CACHED_METHODS)
end

#expire_avatar_cacheObject


336
337
338
# File 'app/models/repository.rb', line 336

def expire_avatar_cache
  expire_method_caches(%i(avatar))
end

#expire_branch_cache(branch_name = nil) ⇒ Object


360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
# File 'app/models/repository.rb', line 360

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}")
      cache.expire(:"commit_count_#{branch.name}")
    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}")
    cache.expire(:"commit_count_#{branch_name}")
  end
end

#expire_branches_cacheObject


321
322
323
324
325
326
# File 'app/models/repository.rb', line 321

def expire_branches_cache
  expire_method_caches(%i(branch_names merged_branch_names branch_count has_visible_content? has_ambiguous_refs?))
  @local_branches = nil
  @branch_exists_memo = nil
  @branch_names_include = nil
end

#expire_caches_for_tagsObject


447
448
449
450
451
# File 'app/models/repository.rb', line 447

def expire_caches_for_tags
  expire_statistics_caches
  expire_emptiness_caches
  expire_tags_cache
end

#expire_content_cacheObject

expire cache that doesn't depend on repository data (when expiring)


398
399
400
401
402
403
404
405
# File 'app/models/repository.rb', line 398

def expire_content_cache
  expire_tags_cache
  expire_branches_cache
  expire_root_ref_cache
  expire_emptiness_caches
  expire_exists_cache
  expire_statistics_caches
end

#expire_emptiness_cachesObject

Expires the cache(s) used to determine if a repository is empty or not.


382
383
384
385
386
387
# File 'app/models/repository.rb', line 382

def expire_emptiness_caches
  return unless empty?

  expire_method_caches(%i(has_visible_content?))
  raw_repository.expire_has_local_branches_cache
end

#expire_exists_cacheObject


393
394
395
# File 'app/models/repository.rb', line 393

def expire_exists_cache
  expire_method_caches(%i(exists?))
end

#expire_root_ref_cacheObject


377
378
379
# File 'app/models/repository.rb', line 377

def expire_root_ref_cache
  expire_method_caches(%i(root_ref))
end

#expire_statistics_cachesObject


328
329
330
# File 'app/models/repository.rb', line 328

def expire_statistics_caches
  expire_method_caches(%i(size commit_count))
end

#expire_status_cacheObject


407
408
409
410
411
# File 'app/models/repository.rb', line 407

def expire_status_cache
  expire_exists_cache
  expire_root_ref_cache
  expire_emptiness_caches
end

#expire_tags_cacheObject


315
316
317
318
319
# File 'app/models/repository.rb', line 315

def expire_tags_cache
  expire_method_caches(%i(tag_names tag_count has_ambiguous_refs?))
  @tags = nil
  @tag_names_include = nil
end

#fetch_as_mirror(url, forced: false, refmap: :all_refs, remote_name: nil, prune: true) ⇒ Object


976
977
978
979
980
981
982
983
984
985
986
# File 'app/models/repository.rb', line 976

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

  add_remote(remote_name, url, mirror_refmap: refmap)
  fetch_remote(remote_name, forced: forced, prune: prune)
ensure
  async_remove_remote(remote_name) if tmp_remote_name
end

#fetch_ref(source_repository, source_ref:, target_ref:) ⇒ Object


1072
1073
1074
# File 'app/models/repository.rb', line 1072

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

#fetch_source_branch!(source_repository, source_branch, local_ref) ⇒ Object


1003
1004
1005
# File 'app/models/repository.rb', line 1003

def fetch_source_branch!(source_repository, source_branch, local_ref)
  raw_repository.fetch_source_branch!(source_repository.raw_repository, source_branch, local_ref)
end

#ff_merge(user, source, target_branch, merge_request: nil) ⇒ Object


876
877
878
879
880
881
882
883
# File 'app/models/repository.rb', line 876

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

  merge_request&.update_and_mark_in_progress_merge_commit_sha(their_commit_id)

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

#file_on_head(type, object_type = :blob) ⇒ Object


1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
# File 'app/models/repository.rb', line 1042

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"
    end

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

#find_branch(name) ⇒ Object


188
189
190
# File 'app/models/repository.rb', line 188

def find_branch(name)
  raw_repository.find_branch(name)
end

#find_commits_by_message(query, ref = nil, path = nil, limit = 1000, offset = 0) ⇒ Object


177
178
179
180
181
182
183
184
185
186
# File 'app/models/repository.rb', line 177

def find_commits_by_message(query, ref = nil, path = nil, limit = 1000, offset = 0)
  unless exists? && has_visible_content? && query.present?
    return []
  end

  commits = raw_repository.find_commits_by_message(query, ref, path, limit, offset).map do |c|
    commit(c)
  end
  CommitCollection.new(container, commits, ref)
end

#find_tag(name) ⇒ Object


192
193
194
# File 'app/models/repository.rb', line 192

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

#gitignoreObject


663
664
665
# File 'app/models/repository.rb', line 663

def gitignore
  file_on_head(:gitignore)
end

#gitlab_ci_ymlObject


668
669
670
# File 'app/models/repository.rb', line 668

def gitlab_ci_yml
  file_on_head(:gitlab_ci)
end

#gitlab_ci_yml_for(sha, path = '.gitlab-ci.yml') ⇒ Object


1064
1065
1066
# File 'app/models/repository.rb', line 1064

def gitlab_ci_yml_for(sha, path = '.gitlab-ci.yml')
  blob_data_at(sha, path)
end

#has_ambiguous_refs?Boolean

It's possible for a tag name to be a prefix (including slash) of a branch name, or vice versa. For instance, a tag named `foo` means we can't create a tag `foo/bar`, but we can create a branch `foo/bar`.

If we know a repository has no refs of this type (which is the common case) then separating refs from paths - as in ExtractsRef - can be faster.

This method only checks one level deep, so only prefixes that contain no slashes are considered. If a repository has a tag `foo/bar` and a branch `foo/bar/baz`, it will return false.

Returns:

  • (Boolean)

210
211
212
213
214
215
216
217
218
219
220
221
222
223
# File 'app/models/repository.rb', line 210

def has_ambiguous_refs?
  return false unless branch_names.present? && tag_names.present?

  with_slash, no_slash = (branch_names + tag_names).partition { |ref| ref.include?('/') }

  return false if with_slash.empty?

  prefixes = no_slash.map { |ref| Regexp.escape(ref) }.join('|')
  prefix_regex = %r{^(#{prefixes})/}

  with_slash.any? do |ref|
    prefix_regex.match?(ref)
  end
end

#hashObject


84
85
86
# File 'app/models/repository.rb', line 84

def hash
  [self.class, @disk_path].hash
end

#head_commitObject


678
679
680
# File 'app/models/repository.rb', line 678

def head_commit
  @head_commit ||= commit(self.root_ref)
end

#head_treeObject


682
683
684
685
686
# File 'app/models/repository.rb', line 682

def head_tree
  if head_commit
    @head_tree ||= Tree.new(self, head_commit.sha, nil)
  end
end

#inspectObject


108
109
110
# File 'app/models/repository.rb', line 108

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

#issue_template_namesObject


601
602
603
# File 'app/models/repository.rb', line 601

def issue_template_names
  Gitlab::Template::IssueTemplate.dropdown_names(project)
end

#keep_around(*shas) ⇒ Object


296
297
298
# File 'app/models/repository.rb', line 296

def keep_around(*shas)
  Gitlab::Git::KeepAround.execute(self, shas)
end

#languagesObject


290
291
292
293
294
# File 'app/models/repository.rb', line 290

def languages
  return [] if empty?

  raw_repository.languages(root_ref)
end

#last_commit_for_path(sha, path, literal_pathspec: false) ⇒ Object


720
721
722
723
# File 'app/models/repository.rb', line 720

def last_commit_for_path(sha, path, literal_pathspec: false)
  commit = raw_repository.last_commit_for_path(sha, path, literal_pathspec: literal_pathspec)
  ::Commit.new(commit, container) if commit
end

#last_commit_id_for_path(sha, path, literal_pathspec: false) ⇒ Object


725
726
727
728
729
730
731
# File 'app/models/repository.rb', line 725

def last_commit_id_for_path(sha, path, literal_pathspec: false)
  key = path.blank? ? "last_commit_id_for_path:#{sha}" : "last_commit_id_for_path:#{sha}:#{Digest::SHA1.hexdigest(path)}"

  cache.fetch(key) do
    last_commit_for_path(sha, path, literal_pathspec: literal_pathspec)&.id
  end
end

#lfsconfig_for(sha) ⇒ Object


1068
1069
1070
# File 'app/models/repository.rb', line 1068

def lfsconfig_for(sha)
  blob_data_at(sha, '.lfsconfig')
end

#licenseObject


656
657
658
659
660
# File 'app/models/repository.rb', line 656

def license
  return unless license_key

  Licensee::License.new(license_key)
end

#license_blobObject


644
645
646
# File 'app/models/repository.rb', line 644

def license_blob
  file_on_head(:license)
end

#license_keyObject


649
650
651
652
653
# File 'app/models/repository.rb', line 649

def license_key
  return unless exists?

  raw_repository.license_short_name
end

#list_last_commits_for_tree(sha, path, offset: 0, limit: 25, literal_pathspec: false) ⇒ Object


712
713
714
715
716
717
718
# File 'app/models/repository.rb', line 712

def list_last_commits_for_tree(sha, path, offset: 0, limit: 25, literal_pathspec: false)
  commits = raw_repository.list_last_commits_for_tree(sha, path, offset: offset, limit: limit, literal_pathspec: literal_pathspec)

  commits.each do |path, commit|
    commits[path] = ::Commit.new(commit, container)
  end
end

#local_branchesObject Also known as: branches


799
800
801
# File 'app/models/repository.rb', line 799

def local_branches
  @local_branches ||= raw_repository.local_branches
end

#lookup_cacheObject


389
390
391
# File 'app/models/repository.rb', line 389

def lookup_cache
  @lookup_cache ||= {}
end

#ls_files(ref) ⇒ Object


1015
1016
1017
1018
# File 'app/models/repository.rb', line 1015

def ls_files(ref)
  actual_ref = ref || root_ref
  raw_repository.ls_files(actual_ref)
end

#merge(user, source_sha, merge_request, message) ⇒ Object


857
858
859
860
861
862
863
864
# File 'app/models/repository.rb', line 857

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_and_mark_in_progress_merge_commit_sha(commit_id)
      nil # Return value does not matter.
    end
  end
end

#merge_base(*commits_or_ids) ⇒ Object


957
958
959
960
961
962
963
# File 'app/models/repository.rb', line 957

def merge_base(*commits_or_ids)
  commit_ids = commits_or_ids.map do |commit_or_id|
    commit_or_id.is_a?(::Commit) ? commit_or_id.id : commit_or_id
  end

  raw_repository.merge_base(*commit_ids)
end

#merge_request_template_namesObject


606
607
608
# File 'app/models/repository.rb', line 606

def merge_request_template_names
  Gitlab::Template::MergeRequestTemplate.dropdown_names(project)
end

#merge_to_ref(user, source_sha, merge_request, target_ref, message, first_parent_ref, allow_conflicts = false) ⇒ Object


866
867
868
869
870
# File 'app/models/repository.rb', line 866

def merge_to_ref(user, source_sha, merge_request, target_ref, message, first_parent_ref, allow_conflicts = false)
  branch = merge_request.target_branch

  raw.merge_to_ref(user, source_sha, branch, target_ref, message, first_parent_ref, allow_conflicts)
end

#merged_branch_names(branch_names = []) ⇒ Object

If this method is not provided a set of branch names to check merge status, it fetches all branches.


937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
# File 'app/models/repository.rb', line 937

def merged_branch_names(branch_names = [])
  # Currently we should skip caching if requesting all branch names
  # This is only used in a few places, notably app/services/branches/delete_merged_service.rb,
  # and it could potentially result in a very large cache.
  return raw_repository.merged_branch_names(branch_names) if branch_names.empty?

  cache = redis_hash_cache

  merged_branch_names_hash = cache.fetch_and_add_missing(:merged_branch_names, branch_names) do |missing_branch_names, hash|
    merged = raw_repository.merged_branch_names(missing_branch_names)

    missing_branch_names.each do |bn|
      # Redis only stores strings in hset keys, use a fancy encoder
      hash[bn] = Gitlab::Redis::Boolean.new(merged.include?(bn))
    end
  end

  Set.new(merged_branch_names_hash.select { |_, v| Gitlab::Redis::Boolean.true?(v) }.keys)
end

#merged_to_root_ref?(branch_or_name) ⇒ Boolean

Returns:

  • (Boolean)

919
920
921
922
923
924
925
926
927
928
929
# File 'app/models/repository.rb', line 919

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

  if branch
    same_head = branch.target == root_ref_sha
    merged = ancestor?(branch.target, root_ref_sha)
    !same_head && merged
  else
    nil
  end
end

#multi_action(user, **options) ⇒ Object


847
848
849
850
851
852
853
854
855
# File 'app/models/repository.rb', line 847

def multi_action(user, **options)
  start_project = options.delete(:start_project)

  if start_project
    options[:start_repository] = start_project.repository.raw_repository
  end

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

#new_commits(newrev) ⇒ Object

Returns a list of commits that are not present in any reference


170
171
172
173
174
# File 'app/models/repository.rb', line 170

def new_commits(newrev)
  commits = raw.new_commits(newrev)

  ::Commit.decorate(commits, container)
end

#next_branch(name, opts = {}) ⇒ Object


733
734
735
736
737
738
739
740
741
742
743
744
745
746
# File 'app/models/repository.rb', line 733

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

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

  highest_branch_id = branch_ids.max || 0

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

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

#path_to_repoObject

Don't use this! It's going away. Use Gitaly to read or write from repos.


97
98
99
100
101
102
103
104
105
106
# File 'app/models/repository.rb', line 97

def path_to_repo
  @path_to_repo ||=
    begin
      storage = Gitlab.config.repositories.storages[shard]

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

#projectObject


1148
1149
1150
1151
1152
1153
1154
# File 'app/models/repository.rb', line 1148

def project
  if container.is_a?(Project)
    container
  else
    container.try(:project)
  end
end

#raw_repositoryObject Also known as: raw


88
89
90
91
92
# File 'app/models/repository.rb', line 88

def raw_repository
  return unless full_path

  @raw_repository ||= initialize_raw_repository
end

#readmeObject


616
617
618
# File 'app/models/repository.rb', line 616

def readme
  head_tree&.readme
end

#readme_pathObject


620
621
622
# File 'app/models/repository.rb', line 620

def readme_path
  readme&.path
end

#rebase(user, merge_request, skip_ci: false) ⇒ Object


1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
# File 'app/models/repository.rb', line 1076

def rebase(user, merge_request, skip_ci: false)
  push_options = []
  push_options << Gitlab::PushOptions::CI_SKIP if skip_ci

  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,
    push_options: push_options
  ) do |commit_id|
    merge_request.update!(rebase_commit_sha: commit_id, merge_error: nil)
  end
rescue StandardError => error
  merge_request.update!(rebase_commit_sha: nil)
  raise error
end

#ref_exists?(ref) ⇒ Boolean

Returns:

  • (Boolean)

284
285
286
287
288
# File 'app/models/repository.rb', line 284

def ref_exists?(ref)
  !!raw_repository&.ref_exists?(ref)
rescue ArgumentError
  false
end

#ref_namesObject


268
269
270
# File 'app/models/repository.rb', line 268

def ref_names
  branch_names + tag_names
end

#refresh_method_caches(types) ⇒ Object

Refreshes the method caches of this repository.

types - An Array of file types (e.g. `:readme`) used to refresh extra

caches.

344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
# File 'app/models/repository.rb', line 344

def refresh_method_caches(types)
  return if types.empty?

  to_refresh = []

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

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

  expire_method_caches(to_refresh)

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

#rendered_readmeObject


625
626
627
628
629
630
631
# File 'app/models/repository.rb', line 625

def rendered_readme
  return unless readme

  context = { project: project }

  MarkupHelper.markup_unsafe(readme.name, readme.data, context)
end

#respond_to_missing?(method, include_private = false) ⇒ Boolean

Returns:

  • (Boolean)

506
507
508
# File 'app/models/repository.rb', line 506

def respond_to_missing?(method, include_private = false)
  raw_repository.respond_to?(method, include_private) || super
end

#revert(user, commit, branch_name, message, start_branch_name: nil, start_project: project, dry_run: false) ⇒ Object


885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
# File 'app/models/repository.rb', line 885

def revert(
  user, commit, branch_name, message,
  start_branch_name: nil, start_project: project, dry_run: false)

  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,
      dry_run: dry_run
    )
  end
end

#rm_branch(user, branch_name) ⇒ Object


250
251
252
253
254
255
256
257
# File 'app/models/repository.rb', line 250

def rm_branch(user, branch_name)
  before_remove_branch

  raw_repository.rm_branch(branch_name, user: user)

  after_remove_branch
  true
end

#rm_tag(user, tag_name) ⇒ Object


259
260
261
262
263
264
265
266
# File 'app/models/repository.rb', line 259

def rm_tag(user, tag_name)
  before_remove_tag

  raw_repository.rm_tag(tag_name, user: user)

  after_remove_tag
  true
end

#root_refObject


541
542
543
# File 'app/models/repository.rb', line 541

def root_ref
  raw_repository&.root_ref
end

#root_ref_shaObject


931
932
933
# File 'app/models/repository.rb', line 931

def root_ref_sha
  @root_ref_sha ||= commit(root_ref).sha
end

#route_map_for(sha) ⇒ Object


1060
1061
1062
# File 'app/models/repository.rb', line 1060

def route_map_for(sha)
  blob_data_at(sha, '.gitlab/route-map.yml')
end

#search_files_by_content(query, ref, options = {}) ⇒ Object


1020
1021
1022
1023
1024
# File 'app/models/repository.rb', line 1020

def search_files_by_content(query, ref, options = {})
  return [] if empty? || query.blank?

  raw_repository.search_files_by_content(query, ref, options)
end

#search_files_by_name(query, ref) ⇒ Object


1026
1027
1028
1029
1030
# File 'app/models/repository.rb', line 1026

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

  raw_repository.search_files_by_name(query, ref)
end

#sizeObject

The size of this repository in megabytes.


564
565
566
# File 'app/models/repository.rb', line 564

def size
  exists? ? raw_repository.size : 0.0
end

#squash(user, merge_request, message) ⇒ Object


1096
1097
1098
1099
1100
1101
# File 'app/models/repository.rb', line 1096

def squash(user, merge_request, message)
  raw.squash(user, merge_request.id, start_sha: merge_request.diff_start_sha,
                                     end_sha: merge_request.diff_head_sha,
                                     author: merge_request.author,
                                     message: message)
end

1103
1104
1105
# File 'app/models/repository.rb', line 1103

def submodule_links
  @submodule_links ||= ::Gitlab::SubmoduleLinks.new(self)
end

#tag_exists?(tag_name) ⇒ Boolean

Returns:

  • (Boolean)

278
279
280
281
282
# File 'app/models/repository.rb', line 278

def tag_exists?(tag_name)
  return false unless raw_repository

  tag_names_include?(tag_name)
end

#tag_names_contains(sha) ⇒ Object


795
796
797
# File 'app/models/repository.rb', line 795

def tag_names_contains(sha)
  raw_repository.tag_names_contains_sha(sha)
end

#tagsObject


805
806
807
# File 'app/models/repository.rb', line 805

def tags
  @tags ||= raw_repository.tags
end

#tags_sorted_by(value) ⇒ Object


752
753
754
755
756
757
758
759
760
761
762
763
764
765
# File 'app/models/repository.rb', line 752

def tags_sorted_by(value)
  case value
  when 'name_asc'
    VersionSorter.sort(tags) { |tag| tag.name }
  when 'name_desc'
    VersionSorter.rsort(tags) { |tag| tag.name }
  when 'updated_desc'
    tags_sorted_by_committed_date.reverse
  when 'updated_asc'
    tags_sorted_by_committed_date
  else
    tags
  end
end

#tree(sha = :head, path = nil, recursive: false) ⇒ Object


688
689
690
691
692
693
694
695
696
697
698
699
700
# File 'app/models/repository.rb', line 688

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

    if path.nil?
      return head_tree
    else
      sha = head_commit.sha
    end
  end

  Tree.new(self, sha, path, recursive: recursive)
end

#update_file(user, path, content, **options) ⇒ Object


821
822
823
824
825
826
827
828
# File 'app/models/repository.rb', line 821

def update_file(user, path, content, **options)
  previous_path = options.delete(:previous_path)
  action = previous_path && previous_path != path ? :move : :update

  options[:actions] = [{ action: action, file_path: path, previous_path: previous_path, content: content }]

  multi_action(user, **options)
end

#update_submodule(user, submodule, commit_sha, message:, branch:) ⇒ Object


1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
# File 'app/models/repository.rb', line 1107

def update_submodule(user, submodule, commit_sha, message:, branch:)
  with_cache_hooks do
    raw.update_submodule(
      user: user,
      submodule: submodule,
      commit_sha: commit_sha,
      branch: branch,
      message: message
    )
  end
end

#user_defined_metrics_dashboard_pathsObject


611
612
613
# File 'app/models/repository.rb', line 611

def user_defined_metrics_dashboard_paths
  Gitlab::Metrics::Dashboard::RepoDashboardFinder.list_dashboards(project)
end

#with_cache_hooksObject


836
837
838
839
840
841
842
843
844
845
# File 'app/models/repository.rb', line 836

def with_cache_hooks
  result = yield

  return unless result

  after_create if result.repo_created?
  after_create_branch if result.branch_created?

  result.newrev
end

#xcode_project?Boolean

Returns:

  • (Boolean)

673
674
675
# File 'app/models/repository.rb', line 673

def xcode_project?
  file_on_head(:xcode_config, :tree).present?
end