katello 3.0.0.rc4 → 3.0.0.rc5

data/app/controllers/katello/application_controller.rb

@@ -251,7 +251,7 @@ module Katello
     def require_org
       unless session && current_organization
         execute_after_filters
-        fail Errors::SecurityViolation, _("User does not belong to an organization.")
+        redirect_to '/select_organization?toState=' + request.path
       end
     end
 

data/app/controllers/katello/concerns/organizations_controller_extensions.rb

@@ -32,7 +32,7 @@ module Katello
             if @count_nil_hosts > 0
               redirect_to send("step2_#{taxonomy_single}_path",   @taxonomy)
             else
-              process_success(:object => @taxonomy)
+              process_success(:object => @taxonomy, :success_redirect => send("edit_#{taxonomy_single}_path", @taxonomy))
             end
           rescue ActiveRecord::RecordInvalid
             process_error(:render => "taxonomies/new", :object => @taxonomy)

data/app/helpers/katello/hosts_and_hostgroups_helper.rb

@@ -4,6 +4,10 @@ module Katello
       "kt_activation_keys"
     end
 
+    def using_hostgroups_page?
+      controller.controller_name == "hostgroups"
+    end
+
     def blank_or_inherit_with_id(f, attr)
       return true unless f.object.respond_to?(:parent_id) && f.object.parent_id
       inherited_value  = f.object.send(attr).try(:id) || ''
@@ -34,18 +38,57 @@ module Katello
       end
     end
 
+    def use_install_media(host, options = {})
+      return true if host && host.errors && host.errors.include?(:medium_id)
+      kickstart_repository_id(host, options).blank?
+    end
+
+    def host_hostgroup_kickstart_repository_id(host)
+      return if host.blank?
+      return host.kickstart_repository_id if host.is_a?(Hostgroup)
+      host.content_facet.kickstart_repository_id if host.try(:content_facet).present?
+    end
+
+    def kickstart_repository_id(host, options = {})
+      return if host.try(:medium_id).present?
+
+      host_ks_repo_id = host_hostgroup_kickstart_repository_id(host)
+      ks_repo_options = kickstart_repository_options(host, options)
+      # if the kickstart repo id is set in the selected_hostgroup use that
+      selected_host_group = options.fetch(:selected_host_group, nil)
+      if selected_host_group.try(:kickstart_repository_id).present?
+        ks_repo_ids = ks_repo_options.map(&:id)
+
+        if ks_repo_ids.include?(selected_host_group.kickstart_repository_id)
+          return selected_host_group.kickstart_repository_id
+        elsif host_ks_repo_id && ks_repo_ids.include?(host_ks_repo_id)
+          return host_ks_repo_id
+        else
+          return ks_repo_options.first.try(:id)
+        end
+      end
+
+      # if the kickstart repo id is set in the host use that
+      return host_ks_repo_id if host_ks_repo_id.present?
+
+      if selected_host_group.try(:medium_id).blank? && host.try(:medium_id).blank?
+        ks_repo_options.first.try(:id)
+      end
+    end
+
     def fetch_lifecycle_environment(host, options = {})
       selected_host_group = options.fetch(:selected_host_group, nil)
+      return lifecycle_environment(selected_host_group) if selected_host_group.present?
       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)
+      return content_view(selected_host_group) if selected_host_group.present?
+
       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?
+      selected_content_view if selected_content_view.present?
     end
 
     def lifecycle_environment_options(host, options = {})
@@ -98,5 +141,84 @@ module Katello
       view_options.insert(0, include_blank) if include_blank
       view_options.html_safe
     end
