katello 3.5.0.rc1 → 3.5.0.rc2

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

@@ -25,12 +25,12 @@ module Katello
     api :GET, "/sync_plans/:sync_plan_id/products", N_("List of Products for sync plan")
     api :GET, "/organizations/:organization_id/sync_plans/:sync_plan_id/products", N_("List of Products for sync plan")
     param :organization_id, :number, :desc => N_("Filter products by organization"), :required => true
-    param :subscription_id, :identifier, :desc => N_("Filter products by subscription")
+    param :subscription_id, :number, :desc => N_("Filter products by subscription")
     param :name, String, :desc => N_("Filter products by name")
     param :enabled, :bool, :desc => N_("Filter products by enabled or disabled")
     param :custom, :bool, :desc => N_("Filter products by custom")
     param :include_available_content, :bool, :desc => N_("Whether to include available content attribute in results")
-    param :sync_plan_id, :identifier, :desc => N_("Filter products by sync plan id")
+    param :sync_plan_id, :number, :desc => N_("Filter products by sync plan id")
     param :available_for, String, :desc => N_("Interpret specified object to return only Products that can be associated with specified object.  Only 'sync_plan' is supported."),
           :required => false
     param_group :search, Api::V2::ApiController
@@ -102,7 +102,7 @@ module Katello
     end
 
     api :POST, "/products/:id/sync", N_("Sync all repositories for a product")
-    param :id, :identifier, :required => true, :desc => "product ID"
+    param :id, :number, :required => true, :desc => "product ID"
     def sync
       syncable_repos = @product.library_repositories.has_url.syncable
       if syncable_repos.empty?

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

@@ -171,20 +171,20 @@ module Katello
     end
 
     api :PUT, "/repositories/:id/republish", N_("Forces a republish of the specified repository, regenerating metadata and symlinks on the filesystem.")
-    param :id, :identifier, :desc => N_("Repository identifier"), :required => true
+    param :id, :number, :desc => N_("Repository identifier"), :required => true
     def republish
       task = async_task(::Actions::Katello::Repository::MetadataGenerate, @repository, :force => true)
       respond_for_async :resource => task
     end
 
     api :GET, "/repositories/:id", N_("Show a repository")
-    param :id, :identifier, :required => true, :desc => N_("repository ID")
+    param :id, :number, :required => true, :desc => N_("repository ID")
     def show
       respond_for_show(:resource => @repository)
     end
 
     api :POST, "/repositories/:id/sync", N_("Sync a repository")
-    param :id, :identifier, :required => true, :desc => N_("repository ID")
+    param :id, :number, :required => true, :desc => N_("repository ID")
     param :source_url, String, :desc => N_("temporarily override feed URL for sync"), :required => false
     param :incremental, :bool, :desc => N_("perform an incremental import"), :required => false
     param :skip_metadata_check, :bool, :desc => N_("Force sync even if no upstream changes are detected. Only used with yum repositories."), :required => false
@@ -212,7 +212,7 @@ module Katello
     end
 
     api :POST, "/repositories/:id/export", N_("Export a repository")
-    param :id, :identifier, :desc => N_("Repository identifier"), :required => true
+    param :id, :number, :desc => N_("Repository identifier"), :required => true
     param :export_to_iso, :bool, :desc => N_("Export to ISO format"), :required => false
     param :iso_mb_size, :number, :desc => N_("maximum size of each ISO in MB"), :required => false
     param :since, Date, :desc => N_("Optional date of last export (ex: 2010-01-01T12:00:00Z)"), :required => false
@@ -241,7 +241,7 @@ module Katello
 
     api :PUT, "/repositories/:id", N_("Update a repository")
     param :name, String, :desc => N_("New name for the repository")
