Module: Glue::Pulp::Repo::InstanceMethods

Defined in:
app/models/katello/glue/pulp/repo.rb

Overview

rubocop:disable Metrics/ModuleLength

Instance Method Summary collapse

Instance Method Details

#capsule_download_policy ⇒ Object 



774
775
776
777
778
779
 
# File 'app/models/katello/glue/pulp/repo.rb', line 774

def capsule_download_policy
  if self.yum?
    repo = self.library_instance || self
    repo.download_policy
  end
end

#clear_contents ⇒ Object 



604
605
606
607
608
609
610
 
# File 'app/models/katello/glue/pulp/repo.rb', line 604

def clear_contents
  tasks = content_types.flat_map { |type| type.unassociate_from_repo(self.pulp_id, {}) }

  tasks << Katello.pulp_server.extensions.repository.unassociate_units(self.pulp_id,
             :type_ids => ['rpm'], :filters => {}, :fields => { :unit => Pulp::Rpm::PULP_SELECT_FIELDS})
  tasks
end

#clone_contents(to_repo) ⇒ Object 



569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
 
# File 'app/models/katello/glue/pulp/repo.rb', line 569

def clone_contents(to_repo)
  events = []

  if self.content_type == Repository::PUPPET_TYPE
    events << Katello.pulp_server.extensions.puppet_module.copy(self.pulp_id, to_repo.pulp_id)
  else
    # In order to reduce the memory usage of pulp during the copy process,
    # include the fields that will uniquely identify the rpm. If no fields
    # are listed, pulp will retrieve every field it knows about for the rpm
    # (e.g. changelog, filelist...etc).
    events << Katello.pulp_server.extensions.rpm.copy(self.pulp_id, to_repo.pulp_id,
                                              :fields => Pulp::Rpm::PULP_SELECT_FIELDS)

    # Since the rpms will be copied above, during the copy of errata and package groups,
    # include the copy_children flag to request that pulp skip copying them again.
    events << Katello.pulp_server.extensions.errata.copy(self.pulp_id, to_repo.pulp_id,  :copy_children => false)
    events << Katello.pulp_server.extensions.package_group.copy(self.pulp_id, to_repo.pulp_id,  :copy_children => false)
    events << clone_file_metadata(to_repo)
  end

  events
end

#clone_contents_by_filter(to_repo, content_type, filter_clauses, override_config = {}) ⇒ Object 



544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
 
# File 'app/models/katello/glue/pulp/repo.rb', line 544

def clone_contents_by_filter(to_repo, content_type, filter_clauses, override_config = {})
  content_classes = {
    Katello::Rpm::CONTENT_TYPE => :rpm,
    Katello::PackageGroup::CONTENT_TYPE => :package_group,
    Katello::Erratum::CONTENT_TYPE => :errata,
    Katello::PuppetModule::CONTENT_TYPE => :puppet_module
  }
  fail "Invalid content type #{content_type} sent. It needs to be one of #{content_classes.keys}"\
                                                                 unless content_classes[content_type]
  criteria = {}
  if content_type == Runcible::Extensions::Rpm.content_type
    criteria[:fields] = Pulp::Rpm::PULP_SELECT_FIELDS
  end

  if filter_clauses && !filter_clauses.empty?
    if content_type == Runcible::Extensions::PuppetModule.content_type
      criteria[:filters] = {:association => filter_clauses}
    else
      criteria[:filters] = {:unit => filter_clauses}
    end
  end
  criteria[:override_config] = override_config unless override_config.empty?
  Katello.pulp_server.extensions.send(content_classes[content_type]).copy(self.pulp_id, to_repo.pulp_id, criteria)
end

#clone_file_metadata(to_repo) ⇒ Object 



592
593
594
 
# File 'app/models/katello/glue/pulp/repo.rb', line 592

def clone_file_metadata(to_repo)
  Katello.pulp_server.extensions.yum_repo_metadata_file.copy(self.pulp_id, to_repo.pulp_id)
end

#content_types ⇒ Object 



612
613
614
615
616
617
 
# File 'app/models/katello/glue/pulp/repo.rb', line 612

def content_types
  [Katello.pulp_server.extensions.errata,
   Katello.pulp_server.extensions.package_group,
   Katello.pulp_server.extensions.puppet_module
  ]
end

#create_docker_tag(manifest, tag_name) ⇒ Object 



460
461
462
463
464
465
466
467
 
# File 'app/models/katello/glue/pulp/repo.rb', line 460

