katello 3.0.0.rc1 → 3.0.0.rc2

data/app/controllers/katello/concerns/api/v2/bulk_hosts_extensions.rb

@@ -13,16 +13,22 @@ module Katello
         unless bulk_params[:included][:ids].blank?
           @hosts = ::Host::Managed.authorized(permission).where(:id => bulk_params[:included][:ids])
           @hosts = @hosts.where(:organization_id => organization.id) if organization
-          @hosts = @hosts.where('id not in (?)', bulk_params[:excluded]) unless bulk_params[:excluded][:ids].blank?
-          @hosts = restrict_to.call(@hosts) if restrict_to
         end
 
         if bulk_params[:included][:search]
-          search_hosts = ::Host::Managed.where(:organization_id => organization_id) if params[:organization_id]
+          search_hosts = ::Host::Managed.authorized(permission)
+          search_hosts = search_hosts.where(:organization_id => organization_id) if params[:organization_id]
           search_hosts = search_hosts.search_for(bulk_params[:included][:search])
-          @hosts += search_hosts
+          if @hosts.any?
+            ::Host.where("id in (?) OR id in (?)", @hosts, search_hosts)
+          else
+            @hosts = search_hosts
+          end
         end
 
+        @hosts = restrict_to.call(@hosts) if restrict_to
+        @hosts = @hosts.where('id not in (?)', bulk_params[:excluded][:ids]) unless bulk_params[:excluded][:ids].blank?
+
         if bulk_params[:included][:ids].blank? && bulk_params[:included][:search].nil?
           fail HttpErrors::BadRequest, _("No hosts have been specified.")
         elsif @hosts.empty?

data/app/controllers/katello/remote_execution_controller.rb

@@ -25,7 +25,7 @@ module Katello
         if params[:scoped_search].present?
           params[:scoped_search]
         else
-          ::Host.where(:id => params[:host_ids])
+          ::Host.where(:id => params[:host_ids].try(:split, ','))
         end
       end
 

data/app/helpers/katello/concerns/settings_helper_extensions.rb

@@ -0,0 +1,50 @@
+module Katello
+  module Concerns
+    module SettingsHelperExtensions
+      extend ActiveSupport::Concern
+
+      included do
+        alias_method_chain :value, :katello
+      end
+
+      def value_with_katello(setting)
+        return value_without_katello(setting) unless [
+          'default_download_policy',
+          'katello_default_finish',
+          'katello_default_iPXE',
+          'katello_default_provision',
+          'katello_default_ptable',
+          'katello_default_PXELinux',
+          'katello_default_user_data',
+          'katello_default_kexec'
+        ].include?(setting.name)
+
+        case setting.name
+        when "default_download_policy"
+          edit_select(setting, :value, :select_values => Hash[::Runcible::Models::YumImporter::DOWNLOAD_POLICIES.collect { |p| [p, p] }].to_json)
+        when "katello_default_finish"
+          edit_select(setting, :value, :select_values => katello_template_setting_values("finish"))
+        when "katello_default_iPXE"
+          edit_select(setting, :value, :select_values => katello_template_setting_values("iPXE"))
+        when "katello_default_provision"
+          edit_select(setting, :value, :select_values => katello_template_setting_values("provision"))
+        when "katello_default_ptable"
+          edit_select(setting, :value, :select_values => Hash[Template.all.where(:type => "Ptable").map { |tmp| [tmp[:name], tmp[:name]] }].to_json)
+        when "katello_default_PXELinux"
+          edit_select(setting, :value, :select_values => katello_template_setting_values("PXELinux"))
+        when "katello_default_user_data"
+          edit_select(setting, :value, :select_values => katello_template_setting_values("user_data"))
+        when "katello_default_kexec"
+          edit_select(setting, :value, :select_values => katello_template_setting_values("kexec"))
+        end
+      end
+
+      private
+
+      def katello_template_setting_values(name)
+        templates = ProvisioningTemplate.where(:template_kind => TemplateKind.where(:name => name))
+        templates.each_with_object({}) { |tmpl, hash| hash[tmpl.name] = tmpl.name }.to_json
+      end
+    end
+  end
+end

data/app/helpers/katello/hosts_and_hostgroups_helper.rb

@@ -34,13 +34,27 @@ module Katello
       end
     end
 