-    param :id, :identifier, :required => true, :desc => N_("repository ID")
+    param :id, :number, :required => true, :desc => N_("repository ID")
     param :gpg_key_id, :number, :desc => N_("ID of a gpg key that will be assigned to this repository")
     param :unprotected, :bool, :desc => N_("true if this repository can be published via HTTP")
     param :checksum_type, String, :desc => N_("checksum of the repository, currently 'sha1' & 'sha256' are supported.'")
@@ -261,7 +261,7 @@ module Katello
     end
 
     api :DELETE, "/repositories/:id", N_("Destroy a custom repository")
-    param :id, :identifier, :required => true
+    param :id, :number, :required => true
     def destroy
       sync_task(::Actions::Katello::Repository::Destroy, @repository)
       respond_for_destroy
@@ -290,7 +290,7 @@ module Katello
       Rails.logger.info("Sync_complete called for #{repo.name}, running after_sync.")
 
       unless repo.dynflow_handled_last_sync?(task_id)
-        async_task(::Actions::Katello::Repository::Sync, repo, task_id)
+        async_task(::Actions::Katello::Repository::ScheduledSync, repo, task_id)
       end
       render :json => {}
     end
@@ -300,7 +300,7 @@ module Katello
     api :PUT, "/repositories/:id/remove_puppet_modules"
     api :PUT, "/repositories/:id/remove_content"
     desc "Remove content from a repository"
-    param :id, :identifier, :required => true, :desc => "repository ID"
+    param :id, :number, :required => true, :desc => "repository ID"
     param 'ids', Array, :required => true, :desc => "Array of content ids to remove"
     param 'sync_capsule', :bool, :desc => N_("Whether or not to sync an external capsule after upload. Default: true")
     def remove_content
@@ -310,7 +310,7 @@ module Katello
     end
 
     api :POST, "/repositories/:id/upload_content", N_("Upload content into the repository")
-    param :id, :identifier, :required => true, :desc => N_("repository ID")
+    param :id, :number, :required => true, :desc => N_("repository ID")
     param :content, File, :required => true, :desc => N_("Content files to upload. Can be a single file or array of files.")
     def upload_content
       fail Katello::Errors::InvalidRepositoryContent, _("Cannot upload Docker content.") if @repository.docker?
@@ -336,7 +336,7 @@ module Katello
     end
 
     api :PUT, "/repositories/:id/import_uploads", N_("Import uploads into a repository")
-    param :id, :identifier, :required => true, :desc => N_("Repository id")
+    param :id, :number, :required => true, :desc => N_("Repository id")
     param :upload_ids, Array, :desc => N_("Array of upload ids to import"), :deprecated => true
     param :async, :bool, desc: N_("Do not wait for the ImportUpload action to finish. Default: false")
     param 'publish_repository', :bool, :desc => N_("Whether or not to regenerate the repository on disk. Default: true")
@@ -385,7 +385,7 @@ module Katello
     # we don't want to authenticate, authorize etc, trying to distinguish between a yum request and normal api request
     # might not always be 100% bullet proof, and its more important that yum can fetch the key.
     api :GET, "/repositories/:id/gpg_key_content", N_("Return the content of a repo gpg key, used directly by yum")
-    param :id, :identifier, :required => true
+    param :id, :number, :required => true
     def gpg_key_content
       if @repository.gpg_key && @repository.gpg_key.content.present?
         render(:plain => @repository.gpg_key.content, :layout => false)

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

@@ -18,7 +18,7 @@ module Katello
     def index
       collection = {}
       if @product.nil?
-        collection[:results] = available_repository_sets
+        collection[:results] = @organization.enabled_product_content
       else
         collection[:results] = @product.displayable_product_contents
       end
@@ -108,14 +108,5 @@ module Katello
     def substitutions
       params.slice(:basearch, :releasever)
     end
-
-    def available_repository_sets
-      repository_sets = @organization.products.enabled.uniq.flat_map do |product|
-        product.available_content
-      end
-      repository_sets.uniq.sort_by do |repository_set|
-        repository_set.content.name.downcase
-      end
-    end
   end
 end

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