def create_docker_tag(manifest, tag_name)
  tag = unit_search(:type_ids => [Runcible::Extensions::DockerTag.content_type],
                    :filters => { :unit => { :manifest_digest => manifest.digest,
                                             :name => tag_name } }).first

  DockerTag.where(:repository_id => id, :docker_manifest_id => manifest.id,
                  :name => tag[:metadata][:name], :uuid => tag[:metadata][:_id]).first_or_create
end

#create_pulp_repo ⇒ Object 



100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
 
# File 'app/models/katello/glue/pulp/repo.rb', line 100

def create_pulp_repo
  #if we are in library, no need for an distributor, but need to sync
  if self.environment.try(:library?)
    importer = generate_importer
  else
    #if not in library, no need for sync info, but we need a distributor
    case self.content_type
    when Repository::YUM_TYPE
      importer = Runcible::Models::YumImporter.new
    when Repository::PUPPET_TYPE
      importer = Runcible::Models::PuppetImporter.new
    end
  end

  distributors = generate_distributors

  Katello.pulp_server.extensions.repository.create_with_importer_and_distributors(self.pulp_id,
                                                                                  importer,
                                                                                  distributors,
                                                                                  :display_name => self.name)
rescue RestClient::ServiceUnavailable => e
  message = _("Pulp service unavailable during creating repository '%s', please try again later.") % self.name
  raise PulpErrors::ServiceUnavailable.new(message, e)
end

#distributors_match?(capsule_distributors) ⇒ Boolean

Returns:

  • (Boolean) 


781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
 
# File 'app/models/katello/glue/pulp/repo.rb', line 781

def distributors_match?(capsule_distributors)
  generated_distributors = self.generate_distributors(true).map(&:as_json)
  capsule_distributors.each do |dist|
    dist.merge!(dist["config"])
    dist.delete("config")
  end

  config_check = generated_distributors.any? do |gen_dist|
    capsule_distributors.any? do |cap_dist|
      (gen_dist.to_a - cap_dist.to_a).empty?
    end
  end
  equal_amount_check = generated_distributors.count == capsule_distributors.count
  config_check && equal_amount_check
end

#docker? ⇒ Boolean

Returns:

  • (Boolean) 


754
755
756
 
# File 'app/models/katello/glue/pulp/repo.rb', line 754

def docker?
  self.content_type == Repository::DOCKER_TYPE
end

#docker_feed_url(capsule = false) ⇒ Object 



151
152
153
154
155
156
157
158
 
# File 'app/models/katello/glue/pulp/repo.rb', line 151

def docker_feed_url(capsule = false)
  pulp_uri = URI.parse(SETTINGS[:katello][:pulp][:url])
  if capsule
    "https://#{pulp_uri.host.downcase}:5000"
  else
    self.url if self.respond_to?(:url)
  end
end

#docker_manifests_json ⇒ Object 



452
453
454
455
456
457
458
 
# File 'app/models/katello/glue/pulp/repo.rb', line 452

def docker_manifests_json
  docker_manifests = []
  pulp_docker_manifest_ids.each_slice(SETTINGS[:katello][:pulp][:bulk_load_size]) do |sub_list|
    docker_manifests.concat(Katello.pulp_server.extensions.docker_manifest.find_all_by_unit_ids(sub_list))
  end
  docker_manifests
end

#errata_json ⇒ Object 



407
408
409
410
411
412
413
414
415
 
# File 'app/models/katello/glue/pulp/repo.rb', line 407

def errata_json
  tmp_errata = []
  #we fetch ids and then fetch errata by id, because repo errata
  #  do not contain all the info we need (bz 854260)
  self.pulp_errata_ids.each_slice(SETTINGS[:katello][:pulp][:bulk_load_size]) do |sub_list|
    tmp_errata.concat(Katello.pulp_server.extensions.errata.find_all_by_unit_ids(sub_list))
  end
  tmp_errata
end

#file? ⇒ Boolean

Returns:

  • (Boolean) 


762
763
764
 
# File 'app/models/katello/glue/pulp/repo.rb', line 762

def file?
  self.content_type == Repository::FILE_TYPE
end

#find_distributor(use_clone_distributor = false) ⇒ Object 



661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
 
# File 'app/models/katello/glue/pulp/repo.rb', line 661

def find_distributor(use_clone_distributor = false)
  dist_type_id = if use_clone_distributor
                   case self.content_type
                   when Repository::YUM_TYPE
                     Runcible::Models::YumCloneDistributor.type_id
                   when Repository::PUPPET_TYPE
                     Runcible::Models::PuppetInstallDistributor.type_id
                   end
                 else
                   case self.content_type
                   when Repository::YUM_TYPE
                     Runcible::Models::YumDistributor.type_id
                   when Repository::PUPPET_TYPE
                     Runcible::Models::PuppetInstallDistributor.type_id
                   end
                 end

  distributors.detect { |dist| dist["distributor_type_id"] == dist_type_id }
