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.


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

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


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

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?


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

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

#add_branch(user, branch_name, ref) ⇒ Object


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

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


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

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.


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

def after_change_head
  expire_all_method_caches
end

#after_createObject

Runs code after a repository has been created.


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

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.


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

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.


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

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.


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

def after_remove_branch(expire_cache: true)
  expire_branches_cache if expire_cache
end

#after_remove_tagObject

Runs code after removing a tag.


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

def after_remove_tag
  expire_caches_for_tags
end

#ambiguous_ref?(ref) ⇒ Boolean

Returns:

  • (Boolean)

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

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

#ancestor?(ancestor_id, descendant_id) ⇒ Boolean

Returns:

  • (Boolean)

961
962
963
964
965
966
967
968
969
970
# File 'app/models/repository.rb', line 961

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


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

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


984
985
986
987
988
989
990
991
992
993
994
995
996
997
# File 'app/models/repository.rb', line 984

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


587
588
589
590
591
592
593
594
# File 'app/models/repository.rb', line 587

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.


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

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.


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

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.


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

def before_push_tag
  repository_event(:push_tag)
end

#before_remove_branchObject

Runs code before removing an existing branch.


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

def before_remove_branch
  expire_branches_cache

  repository_event(:remove_branch)
end

#before_remove_tagObject

Runs code before removing a tag.


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

def before_remove_tag
  expire_caches_for_tags

  repository_event(:remove_tag)
end

#blob_at(sha, path) ⇒ Object


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

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


698
699
700
701
702
703
704
705
706
# File 'app/models/repository.rb', line 698

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


1115
1116
1117
1118
1119
1120
1121
# File 'app/models/repository.rb', line 1115

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]]


529
530
531
532
533
534
535
# File 'app/models/repository.rb', line 529

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


1138
1139
1140
1141
1142
# File 'app/models/repository.rb', line 1138

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)

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

def branch_exists?(branch_name)
  return false unless raw_repository

  branch_names_include?(branch_name)
end

#branch_names_contains(sha) ⇒ Object


787
788
789
# File 'app/models/repository.rb', line 787

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

#branches_sorted_by(sort_by, pagination_params = nil) ⇒ Object


744
745
746
# File 'app/models/repository.rb', line 744

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

#cached_methodsObject


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

def cached_methods
  CACHED_METHODS
end

#changelogObject


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

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


898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
# File 'app/models/repository.rb', line 898

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


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

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


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

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

  @commit_cache[oid] = find_commit(oid)
end

#commit_countObject


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

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

#commit_count_for_ref(ref) ⇒ Object


570
571
572
573
574
# File 'app/models/repository.rb', line 570

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


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

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


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

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


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

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


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

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


630
631
632
# File 'app/models/repository.rb', line 630

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'


767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
# File 'app/models/repository.rb', line 767

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


1028
1029
1030
1031
1032
1033
1034
1035
1036
# File 'app/models/repository.rb', line 1028

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


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

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


811
812
813
814
815
# File 'app/models/repository.rb', line 811

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


1132
1133
1134
1135
1136
# File 'app/models/repository.rb', line 1132

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


1123
1124
1125
1126
1127
1128
1129
1130
# File 'app/models/repository.rb', line 1123

def create_if_not_exists
  return if exists?

  raw.create_repository
  after_create

  true
end

#create_ref(ref, ref_path) ⇒ Object


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

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

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


826
827
828
829
830
# File 'app/models/repository.rb', line 826

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

  multi_action(user, **options)
end

#delete_refs(*ref_names) ⇒ Object


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

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)

553
554
555
556
557
# File 'app/models/repository.rb', line 553

def empty?
  return true unless exists?

  !has_visible_content?
end

#exists?Boolean

Returns:

  • (Boolean)

543
544
545
546
547
# File 'app/models/repository.rb', line 543

def exists?
  return false unless full_path

  raw_repository.exists?
end

#expand_ref(ref) ⇒ Object


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

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


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

def expire_all_method_caches
  expire_method_caches(CACHED_METHODS)
end

#expire_avatar_cacheObject


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

def expire_avatar_cache
  expire_method_caches(%i(avatar))
end

#expire_branch_cache(branch_name = nil) ⇒ Object


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

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


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

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


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

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)


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

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.


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

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


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

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

#expire_root_ref_cacheObject


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

def expire_root_ref_cache
  expire_method_caches(%i(root_ref))
end

#expire_statistics_cachesObject


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

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

#expire_status_cacheObject


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

def expire_status_cache
  expire_exists_cache
  expire_root_ref_cache
  expire_emptiness_caches
end

#expire_tags_cacheObject


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

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


972
973
974
975
976
977
978
979
980
981
982
# File 'app/models/repository.rb', line 972

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


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

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


999
1000
1001
# File 'app/models/repository.rb', line 999

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


872
873
874
875
876
877
878
879
# File 'app/models/repository.rb', line 872

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(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


1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
# File 'app/models/repository.rb', line 1038

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


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

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

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


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

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


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

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

#gitignoreObject


659
660
661
# File 'app/models/repository.rb', line 659

def gitignore
  file_on_head(:gitignore)
end

#gitlab_ci_ymlObject


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

def gitlab_ci_yml
  file_on_head(:gitlab_ci)
end

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


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

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)

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

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


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

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