@@ -13,7 +13,7 @@ module Katello
         end
 
         api :PUT, "/hosts/:host_id/host_collections", N_("Alter a hosts host collections")
-        param :host_id, :identifier, :required => true, :desc => N_("The id of the host to alter")
+        param :host_id, :number, :required => true, :desc => N_("The id of the host to alter")
         param :host_collection_ids, Array, :required => true, :desc => N_("List of host collection ids to update")
         def host_collections
           @host.host_collection_ids = params[:host_collection_ids]

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

@@ -21,8 +21,8 @@ module Katello
       api :GET, "/content_view_filters/:content_view_filter_id/:resource_id", N_("List :resource_id")
       api :GET, "/repositories/:repository_id/:resource_id", N_("List :resource_id")
       param :organization_id, :number, :desc => N_("organization identifier")
-      param :content_view_version_id, :identifier, :desc => N_("content view version identifier")
-      param :content_view_filter_id, :identifier, :desc => N_("content view filter identifier")
+      param :content_view_version_id, :number, :desc => N_("content view version identifier")
+      param :content_view_filter_id, :number, :desc => N_("content view filter identifier")
       param :repository_id, :number, :desc => N_("repository identifier")
       param :environment_id, :number, :desc => N_("environment identifier")
       param :ids, Array, :desc => N_("ids to filter content by")
@@ -51,7 +51,7 @@ module Katello
 
       api :GET, "/compare/", N_("List :resource_id")
       param :content_view_version_ids, Array, :desc => N_("content view versions to compare")
-      param :repository_id, :identifier, :desc => N_("Library repository id to restrict comparisons to")
+      param :repository_id, :number, :desc => N_("Library repository id to restrict comparisons to")
       def compare
         fail _("No content_view_version_ids provided") if params[:content_view_version_ids].empty?
         @versions = ContentViewVersion.readable.where(:id => params[:content_view_version_ids])

data/app/helpers/katello/providers_helper.rb

@@ -20,8 +20,11 @@ module Katello
       tabs = {}.with_indifferent_access
       redhat_repo_tabs.each { |tab| tabs[tab[:id]] = tab }
 
+      product_content = provider.organization.filtered_product_content
+
       provider.products.each do |product|
-        product.displayable_product_contents.each do |prod_content|
+        selected_contents = product_content.select { |pc| pc.product_id == product.id }.select(&:displayable?)
+        selected_contents.each do |prod_content|
           name = prod_content.content.name
           if prod_content.content_type == ::Katello::Repository::CANDLEPIN_OSTREE_TYPE
             key = :ostree

data/app/lib/actions/candlepin/abstract.rb

@@ -4,6 +4,7 @@ module Actions
       middleware.use ::Actions::Middleware::RemoteAction
       middleware.use ::Actions::Middleware::PropagateCandlepinErrors
       middleware.use ::Actions::Middleware::CandlepinServicesCheck
+      middleware.use ::Actions::Middleware::KeepSessionId
     end
   end
 end

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

@@ -40,6 +40,7 @@ module Actions
           host.subscription_facet.uuid = hypervisor_json[:uuid]
           host.subscription_facet.import_database_attributes(host.subscription_facet.candlepin_consumer.consumer_attributes)
           host.subscription_facet.save!
+          host.subscription_facet.update_subscription_status
           host.save!
         end
 

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

@@ -0,0 +1,29 @@
+module Actions
+  module Katello
+    module Host
+      class UpdateReleaseVersion < Actions::EntryAction
+        def plan(host, release_version)
+          plan_self(:hostname => host.name)
+          if host.content_facet && host.subscription_facet
+            if release_version.present? && !host.content_facet.available_releases.include?(release_version)
+              fail _("Host %{name} cannot be assigned release version %{release_version}.") % { :name => host.name, :release_version => release_version }
+            else
+              host.subscription_facet.release_version = release_version
+            end
+            plan_action(Actions::Katello::Host::Update, host)
+          else
+            fail _("Host %s has not been registered with subscription-manager.") % host.name
+          end
+        end
+
+        def humanized_name
+          if input.try(:[], :hostname).nil?
+            _("Update release version for host")
+          else
+            _("Update release version for host %s") % input[:hostname]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -32,13 +32,10 @@ module Actions
         end
 
         def run
