katello 4.5.0 → 4.6.0.rc1

data/app/services/katello/pulp3/content_view_version/export.rb

@@ -3,16 +3,31 @@ module Katello
     module ContentViewVersion
       class Export
         include ImportExportCommon
-        attr_reader :smart_proxy, :content_view_version, :destination_server, :from_content_view_version
+        SYNCABLE = "syncable".freeze
+        IMPORTABLE = "importable".freeze
+        FORMATS = [SYNCABLE, IMPORTABLE].freeze
+
+        attr_reader :smart_proxy, :content_view_version, :destination_server, :from_content_view_version, :repository, :base_path
+        def self.create(options)
+          if options.delete(:format) == SYNCABLE
+            SyncableFormatExport.new(options)
+          else
+            self.new(options)
+          end
+        end
 
         def initialize(smart_proxy:,
                         content_view_version: nil,
                         destination_server: nil,
-                        from_content_view_version: nil)
+                        from_content_view_version: nil,
+                        repository: nil,
+                        base_path: nil)
           @smart_proxy = smart_proxy
           @content_view_version = content_view_version
           @destination_server = destination_server
           @from_content_view_version = from_content_view_version
+          @repository = repository
+          @base_path = base_path
         end
 
         def repository_hrefs
@@ -37,21 +52,27 @@ module Katello
         end
 
         def generate_exporter_path
-          export_path = "#{content_view_version.content_view}/#{content_view_version.version}/#{destination_server}/#{date_dir}".gsub(/\s/, '_')
-          "#{content_view_version.organization.label}/#{export_path}"
+          return base_path if base_path
+          export_path = "#{content_view_version.content_view}/#{content_view_version.version}/"
+          export_path += "#{destination_server}/" unless destination_server.blank?
+          export_path += "#{date_dir}".gsub(/\s/, '_')
+          @base_path = "#{Setting['pulpcore_export_destination']}/#{content_view_version.organization.label}/#{export_path}"
         end
 
         def date_dir
           DateTime.now.to_s.gsub(/\W/, '-')
         end
 
-        def create_exporter(export_base_dir: Setting['pulpcore_export_destination'])
-          api.exporter_api.create(name: generate_id(content_view_version),
-                                  path: "#{export_base_dir}/#{generate_exporter_path}",
-                                  repositories: repository_hrefs)
+        def create_exporter
+          exporter_api = api.exporter_api
+          options = { name: generate_id(content_view_version), path: generate_exporter_path }
+          options[:repositories] = repository_hrefs
+
+          exporter_api.create(options)
         end
 
-        def create_export(exporter_href, chunk_size: nil)
+        def create_export(exporter_data, chunk_size: nil)
+          exporter_href = exporter_data[:pulp_href]
           options = { versions: version_hrefs }
           options[:chunk_size] = "#{chunk_size}GB" if chunk_size
           if from_content_view_version
@@ -77,14 +98,16 @@ module Katello
             options[:start_versions] = start_versions
             options[:full] = 'false'
           end
-          [api.export_api.create(exporter_href, options)]
+          export_api = api.export_api
+          [export_api.create(exporter_href, options)]
         end
 
         def fetch_export(exporter_href)
           api.export_api.list(exporter_href).results.first
         end
 
-        def destroy_exporter(exporter_href)
+        def destroy_exporter(exporter_data)
+          exporter_href = exporter_data[:pulp_href]
           export_data = fetch_export(exporter_href)
           api.exporter_api.partial_update(exporter_href, :last_export => nil)
           api.export_api.delete(export_data.pulp_href) unless export_data.blank?
@@ -162,6 +185,10 @@ module Katello
                                        generated_for: generated_for).send(select_method)
         end
 
+        def format
+          is_a?(SyncableFormatExport) ? SYNCABLE : IMPORTABLE
+        end
+
         def self.find_library_export_view(create_by_default: false,
                                           destination_server:,
                                           organization:)

data/app/services/katello/pulp3/content_view_version/metadata_generator.rb