+    def fetch_lifecycle_environment(host, options = {})
+      selected_host_group = options.fetch(:selected_host_group, nil)
+      selected_env = lifecycle_environment(host)
+      return selected_env if selected_env.present?
+      lifecycle_environment(selected_host_group) if selected_host_group.present?
+    end
+
+    def fetch_content_view(host, options = {})
+      selected_host_group = options.fetch(:selected_host_group, nil)
+      selected_content_view = content_view(host)
+      return selected_content_view if selected_content_view.present?
+      content_view(selected_host_group) if selected_host_group.present?
+    end
+
     def lifecycle_environment_options(host, options = {})
       include_blank = options.fetch(:include_blank, nil)
       if include_blank == true #check for true specifically
         include_blank = '<option></option>'
       end
+      selected_id = fetch_lifecycle_environment(host, options).try(:id)
 
-      selected_id = lifecycle_environment(host).try(:id)
       orgs = Organization.current ? [Organization.current] : Organization.my_organizations
       all_options = []
       orgs.each do |org|
@@ -67,9 +81,8 @@ module Katello
       if include_blank == true #check for true specifically
         include_blank = '<option></option>'
       end
-
-      content_view = content_view(host)
-      lifecycle_environment = lifecycle_environment(host)
+      lifecycle_environment = fetch_lifecycle_environment(host, options)
+      content_view = fetch_content_view(host, options)
 
       views = []
       if lifecycle_environment

data/app/helpers/katello/katello_urls_helper.rb

@@ -5,14 +5,15 @@ module Katello
       URI(url).host unless url.nil?
     end
 
-    def subscription_manager_configuration_url(host = nil)
+    def subscription_manager_configuration_url(host = nil, rpm = true)
       prefix = if host && host.content_source
                  "http://#{@host.content_source.hostname}"
                else
                  Setting[:foreman_url].sub(/\Ahttps/, 'http')
                end
+      config = rpm ? SETTINGS[:katello][:consumer_cert_rpm] : SETTINGS[:katello][:consumer_cert_sh]
 
-      "#{prefix}/pub/#{SETTINGS[:katello][:consumer_cert_rpm]}"
+      "#{prefix}/pub/#{config}"
     end
   end
 end

data/app/helpers/katello/providers_helper.rb

@@ -11,7 +11,6 @@ module Katello
         {:id => :debug, :name => _('Debug RPMs'), :products => {}},
         {:id => :beta, :name => _('Beta'), :products => {}},
         {:id => :isos, :name => _('ISOs'), :products => {}},
-        {:id => :docker_manifests, :name => _('Docker Manifests'), :products => {}},
         {:id => :ostree, :name => _('OSTree'), :products => {}},
         {:id => :other, :name => _('Other'), :products => {}}
       ]
@@ -22,11 +21,9 @@ module Katello
       redhat_repo_tabs.each { |tab| tabs[tab[:id]] = tab }
 
       provider.products.each do |product|
-        product.productContent.each do |prod_content|
+        product.displayable_product_contents.each do |prod_content|
           name = prod_content.content.name
-          if prod_content.content.type == ::Katello::Repository::CANDLEPIN_DOCKER_TYPE
-            key = :docker_manifests
-          elsif prod_content.content.type == ::Katello::Repository::CANDLEPIN_OSTREE_TYPE
+          if prod_content.content_type == ::Katello::Repository::CANDLEPIN_OSTREE_TYPE
             key = :ostree
           elsif name.include?(" Beta ")
             key = :beta

data/app/lib/actions/katello/capsule_content/configure_capsule.rb

@@ -5,7 +5,7 @@ module Actions
         def plan(capsule, environment, content_view)
           sequence do
             plan_action(RemoveUnneededRepos, capsule)
-            plan_action(CreateOrUpdate, capsule, environment, content_view)
+            plan_action(CreateRepos, capsule, environment, content_view)
           end
         end
       end

data/app/lib/actions/katello/capsule_content/{create_or_update.rb → create_repos.rb}

@@ -1,7 +1,7 @@
 module Actions
   module Katello
     module CapsuleContent
-      class CreateOrUpdate < ::Actions::EntryAction
+      class CreateRepos < ::Actions::EntryAction
         # @param capsule_content [::Katello::CapsuleContent]
         def plan(capsule_content, environment = nil, content_view = nil)
           fail _("Action not allowed for the default capsule.") if capsule_content.default_capsule?
@@ -9,15 +9,10 @@ module Actions
           current_repos_on_capsule = capsule_content.current_repositories(environment, content_view)
           list_of_repos_to_sync = capsule_content.repos_available_to_capsule(environment, content_view)
           need_creation =  list_of_repos_to_sync - current_repos_on_capsule