end

#find_node_distributor ⇒ Object 



681
682
683
 
# File 'app/models/katello/glue/pulp/repo.rb', line 681

def find_node_distributor
  self.distributors.detect { |i| i["distributor_type_id"] == Runcible::Models::NodesHttpDistributor.type_id }
end

#find_packages_by_name(name) ⇒ Object 



515
516
517
 
# File 'app/models/katello/glue/pulp/repo.rb', line 515

def find_packages_by_name(name)
  Katello.pulp_server.extensions.repository.rpms_by_nvre self.pulp_id, name
end

#find_packages_by_nvre(name, version, release, epoch) ⇒ Object 



519
520
521
 
# File 'app/models/katello/glue/pulp/repo.rb', line 519

def find_packages_by_nvre(name, version, release, epoch)
  Katello.pulp_server.extensions.repository.rpms_by_nvre self.pulp_id, name, version, release, epoch
end

#generate_applicability ⇒ Object 



293
294
295
296
 
# File 'app/models/katello/glue/pulp/repo.rb', line 293

def generate_applicability
  task = Katello.pulp_server.extensions.repository.regenerate_applicability_by_ids([self.pulp_id])
  PulpTaskStatus.using_pulp_task(task)
end

#generate_distributors(capsule = false) ⇒ Object 



206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
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
 
# File 'app/models/katello/glue/pulp/repo.rb', line 206

def generate_distributors(capsule = false)
  case self.content_type
  when Repository::YUM_TYPE
    yum_dist_id = self.pulp_id
    yum_dist_options = {:protected => true, :id => yum_dist_id, :auto_publish => true}
    #check the instance variable, as we do not want to go to pulp
    yum_dist_options['checksum_type'] = self.checksum_type
    yum_dist = Runcible::Models::YumDistributor.new(self.relative_path, (self.unprotected), true,
                                                    yum_dist_options)
    clone_dist = Runcible::Models::YumCloneDistributor.new(:id => "#{self.pulp_id}_clone",
                                                           :destination_distributor_id => yum_dist_id)
    export_dist = Runcible::Models::ExportDistributor.new(false, false, self.relative_path)
    distributors = [yum_dist, export_dist]
    distributors << clone_dist unless capsule
  when Repository::FILE_TYPE
    dist = Runcible::Models::IsoDistributor.new(true, true)
    dist.auto_publish = true
    distributors = [dist]
  when Repository::PUPPET_TYPE
    dist_options = { :id => self.pulp_id, :auto_publish => true }
    repo_path =  File.join(SETTINGS[:katello][:puppet_repo_root],
                           Environment.construct_name(self.organization,
                                                      self.environment,
                                                      self.content_view),
                           'modules')
    puppet_install_dist = Runcible::Models::PuppetInstallDistributor.new(repo_path, dist_options)

    dist_options[:id] = "#{self.pulp_id}_puppet"
    puppet_dist = Runcible::Models::PuppetDistributor.new(nil, (self.unprotected || false),
                                                          true, dist_options)

    distributors = [puppet_dist, puppet_install_dist]
  when Repository::DOCKER_TYPE
    options = { :protected => !self.unprotected, :id => self.pulp_id, :auto_publish => true }
    docker_dist = Runcible::Models::DockerDistributor.new(options)
    distributors = [docker_dist]
  when Repository::OSTREE_TYPE
    options = { :id => self.pulp_id,
                :auto_publish => true,
                :relative_path => relative_path }
    dist = Runcible::Models::OstreeDistributor.new(options)
    distributors = [dist]
  else
    fail _("Unexpected repo type %s") % self.content_type
  end

  distributors
end

#generate_importer(capsule = false) ⇒ Object 



125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
 
# File 'app/models/katello/glue/pulp/repo.rb', line 125

def generate_importer(capsule = false)
  case self.content_type
  when Repository::YUM_TYPE
    Runcible::Models::YumImporter.new(yum_importer_values(capsule))
  when Repository::FILE_TYPE
    Runcible::Models::IsoImporter.new(importer_ssl_options(capsule).merge(:feed => importer_feed_url(capsule)))
  when Repository::PUPPET_TYPE
    options = {}
    options[:feed] = importer_feed_url(capsule)
    Runcible::Models::PuppetImporter.new(options)
  when Repository::DOCKER_TYPE
    options = {}
    options[:upstream_name] = capsule ? self.pulp_id : self.docker_upstream_name
    options[:feed] = docker_feed_url(capsule)
    options[:enable_v1] = false if self.respond_to?(:enable_v1)
    Runcible::Models::DockerImporter.new(options)
  when Repository::OSTREE_TYPE
    options = importer_ssl_options(capsule)

    options[:feed] = self.url if self.respond_to?(:url)
    Runcible::Models::OstreeImporter.new(options)
  else
    fail _("Unexpected repo type %s") % self.content_type
  end