+
+    def view_to_options(view_options, selected_val, include_blank = false)
+      if include_blank == true #check for true specifically
+        include_blank = '<option></option>'
+      end
+      views = view_options.map do |view|
+        selected = selected_val == view.id ? 'selected' : ''
+        %(<option #{selected} value="#{view.id}">#{h(view.name)}</option>)
+      end
+      views = views.join
+      views.insert(0, include_blank) if include_blank
+      views.html_safe
+    end
+
+    def kickstart_repository_options(param_host, options = {})
+      # this method gets called in 2 places
+      # 1) On initial page load or a host group selection. At that point the host object is already
+      #  =>  populated and we should just use that.
+      # 2) Once you chose a diff os/content source/arch/lifecycle env/cv via the os_selected method.
+      #   In case 2 we want it to play by the rules of "one of these params" and
+      #   in case 1 we want it to behave as if everything is already set right and
+      # We need to figure out the available KS repos in both cases.
+      if param_host.present?
+        # case 1
+        selected_host_group = options.fetch(:selected_host_group, nil)
+        host = selected_host_group.present? ? selected_host_group : param_host
+        return [] unless host.operatingsystem.is_a?(Redhat)
+
+        new_host = ::Host.new
+        # there is foreman bug right now that prevents
+        # os and arch to get updated properly,
+        # http://projects.theforeman.org/issues/14737
+        # so we are going to hard code it to use what
+        # is in the param host for now.
+        new_host.operatingsystem = param_host.operatingsystem.present? ? param_host.operatingsystem : host.operatingsystem
+        new_host.architecture = param_host.architecture.present? ? param_host.architecture : host.architecture
+
+        if (host.is_a? Hostgroup)
+          new_host.content_facet = Host::ContentFacet.new(:lifecycle_environment_id => host.lifecycle_environment_id,
+                                                          :content_view_id => host.content_view_id)
+        elsif host.content_facet.present?
+          new_host.content_facet = Host::ContentFacet.new(:lifecycle_environment_id => host.content_facet.lifecycle_environment_id,
+                                                          :content_view_id => host.content_facet.content_view_id)
+        end
+
+        new_host.content_source = host.content_source
+        new_host.operatingsystem.kickstart_repos(new_host).map { |repo| OpenStruct.new(repo) }
+      else
+        # case 2
+        os_updated_kickstart_options(host)
+      end
+    end
+
+    def os_updated_kickstart_options(host)
+      # this method gets called in 1 place Once you chose a diff os/content source/arch/lifecycle env/cv
+      # via the os_selected method.
+      # In this case we want it play by the rules of "one of these params" and
+      # need to figure out the available KS repos for the given params.
+      os_selection_params = ["operatingsystem_id", 'content_view_id', 'lifecycle_environment_id',
+                             'content_source_id', 'architecture_id']
+      view_options = []
+      if os_selection_params.all? { |key| params[key].present? }
+        if host.nil?
+          host = ::Host.new
+        end
+        host.operatingsystem = Operatingsystem.find(params[:operatingsystem_id])
+        host.architecture = Architecture.find(params[:architecture_id])
+
+        lifecycle_env = Katello::KTEnvironment.find(params[:lifecycle_environment_id])
+        content_view = Katello::ContentView.find(params[:content_view_id])
+        host.content_facet = Host::ContentFacet.new(:lifecycle_environment_id => lifecycle_env.id,
+                                                    :content_view_id => content_view.id)
+        host.content_source = SmartProxy.find(params[:content_source_id])
+        if host.operatingsystem.is_a?(Redhat)
+          view_options =  host.operatingsystem.kickstart_repos(host).map { |repo| OpenStruct.new(repo) }
+        end
+      end
+      view_options
+    end
   end
 end

data/app/lib/actions/candlepin/owner/refresh_subscriptions.rb

@@ -0,0 +1,15 @@
+module Actions
+  module Candlepin
+    module Owner
+      class RefreshSubscriptions < Candlepin::AbstractAsyncTask
+        input_format do
+          param :label
+        end
+
+        def invoke_external_task
+          ::Katello::Resources::Candlepin::Subscription.refresh_for_owner(input[:label])
+        end
+      end
+    end
+  end
+end

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

@@ -7,6 +7,7 @@ module Actions
         def plan(host, system, consumer_params, content_view_environment, activation_keys = [])
           sequence do
             unless host.new_record?
+              host.save!
               plan_action(Katello::Host::Unregister, host)
               host.reload
             end
@@ -66,8 +67,7 @@ module Actions
 
           if smart_proxy
             smart_proxy.content_host = system.content_host
-            org = system.content_facet.lifecycle_environment.organization
-            smart_proxy.organizations << org unless smart_proxy.organizations.include?(org)
+            smart_proxy.organizations << system.organization unless smart_proxy.organizations.include?(system.organization)
             smart_proxy.save!
           end
         end

data/app/lib/actions/katello/product/create.rb

@@ -3,26 +3,31 @@ module Actions
     module Product
       class Create < Actions::EntryAction
         def plan(product, organization)
-          product.provider = organization.anonymous_provider
-          product.organization = organization
+          sequence do
+            product.provider = organization.anonymous_provider
+            product.organization = organization
 
-          cp_create = plan_action(::Actions::Candlepin::Product::Create,
-                                  :name => product.name,
-                                  :multiplier => 1,
-                                  :attributes => [{:name => "arch", :value => "ALL"}])
+            cp_create = plan_action(::Actions::Candlepin::Product::Create,
+                                    :name => product.name,
+                                    :multiplier => 1,
+                                    :attributes => [{:name => "arch", :value => "ALL"}])
 
-          cp_id = cp_create.output[:response][:id]
+            cp_id = cp_create.output[:response][:id]
 
-          sub_create = plan_action(::Actions::Candlepin::Product::CreateUnlimitedSubscription,
-                      :owner_key => organization.label,
-                      :product_id => cp_id)
-          subscription_id = sub_create.output[:response][:id]
+            sub_create = plan_action(::Actions::Candlepin::Product::CreateUnlimitedSubscription,
+                        :owner_key => organization.label,
+                        :product_id => cp_id)
 
-          product.save!
-          action_subject product, :cp_id => cp_id
+            subscription_id = sub_create.output[:response][:id]
+
+            plan_action(::Actions::Candlepin::Owner::RefreshSubscriptions,
+                                  :label => organization.label)
+            product.save!
+            action_subject product, :cp_id => cp_id
 
-          plan_self
-          plan_action Katello::Product::ReindexSubscriptions, product, subscription_id
+            plan_self
+            plan_action Katello::Product::ReindexSubscriptions, product, subscription_id
+          end
         end
 
         def finalize

data/app/lib/actions/katello/repository/clone_yum_content.rb

@@ -38,15 +38,16 @@ module Actions
             plan_copy(Pulp::Repository::CopyYumMetadataFile, source_repo, target_repo)
             plan_copy(Pulp::Repository::CopyDistribution, source_repo, target_repo)
 
+            plan_action(Katello::Repository::IndexContent, id: target_repo.id) if index_content
+
             if purge_empty_units
-              plan_action(Katello::Repository::IndexErrata, target_repo)
               plan_action(Pulp::Repository::PurgeEmptyErrata, :pulp_id => target_repo.pulp_id)
-              plan_action(Katello::Repository::IndexPackageGroups, target_repo)
               plan_action(Pulp::Repository::PurgeEmptyPackageGroups, :pulp_id => target_repo.pulp_id)
+              plan_action(Katello::Repository::IndexErrata, target_repo)
+              plan_action(Katello::Repository::IndexPackageGroups, target_repo)
             end
 
             plan_action(Katello::Repository::MetadataGenerate, target_repo, filters.empty? ? source_repo : nil) if generate_metadata
-            plan_action(Katello::Repository::IndexContent, id: target_repo.id) if index_content
           end
         end
 

data/app/lib/actions/katello/repository/index_errata.rb

@@ -7,11 +7,8 @@ module Actions
         end
 
         def run
-          ::User.current = ::User.find(input[:user_id])
           repo = ::Katello::Repository.find(input[:id])
           repo.index_db_errata
-        ensure
-          ::User.current = nil
         end
       end
     end

data/app/lib/actions/pulp/repository/purge_empty_errata.rb

@@ -8,16 +8,10 @@ module Actions
 
         def invoke_external_task
           repo = ::Katello::Repository.where(:pulp_id => input[:pulp_id]).first
+          errata_to_delete = repo.empty_errata
 
-          package_lists = repo.package_lists_for_publish
-          filenames = package_lists[:filenames]
-
-          errata_to_delete = repo.errata.collect do |erratum|
-            erratum.errata_id if filenames.intersection(erratum.packages.pluck(:filename)).empty?
-          end
-          errata_to_delete.compact!
           repo.unassociate_by_filter(::Katello::ContentViewErratumFilter::CONTENT_TYPE,
-                                 "id" => { "$in" => errata_to_delete })
+                                 "id" => { "$in" => errata_to_delete.map(&:errata_id) })
         end
       end
     end