@@ -16,10 +16,12 @@ module Katello
 
         def generate!
           ret = { organization: organization.name,
+                  base_path: Setting['pulpcore_export_destination'],
                   repositories: {},
                   content_view: content_view.slice(:name, :label, :description, :generated_for),
                   content_view_version: content_view_version.slice(:major, :minor, :description),
-                  incremental: from_content_view_version.present?
+                  incremental: from_content_view_version.present?,
+                  format: export_service.format
           }
 
           unless from_content_view_version.blank?

data/app/services/katello/pulp3/content_view_version/syncable_format_export.rb

@@ -0,0 +1,34 @@
+module Katello
+  module Pulp3
+    module ContentViewVersion
+      class SyncableFormatExport < Export
+        def create_exporter
+          api.yum_exporter_api.create(name: "#{generate_id(content_view_version)}-#{repository.id}",
+                                      path: generate_repository_exporter_path,
+                                      method: :hardlink)
+        end
+
+        def create_export(exporter_data, _options = {})
+          [api.yum_export_api.create(exporter_data[:pulp_href], publication: repository.publication_href)]
+        end
+
+        def fetch_export(exporter_href)
+          api.yum_export_api.list(exporter_href).results.first
+        end
+
+        def destroy_exporter(exporter_data)
+          exporter_href = exporter_data[:pulp_href]
+          export_data = fetch_export(exporter_href)
+          api.yum_export_api.delete(export_data.pulp_href)
+          api.yum_exporter_api.delete(exporter_href)
+        end
+
+        def generate_repository_exporter_path
+          _org, _content, content_path = repository.library_instance_or_self.relative_path.split("/", 3)
+          content_path = content_path.sub(%r|^/|, '')
+          "#{generate_exporter_path}/#{content_path}".gsub(/\s/, '_')
+        end
+      end
+    end
+  end
+end

data/app/services/katello/pulp3/deb.rb

@@ -9,6 +9,7 @@ module Katello
       end
 
       def self.content_api_create(opts = {})
+        opts.delete(:relative_path) if opts.key?(:relative_path)
         self.content_api.create(opts)
       end
 
@@ -24,7 +25,8 @@ module Katello
       end
 
       def self.generate_model_row(unit)