-          need_update = current_repos_on_capsule & list_of_repos_to_sync
 
           need_creation.each do |repo|
             create_repo_in_pulp(capsule_content, repo)
           end
-
-          need_update.each do |repo|
-            plan_action(Pulp::Repository::Refresh, repo, capsule_id: capsule_content.capsule.id)
-          end
         end
 
         def create_repo_in_pulp(capsule_content, repository)
@@ -37,7 +32,7 @@ module Actions
                       checksum_type: checksum_type,
                       path: relative_path,
                       with_importer: true,
-                      docker_upstream_name: repository.try(:docker_upstream_name),
+                      docker_upstream_name: repository.pulp_id,
                       download_policy: repository.capsule_download_policy,
                       capsule_id: capsule_content.capsule.id)
         end

data/app/lib/actions/katello/capsule_content/remove_orphans.rb

@@ -0,0 +1,15 @@
+module Actions
+  module Katello
+    module CapsuleContent
+      class RemoveOrphans < Pulp::Abstract
+        input_format do
+          param :capsule_id
+        end
+
+        def run
+          pulp_resources.content.remove_orphans
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/katello/capsule_content/remove_unneeded_repos.rb

@@ -3,13 +3,14 @@ module Actions
     module CapsuleContent
       class RemoveUnneededRepos < ::Actions::Base
         def plan(capsule_content)
-          repos_currently_on_capsule = capsule_content.current_repositories
-          repos_needed_on_capsule = capsule_content.repos_available_to_capsule
+          currently_on_capsule = capsule_content.current_repositories.map(&:pulp_id)
+          needed_on_capsule = capsule_content.repos_available_to_capsule.map(&:pulp_id)
 
-          need_removal = repos_currently_on_capsule - repos_needed_on_capsule
-          need_removal.each do |repo|
+          need_removal = currently_on_capsule - needed_on_capsule
+          need_removal += capsule_content.orphaned_repos
+          need_removal.each do |pulp_id|
             plan_action(Pulp::Repository::Destroy,
-                        :pulp_id => repo.pulp_id,
+                        :pulp_id => pulp_id,
                         :capsule_id => capsule_content.capsule.id)
           end
         end

data/app/lib/actions/katello/capsule_content/sync.rb

@@ -19,6 +19,11 @@ module Actions
 
           fail _("Action not allowed for the default capsule.") if capsule_content.default_capsule?
 
+          need_updates = repos_needing_updates(capsule_content, environment, content_view)
+          need_updates.each do |repo|
+            plan_action(Pulp::Repository::Refresh, repo, capsule_id: capsule_content.capsule.id)
+          end
+
           repository_ids = get_repository_ids(capsule_content, environment, content_view, repository)
           unless repository_ids.blank?
             sequence do
@@ -33,6 +38,7 @@ module Actions
                               repo_pulp_id: repo_id)
                 end
               end
+              plan_action(RemoveOrphans, :capsule_id => capsule_content.capsule.id)
             end
           end
         end
@@ -54,6 +60,32 @@ module Actions
           repository_ids
         end
 
+        def repos_needing_updates(capsule_content, environment, content_view)
+          need_importer_update = repos_needing_importer_updates(capsule_content, environment, content_view)
+          need_distributor_update = repos_needing_distributor_updates(capsule_content, environment, content_view)
+          (need_distributor_update + need_importer_update).uniq
+        end
+
+        def repos_needing_distributor_updates(capsule, environment, content_view)
+          repos = capsule.repos_available_to_capsule(environment, content_view)
+          repos.select do |repo|
+            repo_details = capsule.pulp_repo_facts(repo.pulp_id)
+            next unless repo_details
+            capsule_distributors = repo_details["distributors"]
+            !(repo.distributors_match?(capsule_distributors))
+          end
+        end
+
+        def repos_needing_importer_updates(capsule, environment, content_view)
+          repos = capsule.repos_available_to_capsule(environment, content_view)
+          repos.select do |repo|
+            repo_details = capsule.pulp_repo_facts(repo.pulp_id)
+            next unless repo_details
+            capsule_importer = repo_details["importers"][0]["config"]
+            !(repo.importer_matches?(capsule_importer))
+          end
+        end
+
         def rescue_strategy
           Dynflow::Action::Rescue::Skip
         end

data/app/lib/actions/katello/content_view/incremental_updates.rb

@@ -4,7 +4,7 @@ module Actions
       class IncrementalUpdates < Actions::EntryAction
         include Helpers::Presenter
 