end

#importer_feed_url(capsule = false) ⇒ Object 



160
161
162
163
164
165
166
 
# File 'app/models/katello/glue/pulp/repo.rb', line 160

def importer_feed_url(capsule = false)
  if capsule
    self.full_path(nil, true)
  else
    self.url if self.respond_to?(:url)
  end
end

#importer_matches?(capsule_importer) ⇒ Boolean

Returns:

  • (Boolean) 


797
798
799
800
 
# File 'app/models/katello/glue/pulp/repo.rb', line 797

def importer_matches?(capsule_importer)
  generated_importer = self.generate_importer(true).as_json
  (generated_importer.to_a - capsule_importer.to_a).empty?
end

#importer_ssl_options(capsule = nil) ⇒ Object 



183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
 
# File 'app/models/katello/glue/pulp/repo.rb', line 183

def importer_ssl_options(capsule = nil)
  if capsule
    ueber_cert = ::Cert::Certs.ueber_cert(organization)
    {
      :ssl_client_cert => ueber_cert[:cert],
      :ssl_client_key => ueber_cert[:key],
      :ssl_ca_cert => ::Cert::Certs.ca_cert
    }
  elsif redhat? && self.content_view.default?
    {
      :ssl_client_cert => self.product.certificate,
      :ssl_client_key => self.product.key,
      :ssl_ca_cert => Resources::CDN::CdnResource.ca_file_contents
    }
  else
    {
      :ssl_client_cert => nil,
      :ssl_client_key => nil,
      :ssl_ca_cert => nil
    }
  end
end

#importer_type ⇒ Object 



255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
 
# File 'app/models/katello/glue/pulp/repo.rb', line 255

def importer_type
  case self.content_type
  when Repository::YUM_TYPE
    Runcible::Models::YumImporter::ID
  when Repository::FILE_TYPE
    Runcible::Models::IsoImporter::ID
  when Repository::PUPPET_TYPE
    Runcible::Models::PuppetImporter::ID
  when Repository::DOCKER_TYPE
    Runcible::Models::DockerImporter::ID
  when Repository::OSTREE_TYPE
    Runcible::Models::OstreeImporter::ID
  else
    fail _("Unexpected repo type %s") % self.content_type
  end
end

#index_db_docker_manifests ⇒ Object 



443
444
445
446
447
448
449
450
 
# File 'app/models/katello/glue/pulp/repo.rb', line 443

def index_db_docker_manifests
  docker_manifests_json.each do |manifest_json|
    manifest = DockerManifest.where(:uuid => manifest_json[:_id]).first_or_create
    manifest.update_from_json(manifest_json)
    create_docker_tag(manifest, manifest_json[:tag])
  end
  DockerManifest.sync_repository_associations(self, pulp_docker_manifest_ids)
end

#index_db_errata(force = false) ⇒ Object 



353
354
355
356
357
358
359
360
361
362
363
364
365
366
 
# File 'app/models/katello/glue/pulp/repo.rb', line 353

def index_db_errata(force = false)
  if self.content_view.default? || force
    errata_json.each do |erratum_json|
      begin
        erratum = Erratum.where(:uuid => erratum_json['_id']).first_or_create
      rescue ActiveRecord::RecordNotUnique
        retry
      end
      erratum.update_from_json(erratum_json)
    end
  end

  Katello::Erratum.sync_repository_associations(self, pulp_errata_ids)
end

#index_db_ostree_branches ⇒ Object 



491
492
493
494
495
496
497
 
# File 'app/models/katello/glue/pulp/repo.rb', line 491

def index_db_ostree_branches
  ostree_branches_json.each do |ostree_branch_json|
    branch = OstreeBranch.where(:uuid => ostree_branch_json[:_id]).first_or_create
    branch.update_from_json(ostree_branch_json)
  end
  OstreeBranch.sync_repository_associations(self, pulp_ostree_branch_ids)
end

#index_db_package_groups ⇒ Object 



417
418
419
420
421
422
423
424
425
426
427
428
 
# File 'app/models/katello/glue/pulp/repo.rb', line 417