-        {
+        unit = unit.try(:with_indifferent_access)
+        return {
           pulp_id: unit[unit_identifier],
           checksum: unit[:sha256],
           filename: unit[:relative_path],

data/app/services/katello/pulp3/pulp_content_unit.rb

@@ -146,6 +146,8 @@ module Katello
         elsif repository.generic?
           duplicate_sha_path_content_list = content_backend_service.content_api(repository.repository_type, unit_type_id).list(
             filter_label => checksum)
+        elsif unit_type_id == 'deb'
+          duplicate_sha_path_content_list = content_backend_service.content_api.list(filter_label => checksum)
         else
           duplicate_sha_path_content_list = content_backend_service.content_api.list(
             filter_label => checksum,

data/app/services/katello/pulp3/repository/apt.rb

@@ -4,6 +4,7 @@ module Katello
   module Pulp3
     class Repository
       class Apt < ::Katello::Pulp3::Repository
+        UNIT_LIMIT = 10_000
         SIGNING_SERVICE_NAME = 'katello_deb_sign'.freeze
 
         def remote_options
@@ -66,8 +67,191 @@ module Katello
           "/pulp/deb/#{repo.relative_path}/".sub('//', '/')
         end
 
-        def copy_content_for_source(source_repository, _options = {})
-          copy_units_by_href(source_repository.debs.pluck(:pulp_id))
+        def multi_copy_units(repo_id_map, dependency_solving)
+          tasks = []
+
+          if repo_id_map.values.pluck(:content_unit_hrefs).flatten.any?
+            data = PulpDebClient::Copy.new
+            data.dependency_solving = dependency_solving
+            data.config = []
+            repo_id_map.each do |source_repo_ids, dest_repo_id_map|
+              dest_repo = ::Katello::Repository.find(dest_repo_id_map[:dest_repo])
+              dest_repo_href = ::Katello::Pulp3::Repository::Apt.new(dest_repo, SmartProxy.pulp_primary).repository_reference.repository_href
+              content_unit_hrefs = dest_repo_id_map[:content_unit_hrefs]
+              # Not needed during incremental update due to dest_base_version
+              source_repo_ids.each do |source_repo_id|
+                source_repo_version = ::Katello::Repository.find(source_repo_id).version_href
+                config = { source_repo_version: source_repo_version, dest_repo: dest_repo_href, content: content_unit_hrefs }
+                config[:dest_base_version] = dest_repo_id_map[:base_version] if dest_repo_id_map[:base_version]
+                data.config << config
+              end
+            end
+            tasks << copy_content_chunked(data)
+          else
+            tasks << remove_all_content_from_mapping(repo_id_map)
+          end
+          tasks.flatten
+        end
+
+        def copy_api_data_dup(data)
+          data_dup = PulpDebClient::Copy.new
+          data_dup.dependency_solving = data.dependency_solving
+          data_dup.config = []
+          data.config.each do |repo_config|
+            config_hash = {
+              source_repo_version: repo_config[:source_repo_version],
+              dest_repo: repo_config[:dest_repo],
+              content: []
+            }
+            config_hash[:dest_base_version] = repo_config[:dest_base_version] if repo_config[:dest_base_version]
+            data_dup.config << config_hash
+          end
+          data_dup
+        end
+
+        def copy_content_chunked(data)
+          tasks = []
+          # Don't chunk if there aren't enough content units
+          if data.config.sum { |repo_config| repo_config[:content].size } <= UNIT_LIMIT
+            return api.copy_api.copy_content(data)
+          end
+
+          unit_copy_counter = 0
+          i = 0
+          leftover_units = data.config.first[:content].deep_dup
+
+          # Copy data and clear its content fields
+          data_dup = copy_api_data_dup(data)
+
+          while i < data_dup.config.size
+            # Copy all units within repo or only some?
+            if leftover_units.length < UNIT_LIMIT - unit_copy_counter
+              copy_amount = leftover_units.length
+            else
+              copy_amount = UNIT_LIMIT - unit_copy_counter
+            end
+
+            data_dup.config[i][:content] = leftover_units.pop(copy_amount)
+            unit_copy_counter += copy_amount
+            if unit_copy_counter != 0
+              tasks << api.copy_api.copy_content(data_dup)
+              unit_copy_counter = 0
+            end
+
+            if leftover_units.empty?
+              # Nothing more to copy -- clear current config's content
+              data_dup.config[i][:content] = []
+              i += 1
+              # Fetch unit list for next data config
+              leftover_units = data.config[i][:content].deep_dup unless i == data_dup.config.size
+            end
+          end
+
+          tasks
+        end
+
+        def remove_all_content_from_mapping(repo_id_map)
+          tasks = []
+          repo_id_map.each do |_source_repo_ids, dest_repo_id_map|
+            dest_repo = ::Katello::Repository.find(dest_repo_id_map[:dest_repo])
+            dest_repo_href = ::Katello::Pulp3::Repository::Apt.new(dest_repo, SmartProxy.pulp_primary).repository_reference.repository_href
+            tasks << remove_all_content_from_repo(dest_repo_href)
+          end
+          tasks
+        end
+
+        def remove_all_content_from_repo(repo_href)
+          data = PulpDebClient::RepositoryAddRemoveContent.new(
+            remove_content_units: ['*'])
+          api.repositories_api.modify(repo_href, data)
+        end
+
+        def remove_all_content
+          data = PulpDebClient::RepositoryAddRemoveContent.new(
+            remove_content_units: ['*'])
+          api.repositories_api.modify(repository_reference.repository_href, data)
+        end
+
+        def add_filter_content(source_repo_ids, filters, filter_list_map)
+          filters.each do |filter|
+            if filter.inclusion
+              source_repo_ids.each do |repo_id|
+                filter_list_map[:whitelist_ids] += filter.content_unit_pulp_ids(::Katello::Repository.find(repo_id))
+              end
+            else
+              source_repo_ids.each do |repo_id|
+                filter_list_map[:blacklist_ids] += filter.content_unit_pulp_ids(::Katello::Repository.find(repo_id))
+              end
+            end
+          end
+          filter_list_map
+        end
+
+        def add_debs(source_repo_ids, filters, filter_list_map)
+          if (filter_list_map[:whitelist_ids].empty? && filters.select { |filter| filter.inclusion }.empty?)
+            filter_list_map[:whitelist_ids] += source_repo_ids.collect do |source_repo_id|
+              source_repo = ::Katello::Repository.find(source_repo_id)
+              source_repo.debs.pluck(:pulp_id).sort
+            end
+          end
+          filter_list_map
+        end
+
+        def copy_content_from_mapping(repo_id_map, options = {})
+          repo_id_map.each do |source_repo_ids, dest_repo_map|
+            filters = ContentViewDebFilter.where(:id => options[:filter_ids])
+
+            filter_list_map = { whitelist_ids: [], blacklist_ids: [] }
+            filter_list_map = add_filter_content(source_repo_ids, filters, filter_list_map)
+            filter_list_map = add_debs(source_repo_ids, filters, filter_list_map)
+
+            whitelist_ids = filter_list_map[:whitelist_ids].flatten&.uniq
+            blacklist_ids = filter_list_map[:blacklist_ids].flatten&.uniq
+            content_unit_hrefs = whitelist_ids - blacklist_ids
+
+            dest_repo_map[:content_unit_hrefs] = content_unit_hrefs.uniq.sort
+          end
+
+          dependency_solving = options[:solve_dependencies] || false
+
+          multi_copy_units(repo_id_map, dependency_solving)
+        end
+
+        def copy_units(content_unit_hrefs, remove_all)
+          remove_all = true if remove_all.nil?
+          tasks = []
+
+          if content_unit_hrefs.sort!.any?
+            first_slice = remove_all
+            content_unit_hrefs.each_slice(UNIT_LIMIT) do |slice|
+              tasks << add_content(slice, first_slice)
+              first_slice = false
+            end
+          else
+            tasks << remove_all_content
+          end
+          tasks
+        end
+
+        def copy_content_for_source(source_repository, options = {})
+          # copy_units_by_href(source_repository.debs.pluck(:pulp_id))
+          filters = ContentViewDebFilter.where(:id => options[:filter_ids])
+
+          whitelist_ids = []
+          blacklist_ids = []
+          filters.each do |filter|
+            if filter.inclusion
+              whitelist_ids += filter.content_unit_pulp_ids(source_repository)
+            else
+              blacklist_ids += filter.content_unit_pulp_ids(source_repository)
+            end
+          end
+
+          whitelist_ids = source_repository.debs.pluck(:pulp_id).sort if (whitelist_ids.empty? && filters.select { |filter| filter.inclusion }.empty?)
+
+          content_unit_hrefs = whitelist_ids - blacklist_ids
+
+          copy_units(content_unit_hrefs.uniq, options[:remove_all])
         end
 
         def regenerate_applicability

data/app/services/katello/pulp3/repository.rb

@@ -77,7 +77,7 @@ module Katello
         if remote_options[:url].blank?
           if href
             repo.update(remote_href: nil)
-            delete_remote href
+            delete_remote(href: href)
           end
         else
           if href
@@ -97,8 +97,9 @@ module Katello
         end
       end
 
-      def delete_remote(href = repo.remote_href)
-        ignore_404_exception { remote_options[:url]&.start_with?('uln') ? api.remotes_uln_api.delete(href) : api.remotes_api.delete(href) } if href
+      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
 
       def self.instance_for_type(repo, smart_proxy)

data/app/services/katello/pulp3/service_common.rb

@@ -43,7 +43,7 @@ module Katello
             response = api.remotes_api.create(remote_file_data)
           end
           #delete is async, but if its not properly deleted, orphan cleanup will take care of it later
-          delete_remote(response.pulp_href)
+          delete_remote(href: response.pulp_href)
         end
       end
 

data/app/services/katello/pulp3/smart_proxy_mirror_repository.rb

@@ -83,7 +83,7 @@ module Katello
 
           remotes.each do |remote|
             if !repo_names.include?(remote.name) && !acs_remotes.include?(remote.pulp_href)
-              tasks << api.delete_remote(remote.pulp_href)
+              tasks << api.delete_remote(href: remote.pulp_href)
             end
           end
         end

data/app/views/foreman/smart_proxies/show.html.erb

@@ -1,11 +1,11 @@
 <% if @smart_proxy.pulp_mirror? -%>
   <div ng-controller="CapsuleContentController">
-    <%= render :file => 'smart_proxies/show' %>
+    <%= render :template => 'smart_proxies/show' %>
   </div>
 <% elsif @smart_proxy.pulp_primary? -%>
   <div ng-controller="PulpPrimaryController">
-    <%= render :file => 'smart_proxies/show' %>
+    <%= render :template => 'smart_proxies/show' %>
   </div>
 <% else -%>
-  <%= render :file => 'smart_proxies/show' %>
+  <%= render :template => 'smart_proxies/show' %>
 <% end -%>

data/app/views/katello/api/v2/alternate_content_sources/base.json.rabl

@@ -1,8 +1,23 @@
-object @resource
-
 extends 'katello/api/v2/common/identifier'
 
-attributes :name, :base_url, :subpaths, :content_type, :alternate_content_source_type, :smart_proxies, :upstream_username, :last_refreshed
+if @object.respond_to?(:alternate_content_source_type)
+  if @object.custom?
+    attributes :name, :alternate_content_source_type, :content_type, :base_url, :subpaths, :upstream_username, :smart_proxies, :verify_ssl
+    child :ssl_ca_cert => :ssl_ca_cert do |_object|
+      attributes :id, :name
+    end
+
+    child :ssl_client_cert => :ssl_client_cert do |_object|
+      attributes :id, :name
+    end
+
+    child :ssl_client_key => :ssl_client_key do |_object|
+      attributes :id, :name
+    end
+  elsif @object.simplified?
+    attributes :name, :alternate_content_source_type, :content_type, :products, :smart_proxies
+  end
+end
 
 child :latest_dynflow_refresh_task => :last_refresh do |_object|
   attributes :id, :username, :started_at, :ended_at, :state, :result, :progress

data/app/views/katello/api/v2/alternate_content_sources/show.json.rabl

@@ -1,3 +1,23 @@
 object @resource
 
 extends "katello/api/v2/alternate_content_sources/base"
+
+if @resource.respond_to?(:simplified?)
+  if @resource.simplified?
+    node :products do |acs|
+      acs.products.map do |product|
+        { id: product.id, organization_id: product.organization.id, name: product.name, label: product.label }
+      end
+    end
+  else
+    node :upstream_password_exists do |_acs|
+      @resource.upstream_password.present?
+    end
+  end
+end
+
+node :smart_proxies do |acs|
+  acs.smart_proxies.map do |smart_proxy|
+    { id: smart_proxy.id, name: smart_proxy.name, url: smart_proxy.url, download_policy: smart_proxy.download_policy }
+  end
+end

data/app/views/katello/api/v2/ansible_collections/compare.json.rabl

@@ -0,0 +1,10 @@
+object false
+
+extends "katello/api/v2/common/metadata"
+
+child @collection[:results] => :results do
+  extends 'katello/api/v2/ansible_collections/base'
+  node :comparison do |result|
+    result.comparison
+  end
+end

data/app/views/katello/api/v2/content_view_filters/base.json.rabl

@@ -47,6 +47,11 @@ node :rules do |filter|
       partial('katello/api/v2/content_view_filter_rules/show', :object => rule)
     end
 
+  elsif filter.respond_to?(:deb_rules)
+    filter.deb_rules.map do |rule|
+      partial('katello/api/v2/content_view_filter_rules/show', :object => rule)
+    end
+
   else
     []
   end

data/app/views/katello/api/v2/module_streams/compare.json.rabl

@@ -0,0 +1,10 @@
+object false
+
+extends "katello/api/v2/common/metadata"
+
+child @collection[:results] => :results do
+  extends 'katello/api/v2/module_streams/base'
+  node :comparison do |result|
+    result.comparison
+  end
+end

data/app/views/katello/api/v2/repository_sets/show.json.rabl

@@ -37,6 +37,10 @@ child @resource.repositories => :repositories do
   attributes :minor => :releasever
 end
 
+node :archRestricted do |pc|
+  pc.repositories&.first&.arch
+end
+
 node :osRestricted do |pc|
   pc.repositories&.first&.os_versions&.first
 end

data/app/views/katello/layouts/foreman_with_bastion.html.erb

@@ -2,4 +2,4 @@
   <%= render :partial => 'layouts/application_content' %>
 <% end %>
 
-<%= render :file => 'bastion/layouts/assets' %>
+<%= render :template => 'bastion/layouts/assets' %>

data/app/views/katello/layouts/react.html.erb

@@ -13,4 +13,4 @@
       <%= react_component('katello') %>
     </div>
 <% end %>
-<%= render file: "layouts/base" %>
+<%= render template: "layouts/base" %>

data/app/views/overrides/organizations/_edit_override.html.erb

@@ -12,13 +12,10 @@
                'data-url' => "/katello/api/v2/organizations/#{@taxonomy.id}/download_debug_certificate"
   end %>
 
-  <% if @can_toggle_sca %>
-    <%= field(f, _('Simple Content Access'),
-              :help_inline => _('Toggling Simple Content Access will refresh your manifest.')) do
-      tag1 = hidden_field_tag 'simple_content_access', '0'
-      tag2 = check_box_tag 'simple_content_access', '1', @taxonomy.simple_content_access?
-      tag1 + tag2
-    end %>
-  <% end %>
+  <%= field(f, _('Simple Content Access')) do
+    tag1 = hidden_field_tag 'simple_content_access', '0'
+    tag2 = check_box_tag 'simple_content_access', '1', @taxonomy.simple_content_access?(cached: false)
+    tag1 + tag2
+  end %>
 
 <% end %>

data/app/views/overrides/organizations/_index_row_override.html.erb

@@ -1,3 +1,3 @@
 <% if taxonomy.is_a?(Organization) %>
-  <td><%= checked_icon taxonomy.simple_content_access? %></td>
+  <td><%= checked_icon taxonomy.simple_content_access?(cached: false) %></td>
 <% end %>

data/app/views/overrides/organizations/_step_1_override.html.erb

@@ -1,5 +1,10 @@
 <% if @taxonomy.is_a?(Organization) %>
 
   <%= text_f f, :label, :class => 'input-xlarge' %>
+  <%= field(f, _('Simple Content Access')) do
+      tag1 = hidden_field_tag 'simple_content_access', '0'
+      tag2 = check_box_tag 'simple_content_access', '1', true
+      tag1 + tag2
+    end %>
 
 <% end %>

data/ca/redhat-uep.pem

@@ -39,12 +39,12 @@ tcci9LFHGvijIy4VUDQK8HmGjIxJPrIIe1nB5BkiGyjwn00D5q+BwYVst1C68Rwx
 iRZpyzOZmeineJvhrJZ4Tvs=
 -----END CERTIFICATE-----
 -----BEGIN CERTIFICATE-----
-MIIHZTCCBU2gAwIBAgIJAJGKz8qFAAAAMA0GCSqGSIb3DQEBBQUAMIGwMQswCQYD
+MIIGejCCBGKgAwIBAgIJAJGKz8qFAAAIMA0GCSqGSIb3DQEBDAUAMIGwMQswCQYD
 VQQGEwJVUzEXMBUGA1UECAwOTm9ydGggQ2Fyb2xpbmExEDAOBgNVBAcMB1JhbGVp
 Z2gxFjAUBgNVBAoMDVJlZCBIYXQsIEluYy4xGDAWBgNVBAsMD1JlZCBIYXQgTmV0
 d29yazEeMBwGA1UEAwwVRW50aXRsZW1lbnQgTWFzdGVyIENBMSQwIgYJKoZIhvcN
-AQkBFhVjYS1zdXBwb3J0QHJlZGhhdC5jb20wHhcNMTAwMzE4MTEyNDU0WhcNMzAw
-MzEzMTEyNDU0WjCBsTELMAkGA1UEBhMCVVMxFzAVBgNVBAgMDk5vcnRoIENhcm9s
+AQkBFhVjYS1zdXBwb3J0QHJlZGhhdC5jb20wHhcNMTgwOTEyMTgxMzIxWhcNMzAw
+MzE1MTgxMzIxWjCBsTELMAkGA1UEBhMCVVMxFzAVBgNVBAgMDk5vcnRoIENhcm9s
 aW5hMRYwFAYDVQQKDA1SZWQgSGF0LCBJbmMuMRgwFgYDVQQLDA9SZWQgSGF0IE5l
 dHdvcmsxMTAvBgNVBAMMKFJlZCBIYXQgRW50aXRsZW1lbnQgT3BlcmF0aW9ucyBB
 dXRob3JpdHkxJDAiBgkqhkiG9w0BCQEWFWNhLXN1cHBvcnRAcmVkaGF0LmNvbTCC
@@ -59,26 +59,21 @@ tUeKQUFwIXqSjuOoZDu80H6NQb+4dnRSjWlx/m7HPk75m0zErshpB2HSKUnrs4wR
 i7GsWDDcqBus7eLMwUZPvDNVcLQu/2Y4DUHNbJbn7+DwEqi5D0heC+dyY8iS45gp
 I/yhVvq/GfKL+dqjaNaE4CorJJA5qJ9f383Ol/aub+aJeBahCBNuVa2daA9Bo3BA
 dnL7KkILPFyCcEhQITnu70Qn9sQlwYcRoYF2LWAm9DtLrBT0Y0w7wQHh8vNhwEQ7
-k5G87WpwzcC8y6ePR0vFAgMBAAGjggF9MIIBeTAdBgNVHQ4EFgQUxEl4VkWdHixh
-YMNmS1gFNy8DInswgeUGA1UdIwSB3TCB2oAUiEumRcRG7I/Wz6b2Gs8mPJDMfxeh
-gbakgbMwgbAxCzAJBgNVBAYTAlVTMRcwFQYDVQQIDA5Ob3J0aCBDYXJvbGluYTEQ
-MA4GA1UEBwwHUmFsZWlnaDEWMBQGA1UECgwNUmVkIEhhdCwgSW5jLjEYMBYGA1UE
-CwwPUmVkIEhhdCBOZXR3b3JrMR4wHAYDVQQDDBVFbnRpdGxlbWVudCBNYXN0ZXIg
-Q0ExJDAiBgkqhkiG9w0BCQEWFWNhLXN1cHBvcnRAcmVkaGF0LmNvbYIJAOb+Qigl
-yeZeMAwGA1UdEwQFMAMBAf8wCwYDVR0PBAQDAgEGMBEGCWCGSAGG+EIBAQQEAwIB
-BjAgBgNVHREEGTAXgRVjYS1zdXBwb3J0QHJlZGhhdC5jb20wIAYDVR0SBBkwF4EV
-Y2Etc3VwcG9ydEByZWRoYXQuY29tMA0GCSqGSIb3DQEBBQUAA4ICAQBbTSz+UIXP
-AVIT0ZVL1flCHR113aj2j3UBZkaoDkSxtEfa1nqysmN0llpqh4NVBL3anEFYxokL
-hQ2PB8mmuD5EuWaNxnXTc4Sr5dsOcjkFiU197lybaJK7w4OzQ2Qg/X/t4+R78cfM
-ZK/qHpjuyT3NyHHvCug/WzkvU09pRr2aVHI+fn68u18TRzPJNKvegR4YeA3vsyQW
-BgEc8sU7KrAvikFJ3mCTpAk+6SRgbGFLyZE637Qrzy2DDBw0V020dkTkC6YnEsZg
-HwZWVmLtCgLlnimx6SRft+6zrXVHWZxod1GT/af7vizpmhrXt/Nu5Se7dpOhPayo
-NwYCFNmfZeL4W/foSKNfaizZcc+tiNABRtT+tplfniv/yjr7sBAsFPhJqQB8CfsQ
-8BVvKkHtixygyo+EO+NEotZGw3cn+/7soo9B1bWXk3PFSwEr+KwINACFGv2zcGLI
-oeP4iK6DHZImWEV4tgMrQyXatEyPh2axPWU3SjY/fr1Ub5gEt+WpCtyYIN4ObBaN
-eL3NPfTj79/VFZ22PhUInmGY/VK/ymvl/dkWyWi8zD8Aq55ofZ33FvQ46dcLp1pV
-KWApIVqO27uhL6YxXDFi6n7RXACEIVz6JqDh5fGmOH1F+vfumZKzW78LlVD2QY15
-rmCh0i9+AUCiUsNyYdJbSZDPiFPBwlwUoQ==
+k5G87WpwzcC8y6ePR0vFAgMBAAGjgZMwgZAwHQYDVR0OBBYEFMRJeFZFnR4sYWDD
+ZktYBTcvAyJ7MB8GA1UdIwQYMBaAFIhLpkXERuyP1s+m9hrPJjyQzH8XMAwGA1Ud
+EwQFMAMBAf8wCwYDVR0PBAQDAgEGMBEGCWCGSAGG+EIBAQQEAwIBBjAgBgNVHREE
+GTAXgRVjYS1zdXBwb3J0QHJlZGhhdC5jb20wDQYJKoZIhvcNAQEMBQADggIBAGKk
+q5Ab0AC7SOCYq9up5z0twbe+gI72cm854+VhcxafnLP2/4nH6nQauKLKEFLI8+fV
+RAwYxm1f5nuEiaTvjPE0umYdgMlpEJQeGdW/+/DotDaOon1G6bSMEKFvaKcBHKqa
+kBxQ29trwMG2WN8qZ7/H3XzBvLZ+JrYr01vDSV0P4tcBFOytbMZeJr4xmfxiqWxp
+VUM9eGf6z+ngXyth8lohxGd9MMXwsaPdvM+wptp3AQpq5wFPWyfJqCd6uBxu09k1
+ns3Y/sya2GHqDK4bUW6gCHO13gkYviTCIBLAlX7PDeK5nYVcq8HvTLU9+H9BFGix
+YGDdHphz7i5qO/gLLLcfKhENP6jtbe8i6nwqeDzj+DMy38iMWNYFVWn1OrBaQMtf
+wlVfyRJij9SfyiUAVFld1RoPAN/haf1VmF/0dGrOigibYijqnHvDJffMUND/sbk8
+df6O6VYjvLLlwry4W4dHiLLA7NAHGtkUv2g1+oH1lQIfRG+PvZhWz4pGT1AlzfwD
+aXUfX2X+Bo9tYr9BGy5Li1pLGLvfw+an7cBAbBaw8+HhAHt+Vm4F03KX/bHlge0a
+fMYK6FoA/xQSaZ6IPm4HfPSMvhboguVG+/AZQN4/UxjDleoEz8b0CWYafcJRRZch
+BdxBjTy7JLf3j0HCbenZQF83wwtrSmiTOTK1tLsm
 -----END CERTIFICATE-----
 -----BEGIN CERTIFICATE-----
 MIIHZDCCBUygAwIBAgIJAOb+QiglyeZeMA0GCSqGSIb3DQEBBQUAMIGwMQswCQYD

data/config/katello.yaml.example

@@ -2,8 +2,6 @@
   :rest_client_timeout: 30
   :gpg_strict_validation: false
 
-  :puppet_repo_root: '/etc/puppet/environments/'
-
   :redhat_repository_url: https://cdn.redhat.com
 
   :consumer_cert_rpm: 'katello-ca-consumer-latest.noarch.rpm'