katello 3.15.0.rc1.1 → 3.15.0.rc1.2

data/app/models/katello/glue/candlepin/owner.rb

@@ -35,7 +35,7 @@ module Katello
         self.owner_details['contentAccessMode']
       end
 
-      def golden_ticket?
+      def simple_content_access?
         content_access_mode == "org_environment"
       end
 

data/app/models/katello/glue/candlepin/repository.rb

@@ -13,14 +13,6 @@ module Katello
       def content
         Katello::Content.find_by(:cp_content_id => self.content_id, :organization_id => self.product.organization_id)
       end
-
-      def yum_gpg_key_url
-        # if the repo has a gpg key return a url to access it
-        if (gpg_key && gpg_key.content.present?)
-          host = SETTINGS[:fqdn]
-          gpg_key_content_api_repository_url(self, :host => host + "/katello", :protocol => 'https')
-        end
-      end
     end
   end
 end

data/app/models/katello/glue/pulp/repos.rb

@@ -69,7 +69,7 @@ module Katello
 
       def sync_summary
         summary = {}
-        last_repo_sync_task_group.each do |task|
+        last_repo_sync_task_by_repoid.values.each do |task|
           summary[task.result] ||= 0
           summary[task.result] += 1
         end
@@ -106,6 +106,46 @@ module Katello
         end
       end
 
+      def last_repo_sync_task_by_repoid
+        all_repos = repos(self.library, nil, false)
+        base_combined_table = ForemanTasks::Task::DynflowTask
+          .where(:label => ::Actions::Katello::Repository::Sync.name)
+          .joins(:locks)
+          .where("foreman_tasks_locks.resource_id in (?) and foreman_tasks_locks.resource_type = ?", all_repos.pluck(:id), ::Katello::Repository.name)
+
+        max_per_repoid = ForemanTasks::Task::DynflowTask
+          .joins(:locks)
+          .select("#{ForemanTasks::Task::DynflowTask.table_name}.*, inner_select.resource_id")
+          .joins(
+            "INNER JOIN (#{base_combined_table
+              .select("MAX(foreman_tasks_tasks.started_at) AS started_at", "foreman_tasks_locks.resource_id AS resource_id")
+              .group("foreman_tasks_locks.resource_id")
+              .to_sql}) inner_select
+            ON inner_select.started_at = #{ForemanTasks::Task::DynflowTask.table_name}.started_at
+            AND inner_select.resource_id = locks_foreman_tasks_tasks.resource_id")
+          .distinct
+
+        max_per_repoid.map { |x| [x.resource_id, x] }.to_h
+      end
+
+      def sync_state_aggregated
+        presented = last_repo_sync_task_by_repoid.transform_values { |v| ::Katello::SyncStatusPresenter.new(Katello::Repository.find(v.input["repository"]["id"]), v) }
+        worst = nil
+        scale = [
+          :never_synced,
+          :stopped,
+          :canceled,
+          :error,
+          :paused,
+          :running
+        ]
+
+        presented.each do |_repoid, task|
+          worst = task if worst.nil? || worst.sync_progress[:state].nil? || scale.index(worst.sync_progress[:raw_state].to_sym) < scale.index(task.sync_progress[:raw_state].to_sym)
+        end
+        worst&.sync_progress&.fetch(:state, nil)
+      end
+
       def sync_state
         self.sync_status[:state]
       end

data/app/models/katello/installed_package.rb

@@ -8,10 +8,11 @@ module Katello
     has_many :host_installed_packages, :class_name => "Katello::HostInstalledPackage", :dependent => :destroy, :inverse_of => :installed_package
 
     scoped_search :on => :name, :complete_value => true
+    scoped_search :on => :nvrea
     scoped_search :on => :nvra
-
-    def nvrea
-      nvra
-    end
+    scoped_search :on => :epoch
+    scoped_search :on => :version
+    scoped_search :on => :release
+    scoped_search :on => :arch
   end
 end

data/app/models/katello/pool.rb

@@ -101,7 +101,7 @@ module Katello
     end
 
     class Jail < ::Safemode::Jail
-      allow :id, :name, :available, :quantity, :product_id, :contract_number, :type, :account_number, :start_date, :end_date, :organization
+      allow :id, :name, :available, :quantity, :product_id, :contract_number, :type, :account_number, :start_date, :end_date, :organization, :consumed
     end
   end
 end