-          ::Katello::Repository.ensure_sync_notification
-        end
-
-        def finalize
           product = ::Katello::Product.find(input[:product][:id])
-          product.cp_id = input[:cp_id]
-          product.save!
+          product.update_attributes!(:cp_id => input[:cp_id])
+
+          ::Katello::Repository.ensure_sync_notification
         end
 
         def humanized_name

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

@@ -15,7 +15,7 @@ module Actions
           plan_self(id: product.id, subscription_id: subscription_id)
         end
 
-        def finalize
+        def run
           product = ::Katello::Product.find_by!(:id => input[:id])
           product.import_subscription(input[:subscription_id])
         end

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

@@ -0,0 +1,15 @@
+module Actions
+  module Katello
+    module Repository
+      class ScheduledSync < Sync
+        def humanized_name
+          _("Scheduled Synchronization")
+        end
+
+        def resource_locks
+          :link
+        end
+      end
+    end
+  end
+end

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

@@ -43,6 +43,10 @@ module Actions
           delete_tmp_files(input[:tmp_files])
         end
 
+        def rescue_strategy
+          Dynflow::Action::Rescue::Skip
+        end
+
         private
 
         def tmp_dir

data/app/lib/actions/middleware/keep_session_id.rb

@@ -0,0 +1,29 @@
+module Actions
+  module Middleware
+    class KeepSessionId < Dynflow::Middleware
+      def plan(*args)
+        pass(*args).tap do
+          action.input[:session_id] = ::Logging.mdc['request']
+        end
+      end
+
+      def run(*args)
+        with_session_id { pass(*args) }
+      end
+
+      def finalize
+        with_session_id { pass }
+      end
+
+      private
+
+      def with_session_id(&_block)
+        original_session_id = ::Logging.mdc['request']
+        ::Logging.mdc['request'] = action.input[:session_id]
+        yield
+      ensure
+        ::Logging.mdc['request'] = original_session_id
+      end
+    end
+  end
+end

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

@@ -50,6 +50,14 @@ module Katello
         self.consumer_key = cfg[:oauth_key]
         self.ca_cert_file = cfg[:ca_cert_file]
 
+        class << self
+          def process_response(response)
+            debug_level = response.code >= 400 ? :error : :debug
+            logger.send(debug_level, "Candlepin request #{response.headers[:x_candlepin_request_uuid]} returned with code #{response.code}")
+            super
+          end
+        end
+
         def self.logger
           ::Foreman::Logging.logger('katello/cp_rest')
         end
@@ -65,9 +73,14 @@ module Katello
             cp_oauth_header = User.cp_oauth_header
           end
 
-          {'accept' => 'application/json',
-           'accept-language' => I18n.locale,
-           'content-type' => 'application/json'}.merge(cp_oauth_header)
+          headers = {'accept' => 'application/json',
+                     'accept-language' => I18n.locale,
+                     'content-type' => 'application/json'}
+
+          request_id = ::Logging.mdc['request']
+          headers['X-Correlation-ID'] = request_id.split('-')[0] if request_id
+
+          headers.merge!(cp_oauth_header)
         end
 
         def self.name_to_key(a_name)
@@ -386,6 +399,10 @@ module Katello
             self.post(path, {:import => File.new(path_to_file, 'rb')}, self.default_headers.except('content-type'))
           end
 
+          def product_content(organization_name)
+            Product.all(organization_name, [:id, :productContent])
+          end
+
           def destroy_imports(organization_name, wait_until_complete = false)
             response_json = self.delete(join_path(path(organization_name), 'imports'), self.default_headers)
             response = JSON.parse(response_json).with_indifferent_access