-        def plan(version_environments, composite_version_environments, content, dep_solve, systems, description)
+        def plan(version_environments, composite_version_environments, content, dep_solve, hosts, description)
           old_new_version_map = {}
           output_for_version_ids = []
 
@@ -28,8 +28,9 @@ module Actions
               handle_composites(old_new_version_map, composite_version_environments, output_for_version_ids, description, content[:puppet_module_ids])
             end
 
-            if systems.any? && !content[:errata_ids].blank? #content[:errata_ids] are uuids
-              hosts = systems.collect { |i| i.foreman_host }
+            if hosts.any? && !content[:errata_ids].blank?
+              errata = ::Katello::Erratum.with_identifiers(content[:errata_ids])
+              hosts = hosts.where(:id => ::Katello::Host::ContentFacet.with_applicable_errata(errata).pluck(:host_id))
               plan_action(::Actions::BulkAction, ::Actions::Katello::Host::Erratum::ApplicableErrataInstall, hosts, content[:errata_ids])
             end
             plan_self(:version_outputs => output_for_version_ids)

data/app/lib/actions/katello/content_view/promote.rb

@@ -48,6 +48,10 @@ module Actions
                                   ::Katello::KTEnvironment.find(input[:environment_id]))
         end
 
+        def rescue_strategy_for_self
+          Dynflow::Action::Rescue::Skip
+        end
+
         def finalize
           history = ::Katello::ContentViewHistory.find(input[:history_id])
           history.status = ::Katello::ContentViewHistory::SUCCESSFUL

data/app/lib/actions/katello/content_view/publish.rb

@@ -54,6 +54,10 @@ module Actions
                                   ::Katello::KTEnvironment.find(input[:environment_id]))
         end
 
+        def rescue_strategy_for_self
+          Dynflow::Action::Rescue::Skip
+        end
+
         def finalize
           history = ::Katello::ContentViewHistory.find(input[:history_id])
           history.status = ::Katello::ContentViewHistory::SUCCESSFUL

data/app/lib/actions/katello/content_view_puppet_module/destroy.rb

@@ -11,12 +11,12 @@ module Actions
           repository.puppet_modules.each do |puppet_module|
             # first, process content view puppet modules that have been specified by version
             library_repos = ::Katello::Repository.in_environment(repository.organization.library).
-                                                  where(:pulp_id => puppet_module.repoids)
+              where(:pulp_id => puppet_module.repositories.map(&:pulp_id))
 
             if library_repos.length == 1
               content_view_puppet_modules = ::Katello::ContentViewPuppetModule.joins(:content_view).
                   where("#{::Katello::ContentView.table_name}.organization_id" => repository.organization.id).
-                  where(:uuid => puppet_module.id)
+                  where(:uuid => puppet_module.id.to_s)
 
               content_view_puppet_modules.destroy_all
             end
@@ -29,9 +29,8 @@ module Actions
             if content_view_puppet_modules.any?
               puppet_repoids = ::Katello::Repository.puppet_type.in_environment(repository.organization.library).
                   pluck(:pulp_id).reject { |repoid| repoid == repository.pulp_id }
-              found_puppet_module = ::Katello::PuppetModule.latest_modules_search([{:name => puppet_module.name,
-                                                                                    :author => puppet_module.author}],
-                                                                                  puppet_repoids).first
+              found_puppet_module = ::Katello::PuppetModule.
+                latest_module(puppet_module.name, puppet_module.author, puppet_repoids)
 
               content_view_puppet_modules.destroy_all unless found_puppet_module
             end

data/app/lib/actions/katello/content_view_version/incremental_update.rb

@@ -149,16 +149,18 @@ module Actions
           end
         end
 
-        def copy_yum_content(new_repo, dep_solve, package_uuids, errata_uuids)
+        def copy_yum_content(new_repo, dep_solve, package_ids, errata_ids)
           copy_outputs = []
           if new_repo.content_type == ::Katello::Repository::YUM_TYPE
-            unless errata_uuids.blank?
+            unless errata_ids.blank?
+              errata_uuids = ::Katello::Erratum.with_identifiers(errata_ids).pluck(:uuid)
               copy_outputs << plan_copy(Pulp::Repository::CopyErrata, new_repo.library_instance, new_repo,
                                         { :filters => {:association => {'unit_id' => {'$in' => errata_uuids}}}},
                                         :recursive => true, :resolve_dependencies => dep_solve).output
             end
 
