Class: Katello::Pulp3::Repository

Inherits:
Object
  • Object
show all
Includes:
ServiceCommon, Util::HttpProxy
Defined in:
app/services/katello/pulp3/repository.rb,
app/services/katello/pulp3/repository/apt.rb,
app/services/katello/pulp3/repository/yum.rb,
app/services/katello/pulp3/repository/file.rb,
app/services/katello/pulp3/repository/docker.rb,
app/services/katello/pulp3/repository/generic.rb,
app/services/katello/pulp3/repository/ansible_collection.rb

Direct Known Subclasses

AnsibleCollection, Apt, Docker, File, Generic, Yum

Defined Under Namespace

Classes: AnsibleCollection, Apt, Docker, File, Generic, Yum

Constant Summary collapse

COPY_UNIT_PAGE_SIZE = 
10_000

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from ServiceCommon

#create_test_remote, #ignore_404_exception, #reformat_api_exception, #test_remote_name

Methods included from Util::HttpProxy

#proxy, #proxy_host, #proxy_port, #proxy_scheme, #proxy_uri

Constructor Details

#initialize(repo, smart_proxy) ⇒ Repository

Returns a new instance of Repository.



15
16
17
18
 
# File 'app/services/katello/pulp3/repository.rb', line 15

def initialize(repo, smart_proxy)
  @repo = repo
  @smart_proxy = smart_proxy
end

Instance Attribute Details

#repo ⇒ Object

Returns the value of attribute repo.



8
9
10
 
# File 'app/services/katello/pulp3/repository.rb', line 8

def repo
  @repo
end

#smart_proxy ⇒ Object

Returns the value of attribute smart_proxy.



9
10
11
 
# File 'app/services/katello/pulp3/repository.rb', line 9

def smart_proxy
  @smart_proxy
end

Class Method Details

.api(smart_proxy, repository_type_label) ⇒ Object 



40
41
42
43
 
# File 'app/services/katello/pulp3/repository.rb', line 40

def self.api(smart_proxy, repository_type_label)
  repo_type = RepositoryTypeManager.enabled_repository_types[repository_type_label]
  repo_type.pulp3_api(smart_proxy)
end

.instance_for_type(repo, smart_proxy) ⇒ Object 



105
106
107
 
# File 'app/services/katello/pulp3/repository.rb', line 105

def self.instance_for_type(repo, smart_proxy)
  Katello::RepositoryTypeManager.enabled_repository_types[repo.root.content_type].pulp3_service_class.new(repo, smart_proxy)
end

.publication_href?(href) ⇒ Boolean

Returns:

  • (Boolean) 


24
25
26
 
# File 'app/services/katello/pulp3/repository.rb', line 24

def self.publication_href?(href)
  href.include?('/publications/')
end

.version_href?(href) ⇒ Boolean

Returns:

  • (Boolean) 


20
21
22
 
# File 'app/services/katello/pulp3/repository.rb', line 20

def self.version_href?(href)
  /.*\/versions\/\d*\//.match(href)
end

Instance Method Details

#add_content(content_unit_href, remove_all_units = false) ⇒ Object 



488
489
490
491
492
493
494
495
496
 
# File 'app/services/katello/pulp3/repository.rb', line 488

def add_content(content_unit_href, remove_all_units = false)
  content_unit_href = [content_unit_href] unless content_unit_href.is_a?(Array)
  if remove_all_units
    api.repositories_api.modify(repository_reference.repository_href, remove_content_units: ['*'])
    api.repositories_api.modify(repository_reference.repository_href, add_content_units: content_unit_href)
  else
    api.repositories_api.modify(repository_reference.repository_href, add_content_units: content_unit_href)
  end
end

#add_content_for_repo(repository_href, content_unit_href) ⇒ Object 



498
499
500
501
 
# File 'app/services/katello/pulp3/repository.rb', line 498

def add_content_for_repo(repository_href, content_unit_href)
  content_unit_href = [content_unit_href] unless content_unit_href.is_a?(Array)
  api.repositories_api.modify(repository_href, add_content_units: content_unit_href)
end

#api ⇒ Object 



49
50
51
 
# File 'app/services/katello/pulp3/repository.rb', line 49

def api
  @api ||= self.class.api(smart_proxy, repo.content_type)
end

#append_proxy_cacert(options) ⇒ Object 



451
452
453
454
455
456
 
