Class: MergeRequestDiff
Constant Summary
collapse
- COMMITS_SAFE_SIZE =
Don’t display more than 100 commits at once
100
- BATCH_SIZE =
1000
- EXTERNAL_DIFF_CUTOFF =
Applies to closed or merged MRs when determining whether to migrate their diffs to external storage
7.days.freeze
- FILES_COUNT_SENTINEL =
The files_count column is a 2-byte signed integer. Look up the true value from the database if this sentinel is seen
2**15 - 1
- EXTERNAL_DIFFS_CACHE_TMPDIR =
External diff cache key used by diffs export
'project-%{project_id}-external-mr-%{mr_id}-diff-%{id}-cache'
- EXTERNAL_DIFF_CACHE_CHUNK_SIZE =
8.megabytes
ApplicationRecord::MAX_PLUCK
ResetOnUnionError::MAX_RESET_PERIOD
Instance Attribute Summary
Attributes included from Importable
#imported, #importing
Class Method Summary
collapse
Instance Method Summary
collapse
#bulk_insert_associations!, bulk_inserts_enabled?, with_bulk_insert
cached_column_list, #create_or_load_association, declarative_enum, default_select_columns, id_in, id_not_in, iid_in, pluck_primary_key, primary_key_in, #readable_by?, safe_ensure_unique, safe_find_or_create_by, safe_find_or_create_by!, #to_ability_name, underscore, where_exists, where_not_exists, with_fast_read_statement_timeout, without_order
#serializable_hash
Class Method Details
.find_by_diff_refs(diff_refs) ⇒ Object
201
202
203
|
# File 'app/models/merge_request_diff.rb', line 201
def self.find_by_diff_refs(diff_refs)
find_by(start_commit_sha: diff_refs.start_sha, head_commit_sha: diff_refs.head_sha, base_commit_sha: diff_refs.base_sha)
end
|
.ids_for_external_storage_migration(limit:) ⇒ Object
149
150
151
152
153
154
155
156
157
158
159
160
|
# File 'app/models/merge_request_diff.rb', line 149
def ids_for_external_storage_migration(limit:)
return [] unless Gitlab.config.external_diffs.enabled
case Gitlab.config.external_diffs.when
when 'always'
ids_for_external_storage_migration_strategy_always(limit: limit)
when 'outdated'
ids_for_external_storage_migration_strategy_outdated(limit: limit)
else
[]
end
end
|
.ids_for_external_storage_migration_strategy_always(limit:) ⇒ Object
162
163
164
|
# File 'app/models/merge_request_diff.rb', line 162
def ids_for_external_storage_migration_strategy_always(limit:)
files_in_database.limit(limit).pluck(:id)
end
|
.ids_for_external_storage_migration_strategy_outdated(limit:) ⇒ Object
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
|
# File 'app/models/merge_request_diff.rb', line 166
def ids_for_external_storage_migration_strategy_outdated(limit:)
before = EXTERNAL_DIFF_CUTOFF.ago
ids = files_in_database
.old_merged_diffs(before)
.limit(limit)
.pluck(:id)
return ids if ids.size >= limit
ids += files_in_database
.old_closed_diffs(before)
.limit(limit - ids.size)
.pluck(:id)
return ids if ids.size >= limit
ids + files_in_database
.not_latest_diffs
.limit(limit - ids.size)
.pluck(:id)
end
|
Instance Method Details
#base_commit ⇒ Object
315
316
317
318
319
|
# File 'app/models/merge_request_diff.rb', line 315
def base_commit
return unless base_commit_sha
project.commit_by(oid: base_commit_sha)
end
|
#cached_external_diff ⇒ Object
Yields locally cached external diff if it’s externally stored. Used during Project Export to speed up externally stored merge request diffs export
587
588
589
590
591
592
593
594
595
|
# File 'app/models/merge_request_diff.rb', line 587
def cached_external_diff
return yield(nil) unless stored_externally?
cache_external_diff unless File.exist?(external_diff_cache_filepath)
File.open(external_diff_cache_filepath) do |file|
yield(file)
end
end
|
#commit_shas(limit: nil) ⇒ Object
333
334
335
336
337
338
339
340
341
|
# File 'app/models/merge_request_diff.rb', line 333
def commit_shas(limit: nil)
if association(:merge_request_diff_commits).loaded?
sorted_diff_commits = merge_request_diff_commits.sort_by { |diff_commit| [diff_commit.id, diff_commit.relative_order] }
sorted_diff_commits = sorted_diff_commits.take(limit) if limit
sorted_diff_commits.map(&:sha)
else
merge_request_diff_commits.limit(limit).pluck(:sha)
end
end
|
#commits(limit: nil, load_from_gitaly: false, page: nil) ⇒ Object
297
298
299
300
301
|
# File 'app/models/merge_request_diff.rb', line 297
def commits(limit: nil, load_from_gitaly: false, page: nil)
strong_memoize(:"commits_#{limit || 'all'}_#{load_from_gitaly}_page_#{page}") do
load_commits(limit: limit, load_from_gitaly: load_from_gitaly, page: page)
end
end
|
#compare ⇒ Object
475
476
477
478
479
480
481
482
|
# File 'app/models/merge_request_diff.rb', line 475
def compare
@compare ||=
Gitlab::Git::Compare.new(
repository.raw_repository,
safe_start_commit_sha,
head_commit_sha
)
end
|
#compare_with(sha) ⇒ Object
rubocop: disable CodeReuse/ServiceClass
489
490
491
492
493
494
|
# File 'app/models/merge_request_diff.rb', line 489
def compare_with(sha)
CompareService.new(project, head_commit_sha).execute(project, sha, straight: true)
end
|
#diff_refs ⇒ Object
359
360
361
362
363
364
365
366
367
|
# File 'app/models/merge_request_diff.rb', line 359
def diff_refs
return unless start_commit_sha || base_commit_sha
Gitlab::Diff::DiffRefs.new(
base_sha: base_commit_sha,
start_sha: start_commit_sha,
head_sha: head_commit_sha
)
end
|
#diff_refs=(new_diff_refs) ⇒ Object
353
354
355
356
357
|
# File 'app/models/merge_request_diff.rb', line 353
def diff_refs=(new_diff_refs)
self.base_commit_sha = new_diff_refs&.base_sha
self.start_commit_sha = new_diff_refs&.start_sha
self.head_commit_sha = new_diff_refs&.head_sha
end
|
#diff_refs_by_sha? ⇒ Boolean
392
393
394
|
# File 'app/models/merge_request_diff.rb', line 392
def diff_refs_by_sha?
base_commit_sha? && head_commit_sha? && start_commit_sha?
end
|
#diffs(diff_options = nil) ⇒ Object
449
450
451
452
453
454
455
456
457
458
459
460
461
|
# File 'app/models/merge_request_diff.rb', line 449
def diffs(diff_options = nil)
fetching_repository_diffs(diff_options) do |comparison|
if comparison
comparison.diffs(diff_options)
else
reorder_diff_files!
diffs_collection(diff_options)
end
end
end
|
#diffs_collection(diff_options = nil) ⇒ Object
Should always return the DB persisted diffs collection (e.g. Gitlab::Diff::FileCollection::MergeRequestDiff. It’s useful when trying to invalidate old caches through FileCollection::MergeRequestDiff#clear_cache!
#diffs_in_batch(batch_page, batch_size, diff_options:) ⇒ Object
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
|
# File 'app/models/merge_request_diff.rb', line 396
def diffs_in_batch(batch_page, batch_size, diff_options:)
fetching_repository_diffs(diff_options) do |comparison|
Gitlab::Metrics.measure(:diffs_reorder) do
reorder_diff_files!
end
diffs_batch = Gitlab::Metrics.measure(:diffs_collection) do
diffs_in_batch_collection(batch_page, batch_size, diff_options: diff_options)
end
if comparison
if diff_options[:paths].blank? && !without_files?
break diffs_batch if diffs_batch.diff_paths.blank?
diff_options.merge!(
paths: diffs_batch.diff_paths,
pagination_data: diffs_batch.
)
end
Gitlab::Metrics.measure(:diffs_comparison) do
comparison.diffs(diff_options)
end
else
diffs_batch
end
end
end
|
#ensure_commit_shas ⇒ Object
236
237
238
239
240
241
242
243
244
245
246
247
248
|
# File 'app/models/merge_request_diff.rb', line 236
def ensure_commit_shas
self.start_commit_sha ||= merge_request.target_branch_sha
if merge_head? && merge_request.merge_ref_head.present?
diff_refs = merge_request.merge_ref_head.diff_refs
self.head_commit_sha ||= diff_refs.head_sha
self.base_commit_sha ||= diff_refs.base_sha
else
self.head_commit_sha ||= merge_request.source_branch_sha
self.base_commit_sha ||= find_base_sha
end
end
|
#fallback_diff_refs ⇒ Object
MRs created before 8.4 don’t store their true diff refs (start and base), but we need to get a commit SHA for the “View file @ …” link by a file, so we use an approximation of the diff refs if we can’t get the actual one.
These will not be the actual diff refs if the target branch was merged into the source branch after the merge request was created, but it is good enough for the specific purpose of linking to a commit.
It is not good enough for highlighting diffs, so we can’t simply pass these as ‘diff_refs.`
379
380
381
382
383
384
385
386
387
388
389
390
|
# File 'app/models/merge_request_diff.rb', line 379
def fallback_diff_refs
real_refs = diff_refs
return real_refs if real_refs
likely_base_commit_sha = (first_commit&.parent || first_commit)&.sha
Gitlab::Diff::DiffRefs.new(
base_sha: likely_base_commit_sha,
start_sha: safe_start_commit_sha,
head_sha: head_commit_sha
)
end
|
#files_count ⇒ Object
260
261
262
263
264
265
266
267
268
269
|
# File 'app/models/merge_request_diff.rb', line 260
def files_count
db_value = read_attribute(:files_count)
case db_value
when nil, FILES_COUNT_SENTINEL
merge_request_diff_files.count
else
db_value
end
end
|
#first_commit ⇒ Object
307
308
309
|
# File 'app/models/merge_request_diff.rb', line 307
def first_commit
commits.last
end
|
#head_commit ⇒ Object
327
328
329
330
331
|
# File 'app/models/merge_request_diff.rb', line 327
def head_commit
return unless head_commit_sha
project.commit_by(oid: head_commit_sha)
end
|
#head_commit_sha ⇒ Object
Override head_commit_sha to keep compatibility with merge request diff created before version 8.4 that does not store head_commit_sha in separate db field.
252
253
254
255
256
257
258
|
# File 'app/models/merge_request_diff.rb', line 252
def head_commit_sha
if persisted? && super.nil?
last_commit_sha
else
super
end
end
|
#includes_any_commits?(shas) ⇒ Boolean
343
344
345
346
347
348
349
350
351
|
# File 'app/models/merge_request_diff.rb', line 343
def includes_any_commits?(shas)
return false if shas.blank?
shas.each_slice(BATCH_SIZE).any? do |batched_shas|
merge_request_diff_commits.where(sha: batched_shas).exists?
end
end
|
#last_commit ⇒ Object
311
312
313
|
# File 'app/models/merge_request_diff.rb', line 311
def last_commit
commits.first
end
|
#last_commit_sha ⇒ Object
303
304
305
|
# File 'app/models/merge_request_diff.rb', line 303
def last_commit_sha
commit_shas(limit: 1).first
end
|
#latest? ⇒ Boolean
484
485
486
|
# File 'app/models/merge_request_diff.rb', line 484
def latest?
self.id == merge_request.latest_merge_request_diff_id
end
|
#lines_count ⇒ Object
282
283
284
285
286
|
# File 'app/models/merge_request_diff.rb', line 282
def lines_count
strong_memoize(:lines_count) do
raw_diffs(limits: false).line_count
end
end
|
#migrate_files_to_database! ⇒ Object
Transactionally migrate the current merge_request_diff_files entries from external storage, back to the database. This is the rollback operation for migrate_files_to_external_storage!
If this diff isn’t in external storage, the method is a no-op.
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
|
# File 'app/models/merge_request_diff.rb', line 566
def migrate_files_to_database!
return unless stored_externally?
return if files_count == 0
rows = convert_external_diffs_to_database
transaction do
MergeRequestDiffFile.where(merge_request_diff_id: id).delete_all
ApplicationRecord.legacy_bulk_insert('merge_request_diff_files', rows) update!(stored_externally: false)
end
remove_external_diff!
merge_request_diff_files.reset
end
|
#migrate_files_to_external_storage! ⇒ Object
Transactionally migrate the current merge_request_diff_files entries to external storage. If external storage isn’t an option for this diff, the method is a no-op.
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
|
# File 'app/models/merge_request_diff.rb', line 541
def migrate_files_to_external_storage!
return if stored_externally? || !use_external_diff? || files_count == 0
rows = build_merge_request_diff_files(merge_request_diff_files)
rows = build_external_merge_request_diff_files(rows)
self.external_diff.store!
transaction do
MergeRequestDiffFile.where(merge_request_diff_id: id).delete_all
ApplicationRecord.legacy_bulk_insert('merge_request_diff_files', rows) save!
end
merge_request_diff_files.reset
end
|
#modified_paths(fallback_on_overflow: false) ⇒ Object
rubocop: enable CodeReuse/ServiceClass
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
|
# File 'app/models/merge_request_diff.rb', line 497
def modified_paths(fallback_on_overflow: false)
if fallback_on_overflow && overflow?
strong_memoize(:overflowed_modified_paths) do
project.repository.diff_stats(
base_commit_sha,
head_commit_sha
).paths
end
else
strong_memoize(:modified_paths) do
merge_request_diff_files.pluck(:new_path, :old_path).flatten.uniq
end
end
end
|
#opening_external_diff ⇒ Object
If enabled, yields the external file containing the diff. Otherwise, yields nil. This method is not thread-safe, but it is re-entrant, which allows multiple merge_request_diff_files to load their data efficiently
525
526
527
528
529
530
531
532
533
534
535
536
|
# File 'app/models/merge_request_diff.rb', line 525
def opening_external_diff
return yield(nil) unless stored_externally?
return yield(@external_diff_file) if @external_diff_file
external_diff.open do |file|
@external_diff_file = file
yield(@external_diff_file)
ensure
@external_diff_file = nil
end
end
|
#paginated_diffs(page, per_page) ⇒ Object
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
|
# File 'app/models/merge_request_diff.rb', line 426
def paginated_diffs(page, per_page)
fetching_repository_diffs({}) do |comparison|
reorder_diff_files!
collection = Gitlab::Diff::FileCollection::PaginatedMergeRequestDiff.new(
self,
page,
per_page
)
if comparison
comparison.diffs(
paths: collection.diff_paths,
page: collection.current_page,
per_page: collection.limit_value,
count: collection.total_count
)
else
collection
end
end
end
|
#project ⇒ Object
471
472
473
|
# File 'app/models/merge_request_diff.rb', line 471
def project
merge_request.target_project
end
|
#raw_diffs(options = {}) ⇒ Object
288
289
290
291
292
293
294
295
|
# File 'app/models/merge_request_diff.rb', line 288
def raw_diffs(options = {})
if options[:ignore_whitespace_change]
@diffs_no_whitespace ||= compare.diffs(options)
else
@raw_diffs ||= {}
@raw_diffs[options] ||= load_diffs(options)
end
end
|
#remove_cached_external_diff ⇒ Object
#safe_start_commit_sha ⇒ Object
This method will rely on repository branch sha in case start_commit_sha is nil. It’s necessary for old merge request diff created before version 8.4 to work
274
275
276
|
# File 'app/models/merge_request_diff.rb', line 274
def safe_start_commit_sha
start_commit_sha || merge_request.target_branch_sha
end
|
#save_git_content ⇒ Object
Collect information about commits and diff from repository and save it to the database as serialized data
211
212
213
214
215
216
217
218
219
220
221
222
223
224
|
# File 'app/models/merge_request_diff.rb', line 211
def save_git_content
ensure_commit_shas
save_commits
save_diffs
save
reset
keep_around_commits unless importing?
end
|
#set_as_latest_diff ⇒ Object
226
227
228
229
230
231
232
233
234
|
# File 'app/models/merge_request_diff.rb', line 226
def set_as_latest_diff
return if merge_head?
MergeRequest
.where('id = ? AND COALESCE(latest_merge_request_diff_id, 0) < ?', self.merge_request_id, self.id)
.update_all(latest_merge_request_diff_id: self.id)
end
|
#size ⇒ Object
278
279
280
|
# File 'app/models/merge_request_diff.rb', line 278
def size
real_size.presence || raw_diffs.size
end
|
#start_commit ⇒ Object
321
322
323
324
325
|
# File 'app/models/merge_request_diff.rb', line 321
def start_commit
return unless start_commit_sha
project.commit_by(oid: start_commit_sha)
end
|
#update_external_diff_store ⇒ Object
516
517
518
519
520
|
# File 'app/models/merge_request_diff.rb', line 516
def update_external_diff_store
return unless saved_change_to_external_diff? || saved_change_to_stored_externally?
update_column(:external_diff_store, external_diff.object_store)
end
|
#viewable? ⇒ Boolean
205
206
207
|
# File 'app/models/merge_request_diff.rb', line 205
def viewable?
collected? || without_files? || overflow?
end
|