data/app/lib/actions/pulp/repository/purge_empty_package_groups.rb

@@ -8,13 +8,11 @@ module Actions
 
         def invoke_external_task
           repo = ::Katello::Repository.where(:pulp_id => input[:pulp_id]).first
-
-          package_lists = repo.package_lists_for_publish
-          rpm_names = package_lists[:names]
+          rpm_names = repo.rpms.pluck(:name).uniq
 
           # Remove all  package groups with no packages
-          package_groups_to_delete = repo.package_groups.collect do |group|
-            group.uuid if rpm_names.intersection(group.package_names).empty?
+          package_groups_to_delete = repo.package_groups.select do |group|
+            (rpm_names & group.package_names).empty?
           end
           criteria = {:association => {"unit_id" => {"$in" => package_groups_to_delete.compact}}}
 

data/app/lib/katello/concerns/renderer_extensions.rb

@@ -11,8 +11,7 @@ module Katello
         kickstart_attributes_without_katello
 
         if @host.content_facet.try(:content_view) && @host.operatingsystem.is_a?(Redhat) &&
-          !@host.operatingsystem.kickstart_repo(@host).blank?
-
+                @host.operatingsystem.kickstart_repos(@host).first.present?
           @mediapath ||= @host.operatingsystem.mediumpath(@host)
         end
       end