data/app/services/katello/pulp/repository/docker.rb

@@ -24,10 +24,20 @@ module Katello
           importer_class.new(config.merge(master_importer_connection_options))
         end
 
+        #what foreman proxies w/ content pull docker content from
+        def docker_registry_host
+          if SmartProxy.pulp_master.pulp3_repository_type_support?(Katello::Repository::DOCKER_TYPE)
+            foreman_url = URI.parse(Setting[:foreman_url]).host.downcase
+            "https://#{foreman_url}"
+          else
+            pulp_uri = URI.parse(SmartProxy.pulp_master.pulp_url)
+            "https://#{pulp_uri.host.downcase}:#{Setting['pulp_docker_registry_port']}"
+          end
+        end
+
         def generate_mirror_importer
-          pulp_uri = URI.parse(SmartProxy.pulp_master.pulp_url)
           config = {
-            feed: "https://#{pulp_uri.host.downcase}:#{Setting['pulp_docker_registry_port']}",
+            feed: docker_registry_host,
             upstream_name: repo.container_repository_name,
             enable_v1: false
           }

data/app/services/katello/pulp/simple_package.rb

@@ -9,11 +9,15 @@ module Katello
       end
 
       def nvra
-        nvrea
+        "#{@name}-#{@version}-#{@release}.#{@arch}"
       end
 
       def nvrea
-        "#{@name}-#{@version}-#{@release}.#{@arch}"
+        if epoch == "0"
+          @nvra
+        else
+          "#{@name}-#{@epoch}:#{@version}-#{@release}.#{@arch}"
+        end
       end
     end
   end

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

@@ -7,6 +7,10 @@ module Katello
         PulpRpmClient::ContentAdvisoriesApi.new(Katello::Pulp3::Api::Yum.new(SmartProxy.pulp_master!).api_client)
       end
 
+      def self.unit_identifier
+        "id"
+      end
+
       def self.ids_for_repository(repo_id)
         repo = Katello::Pulp3::Repository::Yum.new(Katello::Repository.find(repo_id), SmartProxy.pulp_master)
         repo_content_list = repo.content_list

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

@@ -11,9 +11,9 @@ module Katello
         Katello::Repository::DOCKER_TYPE
       ].freeze
 
-      def initialize(smart_proxy, repository_type_labels)
+      def initialize(smart_proxy, repository_types = REPOSITORY_TYPES)
         @smart_proxy = smart_proxy
-        @repository_type_labels = repository_type_labels
+        @repository_types = repository_types
       end
 
       def api_client
@@ -28,8 +28,12 @@ module Katello
         Pulp2to3MigrationClient::Pulp2contentApi.new(api_client)
       end
 
-      def create_and_run_migration
-        start_migration(create_migration)
+      def pulp2_repositories_api
+        Pulp2to3MigrationClient::Pulp2repositoriesApi.new(api_client)
+      end
+
+      def create_and_run_migrations
+        create_migrations.map { |href| start_migration(href) }
       end
 
       def self.content_types_for_migration
@@ -41,22 +45,71 @@ module Katello
       end
 
       def import_pulp3_content
-        @repository_type_labels.each do |repository_type_label|
+        @repository_types.each do |repository_type_label|
           Katello::RepositoryTypeManager.repository_types[repository_type_label].content_types_to_index.each do |content_type|
             import_content_type(content_type)
           end
+          import_repositories(repository_type_label)
         end
       end
 
-      def create_migration
-        migration_plan = Katello::Pulp3::MigrationPlan.new(@repository_type_labels)
-        migration_plan_api.create(plan: migration_plan.generate).pulp_href
+      def create_migrations
+        migration_plans = @repository_types.map { |label| Katello::Pulp3::MigrationPlan.new(label) }
+        migration_plans.map { |plan| migration_plan_api.create(plan: plan.generate.as_json).pulp_href }
       end
 
       def start_migration(plan_href)
         migration_plan_api.run(plan_href, dry_run: false)
       end
 