# File 'app/services/katello/pulp3/repository.rb', line 451

def append_proxy_cacert(options)
  if root.http_proxy&.cacert&.present? && options.key?(:cacert)
    options[:cacert] += "\n#{root.http_proxy&.cacert}"
  end
  options
end

#common_remote_options ⇒ Object 



370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
 
# File 'app/services/katello/pulp3/repository.rb', line 370

def common_remote_options
  remote_options = {
    tls_validation: root.verify_ssl_on_sync,
    name: generate_backend_object_name,
    url: root.url,
    proxy_url: root.http_proxy&.url,
    proxy_username: root.http_proxy&.username,
    proxy_password: root.http_proxy&.password,
    total_timeout: Setting[:sync_total_timeout],
    connect_timeout: Setting[:sync_connect_timeout_v2],
    sock_connect_timeout: Setting[:sync_sock_connect_timeout],
    sock_read_timeout: Setting[:sync_sock_read_timeout],
    rate_limit: Setting[:download_rate_limit]
  }
  remote_options[:url] = root.url unless root.url.blank?
  remote_options[:download_concurrency] = root.download_concurrency unless root.download_concurrency.blank?
  remote_options.merge!(username: root&.upstream_username,
                        password: root&.upstream_password)
  remote_options[:username] = nil if remote_options[:username] == ''
  remote_options[:password] = nil if remote_options[:password] == ''
  remote_options.merge!(ssl_remote_options)
end

#compute_remote_options(computed_options = remote_options) ⇒ Object 



160
161
162
 
# File 'app/services/katello/pulp3/repository.rb', line 160

def compute_remote_options(computed_options = remote_options)
  computed_options.except(:name, :client_key)
end

#content_service ⇒ Object 



66
67
68
 
# File 'app/services/katello/pulp3/repository.rb', line 66

def content_service
  Katello::Pulp3::Content
end

#copy_all(source_repository, options = {}) ⇒ Object 



296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
 
# File 'app/services/katello/pulp3/repository.rb', line 296

def copy_all(source_repository, options = {})
  tasks = []
  if options[:remove_all]
    tasks << api.repositories_api.modify(repository_reference.repository_href, remove_content_units: ['*'])
  end

  if options[:mirror] && api.class.respond_to?(:add_remove_content_class)
    data = api.class.add_remove_content_class.new(
              base_version: source_repository.version_href)

    tasks << api.repositories_api.modify(repository_reference.repository_href, data)
    tasks
  elsif api.respond_to? :copy_api
    data = api.class.copy_class.new
    data.config = [{
      source_repo_version: source_repository.version_href,
      dest_repo: repository_reference.repository_href
    }]
    tasks << api.copy_api.copy_content(data)
    tasks
  else
    copy_content_for_source(source_repository)
  end
end

#copy_units_by_href(unit_hrefs) ⇒ Object 



288
289
290
291
292
293
294
 
# File 'app/services/katello/pulp3/repository.rb', line 288

def copy_units_by_href(unit_hrefs)
  tasks = []
  unit_hrefs.each_slice(COPY_UNIT_PAGE_SIZE) do |slice|
    tasks << create_version(:add_content_units => slice)
  end
  tasks
end

#copy_version(from_repository) ⇒ Object 



321
322
323
 
# File 'app/services/katello/pulp3/repository.rb', line 321

def copy_version(from_repository)
  create_version(:base_version => from_repository.version_href)
end

#core_api ⇒ Object 



45
46
47
 
# File 'app/services/katello/pulp3/repository.rb', line 45

def core_api
  Katello::Pulp3::Api::Core.new(smart_proxy)
end

#create(force = false) ⇒ Object 



164
165
166
167
168
169
170
171
172
173
174
175
176
 
# File 'app/services/katello/pulp3/repository.rb', line 164

def create(force = false)
  if force || !repository_reference
    response = api.repositories_api.create(create_options)
    RepositoryReference.where(
      root_repository_id: repo.root_id,
      content_view_id: repo.content_view.id).destroy_all
    RepositoryReference.where(
      root_repository_id: repo.root_id,
      content_view_id: repo.content_view.id,
      repository_href: response.pulp_href).create!
    response
  end
end

#create_distribution(path) ⇒ Object 



261
262
263
264
265
266
267
 
# File 'app/services/katello/pulp3/repository.rb', line 261

