katello 3.7.1.1 → 3.8.0.rc1

data/app/controllers/katello/api/v2/sync_plans_controller.rb

@@ -57,7 +57,7 @@ module Katello
       @sync_plan.organization = @organization
       @sync_plan.save!
 
-      respond_for_show(:resource => @sync_plan)
+      respond_for_create(:resource => @sync_plan)
     end
 
     api :PUT, "/organizations/:organization_id/sync_plans/:id", N_("Update a sync plan")

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

@@ -62,23 +62,17 @@ module Katello
         respond_for_index(:collection => collection)
       end
 
-      param :available_for, :string, :desc => N_("Show available to be added to content view filter")
+      param :available_for, :string, :desc => N_("Return content that can be added to the specified object.  The values 'content_view_version' and 'content_view_filter are supported.")
       param :filterId, :integer, :desc => N_("Content View Filter id")
       def index_relation
-        collection = resource_class.all
-        repos = Repository.readable
-        repos = repos.where(:id => @repo) if @repo
-        repos = repos.where(:id => Repository.readable.in_organization(@organization)) if @organization
-        if @environment && (@environment.library? || resource_class != Katello::PuppetModule)
-          # if the environment is not library and this is for puppet modules,
-          # we can skip environment filter, as those would be associated to
-          # content view puppet environments and handled by the puppet modules
-          # controller.
-          repos = repos.where(:id => @environment.repositories)
+        if @version && params[:available_for] == "content_view_version" && self.respond_to?(:available_for_content_view_version)
+          collection = self.available_for_content_view_version(@version)
+        else
+          collection = resource_class.all
+          collection = filter_by_content_view_version(@version, collection) if @version
         end
 
         collection = filter_by_repos(repos, collection)
-        collection = filter_by_content_view_version(@version, collection) if @version
         collection = filter_by_ids(params[:ids], collection) if params[:ids]
         @filter = ContentViewFilter.find(params[:filterId]) if params[:filterId]
         if params[:available_for] == "content_view_filter" && self.respond_to?(:available_for_content_view_filter)
@@ -111,6 +105,20 @@ module Katello
         filter_by_ids(ids, collection)
       end
 
+      def repos
+        repos = Repository.readable
+        repos = repos.where(:id => @repo) if @repo
+        repos = repos.where(:id => Repository.readable.in_organization(@organization)) if @organization
+        if @environment && (@environment.library? || resource_class != Katello::PuppetModule)
+          # if the environment is not library and this is for puppet modules,
+          # we can skip environment filter, as those would be associated to
+          # content view puppet environments and handled by the puppet modules
+          # controller.
+          repos = repos.where(:id => @environment.repositories)
+        end
+        repos
+      end
+
       def filter_by_repos(repos, collection)
         collection.in_repositories(repos)
       end

data/app/controllers/katello/remote_execution_controller.rb

@@ -15,12 +15,6 @@ module Katello
         end
       end
 
-      # to overcome the isolated namespace engine difficulties with paths
-      helper Rails.application.routes.url_helpers
-      def _routes
-        Rails.application.routes
-      end
-
       private
 
       def prepare_composer
@@ -49,6 +43,12 @@ module Katello
         # getting packageInstall from UI, translating to 'katello_package_install' feature
         "katello_#{params[:remote_action].underscore}"
       end
+
+      # to overcome the isolated namespace engine difficulties with paths
+      helper Rails.application.routes.url_helpers
+      def _routes
+        Rails.application.routes
+      end
     end
   else
     class RemoteExecutionController < ApplicationController

data/app/helpers/katello/hosts_and_hostgroups_helper.rb

@@ -72,12 +72,6 @@ module Katello
       return selected_host_group.content_view if selected_host_group.present?
     end
 
-    def fetch_content_source(host, options = {})
-      return host.content_source if host.content_source.present?
-      selected_host_group = options.fetch(:selected_host_group, nil)
-      return selected_host_group.content_source if selected_host_group.present?
-    end
-
     def accessible_lifecycle_environments(org, host)
       selected = host.lifecycle_environment
       envs = org.kt_environments.readable
@@ -103,28 +97,24 @@ module Katello
       end
     end
 
-    # Generic method to provide a list of options in the UI
-    def content_options(host, selected_id, object_type, options = {})
+    def lifecycle_environment_options(host, options = {})
       include_blank = options.fetch(:include_blank, nil)
       include_blank = '<option></option>' if include_blank == true #check for true specifically