def index_db_package_groups
  package_group_json.each do |pg_json|
    begin
      package_group = Katello::PackageGroup.where(:uuid => pg_json['_id']).first_or_create
    rescue ActiveRecord::RecordNotUnique
      retry
    end
    package_group.update_from_json(pg_json)
  end
  pg_ids = package_group_json.map { |pg| pg['_id'] }
  Katello::PackageGroup.sync_repository_associations(self, pg_ids)
end

#index_db_puppet_modules(force = false) ⇒ Object 



382
383
384
385
386
387
388
389
390
391
392
393
394
395
 
# File 'app/models/katello/glue/pulp/repo.rb', line 382

def index_db_puppet_modules(force = false)
  if self.content_view.default? || force
    puppet_modules_json.each do |puppet_module_json|
      begin
        puppet_module = Katello::PuppetModule.where(:uuid => puppet_module_json['_id']).first_or_create
      rescue ActiveRecord::RecordNotUnique
        retry
      end
      puppet_module.update_from_json(puppet_module_json)
    end
  end

  Katello::PuppetModule.sync_repository_associations(self, pulp_puppet_module_ids)
end

#index_db_rpms(force = false) ⇒ Object 



368
369
370
371
372
373
374
375
376
377
378
379
380
 
# File 'app/models/katello/glue/pulp/repo.rb', line 368

def index_db_rpms(force = false)
  if self.content_view.default? || force
    rpms_json.each do |rpm_json|
      begin
        rpm = Rpm.where(:uuid => rpm_json['_id']).first_or_create
      rescue ActiveRecord::RecordNotUnique
        retry
      end
      rpm.update_from_json(rpm_json)
    end
  end
  Katello::Rpm.sync_repository_associations(self, pulp_rpm_ids)
end

#initialize(attrs = nil, options = {}) ⇒ Object 



71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
 
# File 'app/models/katello/glue/pulp/repo.rb', line 71

def initialize(attrs = nil, options = {})
  if attrs.nil?
    super
  else
    #rename "type" to "cp_type" (activerecord and candlepin variable name conflict)
    #if attrs.has_key?(type_key) && !(attrs.has_key?(:cp_type) || attrs.has_key?('cp_type'))
    #  attrs[:cp_type] = attrs[type_key]
    #end

    attrs_used_by_model = attrs.reject do |k, _v|
      !self.class.column_defaults.keys.member?(k.to_s) && (!respond_to?(:"#{k.to_s}=") rescue true)
    end
    super(attrs_used_by_model, options)
  end
end

#last_sync ⇒ Object

TODO: This module is too long. See projects.theforeman.org/issues/12584.



66
67
68
69
 
# File 'app/models/katello/glue/pulp/repo.rb', line 66

def last_sync
  last = self.latest_dynflow_sync
  last.nil? ? nil : last.to_s
end

#ostree? ⇒ Boolean

Returns:

  • (Boolean) 


770
771
772
 
# File 'app/models/katello/glue/pulp/repo.rb', line 770

def ostree?
  self.content_type == Repository::OSTREE_TYPE
end

#ostree_branches_json ⇒ Object 



499
500
501
502
503
504
505
 
# File 'app/models/katello/glue/pulp/repo.rb', line 499

def ostree_branches_json
  ostree_branches = []
  pulp_ostree_branch_ids.each_slice(SETTINGS[:katello][:pulp][:bulk_load_size]) do |sub_list|
    ostree_branches.concat(Katello.pulp_server.extensions.ostree_branch.find_all_by_unit_ids(sub_list))
  end
  ostree_branches
end

#other_repos_with_same_content ⇒ Object 



302
303
304
 
# File 'app/models/katello/glue/pulp/repo.rb', line 302

def other_repos_with_same_content
  Repository.where(:content_id => self.content_id).pluck(:pulp_id) - [self.pulp_id]
end

#other_repos_with_same_product_and_content ⇒ Object 



298
299
300
 
# File 'app/models/katello/glue/pulp/repo.rb', line 298

def other_repos_with_same_product_and_content
  Repository.where(:content_id => self.content_id).in_product(self.product).pluck(:pulp_id) - [self.pulp_id]
end

#package_group_categories(search_args = {}) ⇒ Object 



469
470
471
472
473
474
475
476
477
 
# File 'app/models/katello/glue/pulp/repo.rb', line 469

def package_group_categories(search_args = {})
  categories = Katello.pulp_server.extensions.repository.package_categories(self.pulp_id)
  unless search_args.empty?
    categories.delete_if do |category_attrs|
      search_args.any? { |attr, value| category_attrs[attr] != value }
    end
  end
  categories
end

#package_group_count ⇒ Object 



314
315
316
317
318
319
320
 
# File 'app/models/katello/glue/pulp/repo.rb', line 314