def create_distribution(path)
  distribution_data = api.distribution_class.new(secure_distribution_options(path))
  unless ::Katello::RepositoryTypeManager.find(repo.content_type).pulp3_skip_publication
    fail_missing_publication(distribution_data.publication)
  end
  api.distributions_api.create(distribution_data)
end

#create_mirror_entities ⇒ Object 



125
126
127
 
# File 'app/services/katello/pulp3/repository.rb', line 125

def create_mirror_entities
  RepositoryMirror.new(self).create_entities
end

#create_options ⇒ Object 



404
405
406
 
# File 'app/services/katello/pulp3/repository.rb', line 404

def create_options
  { name: generate_backend_object_name }.merge!(specific_create_options)
end

#create_publication ⇒ Object 



207
208
209
210
 
# File 'app/services/katello/pulp3/repository.rb', line 207

def create_publication
  publication_data = api.publication_class.new(publication_options(repo.version_href))
  api.publications_api.create(publication_data)
end

#create_remote ⇒ Object 



70
71
72
73
 
# File 'app/services/katello/pulp3/repository.rb', line 70

def create_remote
  response = super
  repo.update!(:remote_href => response.pulp_href)
end

#create_version(options = {}) ⇒ Object 



333
334
335
 
# File 'app/services/katello/pulp3/repository.rb', line 333

def create_version(options = {})
  api.repositories_api.modify(repository_reference.repository_href, options)
end

#delete_distributions ⇒ Object 



354
355
356
357
358
359
 
# File 'app/services/katello/pulp3/repository.rb', line 354

def delete_distributions
  if (dist_ref = distribution_reference)
    ignore_404_exception { api.delete_distribution(dist_ref.href) }
    dist_ref.destroy!
  end
end

#delete_distributions_by_path ⇒ Object 



361
362
363
364
365
366
367
368
 
# File 'app/services/katello/pulp3/repository.rb', line 361

def delete_distributions_by_path
  path = relative_path
  dists = lookup_distributions(base_path: path)

  task = api.delete_distribution(dists.first.pulp_href) if dists.first
  Katello::Pulp3::DistributionReference.where(:path => path).destroy_all
  task
end

#delete_remote(options = {}) ⇒ Object 



100
101
102
103
 
# File 'app/services/katello/pulp3/repository.rb', line 100

def delete_remote(options = {})
  options[:href] ||= repo.remote_href
  ignore_404_exception { remote_options[:url]&.start_with?('uln') ? api.remotes_uln_api.delete(options[:href]) : api.remotes_api.delete(options[:href]) } if options[:href]
end

#delete_repository(repo_reference = repository_reference) ⇒ Object 



190
191
192
193
194
 
# File 'app/services/katello/pulp3/repository.rb', line 190

def delete_repository(repo_reference = repository_reference)
  href = repo_reference.try(:repository_href)
  repo_reference.try(:destroy)
  ignore_404_exception { api.repositories_api.delete(href) } if href
end

#delete_version ⇒ Object 



329
330
331
 
# File 'app/services/katello/pulp3/repository.rb', line 329

def delete_version
  ignore_404_exception { api.repository_versions_api.delete(repo.version_href) } unless version_zero?
end

#distribution_needs_update? ⇒ Boolean

Returns:

  • (Boolean) 


148
149
150
151
152
153
154
155
156
157
158
 
# File 'app/services/katello/pulp3/repository.rb', line 148

def distribution_needs_update?
  if distribution_reference
    expected = secure_distribution_options(relative_path).except(:name).compact
    actual = get_distribution&.to_hash || {}
    expected != actual.slice(*expected.keys)
  elsif repo.environment
    true
  else
    false
  end
end

#distribution_reference ⇒ Object 



121
122
123
 
# File 'app/services/katello/pulp3/repository.rb', line 121

def distribution_reference
  DistributionReference.find_by(:repository_id => repo.id)
end

#fail_missing_publication(publication_href) ⇒ Object 



514
515
516
517
518
 
# File 'app/services/katello/pulp3/repository.rb', line 514

def fail_missing_publication(publication_href)
  unless lookup_publication(publication_href)
    fail _("The repository's publication is missing. Please run a 'complete sync' on %s." % repo.name)
  end
end

#generate_backend_object_name ⇒ Object 



113
114
115
 
# File 'app/services/katello/pulp3/repository.rb', line 113

def generate_backend_object_name
  "#{root.label}-#{repo.id}#{rand(9999)}"
end