-            unless package_uuids.blank?
+            unless package_ids.blank?
+              package_uuids = ::Katello::Rpm.with_identifiers(package_ids).pluck(:uuid)
               copy_outputs << plan_copy(Pulp::Repository::CopyRpm, new_repo.library_instance, new_repo,
                                         { :filters => {:association => {'unit_id' => {'$in' => package_uuids}}}},
                                         :resolve_dependencies => dep_solve).output

data/app/lib/actions/katello/host/erratum/applicable_errata_install.rb

@@ -6,8 +6,8 @@ module Actions
           include Helpers::Presenter
 
           #takes a list of errata and schedules the installation of those that are applicable
-          def plan(host, errata_uuids)
-            applicable_errata = host.content_facet.applicable_errata.where(:uuid => errata_uuids)
+          def plan(host, errata_ids)
+            applicable_errata = host.content_facet.applicable_errata.with_identifiers(errata_ids)
             plan_action(Actions::Katello::Host::Erratum::Install, host, applicable_errata.pluck(:errata_id))
             plan_self(:hostname => host.name)
           end

data/app/lib/actions/katello/host/generate_applicability.rb

@@ -15,7 +15,7 @@ module Actions
         def finalize
           ::Host.where(:id => input[:host_ids]).each do |host|
             host.content_facet.try(:import_applicability)
-            host.get_status(::Katello::ErrataStatus).refresh!
+            host.content_facet.update_errata_status
           end
         end
       end

data/app/lib/actions/katello/host/hypervisors_update.rb

@@ -43,7 +43,7 @@ module Actions
                                     content_view.organization)
           host.subscription_facet ||= ::Katello::Host::SubscriptionFacet.new
           host.subscription_facet.update_from_consumer_attributes(hypervisor_json)
-          host.subscription_facet.update_attributes(:uuid => hypervisor_json[:uuid])
+          host.subscription_facet.uuid = hypervisor_json[:uuid]
           host.subscription_facet.save!
 
           # TODO: Remove this legacy

data/app/lib/actions/katello/host/register.rb

@@ -6,7 +6,10 @@ module Actions
 
         def plan(host, system, consumer_params, content_view_environment, activation_keys = [])
           sequence do
-            plan_action(Katello::Host::Unregister, host) unless host.new_record?
+            unless host.new_record?
+              plan_action(Katello::Host::Unregister, host)
+              host.reload
+            end
             ::Katello::Host::SubscriptionFacet.update_facts(host, consumer_params[:facts]) unless consumer_params[:facts].blank?
 
             unless activation_keys.empty?
@@ -20,12 +23,12 @@ module Actions
             system.save!
 
             host.content_host = system
+            host.save!
             host.content_facet = plan_content_facet(host, content_view_environment)
             host.subscription_facet = plan_subscription_facet(host, activation_keys, consumer_params)
             host.save!
 
             action_subject host
-            connect_to_smart_proxy(host)
 
             cp_create = plan_action(Candlepin::Consumer::Create, cp_environment_id: content_view_environment.cp_id,
                                     consumer_parameters: consumer_params, activation_keys: activation_keys.map(&:cp_name))
@@ -51,6 +54,8 @@ module Actions
           host.content_facet.save!
           host.subscription_facet.update_from_consumer_attributes(host.subscription_facet.candlepin_consumer.consumer_attributes)
           host.subscription_facet.save!
+          host.refresh_global_status!
+          connect_to_smart_proxy(host)
 
           system = ::Katello::System.find(input[:system_id])
           system.uuid = input[:uuid]
@@ -62,7 +67,8 @@ module Actions
 
           if smart_proxy
             smart_proxy.content_host = system.content_host
-            smart_proxy.organizations << system.organization unless smart_proxy.organizations.include?(system.organization)
+            org = system.content_facet.lifecycle_environment.organization
+            smart_proxy.organizations << org unless smart_proxy.organizations.include?(org)
             smart_proxy.save!
           end
         end
@@ -77,7 +83,7 @@ module Actions
             if !host_collection.unlimited_hosts && host_collection.max_hosts >= 0 &&
                host_collection.systems.length >= host_collection.max_hosts
               fail _("Host collection '%{name}' exceeds maximum usage limit of '%{limit}'") %
-                       {:limit => host_collection.max_content_hosts, :name => host_collection.name}
+                       {:limit => host_collection.max_hosts, :name => host_collection.name}
             end
           end
           host.host_collection_ids = host_collection_ids