katello 3.0.2 → 3.1.0.rc1

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

@@ -57,23 +57,14 @@ module Actions
           host.subscription_facet.update_from_consumer_attributes(host.subscription_facet.candlepin_consumer.
               consumer_attributes.except(:installedProducts, :guestIds, :facts))
           host.subscription_facet.save!
-          connect_to_smart_proxy(host)
+          host.subscription_facet.update_subscription_status
+          host.refresh_global_status!
 
           system = ::Katello::System.find(input[:system_id])
           system.uuid = input[:uuid]
           system.save!
         end
 
-        def connect_to_smart_proxy(system)
-          smart_proxy = SmartProxy.where(:name => system.name).first
-
-          if smart_proxy
-            smart_proxy.content_host = system.content_host
-            smart_proxy.organizations << system.organization unless smart_proxy.organizations.include?(system.organization)
-            smart_proxy.save!
-          end
-        end
-
         private
 
         def set_host_collections(host, activation_keys)

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

@@ -9,7 +9,7 @@ module Actions
 
           entitlements.each do |entitlement|
             plan_action(::Actions::Candlepin::Consumer::RemoveSubscription, :uuid => host.subscription_facet.uuid,
-                        :entitlement_id => entitlement['id'])
+                        :entitlement_id => entitlement['id'], :pool_id => entitlement['pool']['id'])
             plan_self(:host_name => host.name)
           end
         end

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

@@ -17,7 +17,7 @@ module Actions
               else
                 consumer_params = host.subscription_facet.consumer_attributes
               end
-              ::Katello::Host::SubscriptionFacet.update_facts(host, consumer_params[:facts]) unless consumer_params[:facts].blank?
+              ::Katello::Host::SubscriptionFacet.update_facts(::Host.find(host.id), consumer_params[:facts]) unless consumer_params[:facts].blank?
               host.subscription_facet.save!
               plan_action(::Actions::Candlepin::Consumer::Update, host.subscription_facet.uuid, consumer_params)
             end

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

@@ -14,7 +14,11 @@ module Actions
         end
 
         def humanized_name
-          _("Update for host %s") % input[:hostname]
+          if input.try(:[], :hostname).nil?
+            _("Update for host")
+          else
+            _("Update for host %s") % input[:hostname]
+          end
         end
       end
     end

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

@@ -17,7 +17,7 @@ module Actions
           errata = ::Katello::Erratum.where(:id => repo.repository_errata.where('katello_repository_errata.updated_at > ?', input[:last_updated].to_datetime).pluck(:erratum_id))
 
           begin
-            MailNotification[:katello_sync_errata].deliver(:users => users, :repo => repo, :errata => errata) unless users.blank?
+            MailNotification[:katello_sync_errata].deliver_now(:users => users, :repo => repo, :errata => errata) unless users.blank?
           rescue => e
             message = _('Unable to send errata e-mail notification: %{error}' % {:error => e})
             Rails.logger.error(message)

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

@@ -9,7 +9,7 @@ module Actions
           param :export_result, Hash
         end
 
-        EXPORT_OUTPUT_BASEDIR = "/var/lib/pulp/published/yum/master/group_export_distributor/"
+        EXPORT_OUTPUT_BASEDIR = "/var/lib/pulp/published/yum/master/group_export_distributor/".freeze
 
         def plan(repos, export_to_iso, since, iso_size, group_id)
           unless File.directory?(Setting['pulp_export_destination'])

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

@@ -1,3 +1,4 @@
+# rubocop:disable HandleExceptions
 module Actions
   module Katello
     module Repository
@@ -51,6 +52,7 @@ module Actions
 
         def run
           ForemanTasks.async_task(Repository::CapsuleGenerateAndSync, ::Katello::Repository.find(input[:id]))
+        rescue ::Katello::Errors::CapsuleCannotBeReached # skip any capsules that cannot be connected to
         end
 
         def humanized_name

data/app/lib/actions/pulp/abstract_async_task.rb