#get_distribution(href = distribution_reference.href) ⇒ Object 



144
145
146
 
# File 'app/services/katello/pulp3/repository.rb', line 144

def get_distribution(href = distribution_reference.href)
  api.get_distribution(href)
end

#get_remote(href = repo.remote_href) ⇒ Object 



140
141
142
 
# File 'app/services/katello/pulp3/repository.rb', line 140

def get_remote(href = repo.remote_href)
  repo.url&.start_with?('uln') ? api.remotes_uln_api.read(href) : api.remotes_api.read(href)
end

#list(options) ⇒ Object 



182
183
184
 
# File 'app/services/katello/pulp3/repository.rb', line 182

def list(options)
  api.repositories_api.list(options).results
end

#lookup_distributions(args) ⇒ Object 



269
270
271
 
# File 'app/services/katello/pulp3/repository.rb', line 269

def lookup_distributions(args)
  api.distributions_api.list(args).results
end

#lookup_publication(href) ⇒ Object 



465
466
467
468
469
470
 
# File 'app/services/katello/pulp3/repository.rb', line 465

def lookup_publication(href)
  api.publications_api.read(href) if href
rescue api.api_exception_class => e
  Rails.logger.error "Exception when calling publications_api->read: #{e}"
  nil
end

#lookup_version(href) ⇒ Object 



458
459
460
461
462
463
 
# File 'app/services/katello/pulp3/repository.rb', line 458

def lookup_version(href)
  api.repository_versions_api.read(href) if href
rescue api.api_exception_class => e
  Rails.logger.error "Exception when calling repository_versions_api->read: #{e}"
  nil
end

#mirror_remote_options ⇒ Object 



393
394
395
396
397
398
399
400
401
402
 
# File 'app/services/katello/pulp3/repository.rb', line 393

def mirror_remote_options
  options = {}
  if Katello::RootRepository::CONTENT_ATTRIBUTE_RESTRICTIONS[:download_policy].include?(repo.content_type)
    options[:policy] = smart_proxy.download_policy
    if smart_proxy.download_policy == SmartProxy::DOWNLOAD_INHERIT
      options[:policy] = repo.root.download_policy
    end
  end
  options
end

#partial_repo_path ⇒ Object 



28
29
30
 
# File 'app/services/katello/pulp3/repository.rb', line 28

def partial_repo_path
  fail NotImplementedError
end

#publication_options(repository_version) ⇒ Object 



212
213
214
215
216
 
# File 'app/services/katello/pulp3/repository.rb', line 212

def publication_options(repository_version)
  {
    repository_version: repository_version
  }
end

#published? ⇒ Boolean

Returns:

  • (Boolean) 


53
54
55
 
# File 'app/services/katello/pulp3/repository.rb', line 53

def published?
  !repo.publication_href.nil?
end

#read ⇒ Object 



186
187
188
 
# File 'app/services/katello/pulp3/repository.rb', line 186

def read
  api.repositories_api.read(repository_reference.try(:repository_href))
end

#read_distribution(href = distribution_reference.href) ⇒ Object 



273
274
275
 
# File 'app/services/katello/pulp3/repository.rb', line 273

def read_distribution(href = distribution_reference.href)
  ignore_404_exception { api.distributions_api.read(href) }
end

#refresh_distributions ⇒ Object 



222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
 
# File 'app/services/katello/pulp3/repository.rb', line 222

def refresh_distributions
  if repo.docker?
    dist = lookup_distributions(base_path: repo.container_repository_name).first
  else
    dist = lookup_distributions(base_path: repo.relative_path).first
  end
  dist_ref = distribution_reference

  if dist && !dist_ref
    save_distribution_references([dist.pulp_href])
    return update_distribution
  end

  if dist && dist_ref
    # If the saved distribution reference is wrong, delete it and use the existing distribution
    if dist.pulp_href != dist_ref.href
      dist_ref.destroy
      save_distribution_references([dist.pulp_href])
    end
    return update_distribution
  end

  # Since we got this far, we need to create a new distribution
  # Note: the distribution reference can't be saved yet because distribution creation is async
  begin
    create_distribution(relative_path)
  rescue api.client_module::ApiError => e
    # Now it seems there is a distribution. Fetch it and save the reference.
    if e.message.include?("\"base_path\":[\"This field must be unique.\"]") ||
        e.message.include?("\"base_path\":[\"Overlaps with existing distribution\"")
      dist = lookup_distributions(base_path: repo.relative_path).first
      save_distribution_references([dist.pulp_href])
      return update_distribution
    else
      raise e
    end
  end