data/app/lib/katello/resources/candlepin.rb

@@ -569,7 +569,6 @@ module Katello
 
           def create_for_owner(owner_key, attrs)
             subscription = self.post("/candlepin/owners/#{owner_key}/subscriptions", attrs.to_json, self.default_headers).body
-            self.put("/candlepin/owners/#{owner_key}/subscriptions", {}.to_json, self.default_headers).body
             subscription
           end
 

data/app/models/katello/concerns/host_managed_extensions.rb

@@ -10,7 +10,6 @@ module Katello
         alias_method_chain :set_hostgroup_defaults, :katello_attributes
         alias_method_chain :info, :katello
         alias_method_chain :smart_proxy_ids, :katello
-
         has_one :content_host, :class_name => "Katello::System", :foreign_key => :host_id,
                                :dependent => :destroy, :inverse_of => :foreman_host
         belongs_to :content_source, :class_name => "::SmartProxy", :foreign_key => :content_source_id, :inverse_of => :hosts
@@ -33,7 +32,7 @@ module Katello
       end
 
       def validate_media_with_capsule?
-        content_source_id.blank? && validate_media_without_capsule?
+        (content_source_id.blank? || (content_facet && content_facet.kickstart_repository.blank?)) && validate_media_without_capsule?
       end
 
       def rhsm_organization_label
@@ -56,6 +55,9 @@ module Katello
         info['parameters']['kt_cv'] = self.content_view.try(:label) #deprecated
         info['parameters']['lifecycle_environment'] = self.lifecycle_environment.try(:label)
         info['parameters']['content_view'] = self.content_view.try(:label)
+        if self.content_facet.present?
+          info['parameters']['kickstart_repository'] = self.content_facet.kickstart_repository.try(:label)
+        end
         info
       end
 
@@ -78,6 +80,9 @@ module Katello
 
       def set_hostgroup_defaults_with_katello_attributes
         if hostgroup.present?
+          if content_facet.present?
+            self.content_facet.kickstart_repository_id = hostgroup.inherited_kickstart_repository_id
+          end
           assign_hostgroup_attributes(%w(content_source_id content_view_id lifecycle_environment_id))
         end
         set_hostgroup_defaults_without_katello_attributes

data/app/models/katello/concerns/hostgroup_extensions.rb

@@ -5,14 +5,14 @@ module Katello
 
       included do
         before_save :add_organization_for_environment