@@ -641,8 +658,8 @@ module Katello
 
       class Product < CandlepinResource
         class << self
-          def all(owner_label)
-            JSON.parse(Candlepin::CandlepinResource.get(path(owner_label), self.default_headers).body)
+          def all(owner_label, included = [])
+            JSON.parse(Candlepin::CandlepinResource.get(path(owner_label) + "?#{included_list(included)}", self.default_headers).body)
           end
 
           def find_for_stacking_id(owner_key, stacking_id)

data/app/lib/katello/validators/hostgroup_kickstart_repository_validator.rb

@@ -0,0 +1,30 @@
+module Katello
+  module Validators
+    class HostgroupKickstartRepositoryValidator < ActiveModel::Validator
+      def validate(hostgroup)
+        # check content source first, otherwise it's meaningless to proceed
+        if hostgroup.content_source && hostgroup.lifecycle_environment
+          valid = hostgroup.content_source.lifecycle_environments.include?(hostgroup.lifecycle_environment)
+          hostgroup.errors.add(:base, _("The selected content source and lifecycle environment do not match")) && return unless valid
+        end
+
+        return unless hostgroup.kickstart_repository_id
+
+        msg = if hostgroup.content_source.blank?
+                hostgroup.errors.add(:base, _("Please select a content source before assigning a kickstart repository"))
+              elsif hostgroup.operatingsystem.blank?
+                _("Please select an operating system before assigning a kickstart repository")
+              elsif !hostgroup.operatingsystem.is_a?(Redhat)
+                _("Kickstart repositories can only be assigned to hosts in the Red Hat family")
+              elsif hostgroup.architecture.blank?
+                _("Please select an architecture before assigning a kickstart repository")
+              elsif hostgroup.operatingsystem.kickstart_repos(hostgroup).none? { |repo| repo[:id] == hostgroup.kickstart_repository_id }
+                _("The selected kickstart repository is not part of the assigned content view, lifecycle environment,
+                  content source, operating system, and architecture")
+              end
+
+        hostgroup.errors.add(:base, msg) if msg
+      end
+    end
+  end
+end

data/app/models/katello/activation_key.rb

@@ -20,6 +20,8 @@ module Katello
     has_many :subscription_facet_activation_keys, :class_name => "Katello::SubscriptionFacetActivationKey", :dependent => :destroy
     has_many :subscription_facets, :through => :subscription_facet_activation_keys
 
+    alias_method :lifecycle_environment, :environment
+
     before_validation :set_default_content_view, :unless => :persisted?
 
     validates_lengths_from_database
@@ -90,39 +92,7 @@ module Katello
     end
 
     def products
-      all_products = []
-
-      self.pools.each do |pool|
-        if pool.subscription
-          all_products << pool.subscription.products
-        else
-          Rails.logger.error("Pool #{pool.id} is missing its subscription id.")
-        end
-      end
-      all_products.uniq.flatten
-    end
-
-    def all_products
-      organization.products.enabled.uniq
-    end
-
-    def available_content(content_access_mode_all = false, content_access_mode_env = false)
-      if content_access_mode_env
-        return [] unless environment_id && content_view_id
-        version = ContentViewVersion.in_environment(environment_id).where(:content_view_id => content_view_id).first
-        content_view_version_id = version.id
-      end
-
-      if content_access_mode_all
-        content = all_products.flat_map do |product|
-          product.available_content(content_view_version_id)
-        end
-      else
-        content = products.flat_map do |product|
-          product.available_content(content_view_version_id)
-        end
-      end
-      content.uniq
+      Katello::Product.joins(:subscriptions => {:pools => :activation_keys}).where("#{Katello::ActivationKey.table_name}.id" => self.id).enabled.uniq
     end
 
     def valid_content_override_label?(content_label)