end

#refresh_if_needed ⇒ Object 



133
134
135
136
137
138
 
# File 'app/services/katello/pulp3/repository.rb', line 133

def refresh_if_needed
  tasks = []
  tasks << update_remote #always update remote
  tasks << update_distribution if distribution_needs_update?
  tasks.compact
end

#refresh_mirror_entities ⇒ Object 



129
130
131
 
# File 'app/services/katello/pulp3/repository.rb', line 129

def refresh_mirror_entities
  RepositoryMirror.new(self).refresh_entities
end

#relative_path ⇒ Object 



218
219
220
 
# File 'app/services/katello/pulp3/repository.rb', line 218

def relative_path
  repo.relative_path.sub(/^\//, '')
end

#remote_partial_update ⇒ Object 



92
93
94
95
96
97
98
 
# File 'app/services/katello/pulp3/repository.rb', line 92

def remote_partial_update
  if remote_options[:url]&.start_with?('uln')
    api.remotes_uln_api.partial_update(repo.remote_href, remote_options)
  else
    api.remotes_api.partial_update(repo.remote_href, remote_options)
  end
end

#remove_content(content_units) ⇒ Object 



472
473
474
475
476
477
478
 
# File 'app/services/katello/pulp3/repository.rb', line 472

def remove_content(content_units)
  if repo.root.content_type == "docker"
    api.repositories_api.remove(repository_reference.repository_href, content_units: content_units.map(&:pulp_id))
  else
    api.repositories_api.modify(repository_reference.repository_href, remove_content_units: content_units.map(&:pulp_id))
  end
end

#repair(repository_version_href) ⇒ Object 



57
58
59
60
 
# File 'app/services/katello/pulp3/repository.rb', line 57

def repair(repository_version_href)
  data = api.repair_class.new
  api.repository_versions_api.repair(repository_version_href, data)
end

#repository_import_content(artifact_href, options = {}) ⇒ Object 



480
481
482
483
484
485
486
 
# File 'app/services/katello/pulp3/repository.rb', line 480

def repository_import_content(artifact_href, options = {})
  ostree_import = PulpOstreeClient::OstreeRepoImport.new
  ostree_import.artifact = artifact_href
  ostree_import.repository_name = options[:ostree_repository_name]
  ostree_import.ref = options[:ostree_ref]
  api.repositories_api.import_commits(repository_reference.repository_href, ostree_import)
end

#repository_reference ⇒ Object 



117
118
119
 
# File 'app/services/katello/pulp3/repository.rb', line 117

def repository_reference
  RepositoryReference.find_by(:root_repository_id => repo.root_id, :content_view_id => repo.content_view.id)
end

#retain_package_versions_count ⇒ Object 



509
510
511
512
 
# File 'app/services/katello/pulp3/repository.rb', line 509

def retain_package_versions_count
  return 0 if root.retain_package_versions_count.nil? || root.using_mirrored_content?
  root.retain_package_versions_count.to_i
end

#save_distribution_references(hrefs) ⇒ Object 



337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
 
# File 'app/services/katello/pulp3/repository.rb', line 337

def save_distribution_references(hrefs)
  hrefs.each do |href|
    pulp3_distribution_data = api.get_distribution(href)
    path, content_guard_href = pulp3_distribution_data&.base_path, pulp3_distribution_data&.content_guard
    if distribution_reference
      found_distribution = read_distribution(distribution_reference.href)
      unless found_distribution
        distribution_reference.destroy
      end
    end
    unless distribution_reference
      # Ensure that duplicates won't be created in the case of a race condition
      DistributionReference.where(path: path, href: href, repository_id: repo.id, content_guard_href: content_guard_href).first_or_create!
    end
  end
end

#secure_distribution_options(path) ⇒ Object 



412
413
414
415
416
417
418
419
420
 
# File 'app/services/katello/pulp3/repository.rb', line 412

def secure_distribution_options(path)
  secured_distribution_options = {}
  if root.unprotected
    secured_distribution_options[:content_guard] = nil
  else
    secured_distribution_options[:content_guard] = ::Katello::Pulp3::ContentGuard.first.pulp_href
  end
  secured_distribution_options.merge!(distribution_options(path))
end

#should_purge_empty_contents? ⇒ Boolean

Returns:

  • (Boolean) 


109
110
111
 
# File 'app/services/katello/pulp3/repository.rb', line 109

def should_purge_empty_contents?
  false
end

#skip_types ⇒ Object 



62
63
64
 
# File 'app/services/katello/pulp3/repository.rb', line 62

def skip_types
  nil
end

#specific_create_options ⇒ Object 



408
409
410
 
# File 'app/services/katello/pulp3/repository.rb', line 408

def specific_create_options
  {}
end

#ssl_remote_options ⇒ Object 



422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
 
# File 'app/services/katello/pulp3/repository.rb', line 422

def ssl_remote_options
  options = {}
  if root.redhat? && root.cdn_configuration.redhat_cdn?
    options = {
      client_cert: root.product.certificate,
      client_key: root.product.key,
      ca_cert: Katello::Repository.feed_ca_cert(root.url)
    }
  elsif root.redhat? && root.cdn_configuration.custom_cdn?
    options = {
      ca_cert: root.cdn_configuration.ssl_ca
    }
  elsif root.redhat? && root.cdn_configuration.network_sync?
    options = {
      client_cert: root.cdn_configuration.ssl_cert,
      client_key: root.cdn_configuration.ssl_key,
      ca_cert: root.cdn_configuration.ssl_ca
    }
  elsif root.custom?
    options = {
      client_cert: root.ssl_client_cert&.content,
      client_key: root.ssl_client_key&.content,
      ca_cert: root.ssl_ca_cert&.content
    }
  end
  append_proxy_cacert(options) if options.key?(:cacert)
  options
end

#sync(options = {}) ⇒ Object 



196
197
198
199
 
# File 'app/services/katello/pulp3/repository.rb', line 196

def sync(options = {})
  repository_sync_url_data = api.repository_sync_url_class.new(sync_url_params(options))
  [api.repositories_api.sync(repository_reference.repository_href, repository_sync_url_data)]
end

#sync_url_params(_sync_options) ⇒ Object 



201
202
203
204
205
 
# File 'app/services/katello/pulp3/repository.rb', line 201

def sync_url_params(_sync_options)
  params = {remote: repo.remote_href, mirror: repo.root.mirroring_policy == Katello::RootRepository::MIRRORING_POLICY_CONTENT}
  params[:skip_types] = skip_types if (skip_types && repo.root.mirroring_policy != Katello::RootRepository::MIRRORING_POLICY_COMPLETE)
  params
end

#unit_keys(uploads) ⇒ Object 



503
504
505
506
507
 
# File 'app/services/katello/pulp3/repository.rb', line 503

def unit_keys(uploads)
  uploads.map do |upload|
    upload.except('id')
  end
end

#update ⇒ Object 



178
179
180
 
# File 'app/services/katello/pulp3/repository.rb', line 178

def update
  api.repositories_api.update(repository_reference.try(:repository_href), create_options)
end

#update_distribution ⇒ Object 



277
278
279
280
281
282
283
284
285
286
 
# File 'app/services/katello/pulp3/repository.rb', line 277

def update_distribution
  if distribution_reference
    options = secure_distribution_options(relative_path).except(:name)
    unless ::Katello::RepositoryTypeManager.find(repo.content_type).pulp3_skip_publication
      fail_missing_publication(options[:publication])
    end
    distribution_reference.update(:content_guard_href => options[:content_guard])
    api.distributions_api.partial_update(distribution_reference.href, options)
  end
end

#update_remote ⇒ Object 



75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
 
# File 'app/services/katello/pulp3/repository.rb', line 75

def update_remote
  href = repo.remote_href
  if remote_options[:url].blank?
    if href
      repo.update(remote_href: nil)
      delete_remote(href: href)
    end
  else
    if href
      remote_partial_update
    else
      create_remote
      return nil #return nil, as create isn't async
    end
  end
end

#version_zero? ⇒ Boolean

Returns:

  • (Boolean) 


325
326
327
 
# File 'app/services/katello/pulp3/repository.rb', line 325

def version_zero?
  repo.version_href.ends_with?('/versions/0/')
end

#with_mirror_adapter ⇒ Object 



32
33
34
35
36
37
38
 
# File 'app/services/katello/pulp3/repository.rb', line 32

def with_mirror_adapter
  if smart_proxy.pulp_primary?
    return self
  else
    return RepositoryMirror.new(self)
  end
end