def package_group_count
  content_unit_counts = 0
  if self.pulp_repo_facts
    content_unit_counts = self.pulp_repo_facts[:content_unit_counts][:package_group]
  end
  content_unit_counts
end

#package_group_json ⇒ Object 



430
431
432
 
# File 'app/models/katello/glue/pulp/repo.rb', line 430

def package_group_json
  Katello.pulp_server.extensions.repository.package_groups(self.pulp_id)
end

#package_lists_for_publish ⇒ Object

A helper method used by purge_empty_groups_errata to obtain a list of package filenames and names so that it could mix/match empty package groups and errata and purge them.



737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
 
# File 'app/models/katello/glue/pulp/repo.rb', line 737

def package_lists_for_publish
  names = []
  filenames = []
  rpm_list = []
  self.pulp_rpm_ids.each_slice(SETTINGS[:katello][:pulp][:bulk_load_size]) do |sub_list|
    rpm_list.concat(Katello.pulp_server.extensions.rpm.find_all_by_unit_ids(
                            sub_list, %w(filename name), :include_repos => false))
  end

  rpm_list.each do |rpm|
    filenames << rpm["filename"]
    names << rpm["name"]
  end
  {:names => names.to_set,
   :filenames => filenames.to_set}
end

#populate_from(repos_map) ⇒ Object 



287
288
289
290
291
 
# File 'app/models/katello/glue/pulp/repo.rb', line 287

def populate_from(repos_map)
  found = repos_map[self.pulp_id]
  prepopulate(found) if found
  !found.nil?
end

#pulp_checksum_type ⇒ Object 



96
97
98
 
# File 'app/models/katello/glue/pulp/repo.rb', line 96

def pulp_checksum_type
  find_distributor['config']['checksum_type'] if self.try(:yum?) && find_distributor
end

#pulp_docker_manifest_ids ⇒ Object 



483
484
485
 
# File 'app/models/katello/glue/pulp/repo.rb', line 483

def pulp_docker_manifest_ids
  Katello.pulp_server.extensions.repository.docker_manifest_ids(self.pulp_id)
end

#pulp_errata_ids ⇒ Object 



310
311
312
 
# File 'app/models/katello/glue/pulp/repo.rb', line 310

def pulp_errata_ids
  Katello.pulp_server.extensions.repository.errata_ids(self.pulp_id)
end

#pulp_ostree_branch_ids ⇒ Object 



487
488
489
 
# File 'app/models/katello/glue/pulp/repo.rb', line 487

def pulp_ostree_branch_ids
  Katello.pulp_server.extensions.repository.ostree_branch_ids(self.pulp_id)
end

#pulp_puppet_module_ids ⇒ Object 



479
480
481
 
# File 'app/models/katello/glue/pulp/repo.rb', line 479

def pulp_puppet_module_ids
  Katello.pulp_server.extensions.repository.puppet_module_ids(self.pulp_id)
end

#pulp_rpm_ids ⇒ Object 



306
307
308
 
# File 'app/models/katello/glue/pulp/repo.rb', line 306

def pulp_rpm_ids
  Katello.pulp_server.extensions.repository.rpm_ids(self.pulp_id)
end

#pulp_update_needed? ⇒ Boolean

Returns:

  • (Boolean) 


523
524
525
526
527
 
# File 'app/models/katello/glue/pulp/repo.rb', line 523

def pulp_update_needed?
  changeable_attributes = %w(url unprotected checksum_type docker_upstream_name download_policy mirror_on_sync)
  changeable_attributes << "name" if docker?
  changeable_attributes.any? { |key| previous_changes.key?(key) }
end

#puppet? ⇒ Boolean

Returns:

  • (Boolean) 


758
759
760
 
# File 'app/models/katello/glue/pulp/repo.rb', line 758

def puppet?
  self.content_type == Repository::PUPPET_TYPE
end

#puppet_modules_json ⇒ Object 



397
398
399
400
401
402
403
404
405
 
# File 'app/models/katello/glue/pulp/repo.rb', line 397

def puppet_modules_json
  tmp_puppet_modules = []
  #we fetch ids and then fetch errata by id, because repo errata
  #  do not contain all the info we need (bz 854260)
  self.pulp_puppet_module_ids.each_slice(SETTINGS[:katello][:pulp][:bulk_load_size]) do |sub_list|
    tmp_puppet_modules.concat(Katello.pulp_server.extensions.puppet_module.find_all_by_unit_ids(sub_list))
  end
  tmp_puppet_modules
end

#purge_empty_groups_errata ⇒ Object

remove errata and groups from this repo that have no packages



324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
 
