katello 3.2.1.1 → 3.3.0.rc1

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

@@ -24,7 +24,7 @@ module Katello
     param :name, String, :desc => N_("name of the GPG key"), :required => false
     param_group :search, Api::V2::ApiController
     def index
-      respond(:collection => scoped_search(index_relation.uniq, :name, :desc))
+      respond(:collection => scoped_search(index_relation.uniq, :name, :asc))
     end
 
     def index_relation

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

@@ -1,7 +1,7 @@
 module Katello
   class Api::V2::HostCollectionsController < Api::V2::ApiController
     include Katello::Concerns::FilteredAutoCompleteSearch
-    before_action :find_host_collection, :only => [:copy, :show, :update, :destroy, :destroy_hosts,
+    before_action :find_host_collection, :only => [:copy, :show, :update, :destroy,
                                                    :add_hosts, :remove_hosts, :hosts]
     before_action :find_activation_key
     before_action :find_host
@@ -34,7 +34,7 @@ module Katello
     param :available_for, String, :required => false,
           :desc => N_("Interpret specified object to return only Host Collections that can be associated with specified object. The value 'host' is supported.")
     def index
-      respond(:collection => scoped_search(index_relation.uniq, :name, :desc))
+      respond(:collection => scoped_search(index_relation.uniq, :name, :asc))
     end
 
     def index_relation

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

@@ -0,0 +1,31 @@
+module Katello
+  class Api::V2::HostTracerController < Api::V2::ApiController
+    #include Katello::Concerns::FilteredAutoCompleteSearch
+
+    before_action :find_host, :only => :index
+
+    resource_description do
+      api_version 'v2'
+      api_base_url "/api"
+    end
+
+    api :GET, "/hosts/:host_id/tracer", N_("List servises that need restarting on the host")
+    param :host_id, :identifier, :required => true, :desc => N_("ID of the host")
+    def index
+      collection = scoped_search(index_relation.uniq, :application, :asc, :resource_class => ::Katello::HostTracer)
+      respond_for_index(:collection => collection)
+    end
+
+    protected
+
+    def index_relation
+      @host.host_traces
+    end
+
+    private
+
+    def find_host
+      @host = resource_finder(::Host::Managed.authorized(:view_hosts, ::Host::Managed), params[:host_id])
+    end
+  end
+end

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

@@ -3,7 +3,8 @@ module Katello
     apipie_concern_subst(:a_resource => N_("a package"), :resource => "packages")
     include Katello::Concerns::Api::V2::RepositoryContentController
 
-    before_action :find_repositories, :only => :auto_complete_name
+    before_action :find_repositories, :only => [:auto_complete_name, :auto_complete_arch]
+    before_action :find_host, :only => :index
 
     def auto_complete_name
       page_size = Katello::Concerns::FilteredAutoCompleteSearch::PAGE_SIZE
@@ -13,6 +14,57 @@ module Katello
       render :json => rpms.pluck(col)
     end
 
+    def auto_complete_arch
+      page_size = Katello::Concerns::FilteredAutoCompleteSearch::PAGE_SIZE
+      rpms = Rpm.in_repositories(@repositories)
+      col = "#{Rpm.table_name}.arch"
+      rpms = rpms.where("#{col} ILIKE ?", "%#{params[:term]}%").select(col).group(col).order(col).limit(page_size)
+      render :json => rpms.pluck(col)
+    end
+
+    api :GET, "/packages", N_("List packages")
+    api :GET, "/content_views/:content_view_id/filters/:filter_id/:resource_id", N_("List :resource_id")
+    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 :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")
+    param :host_id, :number, :desc => N_("host id to list applicable packages for")
+    param :packages_restrict_upgradable, :boolean, :desc => N_("Only show packages that are upgradable in the host(s) Content View.")
+    param :packages_restrict_applicable, :boolean, :desc => N_("Only show packages that are applicable to hosts (defaults to true if host_id is specified)")
+    param_group :search, ::Katello::Api::V2::ApiController
+    def index
+      super
+    end
+
+    def custom_index_relation(collection)
+      if ::Foreman::Cast.to_bool(params[:packages_restrict_upgradable])
+        if @host
+          collection = collection.installable_for_hosts([@host])
+        else
+          collection = collection.installable_for_hosts(::Host::Managed.authorized("view_hosts"))
+        end
+      elsif ::Foreman::Cast.to_bool(params[:packages_restrict_applicable]) || @host
+        if @host
+          collection = collection.applicable_to_hosts([@host])
+        else
+          collection = collection.applicable_to_hosts(::Host::Managed.authorized("view_hosts"))
+        end
+      end
+
+      collection
+    end
+
+    def find_host
+      if params[:host_id]
+        @host = ::Host::Managed.authorized("view_hosts").find_by(:id => params[:host_id])
+        fail HttpErrors::NotFound, _('Could not find a host with id %s') % params[:host_id] unless @host
+      end
+    end
+
     def find_repositories
       @repositories = Repository.readable.where(:id => params[:repoids])
     end

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

@@ -36,7 +36,7 @@ module Katello
     param_group :search, Api::V2::ApiController
     def index
       options = {:includes => [:sync_plan, :provider]}
-      respond(:collection => scoped_search(index_relation.uniq, :name, :desc, options))
+      respond(:collection => scoped_search(index_relation.uniq, :name, :asc, options))
     end
 
     def index_relation

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

@@ -2,5 +2,13 @@ module Katello
   class Api::V2::PuppetModulesController < Api::V2::ApiController
     apipie_concern_subst(:a_resource => N_("a puppet module"), :resource => "puppet_modules")
     include Katello::Concerns::Api::V2::RepositoryContentController
+
+    def custom_index_relation(collection)
+      if @environment && !@environment.library?
+        collection = collection.joins(:content_view_puppet_environments).
+            where("#{Katello::ContentViewPuppetEnvironment.table_name}.environment_id" => @environment.id)
+      end
+      collection
+    end
   end
 end

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

@@ -33,6 +33,8 @@ module Katello
       param :download_policy, ["immediate", "on_demand", "background"], :desc => N_("download policy for yum repos (either 'immediate', 'on_demand', or 'background')")
       param :mirror_on_sync, :bool, :desc => N_("true if this repository when synced has to be mirrored from the source and stale rpms removed.")
       param :verify_ssl_on_sync, :bool, :desc => N_("if true, Katello will verify the upstream url's SSL certifcates are signed by a trusted CA.")
+      param :upstream_username, String, :desc => N_("Username of the upstream repository user used for authentication")
+      param :upstream_password, String, :desc => N_("Password of the upstream repository user used for authentication")
     end
 
     api :GET, "/repositories", N_("List of enabled repositories")
@@ -57,7 +59,7 @@ module Katello
     param_group :search, Api::V2::ApiController
     def index
       options = {:includes => [:gpg_key, :product, :environment]}
-      respond(:collection => scoped_search(index_relation.uniq, :name, :desc, options))
+      respond(:collection => scoped_search(index_relation.uniq, :name, :asc, options))
     end
 
     def index_relation
@@ -147,7 +149,8 @@ module Katello
       repository.docker_upstream_name = repo_params[:docker_upstream_name] if repo_params[:docker_upstream_name]
       repository.mirror_on_sync = ::Foreman::Cast.to_bool(repo_params[:mirror_on_sync]) if repo_params.key?(:mirror_on_sync)
       repository.verify_ssl_on_sync = ::Foreman::Cast.to_bool(repo_params[:verify_ssl_on_sync]) if repo_params.key?(:verify_ssl_on_sync)
-
+      repository.upstream_username = repo_params[:upstream_username] if repo_params.key?(:upstream_username)
+      repository.upstream_password = repo_params[:upstream_password] if repo_params.key?(:upstream_password)
       sync_task(::Actions::Katello::Repository::Create, repository, false, true)
       repository = Repository.find(repository.id)
       respond_for_show(:resource => repository)
@@ -224,6 +227,8 @@ module Katello
     param :download_policy, ["immediate", "on_demand", "background"], :desc => N_("download policy for yum repos (either 'immediate', 'on_demand', or 'background')")
     param :mirror_on_sync, :bool, :desc => N_("true if this repository when synced has to be mirrored from the source and stale rpms removed.")
     param :verify_ssl_on_sync, :bool, :desc => N_("if true, Katello will verify the upstream url's SSL certifcates are signed by a trusted CA.")
+    param :upstream_username, String, :desc => N_("Username of the upstream repository user for authentication")
+    param :upstream_password, String, :desc => N_("Password of the upstream repository user for authentication")
     def update
       repo_params = repository_params
       sync_task(::Actions::Katello::Repository::Update, @repository, repo_params)
@@ -319,7 +324,7 @@ module Katello
       end
 
       if params.key?(:upload_ids)
-        Foreman::Deprecation.api_deprecation_warning("The parameter upload_ids will be removed in Katello 3.3. Please update to use the uploads parameter.")
+        ::Foreman::Deprecation.api_deprecation_warning("The parameter upload_ids will be removed in Katello 3.3. Please update to use the uploads parameter.")
 
         params[:upload_ids].each do |upload_id|
           begin
@@ -384,7 +389,7 @@ module Katello
     end
 
     def repository_params
-      keys = [:download_policy, :mirror_on_sync, :verify_ssl_on_sync]
+      keys = [:download_policy, :mirror_on_sync, :verify_ssl_on_sync, :upstream_password, :upstream_username]
       keys += [:label, :content_type] if params[:action] == "create"
       if params[:action] == 'create' || @repository.custom?
         keys += [:url, :gpg_key_id, :unprotected, :name, :checksum_type, :docker_upstream_name]

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

@@ -111,24 +111,21 @@ module Katello
         @provider.save!
       end
 
-      task = async_task(::Actions::Katello::Provider::ManifestImport, @provider, File.expand_path(temp_file.path), params[:force])
+      task = async_task(::Actions::Katello::Organization::ManifestImport, @organization, File.expand_path(temp_file.path), params[:force])
       respond_for_async :resource => task
     end
 
     api :PUT, "/organizations/:organization_id/subscriptions/refresh_manifest", N_("Refresh previously imported manifest for Red Hat provider")
     param :organization_id, :number, :desc => N_("Organization id"), :required => true
     def refresh_manifest
-      details  = @provider.organization.owner_details
-      upstream = details['upstreamConsumer'].blank? ? {} : details['upstreamConsumer']
-
-      task = async_task(::Actions::Katello::Provider::ManifestRefresh, @provider, upstream)
+      task = async_task(::Actions::Katello::Organization::ManifestRefresh, @organization)
       respond_for_async :resource => task
     end
 
     api :POST, "/organizations/:organization_id/subscriptions/delete_manifest", N_("Delete manifest from Red Hat provider")
     param :organization_id, :number, :desc => N_("Organization id"), :required => true
     def delete_manifest
-      task = async_task(::Actions::Katello::Provider::ManifestDelete, @provider)
+      task = async_task(::Actions::Katello::Organization::ManifestDelete, @organization)
       respond_for_async :resource => task
     end
 

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

@@ -22,7 +22,7 @@ module Katello
     param :sync_date, String, :desc => N_("filter by sync date")
     param :interval, SyncPlan::TYPES, :desc => N_("filter by interval")
     def index
-      respond_for_index(:collection => scoped_search(index_relation.uniq, :name, :desc))
+      respond_for_index(:collection => scoped_search(index_relation.uniq, :name, :asc))
     end
 
     def index_relation

data/app/controllers/katello/application_controller.rb

@@ -242,10 +242,6 @@ module Katello
       end
     end
 
-    def permission_denied
-      render :template => "katello/common/403"
-    end
-
     # Parse the input provided and return the value of displayMessage. If displayMessage is not available, return "".
     # (Note: this can be used to pull the displayMessage from a Candlepin exception.)
     # This assumes that the input follows a syntax similar to:

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

@@ -77,7 +77,13 @@ module Katello
         collection = filter_by_repos(Repository.readable, collection)
         collection = filter_by_repos([@repo], collection) if @repo
         collection = filter_by_content_view_version(@version, collection) if @version
-        collection = filter_by_environment(@environment, collection) if @environment
+        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.
+          collection = filter_by_environment(@environment, collection)
+        end
         collection = filter_by_repos(Repository.readable.in_organization(@organization), collection) if @organization
         collection = filter_by_ids(params[:ids], collection) if params[:ids]
         @filter = ContentViewFilter.find(params[:filterId]) if params[:filterId]
@@ -145,8 +151,10 @@ module Katello
       def find_environment
         if params[:environment_id]
           @environment = KTEnvironment.readable.find_by(:id => params[:environment_id])
-          fail HttpErrors::NotFound, _("Could not find Lifecycle Environment with id '%{id}'.") %
-            {id: params[:environment_id]} if @environment.nil?
+          if @environment.nil?
+            fail HttpErrors::NotFound, _("Could not find Lifecycle Environment with id '%{id}'.") %
+              {id: params[:environment_id]}
+          end
         end
       end
 

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

@@ -0,0 +1,35 @@
+module Katello
+  module Concerns
+    module Api::V2::SmartProxiesControllerExtensions
+      extend ActiveSupport::Concern
+
+      included do
+        def_param_group :smart_proxy do
+          param :smart_proxy, Hash, :required => true, :action_aware => true do
+            param :name, String, :required => true
+            param :url, String, :required => true
+            param :download_policy, String, :required => false, :desc => N_('Download Policy of the capsule, must be one of %s') %
+                                      SmartProxy::DOWNLOAD_POLICIES.join(', ')
+            param_group :taxonomies, ::Api::V2::BaseController
+          end
+        end
+
+        api :POST, "/smart_proxies/", N_("Create a smart proxy")
+        param_group :smart_proxy, :as => :create
+
+        def create
+          @smart_proxy = SmartProxy.new(smart_proxy_params)
+          process_response @smart_proxy.save
+        end
+
+        api :PUT, "/smart_proxies/:id/", N_("Update a smart proxy")
+        param :id, String, :required => true
+        param_group :smart_proxy
+
+        def update
+          process_response @smart_proxy.update_attributes(smart_proxy_params)
+        end
+      end
+    end
+  end
+end

data/app/controllers/katello/providers_controller.rb

@@ -16,8 +16,8 @@ module Katello
     def redhat_provider_tab
       #preload orphaned product information, as it is very slow per product
       subscription_product_ids = []
-
-      subscriptions = Resources::Candlepin::Subscription.get_for_owner(current_organization.label)
+      included_list = %w(product.id providedProducts.id derivedProvidedProducts.id)
+      subscriptions = Resources::Candlepin::Subscription.get_for_owner(current_organization.label, included_list)
       subscriptions.each do |sub|
         subscription_product_ids << sub['product']['id'] if sub['product']['id']
         subscription_product_ids += sub['providedProducts'].map { |p| p['id'] } if sub['providedProducts']

data/app/controllers/katello/remote_execution_controller.rb

@@ -32,6 +32,8 @@ module Katello
       def inputs
         if feature_name == 'katello_errata_install'
           { :errata => params[:name] }
+        elsif feature_name == 'katello_service_restart'
+          { :helper => params[:name] }
         else
           { :package => params[:name] }
         end

data/app/helpers/katello/concerns/foreman_docker/container_steps_helper_extensions.rb

@@ -24,11 +24,11 @@ module Katello
           proxies = Organization.current.nil? ? [] : SmartProxy.with_content
           selected_proxy = proxies.size == 1 ? proxies.first.id : nil
 
-          field(f, 'capsule[id]', :label => _("Capsule"), :required => true) do
+          field(f, 'capsule[id]', :label => _("Smart proxy"), :required => true) do
             make_select_box(:capsule,
                              SmartProxy.with_content,
                              "load_capsules",
-                             :prompt => _("Select a Capsule"),
+                             :prompt => _("Select a Smart proxy"),
                              :selected => selected_proxy)
           end
         end

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

@@ -30,6 +30,29 @@ module Katello
         "#{available_percent}%"
       end
 
+      def download_policies
+        policies = [
+          {
+            :name => _("On Demand"),
+            :label => ::Runcible::Models::YumImporter::DOWNLOAD_ON_DEMAND
+          },
+          {
+            :name => _("Background"),
+            :label => ::Runcible::Models::YumImporter::DOWNLOAD_BACKGROUND
+          },
+          {
+            :name => _("Immediate"),
+            :label => ::Runcible::Models::YumImporter::DOWNLOAD_IMMEDIATE
+          },
+          {
+            :name => _("Inherit from Repository"),
+            :label => SmartProxy::DOWNLOAD_INHERIT
+          }
+        ]
+
+        policies.map { |p| OpenStruct.new(p) }
+      end
+
       def storage_warning(available)
         gb_size = available.to_i / 1_048_576
         case gb_size

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

@@ -6,6 +6,7 @@ module Actions
 
     class CandlepinListeningService
       RECONNECT_ATTEMPTS = 30
+      LOOP_RECEIVE_COUNT = 100
       TIMEOUT = Qpid::Messaging::Duration::SECOND
       NO_MESSAGE_AVAILABLE_ERROR_TYPE = 'NoMessageAvailable'.freeze
 
@@ -72,10 +73,14 @@ module Actions
       def poll_for_messages(suspended_action)
         @thread.kill if @thread
         @thread = Thread.new do
+          count = 0
           loop do
             begin
               message = fetch_message
-              if message[:result]
+              if (message[:result].nil? && message[:error].nil?) || count >= LOOP_RECEIVE_COUNT
+                sleep 1
+                count = 0
+              elsif message[:result]
                 result = message[:result]
                 @session.acknowledge(:message => result, :sync => true)
                 suspended_action.notify_message_received(result.message_id, result.subject, result.content)
@@ -83,10 +88,11 @@ module Actions
                 suspended_action.notify_not_connected(message[:error])
                 break
               end
-              sleep 1
             rescue => e
               suspended_action.notify_fatal(e)
               raise e
+            ensure
+              count += 1
             end
           end
         end

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

@@ -0,0 +1,17 @@
+module Actions
+  module Candlepin
+    module Owner
+      class DestroyImports < Candlepin::Abstract
+        input_format do
+          param :label
+        end
+
+        def run
+          organization = ::Organization.find_by!(label: input[:label])
+          output[:response] = ::Katello::Resources::Candlepin::Owner.destroy_imports(organization.label, true)
+          organization.redhat_provider.index_subscriptions
+        end
+      end
+    end
+  end
+end