+      def import_repositories(repository_type_label)
+        imported = Katello::Pulp3::Api::Core.fetch_from_list { |opts| pulp2_repositories_api.list(opts) }
+        imported = imported.select { |migrated| !migrated.not_in_plan }
+
+        Katello::Repository.with_type(repository_type_label).each do |repo|
+          found = imported.find { |migrated_repo| migrated_repo.pulp2_repo_id == repo.pulp_id }
+          import_repo(repo, found) if found
+        end
+      end
+
+      def api_for_repository(katello_repo)
+        katello_repo.repository_type.pulp3_api_class
+      end
+
+      def import_repo(katello_repo, migrated_repo)
+        pulp3_api = api_for_repository(katello_repo).new(SmartProxy.pulp_master)
+        katello_repo.remote_href = migrated_repo.pulp3_remote_href
+        katello_repo.publication_href = migrated_repo.pulp3_publication_href
+        katello_repo.version_href = migrated_repo.pulp3_repository_version
+        katello_repo.save!
+
+        if katello_repo.environment_id.nil? #a cv archive repo
+          environment_instances = Katello::Repository.where(library_instance_id: katello_repo.library_instance_id,
+                                                            content_view_version_id: katello_repo.content_view_version_id)
+          environment_instances.update_all(publication_href: migrated_repo.pulp3_publication_href, version_href: migrated_repo.pulp3_repository_version)
+        end
+
+        repo_ref = Katello::Pulp3::RepositoryReference.find_or_initialize_by(:root_repository_id => katello_repo.root_id, :content_view_id => katello_repo.content_view.id)
+        repo_ref.repository_href = migrated_repo.pulp3_repository_href
+        repo_ref.save!
+
+        process_distributions(pulp3_api, migrated_repo.pulp3_distribution_hrefs)
+      end
+
+      def process_distributions(pulp3_api, dist_hrefs_list)
+        #distribution_path_hash(pulp3_api, dist_hrefs_list).each do |relative_path, href|
+        dist_hrefs_list.each do |href|
+          relative_path = pulp3_api.distributions_api.read(href).base_path
+
+          dist_ref = Katello::Pulp3::DistributionReference.find_or_initialize_by(:path => relative_path)
+          if (distribution_repo = Katello::Repository.find_by(:relative_path => relative_path))
+            dist_ref.href = href
+            dist_ref.repository_id = distribution_repo.id
+            dist_ref.save!
+          end
+        end
+      end
+
       def import_content_type(content_type)
         content_type.model_class.where(:migrated_pulp3_href => nil).select(:id, :pulp_id).find_in_batches(batch_size: GET_QUERY_ID_LENGTH) do |needing_hrefs|
           migrated_units = pulp2_content_api.list(pulp2_id__in: needing_hrefs.map { |unit| unit.pulp_id }.join(','))

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

@@ -1,27 +1,101 @@
 module Katello
   module Pulp3
     class MigrationPlan
-      def initialize(repository_type_labels)
-        @repository_types = repository_type_labels
+      def initialize(repository_type_label)
+        @repository_type = repository_type_label
+      end
+
+      def master_proxy
+        SmartProxy.pulp_master!
       end
 
       def generate
         plan = {}
         plan[:plugins] = generate_plugins
+        Rails.logger.error("Migration Plan: #{plan.to_json}")
         plan
       end
 
       def generate_plugins
-        @repository_types.map do |repository_type|
+        [
           {
-            type: pulp2_repository_type(repository_type)
+            type: pulp2_repository_type(@repository_type),
+            repositories: repository_migrations(@repository_type)
           }
-        end
+        ]
       end
 
       def pulp2_repository_type(repository_type)
         Katello::RepositoryTypeManager.repository_types[repository_type].service_class::REPOSITORY_TYPE
       end