@@ -4,7 +4,7 @@ module Actions
       include Actions::Base::Polling
       include ::Dynflow::Action::Cancellable
 
-      FINISHED_STATES = %w(finished error canceled skipped)
+      FINISHED_STATES = %w(finished error canceled skipped).freeze
 
       # A call report (documented http://pulp-dev-guide.readthedocs.org/en/latest/conventions/sync-v-async.html)
       # Looks like:  {

data/app/lib/actions/pulp/abstract_async_task_group.rb

@@ -0,0 +1,76 @@
+module Actions
+  module Pulp
+    class AbstractAsyncTaskGroup < Pulp::Abstract
+      include Actions::Base::Polling
+
+      # A call report (documented https://github.com/pulp/pulp/blob/master/docs/dev-guide/integration/rest-api/consumer/applicability.rst#id65)
+      # Looks like:
+      #  {
+      #    "_href": "/pulp/api/v2/task_groups/7744e2df-39b9-46f0-bb10-feffa2f7014b/",
+      #    "group_id": "7744e2df-39b9-46f0-bb10-feffa2f7014b"
+      #  }
+      #
+      # A TaskGroup (https://github.com/pulp/pulp/blob/master/docs/dev-guide/integration/rest-api/tasks.rst#task-group-management)
+      # Looks like:
+      # {
+      #  "accepted": 0,
+      #  "finished": 100,
+      #  "running": 4,
+      #  "canceled": 0,
+      #  "waiting": 2,
+      #  "skipped": 0,
+      #  "suspended": 0,
+      #  "error": 0,
+      #  "total": 106
+      # }
+
+      def run(event = nil)
+        # do nothing when the action is being skipped
+        unless event == Dynflow::Action::Skip
+          super
+        end
+      end
+
+      def humanized_state
+        case state
+        when :running
+          if self.external_task.nil?
+            _("initiating Pulp task")
+          else
+            _("checking Pulp task status")
+          end
+        else
+          super
+        end
+      end
+
+      def done?
+        finishing_states = ["finished", "canceled", "skipped", "suspended", "error"]
+        return false if (finishing_states - external_task.keys).present?
+        task_resource.completed?(external_task)
+      end
+
+      def external_task
+        output["pulp_task_group"]
+      end
+
+      private
+
+      def external_task=(external_task_data)
+        if external_task_data.key?("group_id")
+          output["pulp_task_group"] = {"group_id" => external_task_data["group_id"]}
+        else
+          output["pulp_task_group"] = {"group_id" => output["pulp_task_group"]["group_id"]}.merge(external_task_data)
+        end
+      end
+
+      def poll_external_task
+        task_resource.summary(output["pulp_task_group"]["group_id"])
+      end
+
+      def task_resource
+        ::Katello.pulp_server.resources.task_group
+      end
+    end
+  end
+end

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

@@ -10,7 +10,7 @@ module Actions
         end
 
         def run
-          response =  pulp_extensions.consumer.create(input[:uuid], display_name: input[:name])
+          response = pulp_extensions.consumer.create(input[:uuid], display_name: input[:name])
           output[:response] = response.slice(:uuid, :name)
         end
       end

data/app/lib/actions/pulp/repos/update.rb

@@ -9,7 +9,8 @@ module Actions
             if sync_plan.nil?
               plan_action(::Actions::Pulp::Repository::RemoveSchedule, :repo_id => repo.id)
             else