#head_commitObject


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

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

#head_treeObject


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

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

#inspectObject


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

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

#issue_template_namesObject


597
598
599
# File 'app/models/repository.rb', line 597

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

#keep_around(*shas) ⇒ Object


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

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

#languagesObject


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

def languages
  return [] if empty?

  raw_repository.languages(root_ref)
end

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


716
717
718
719
# File 'app/models/repository.rb', line 716

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


721
722
723
724
725
726
727
# File 'app/models/repository.rb', line 721

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

#lfs_enabled?Boolean

TODO: pass this in directly to `Blob` rather than delegating it to here

gitlab.com/gitlab-org/gitlab/-/issues/201886

Returns:

  • (Boolean)

1155
1156
1157
1158
1159
1160
1161
# File 'app/models/repository.rb', line 1155

def lfs_enabled?
  if container.is_a?(Project)
    container.lfs_enabled?
  else
    false # LFS is not supported for snippet or group repositories
  end
end

#lfsconfig_for(sha) ⇒ Object


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

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

#licenseObject


652
653
654
655
656
# File 'app/models/repository.rb', line 652

def license
  return unless license_key

  Licensee::License.new(license_key)
end

#license_blobObject


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

def license_blob
  file_on_head(:license)
end

#license_keyObject


645
646
647
648
649
# File 'app/models/repository.rb', line 645

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


708
709
710
711
712
713
714
# File 'app/models/repository.rb', line 708

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


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

def local_branches
  @local_branches ||= raw_repository.local_branches
end

#lookup_cacheObject


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

def lookup_cache
  @lookup_cache ||= {}
end

#ls_files(ref) ⇒ Object


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

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

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


853
854
855
856
857
858
859
860
# File 'app/models/repository.rb', line 853

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

#merge_base(*commits_or_ids) ⇒ Object


953
954
955
956
957
958
959
# File 'app/models/repository.rb', line 953

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


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

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) ⇒ Object


862
863
864
865
866
# File 'app/models/repository.rb', line 862

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

  raw.merge_to_ref(user, source_sha, branch, target_ref, message, first_parent_ref)
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.


933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
# File 'app/models/repository.rb', line 933

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)

915
916
917
918
919
920
921
922
923
924
925
# File 'app/models/repository.rb', line 915

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


843
844
845
846
847
848
849
850
851
# File 'app/models/repository.rb', line 843

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


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

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

  ::Commit.decorate(commits, container)
end

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


729
730
731
732
733
734
735
736
737
738
739
740
741
742
# File 'app/models/repository.rb', line 729

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.


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

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


1144
1145
1146
1147
1148
1149
1150
# File 'app/models/repository.rb', line 1144

def project
  if repo_type.snippet?
    container.project
  elsif container.is_a?(Project)
    container
  end
end

#raw_repositoryObject Also known as: raw


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

def raw_repository
  return unless full_path

  @raw_repository ||= initialize_raw_repository
end

#readmeObject


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

def readme
  head_tree&.readme
end

#readme_pathObject


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

def readme_path
  readme&.path
end

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


1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
# File 'app/models/repository.rb', line 1072

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)

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

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

#ref_namesObject


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

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.

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

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


621
622
623
624
625
626
627
# File 'app/models/repository.rb', line 621

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)

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

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


881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
# File 'app/models/repository.rb', line 881

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


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

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


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

def rm_tag(user, tag_name)
  before_remove_tag

  raw_repository.rm_tag(tag_name, user: user)

  after_remove_tag
  true
end

#root_refObject


537
538
539
# File 'app/models/repository.rb', line 537

def root_ref
  raw_repository&.root_ref
end

#root_ref_shaObject


927
928
929
# File 'app/models/repository.rb', line 927

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

#route_map_for(sha) ⇒ Object


1056
1057
1058
# File 'app/models/repository.rb', line 1056

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

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


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

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


1022
1023
1024
1025
1026
# File 'app/models/repository.rb', line 1022

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.


560
561
562
# File 'app/models/repository.rb', line 560

def size
  exists? ? raw_repository.size : 0.0
end

#squash(user, merge_request, message) ⇒ Object


1092
1093
1094
1095
1096
1097
# File 'app/models/repository.rb', line 1092

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

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

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

#tag_exists?(tag_name) ⇒ Boolean

Returns:

  • (Boolean)

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

def tag_exists?(tag_name)
  return false unless raw_repository

  tag_names_include?(tag_name)
end

#tag_names_contains(sha) ⇒ Object


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

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

#tagsObject


801
802
803
# File 'app/models/repository.rb', line 801

def tags
  @tags ||= raw_repository.tags
end

#tags_sorted_by(value) ⇒ Object


748
749
750
751
752
753
754
755
756
757
758
759
760
761
# File 'app/models/repository.rb', line 748

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


684
685
686
687
688
689
690
691
692
693
694
695
696
# File 'app/models/repository.rb', line 684

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


817
818
819
820
821
822
823
824
# File 'app/models/repository.rb', line 817

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


1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
# File 'app/models/repository.rb', line 1103

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


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

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

#with_cache_hooksObject


832
833
834
835
836
837
838
839
840
841
# File 'app/models/repository.rb', line 832

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)

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

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