# File 'app/models/katello/glue/pulp/repo.rb', line 324

def purge_empty_groups_errata
  package_lists = package_lists_for_publish
  rpm_names = package_lists[:names]
  filenames = package_lists[:filenames]

  # Remove all errata with no packages
  errata_to_delete = errata.collect do |erratum|
    erratum.errata_id if filenames.intersection(erratum.package_filenames).empty?
  end
  errata_to_delete.compact!

  #do the errata remove call
  unless errata_to_delete.empty?
    unassociate_by_filter(ContentViewErratumFilter::CONTENT_TYPE,
                           "id" => { "$in" => errata_to_delete })
  end

  # Remove all  package groups with no packages
  package_groups_to_delete = package_groups.collect do |group|
    group.package_group_id if rpm_names.intersection(group.package_names).empty?
  end
  package_groups_to_delete.compact!

  unless package_groups_to_delete.empty?
    unassociate_by_filter(ContentViewPackageGroupFilter::CONTENT_TYPE,
                           "id" => { "$in" => package_groups_to_delete })
  end
end

#refresh_pulp_repo ⇒ Object 



272
273
274
275
276
277
278
279
280
281
282
283
284
285
 
# File 'app/models/katello/glue/pulp/repo.rb', line 272

def refresh_pulp_repo
  Katello.pulp_server.extensions.repository.update_importer(self.pulp_id, self.importers.first['id'], generate_importer.config)

  existing_distributors = self.distributors
  generate_distributors.each do |distributor|
    found = existing_distributors.find { |i| i['distributor_type_id'] == distributor.type_id }
    if found
      Katello.pulp_server.extensions.repository.update_distributor(self.pulp_id, found['id'], distributor.config)
    else
      Katello.pulp_server.extensions.repository.associate_distributor(self.pulp_id, distributor.type_id, distributor.config,
                                                             :distributor_id => distributor.id)
    end
  end
end

#rpms_json ⇒ Object 



434
435
436
437
438
439
440
441
 
# File 'app/models/katello/glue/pulp/repo.rb', line 434

def rpms_json
  tmp_packages = []
  self.pulp_rpm_ids.each_slice(SETTINGS[:katello][:pulp][:bulk_load_size]) do |sub_list|
    tmp_packages.concat(Katello.pulp_server.extensions.rpm.find_all_by_unit_ids(
                            sub_list, ::Katello::Pulp::Rpm::PULP_INDEXED_FIELDS))
  end
  tmp_packages
end

#sort_sync_status(statuses) ⇒ Object 



685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
 
# File 'app/models/katello/glue/pulp/repo.rb', line 685

def sort_sync_status(statuses)
  statuses.sort! do |a, b|
    if a['finish_time'].nil? && b['finish_time'].nil?
      if a['start_time'].nil?
        1
      elsif b['start_time'].nil?
        -1
      else
        a['start_time'] <=> b['start_time']
      end
    elsif a['finish_time'].nil?
      if a['start_time'].nil?
        1
      else
        -1
      end
    elsif b['finish_time'].nil?
      if b['start_time'].nil?
        -1
      else
        1
      end
    else
      b['finish_time'] <=> a['finish_time']
    end
  end
  return statuses
end

#successful_sync?(sync_history_item) ⇒ Boolean

Returns:

  • (Boolean) 


657
658
659
 
# File 'app/models/katello/glue/pulp/repo.rb', line 657

def successful_sync?(sync_history_item)
  sync_history_item['state'] == PulpTaskStatus::Status::FINISHED.to_s
end

#sync(options = {}) ⇒ Object 



529
530
531
532
533
534
535
536
537
538
539
540
541
542
 
# File 'app/models/katello/glue/pulp/repo.rb', line 529

def sync(options = {})
  sync_options = {}
  sync_options[:max_speed] ||= SETTINGS[:katello][:pulp][:sync_KBlimit] if SETTINGS[:katello][:pulp][:sync_KBlimit] # set bandwidth limit
  sync_options[:num_threads] ||= SETTINGS[:katello][:pulp][:sync_threads] if SETTINGS[:katello][:pulp][:sync_threads] # set threads per sync
  pulp_tasks = Katello.pulp_server.extensions.repository.sync(self.pulp_id, :override_config => sync_options)

  task = PulpSyncStatus.using_pulp_task(pulp_tasks) do |t|
    t.organization = organization
    t.parameters ||= {}
    t.parameters[:options] = options
  end
  task.save!
  return [task]
end

#sync_finish ⇒ Object 



631
632
633
634
635
636
637
638
639
640
 
# File 'app/models/katello/glue/pulp/repo.rb', line 631