+
+      selected_id = fetch_lifecycle_environment(host, options).try(:id)
       orgs = relevant_organizations(host)
       all_options = []
       orgs.each do |org|
-        content_object_options = ""
-        accessible_content_objects = if object_type == :lifecycle_environment
-                                       accessible_lifecycle_environments(org, host)
-                                     elsif object_type == :content_source
-                                       accessible_content_proxies(host)
-                                     end
-        accessible_content_objects.each do |content_object|
-          selected = selected_id == content_object.id ? 'selected' : ''
-          content_object_options << %(<option value="#{content_object.id}" class="kt-env" #{selected}>#{h(content_object.name)}</option>)
+        env_options = ""
+        accessible_lifecycle_environments(org, host).each do |env|
+          selected = selected_id == env.id ? 'selected' : ''
+          env_options << %(<option value="#{env.id}" class="kt-env" #{selected}>#{h(env.name)}</option>)
         end
 
         if orgs.count > 1
-          all_options << %(<optgroup label="#{org.name}">#{content_object_options}</optgroup>)
+          all_options << %(<optgroup label="#{org.name}">#{env_options}</optgroup>)
         else
-          all_options << content_object_options
+          all_options << env_options
         end
       end
 
@@ -133,24 +123,6 @@ module Katello
       all_options.html_safe
     end
 
-    def lifecycle_environment_options(host, options = {})
-      content_options(
-        host,
-        fetch_lifecycle_environment(host, options).try(:id),
-        :lifecycle_environment,
-        options
-      )
-    end
-
-    def content_source_options(host, options = {})
-      content_options(
-        host,
-        fetch_content_source(host, options).try(:id),
-        :content_source,
-        options
-      )
-    end
-
     def content_views_for_host(host, options)
       include_blank = options.fetch(:include_blank, nil)
       if include_blank == true #check for true specifically

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

@@ -13,8 +13,12 @@ module Actions
           # Pass the environments as input in order to make them accessible to UI alerts
           plan_self(environments: environments.map(&:name))
           environments.each do |environment|
-            plan_action(ContentView::PromoteToEnvironment, version, environment, description,
-                        :force_yum_metadata_regeneration => options[:force_yum_metadata_regeneration])
+            sequence do
+              plan_action(Katello::ContentViewVersion::BeforePromoteHook, :id => version.id)
+              plan_action(ContentView::PromoteToEnvironment, version, environment, description,
+                          :force_yum_metadata_regeneration => options[:force_yum_metadata_regeneration])
+              plan_action(Katello::ContentViewVersion::AfterPromoteHook, :id => version.id)
+            end
           end
         end
       end

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

@@ -0,0 +1,11 @@
+module Actions
+  module Katello
+    module ContentViewVersion
+      class AfterPromoteHook < Actions::Base
+        def finalize
+          ::Katello::ContentViewVersion.find(input[:id]).after_promote_hooks
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Actions
+  module Katello
+    module ContentViewVersion
+      class BeforePromoteHook < Actions::Base
+        def finalize
+          ::Katello::ContentViewVersion.find(input[:id]).before_promote_hooks
+        end
+      end
+    end
+  end
+end

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

@@ -13,7 +13,7 @@ module Actions
             end
             cp_consumer = host.subscription_facet.candlepin_consumer
             entitlements = pools_with_quantities.map do |pool_with_quantities|
-              cp_consumer.filter_entitlements(pool_with_quantities.pool.cp_id, pool_with_quantities.quantities)
+              cp_consumer.filter_entitlements(pool_with_quantities.pool.cp_id)
             end
 
             entitlements.flatten.each do |entitlement|

data/app/lib/actions/pulp/consumer/abstract_content_action.rb

@@ -44,18 +44,6 @@ module Actions
           messages
         end
 
-        # by default runcible puts whatever we pass into a hash under the 'name' key
-        # here we can make the unit hash more precise
-        def parse_units_for_type
-          if input[:type] == 'rpm'
-            input[:args].collect do |unit|
-              ::Katello::Util::Package.parse_nvrea_nvre(unit) || unit
-            end
-          else
-            input[:args]
-          end
-        end
-
         def presenter
           Consumer::ContentPresenter.new(self)
         end

data/app/lib/actions/pulp/consumer/content_install.rb

@@ -14,7 +14,7 @@ module Actions
         def invoke_external_task
           task = pulp_extensions.consumer.install_content(input[:consumer_uuid],
                                                    input[:type],
-                                                   parse_units_for_type,
+                                                   input[:args],
                                                     "importkeys" => true)
           schedule_timeout(Setting['content_action_accept_timeout'])
           task

data/app/lib/actions/pulp/consumer/content_uninstall.rb

@@ -14,7 +14,7 @@ module Actions
         def invoke_external_task
           pulp_extensions.consumer.uninstall_content(input[:consumer_uuid],
                                                      input[:type],
-                                                     parse_units_for_type)
+                                                     input[:args])
         end
 
         def presenter

data/app/lib/actions/pulp/consumer/content_update.rb

@@ -17,7 +17,7 @@ module Actions
 
           pulp_extensions.consumer.update_content(input[:consumer_uuid],
                                                   input[:type],
-                                                  parse_units_for_type,
+                                                  input[:args],
                                                   options)
         end
 

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

@@ -0,0 +1,40 @@
+require 'katello/util/data'
+
+module Katello
+  module Resources
+    require 'rest_client'
+
+    module Registry
+      class Proxy
+        def self.logger
+          ::Foreman::Logging.logger('katello/registry_proxy')
+        end
+
+        def self.get(path, headers = {:accept => :json})
+          logger.debug "Sending GET request to Registry: #{path}"
+          client = RegistryResource.rest_client(Net::HTTP::Get, :get, path)
+          client.get(headers)
+        end
+      end
+
+      class RegistryResource < HttpResource
+        if SETTINGS[:katello][:registry]
+          cfg = SETTINGS[:katello][:registry]
+          url = cfg[:url]
+          uri = URI.parse(url)
+          self.prefix = uri.path
+          self.site = "#{uri.scheme}://#{uri.host}:#{uri.port}"
+          self.ca_cert_file = cfg[:ca_cert_file]
+        end
+
+        class << self
+          def process_response(response)
+            debug_level = response.code >= 400 ? :error : :debug
+            logger.send(debug_level, "Registry request returned with code #{response.code}")
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/katello/util/package.rb

@@ -99,13 +99,18 @@ module Katello
 
           pack = pack.with_indifferent_access
           if latest_pack.nil? ||
-             (pack[:epoch] > latest_pack[:epoch]) ||
-             (pack[:epoch] == latest_pack[:epoch] && pack[:release] > latest_pack[:release]) ||
-             (pack[:epoch] == latest_pack[:epoch] && pack[:release] == latest_pack[:release] && pack[:version] > latest_pack[:version])
+             (pack[:epoch].to_i > latest_pack[:epoch].to_i) ||
+             (pack[:epoch].to_i == latest_pack[:epoch].to_i &&
+              pack[:version_sortable] > latest_pack[:version_sortable]) ||
+             (pack[:epoch].to_i == latest_pack[:epoch].to_i &&
+              pack[:version_sortable] == latest_pack[:version_sortable] &&
+              pack[:release_sortable] > latest_pack[:release_sortable])
             latest_pack = pack
             selected_packs = [pack]
 
-          elsif (pack[:epoch] == latest_pack[:epoch] && pack[:release] == latest_pack[:release] && pack[:version] == latest_pack[:version])
+          elsif (pack[:epoch].to_i == latest_pack[:epoch].to_i &&
+                 pack[:version_sortable] == latest_pack[:version_sortable] &&
+                 pack[:release_sortable] == latest_pack[:release_sortable])
             selected_packs << pack
           end
         end

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

@@ -50,7 +50,7 @@ module Katello
         scoped_search :on => :hypervisor, :relation => :subscription_facet, :complete_value => true
         scoped_search :on => :name, :relation => :hypervisor_host, :complete_value => true, :rename => :hypervisor_host, :ext_method => :find_by_hypervisor_host
         scoped_search :on => :name, :relation => :subscriptions, :rename => :subscription_name, :complete_value => true, :ext_method => :find_by_subscription_name
-        scoped_search :on => :id, :relation => :pools, :rename => :subscription_id, :complete_value => true, :ext_method => :find_by_subscription_id, :only_explicit => true
+        scoped_search :on => :id, :relation => :pools, :rename => :subscription_id, :complete_value => true, :ext_method => :find_by_subscription_id
       end
 
       module ClassMethods

data/app/models/katello/content_view.rb

@@ -579,22 +579,14 @@ module Katello
 
     def check_composite_action_allowed!(env)
       if composite? && Setting['restrict_composite_view']
-        if components.size != content_view_components.size
-          fail _("Make sure all the component content views are published before publishing/promoting the composite content view. "\
-               "This restriction is optional and can be modified in the Administrator -> Settings -> Content "\
-                "page using the restrict_composite_view flag.")
-        end
-
-        env_ids = env.try(:pluck, 'id') || []
-        env_ids << env.id unless env_ids.size > 0
+        # verify that the composite's component view versions exist in the target environment.
         components.each do |component|
-          component_environment_ids = component.environments.pluck('id')
-          unless (env_ids - component_environment_ids).empty?
+          unless component.environments.include?(env)
             fail _("The action requested on this composite view cannot be performed until all of the "\
                    "component content view versions have been promoted to the target environment: %{env}.  "\
-                   "This restriction is optional and can be modified in the Administrator -> Settings -> Content "\
+                   "This restriction is optional and can be modified in the Administrator -> Settings "\
                    "page using the restrict_composite_view flag.") %
-                   { :env => env.try(:pluck, 'name') || env.name }
+                   { :env => env.name }
           end
         end
       end

data/app/models/katello/content_view_version.rb

@@ -241,6 +241,14 @@ module Katello
       Rpm.in_repositories(archived_repos)
     end
 
+    def library_packages
+      Rpm.in_repositories(library_repos)
+    end
+
+    def available_packages
+      library_packages.where.not(:id => packages)
+    end
+
     def srpm_count
       Katello::Srpm.in_repositories(self.repositories.archived).count
     end
@@ -356,6 +364,24 @@ module Katello
       true
     end
 
+    def before_promote_hooks
+      run_callbacks :sync do
+        logger.debug "custom hook before_promote on #{name} will be executed if defined."
+        true
+      end
+    end
+
+    def after_promote_hooks
+      run_callbacks :sync do
+        logger.debug "custom hook after_promote on #{name} will be executed if defined."
+        true
+      end
+    end
+
+    def rabl_path
+      "katello/api/v2/#{self.class.to_s.demodulize.tableize}/show"
+    end
+
     private
 
     def remove_environment(env)

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

@@ -39,6 +39,14 @@ module Katello
         self.owner_details['contentAccessMode']
       end
 
+      def pools(consumer_uuid = nil)
+        if consumer_uuid
+          Resources::Candlepin::Owner.pools self.label, :consumer => consumer_uuid
+        else
+          Resources::Candlepin::Owner.pools self.label
+        end
+      end
+
       def generate_debug_cert
         Resources::Candlepin::Owner.generate_ueber_cert(label)
       end

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

@@ -40,16 +40,6 @@ module Katello
         end
         pool.import_data(index_hosts)
       end
-
-      def stacking_subscription(org_label, stacking_id)
-        org = Organization.find_by(:label => org_label)
-        subscription = ::Katello::Subscription.find_by(:organization_id => org.id, :cp_id => stacking_id)
-        if subscription.nil?
-          found_product = ::Katello::Resources::Candlepin::Product.find_for_stacking_id(org_label, stacking_id)
-          subscription = ::Katello::Subscription.find_by(:organization_id => org.id, :cp_id => found_product['id']) if found_product
-        end
-        subscription
-      end
     end
 
     module InstanceMethods
@@ -90,6 +80,16 @@ module Katello
         providers.any?
       end
 
+      def stacking_subscription(org_label, stacking_id)
+        org = Organization.find_by(:label => org_label)
+        subscription = ::Katello::Subscription.find_by(:organization_id => org.id, :product_id => stacking_id)
+        if subscription.nil?
+          found_product = ::Katello::Resources::Candlepin::Product.find_for_stacking_id(org_label, stacking_id)
+          subscription = ::Katello::Subscription.find_by(:organization_id => org.id, :cp_id => found_product['id']) if found_product
+        end
+        subscription
+      end
+
       # rubocop:disable MethodLength,Metrics/AbcSize
       def import_data(index_hosts_and_activation_keys = false)
         pool_attributes = {}.with_indifferent_access
@@ -101,7 +101,7 @@ module Katello
         product_attributes.map { |attr| pool_attributes[attr["name"].underscore.to_sym] = attr["value"] }
 
         if pool_json["sourceStackId"]
-          subscription = Pool.stacking_subscription(pool_json['owner']['key'], pool_json["sourceStackId"])
+          subscription = stacking_subscription(pool_json['owner']['key'], pool_json["sourceStackId"])
         else
           subscription = ::Katello::Subscription.find_by(:cp_id => pool_json["productId"])
         end