+
+      def repository_migrations(repo_type)
+        roots = Katello::RootRepository.where(:content_type => repo_type)
+        plans = []
+        roots.each do |root|
+          plans << library_migration_for(root)
+          plans += content_view_migrations_for(root)
+        end
+        plans
+      end
+
+      # plugins: [
+      #   type: TYPE
+      #   repositories: [
+      #     {
+      #       name: FOO,
+      #       pulp2_importer_repository_id: STRING,
+      #       repository_versions: [
+      #         {
+      #           pulp2_repository_id: STRING
+      #           pulp2_distributor_repository_ids: [STRING, STRING]
+      #         }
+      #       ]
+      #     }
+      #   ]
+      # ]
+
+      def library_migration_for(root)
+        repo = root.library_instance
+
+        migration = {
+          name: repo.pulp_id,
+          repository_versions: [
+            {
+              pulp2_repository_id: repo.pulp_id,
+              pulp2_distributor_repository_ids: [repo.pulp_id]
+            }
+          ]
+        }
+        migration[:pulp2_importer_repository_id] = repo.pulp_id
+        migration
+      end
+
+      def content_view_migrations_for(root)
+        plans = []
+        ContentView.non_default.published_with_repositories(root).each do |cv|
+          plans << content_view_migration(cv, root)
+        end
+        plans
+      end
+
+      def content_view_migration(content_view, root)
+        plan = {
+          name: "#{content_view.name}-#{root.id}-#{content_view.id}",
+          repository_versions: []
+        }
+        library_instance = root.library_instance
+        content_view.versions.with_library_repo(library_instance).uniq.each do |version|
+          repo = version.archived_repos.find_by(:library_instance_id => library_instance.id)
+          env_repos = version.repositories.where(:library_instance_id => library_instance.id).where.not(:environment_id => nil)
+          plan[:repository_versions] << {
+            pulp2_repository_id: repo.pulp_id,
+            pulp2_distributor_repository_ids: env_repos.map(&:pulp_id)
+          }
+        end
+
+        plan
+      end
     end
   end
 end

data/app/views/dashboard/_subscription_widget.html.erb

@@ -4,7 +4,7 @@
 
 <% if Organization.current.blank? %>
   <p class="ca"><%= _("Please select an organization to view subscription status.") %></p>
-<% elsif Organization.current.golden_ticket?%>
+<% elsif Organization.current.simple_content_access?%>
   <div class="bastion alert alert-info">
     <span translate>This organization has Simple Content Access enabled. Hosts can consume from all repositories in their Content View regardless of subscription status.
     </span>

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

@@ -7,6 +7,9 @@ attributes :task_id, :label, :owner_details, :redhat_repository_url
 if ::SETTINGS[:katello][:use_cp]
   attributes :system_purposes, :system_purposes
   attributes :service_levels, :service_level
+  node :simple_content_access do |org|
+    org.simple_content_access?
+  end
 end
 
 node :default_content_view_id do |org|

data/app/views/katello/api/v2/packages/backend.json.rabl

@@ -5,3 +5,7 @@ attributes :children, :checksumtype, :size, :url, :build_time, :summary, :group,
 node :human_readable_size do |package|
   number_to_human_size(package.size) if package.size
 end
+
+node :build_time_utc do |package|
+  Time.at(package.build_time).to_datetime if package.build_time
+end

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

@@ -3,6 +3,8 @@ object @resource
 
 extends "katello/api/v2/products/base"
 
+attributes :sync_state_aggregated
+
 child(:product_contents => :product_content) do
   extends "katello/api/v2/products/product_content"
 end

data/app/views/overrides/activation_keys/_host_tab_pane.html.erb

@@ -3,11 +3,19 @@
 
 
 <div class="tab-pane" id="activation_keys">
+  <div id="ak-load-error" class="alert alert-danger" style="display: none;">
+    <%= _("There was a problem retrieving Activation Key data from the server.") %>
+  </div>
+
   <%= field(f, _("Activation Keys"),
-            :help_inline => _("comma separated values. The value will be available in templates as @host.params['#{kt_ak_label}']")) do
-    text_field_tag("kt_activation_keys", "", :style => 'width: 98%')
+            :help_inline => _("The value will be available in templates as @host.params['#{kt_ak_label}']")) do
+    tag.div id: :kt_activation_keys
   end %>
 
+  <%= mount_react_component('TypeAheadSelect', '#kt_activation_keys',
+                            {id: 'kt_activation_keys', multiple: true, allowNew: true}.to_json,
+                            { flatten_data: true }) %>
+
   <div class="alert alert-info">
     <p><b><%= _('Subscriptions information based on selected activation keys:') %></b></p>
     <ul id="ak-subscriptions-info"></ul>

data/config/katello.yaml.example

@@ -64,12 +64,6 @@
     :url: amqp:ssl:katello-devel.example.com:5671
     :subscriptions_queue_address: katello_event_queue
 
-  :cdn_proxy:
-  #    :host: localhost
-  #    :port: 3128
-  #    :user: login
-  #    :password: password
-
   # Internal configuration for communication from server to pulp crane service.
   :container_image_registry:
     :crane_url: https://localhost:5000