def sync_finish
  status = self.sync_status
  retval = nil
  if status.nil? || status['progress']['finish_time'].nil?
    retval = nil
  else
    retval = status['progress']['finish_time']
  end
  retval
end

#sync_schedule(date_and_time) ⇒ Object 



507
508
509
510
511
512
513
 
# File 'app/models/katello/glue/pulp/repo.rb', line 507

def sync_schedule(date_and_time)
  if date_and_time
    Katello.pulp_server.extensions.repository.create_or_update_schedule(self.pulp_id, importer_type, date_and_time)
  else
    Katello.pulp_server.extensions.repository.remove_schedules(self.pulp_id, importer_type)
  end
end

#sync_start ⇒ Object 



619
620
621
622
623
624
625
626
627
628
629
 
# File 'app/models/katello/glue/pulp/repo.rb', line 619

def sync_start
  status = self.sync_status
  retval = nil
  if status.nil? || status['progress']['start_time'].nil?
    retval = nil
  else
    retval = status['progress']['start_time']
    # retval = date.strftime("%H:%M:%S %Y-%m-%d")
  end
  retval
end

#sync_state ⇒ Object 



646
647
648
649
650
 
# File 'app/models/katello/glue/pulp/repo.rb', line 646

def sync_state
  status = sync_status
  return PulpSyncStatus::Status::NOT_SYNCED if status.nil?
  status.state
end

#sync_status ⇒ Object 



642
643
644
 
# File 'app/models/katello/glue/pulp/repo.rb', line 642

def sync_status
  self._get_most_recent_sync_status if @sync_status.nil?
end

#synced? ⇒ Boolean

Returns:

  • (Boolean) 


652
653
654
655
 
# File 'app/models/katello/glue/pulp/repo.rb', line 652

def synced?
  sync_history = self.sync_status
  !sync_history.nil? && successful_sync?(sync_history)
end

#to_hash ⇒ Object 



92
93
94
 
# File 'app/models/katello/glue/pulp/repo.rb', line 92

def to_hash
  pulp_repo_facts.merge(as_json).merge(:sync_state => sync_state)
end

#unassociate_by_filter(content_type, filter_clauses) ⇒ Object 



596
597
598
599
600
601
602
 
# File 'app/models/katello/glue/pulp/repo.rb', line 596

def unassociate_by_filter(content_type, filter_clauses)
  criteria = {:type_ids => [content_type], :filters => {:unit => filter_clauses}}
  if content_type == Katello.pulp_server.extensions.rpm.content_type
    criteria[:fields] = { :unit => Pulp::Rpm::PULP_SELECT_FIELDS}
  end
  Katello.pulp_server.extensions.repository.unassociate_units(self.pulp_id, criteria)
end

#unit_search(options = {}) ⇒ Object 



729
730
731
 
# File 'app/models/katello/glue/pulp/repo.rb', line 729

def unit_search(options = {})
  Katello.pulp_server.extensions.repository.unit_search(self.pulp_id, options)
end

#unit_type_id ⇒ Object 



714
715
716
717
718
719
720
721
722
723
724
725
726
727
 
# File 'app/models/katello/glue/pulp/repo.rb', line 714

def unit_type_id
  case content_type
  when Repository::YUM_TYPE
    "rpm"
  when Repository::PUPPET_TYPE
    "puppet_module"
  when Repository::DOCKER_TYPE
    "docker_manifest"
  when Repository::OSTREE_TYPE
    "ostree"
  when Repository::FILE_TYPE
    "iso"
  end
end

#uri ⇒ Object 



87
88
89
90
 
# File 'app/models/katello/glue/pulp/repo.rb', line 87

def uri
  uri = URI.parse(SETTINGS[:katello][:pulp][:url])
  "https://#{uri.host}/pulp/repos/#{relative_path}"
end

#yum? ⇒ Boolean

Returns:

  • (Boolean) 


766
767
768
 
# File 'app/models/katello/glue/pulp/repo.rb', line 766

def yum?
  self.content_type == Repository::YUM_TYPE
end

#yum_importer_values(capsule) ⇒ Object 



168
169
170
171
172
173
174
175
176
177
178
179
180
181
 
# File 'app/models/katello/glue/pulp/repo.rb', line 168

def yum_importer_values(capsule)
  if capsule && self.library_instance
    new_download_policy = self.library_instance.download_policy
  else
    new_download_policy = self.download_policy
  end

  config = {
    :feed => self.importer_feed_url(capsule),
    :download_policy => new_download_policy,
    :remove_missing => capsule ? true : self.mirror_on_sync?
  }
  config.merge(importer_ssl_options(capsule))
end