-              plan_action(::Actions::Pulp::Repository::UpdateSchedule,
+              plan_action(
+                ::Actions::Pulp::Repository::UpdateSchedule,
                 :repo_id => repo.id,
                 :schedule => sync_plan.schedule_format,
                 :enabled => sync_plan.enabled

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

@@ -13,6 +13,10 @@ module Actions
         def invoke_external_task
           pulp_resources.repository.associate_importer(*input.values_at(:repo_id, :type_id, :config))
         end
+
+        def run_progress_weight
+          0.01
+        end
       end
     end
   end

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

@@ -16,10 +16,6 @@ module Actions
                                                    input[:unit_key],
                                                     unit_metadata: {})
         end
-
-        def rescue_strategy
-          Dynflow::Action::Rescue::Skip
-        end
       end
     end
   end

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

@@ -15,25 +15,24 @@ module Actions
 
         def update_or_associate_importer(capsule_id, repository, repository_details)
           existing_importers = repository_details["importers"]
-          importer = capsule_id ? repository.generate_importer(true) : repository.generate_importer
-          importer_config = capsule_id ? importer.config.merge!(importer_certs(repository)) : importer.config
+          importer = repository.generate_importer(!capsule_id.nil?)
           found = existing_importers.find { |i| i['importer_type_id'] == importer.id }
 
           if found
             plan_action(::Actions::Pulp::Repository::UpdateImporter,
                         :repo_id => repository.pulp_id,
                         :id => found['id'],
-                        :config => importer_config,
+                        :config => importer.config,
                         :capsule_id => capsule_id
-                        )
+                       )
           else
             plan_action(::Actions::Pulp::Repository::AssociateImporter,
                         :repo_id => repository.pulp_id,
                         :type_id => repository.importers.first['importer_type_id'],
-                        :config => importer_config,
+                        :config => importer.config,
                         :capsule_id => capsule_id,
                         :hash => { :importer_id => importer.id }
-                        )
+                       )
           end
         end
 
@@ -48,7 +47,7 @@ module Actions
                             :id => found['id'],
                             :config => distributor.config,
                             :capsule_id => capsule_id
-                            )
+                           )
               else
                 plan_action(::Actions::Pulp::Repository::AssociateDistributor,
                             :repo_id => repository.pulp_id,
@@ -56,7 +55,7 @@ module Actions
                             :config => distributor.config,
                             :capsule_id => capsule_id,
                             :hash => { :distributor_id => distributor.id }
-                            )
+                           )
               end
             end
           end
@@ -77,16 +76,6 @@ module Actions
             end
           end
         end
-
-        def importer_certs(repository)
-          ueber_cert = ::Cert::Certs.ueber_cert(repository.organization)
-
-          {
-            :ssl_ca_cert => ::Cert::Certs.ca_cert,
-            :ssl_client_cert => ueber_cert[:cert],
-            :ssl_client_key => ueber_cert[:key]
-          }
-        end
       end
     end
   end

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

@@ -1,7 +1,7 @@
 module Actions
   module Pulp
     module Repository
-      class RegenerateApplicability < Pulp::AbstractAsyncTask
+      class RegenerateApplicability < Pulp::AbstractAsyncTaskGroup
         middleware.use Actions::Middleware::ExecuteIfContentsChanged
 
         input_format do
@@ -10,7 +10,7 @@ module Actions
         end
 
         def invoke_external_task
-          pulp_extensions.repository.regenerate_applicability_by_ids([input[:pulp_id]])
+          pulp_extensions.repository.regenerate_applicability_by_ids([input[:pulp_id]], true)
         end
       end
     end

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

@@ -31,7 +31,7 @@ module Actions
             sync_options[:validate] = !(SETTINGS[:katello][:pulp][:skip_checksum_validation])
 
             output[:pulp_tasks] = pulp_tasks =
-                [pulp_resources.repository.sync(input[:pulp_id],  override_config: sync_options)]
+                [pulp_resources.repository.sync(input[:pulp_id], override_config: sync_options)]
 
             pulp_tasks
           end

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

@@ -13,6 +13,10 @@ module Actions
           output[:response] = pulp_resources.repository.
               update_importer(*input.values_at(:repo_id, :id, :config))
         end
+
+        def run_progress_weight
+          0.01
+        end
       end
     end
   end

data/app/lib/katello/api/v2/error_handling.rb

@@ -58,7 +58,7 @@ module Katello
             # TODO: why not use http_code from the exception???
             render :json => format_subsys_exception_hash(exception), :status => :bad_request
           else
-            respond_for_exception(exception,  :status => :bad_request)
+            respond_for_exception(exception, :status => :bad_request)
           end
         end
 