-
+        belongs_to :kickstart_repository, :class_name => "::Katello::Repository", :foreign_key => :kickstart_repository_id
         belongs_to :content_source, :class_name => "::SmartProxy", :foreign_key => :content_source_id, :inverse_of => :hostgroups
         belongs_to :content_view, :inverse_of => :hostgroups, :class_name => "::Katello::ContentView"
         belongs_to :lifecycle_environment, :inverse_of => :hostgroups, :class_name => "::Katello::KTEnvironment"
 
         validates_with Katello::Validators::ContentViewEnvironmentValidator
 
-        attr_accessible :content_view_id, :lifecycle_environment_id, :content_source_id
+        attr_accessible :content_view_id, :lifecycle_environment_id, :content_source_id, :kickstart_repository_id
 
         scoped_search :in => :content_source, :on => :name, :complete_value => true, :rename => :content_source
         scoped_search :in => :content_view, :on => :name, :complete_value => true, :rename => :content_view
@@ -47,6 +47,10 @@ module Katello
         inherited_ancestry_attribute(:lifecycle_environment_id)
       end
 
+      def inherited_kickstart_repository_id
+        inherited_ancestry_attribute(:kickstart_repository_id)
+      end
+
       def rhsm_organization_label
         #used for rhsm registration snippet, since hostgroup can belong to muliple organizations, use lifecycle environment or cv
         (self.lifecycle_environment || self.content_view).try(:organization).try(:label)

data/app/models/katello/concerns/redhat_extensions.rb

@@ -44,16 +44,22 @@ module Katello
       end
 
       def medium_uri_with_content_uri(host, url = nil)
-        if host.try(:content_source) && (repo_details = kickstart_repo(host))
-          URI.parse(repo_details[:path])
+        if host.try(:content_source) && host.content_facet.try(:kickstart_repository).present?
+          return URI.parse(host.content_facet.kickstart_repository.full_path(host.content_source))
         else
           medium_uri_without_content_uri(host, url)
         end
       end
 
-      def kickstart_repo(host)
-        distro = distribution_repositories(host).first
-        {:name => distro.name, :path => distro.full_path(host.content_source)} if distro && host.content_source
+      def kickstart_repos(host)
+        distros = distribution_repositories(host)
+        if distros && host.content_source
+          distros.map do |distro|
+            {:id => distro.id, :name => distro.name, :path => distro.full_path(host.content_source)}
+          end
+        else
+          []
+        end
       end
 
       def distribution_repositories(host)

data/app/models/katello/content_view.rb

@@ -454,7 +454,6 @@ module Katello
       fail _("User must be logged in.") if ::User.current.nil?
       fail _("Cannot publish default content view") if default?
       check_composite_action_allowed!(organization.library)
-      check_distribution_conflicts!
       true
     end
 
@@ -511,40 +510,6 @@ module Katello
       return true
     end
 
-    def check_distribution_conflicts!
-      duplicates = duplicate_distributions
-      if duplicates.any?
-        failed_distribution = duplicates.first
-      else
-        conflicts = distribution_conflicts
-        if conflicts.any?
-          failed_distribution = conflicts.first
-        end
-      end
-
-      if failed_distribution
-        failed_repos = [duplicates, conflicts].flat_map { |i| i }
-        fail _("Content Views cannot contain multiple Kickstart trees with the same version and architecture. " \
-               "Multiple Kickstart trees of %{release} %{arch} were found in Repositories: %{repos}") %
-                 {:release => failed_distribution.distribution_version, :arch => failed_distribution.distribution_arch,
-                  :repos => failed_repos.compact.map { |repo| repo.name if repo.name }}
-      end
-    end
-
-    def distribution_conflicts
-      #find distributions, where there are two in the content view with the same version and Arch
-      repos =  self.repositories_to_publish.where("distribution_arch IS NOT NULL OR distribution_version IS NOT NULL")
-      repos = repos.select { |repo| repo.distribution_bootable? }
-      repos.group_by { |repo| [repo.distribution_arch, repo.distribution_version] }
-           .select { |_, value| value.length > 1 }.values.flatten
-    end
-
-    def duplicate_distributions
-      #find distributions where two repositories in the content view share them
-      repos =  self.repositories_to_publish.where("distribution_uuid IS NOT NULL")
-      repos.group_by { |i| i.distribution_uuid }.select { |_, v| v.length > 1 }.values.flatten
-    end
-
     protected
 
     def remove_repository(repository)