data/app/lib/katello/bulk_actions.rb

@@ -6,43 +6,42 @@ module Katello
       @consumer_ids = hosts.map { |host| host.content_facet.try(:uuid) }.compact
     end
 
-    def install_packages(packages)
+    def install_packages(packages, _options = {})
       fail Errors::EmptyBulkActionException if self.consumer_ids.empty?
       perform_bulk_action do |consumer_group|
         consumer_group.install_package(packages)
       end
     end
 
-    def uninstall_packages(packages)
+    def uninstall_packages(packages, _options = {})
       fail Errors::EmptyBulkActionException if self.consumer_ids.empty?
       perform_bulk_action do |consumer_group|
         consumer_group.uninstall_package(packages)
       end
     end
 
-    def update_packages(packages = nil)
-      # if no packages are provided, a full system update will be performed (e.g ''yum update' equivalent)
+    def update_packages(packages = nil, options = {})
       fail Errors::EmptyBulkActionException if self.consumer_ids.empty?
       perform_bulk_action do |consumer_group|
-        consumer_group.update_package(packages)
+        consumer_group.update_package(packages, options)
       end
     end
 
-    def install_package_groups(groups)
+    def install_package_groups(groups, _options = {})
       fail Errors::EmptyBulkActionException if self.consumer_ids.empty?
       perform_bulk_action do |consumer_group|
         consumer_group.install_package_group(groups)
       end
     end
 
-    def update_package_groups(groups)
+    def update_package_groups(groups, _options = {})
       fail Errors::EmptyBulkActionException if self.consumer_ids.empty?
       perform_bulk_action do |consumer_group|
         consumer_group.install_package_group(groups)
       end
     end
 
-    def uninstall_package_groups(groups)
+    def uninstall_package_groups(groups, _options = {})
       fail Errors::EmptyBulkActionException if self.consumer_ids.empty?
       perform_bulk_action do |consumer_group|
         consumer_group.uninstall_package_group(groups)

data/app/lib/katello/capsule_content.rb

@@ -47,16 +47,6 @@ module Katello
       scope
     end
 
-    delegate :uuid, :to => :consumer, :prefix => true
-
-    def consumer
-      @consumer ||= @capsule.content_host
-      unless @consumer
-        fail Errors::CapsuleContentMissingConsumer, _("Could not find Content Host with exact name '%s', verify the Capsule is registered with that name.") % @capsule.name
-      end
-      @consumer
-    end
-
     def sync_tasks
       ForemanTasks::Task.for_resource(self.capsule)
     end
@@ -142,7 +132,7 @@ module Katello
     end
 
     def pulp_url
-      self.capsule.url + "/pulp/api/v2/"
+      "https://" + self.capsule.hostname + "/pulp/api/v2/"
     end
 
     def pulp_repo_facts(pulp_id)
@@ -151,6 +141,12 @@ module Katello
       nil
     end
 
+    def ping_pulp
+      ::Katello::Ping.pulp_without_auth(self.pulp_url)
+    rescue Errno::EHOSTUNREACH, Errno::ECONNREFUSED, RestClient::Exception => error
+      raise ::Katello::Errors::CapsuleCannotBeReached, _("%s is unreachable. %s" % [@capsule.name, error])
+    end
+
     def self.with_environment(environment, include_default = false)
       features = [SmartProxy::PULP_NODE_FEATURE]
       features << SmartProxy::PULP_FEATURE if include_default
@@ -165,5 +161,9 @@ module Katello
       proxy = SmartProxy.with_features(SmartProxy::PULP_FEATURE).first
       self.new(proxy) if proxy
     end
+
+    def self.sync_needed?(environment)
+      ::Katello::CapsuleContent.with_environment(environment).any?
+    end
   end
 end

data/app/lib/katello/errors.rb

@@ -47,6 +47,8 @@ module Katello
 
     class OrganizationDestroyException < StandardError; end
 
+    class CapsuleCannotBeReached < StandardError; end
+
     class UnsupportedActionException < StandardError
       attr_reader :action, :receiver