Replace RestClient with Faraday 2.x for persistent Candlepin connections

app/controllers/katello/api/registry/registry_proxies_controller.rb

@@ -45,6 +45,25 @@ def repackage_message
       end
     end
 
+    rescue_from HttpResource::HttpError do |e|
+      if e.code.to_i == 404
+        parsed = JSON.parse(e.response_body.to_s) rescue {}
+        if parsed["errors"]&.any? { |error| error["code"] == "BLOB_UNKNOWN" }
+          Rails.logger.info(pp_exception(e, with_backtrace: false))
+        else
+          Rails.logger.error(pp_exception(e, with_backtrace: false))
+        end
+      else
+        Rails.logger.error(pp_exception(e, with_backtrace: false))
+      end
+      body = e.response_body.presence || e.message
+      if request_from_katello_cli?
+        render json: { errors: [body] }, status: e.code
+      else
+        render plain: body, status: e.code
+      end
+    end
+
     def authenticate_cert_request
       if cert_present?
         client_cert = ::Cert::RhsmClient.new(cert_from_request)

app/controllers/katello/api/rhsm/candlepin_dynflow_proxy_controller.rb

@@ -44,20 +44,20 @@ def find_host(uuid = nil)
       uuid ||= params[:id]
       facet = Katello::Host::SubscriptionFacet.where(:uuid => uuid).first
       if facet.nil?
-        # check with candlepin if consumer is Gone, raises RestClient::Gone
+        # check with candlepin if consumer is Gone, raises HttpError
         User.as_anonymous_admin { Resources::Candlepin::Consumer.get(uuid) }
         fail HttpErrors::NotFound, _("Couldn't find consumer '%s'") % uuid
       end
       @host = facet.host
     end
 
-    rescue_from RestClient::Exception do |e|
+    rescue_from HttpResource::HttpError do |e|
       Rails.logger.error(pp_exception(e, with_backtrace: false))
-      Rails.logger.error(e.backtrace.detect { |line| line.match("katello.*controller") })
+      body = e.response_body.presence || e.message
       if request_from_katello_cli?
-        render :json => { :errors => [e.http_body] }, :status => e.http_code
+        render :json => { :errors => [body] }, :status => e.code
       else
-        render :plain => e.http_body, :status => e.http_code
+        render :plain => body, :status => e.code
       end
     end
 

app/controllers/katello/api/rhsm/candlepin_proxies_controller.rb

@@ -56,14 +56,23 @@ def error_response_json(display_message, errors)
 
     rescue_from RestClient::Exception do |e|
       Rails.logger.error(pp_exception(e, with_backtrace: false))
-      Rails.logger.error(e.backtrace.detect { |line| line.match("katello.*controller") })
       if request_from_katello_cli?
         render :json => { :errors => [e.http_body] }, :status => e.http_code
       else
         render :plain => e.http_body, :status => e.http_code
       end
     end
 
+    rescue_from HttpResource::HttpError do |e|
+      Rails.logger.error(pp_exception(e, with_backtrace: false))
+      body = e.response_body.presence || e.message
+      if request_from_katello_cli?
+        render :json => { :errors => [body] }, :status => e.code
+      else
+        render :plain => body, :status => e.code
+      end
+    end
+
     def proxy_request_path
       @request_path = drop_api_namespace(@_request.fullpath)
     end
@@ -85,26 +94,26 @@ def get
       end
 
       r = Resources::Candlepin::Proxy.get(@request_path, extra_headers)
-      logger.debug filter_sensitive_data(r)
-      render :json => r, :status => r.code
+      logger.debug filter_sensitive_data(r.body)
+      render :json => r.body, :status => r.status
     end
 
     def delete
       r = Resources::Candlepin::Proxy.delete(@request_path, @request_body.read)
-      logger.debug filter_sensitive_data(r)
-      render :json => r
+      logger.debug filter_sensitive_data(r.body)
+      render :json => r.body, :status => r.status
     end
 
     def post
       r = Resources::Candlepin::Proxy.post(@request_path, @request_body.read)
-      logger.debug filter_sensitive_data(r)
-      render :json => r
+      logger.debug filter_sensitive_data(r.body)
+      render :json => r.body, :status => r.status
     end
 
     def put
       r = Resources::Candlepin::Proxy.put(@request_path, @request_body.read)
-      logger.debug filter_sensitive_data(r)
-      render :json => r
+      logger.debug filter_sensitive_data(r.body)
+      render :json => r.body, :status => r.status
     end
 
     #api :GET, "/consumers/:id", N_("Show a system")
@@ -321,7 +330,7 @@ def find_host(uuid = nil)
       uuid ||= params[:id]
       facet = Katello::Host::SubscriptionFacet.where(:uuid => uuid).first
       if facet.nil?
-        # check with candlepin if consumer is Gone, raises RestClient::Gone
+        # check with candlepin if consumer is Gone, raises HttpError
         User.as_anonymous_admin { Resources::Candlepin::Consumer.get(uuid) }
       end
       @host = ::Host::Managed.unscoped.find(facet.host_id)

app/lib/actions/candlepin/consumer/clean_backend_objects.rb

@@ -19,18 +19,20 @@ def run
             # Set bulk load size for Candlepin operations
             original_candlepin_page_size = SETTINGS[:katello][:candlepin][:bulk_load_size]
             SETTINGS[:katello][:candlepin][:bulk_load_size] = 125
-
-            # Gather data from Candlepin and Katello
-            candlepin_uuids = fetch_candlepin_uuids
-            katello_candlepin_uuids = fetch_katello_candlepin_uuids
-
-            # Find hosts with issues
-            cleanup_hosts_with_nil_facets
-            cleanup_hosts_with_no_subscriptions(candlepin_uuids)
-
-            # Clean up orphaned Candlepin consumers
-            cleanup_candlepin_orphans(candlepin_uuids, katello_candlepin_uuids)
-            SETTINGS[:katello][:candlepin][:bulk_load_size] = original_candlepin_page_size
+            begin
+              # Gather data from Candlepin and Katello
+              candlepin_uuids = fetch_candlepin_uuids
+              katello_candlepin_uuids = fetch_katello_candlepin_uuids
+
+              # Find hosts with issues
+              cleanup_hosts_with_nil_facets
+              cleanup_hosts_with_no_subscriptions(candlepin_uuids)
+
+              # Clean up orphaned Candlepin consumers
+              cleanup_candlepin_orphans(candlepin_uuids, katello_candlepin_uuids)
+            ensure
+              SETTINGS[:katello][:candlepin][:bulk_load_size] = original_candlepin_page_size
+            end
           end
         end
 
@@ -66,8 +68,9 @@ def cleanup_hosts_with_nil_facets
 
               unregister_options = host_unregister_options(host)
               ::Katello::RegistrationManager.unregister_host(host, unregister_options)
-            rescue RestClient::ResourceNotFound
+            rescue HttpResource::HttpError => e
               # Ignore if already gone
+              raise unless e.code == '404'
             rescue => e
               output[:results][:errors] << {
                 type: 'unregister_host',
@@ -94,8 +97,9 @@ def cleanup_hosts_with_no_subscriptions(candlepin_uuids)
 
               unregister_options = host_unregister_options(host)
               ::Katello::RegistrationManager.unregister_host(host, unregister_options)
-            rescue RestClient::ResourceNotFound
+            rescue HttpResource::HttpError => e
               # Ignore if already gone
+              raise unless e.code == '404'
             rescue => e
               output[:results][:errors] << {
                 type: 'unregister_host',
@@ -117,8 +121,9 @@ def cleanup_candlepin_orphans(candlepin_uuids, katello_candlepin_uuids)
               }
 
               ::Katello::Resources::Candlepin::Consumer.destroy(consumer_uuid)
-            rescue RestClient::ResourceNotFound
+            rescue HttpResource::HttpError => e
               # Ignore if already gone
+              raise unless e.code == '404'
             rescue => e
               output[:results][:errors] << {
                 type: 'destroy_consumer',

app/lib/actions/candlepin/environment/add_content_to_environment.rb

@@ -9,7 +9,8 @@ class AddContentToEnvironment < Candlepin::Abstract
 
         def run
           output[:add_response] = ::Katello::Resources::Candlepin::Environment.add_content(input[:view_env_cp_id], [input[:content_id]])
-        rescue RestClient::Conflict
+        rescue HttpResource::HttpError => e
+          raise unless e.code == '409'
           Rails.logger.info("attempted to add content ID #{input[:content_id]} to environment, but content ID already exists.")
         end
       end

app/lib/actions/candlepin/environment/set_content.rb

@@ -30,33 +30,36 @@ def finalize # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
             begin
               output[:add_response] = ::Katello::Resources::Candlepin::Environment.add_content(input[:cp_environment_id], output[:add_ids])
               break
-            rescue RestClient::Conflict => e
-              raise e if ((retries += 1) == max_retries)
-              # Candlepin raises a 409 in case it gets a duplicate content id add to an environment
-              # Since its a dup id refresh the existing ids list (which hopefully will not have the duplicate content)
-              # and try again.
-              output[:add_ids] = content_ids - existing_ids
-            rescue RestClient::ResourceNotFound, RestClient::NotFound => e
-              # Set a higher limit for retries just in case the missing content is not being parsed from the error body correctly.
-              # If the content is not found after the retries, assume it is gone and continue.
-              raise e if ((retries += 1) == 1_000)
-              # Parse the missing content from the Candlepin response and remove it from the add_ids list.
-              missing_content = JSON.parse(e.response.body)['displayMessage'].split(' ')[-1].gsub(/[".]/, '')
-              Rails.logger.debug "Content #{missing_content} not found in the environment. Removing it from the add_ids list."
-              output[:add_ids].delete(missing_content)
+            rescue HttpResource::HttpError => e
+              case e.code
+              when '409'
+                # Candlepin raises a 409 in case it gets a duplicate content id add to an environment.
+                # Refresh the existing ids list and try again.
+                raise e if ((retries += 1) == max_retries)
+                output[:add_ids] = content_ids - existing_ids
+              when '404'
+                # Set a higher limit for retries just in case the missing content is not being parsed correctly.
+                # If the content is not found after the retries, assume it is gone and continue.
+                raise e if ((retries += 1) == 1_000)
+                missing_content = e.message.split(' ')[-1].gsub(/[".]/, '')
+                Rails.logger.debug "Content #{missing_content} not found in the environment. Removing it from the add_ids list."
+                output[:add_ids].delete(missing_content)
+              else
+                raise
+              end
             end
           end
           retries = 0
           until output[:delete_ids].empty?
             begin
               output[:delete_response] = ::Katello::Resources::Candlepin::Environment.delete_content(input[:cp_environment_id], output[:delete_ids])
               break
-            rescue RestClient::ResourceNotFound
-              # If the content is not found after the retries, assume it is gone and continue.
-              break if ((retries += 1) == max_retries)
+            rescue HttpResource::HttpError => e
+              raise unless e.code == '404'
               # Candlepin raises a 404 in case a content id is not found in this environment
               # If thats the case lets just refresh the existing ids list (which hopefully will not have the 404'd content)
               # and try again.
+              break if ((retries += 1) == max_retries)
               output[:delete_ids] = existing_ids - content_ids
             end
           end

app/lib/actions/katello/organization/manifest_delete.rb

@@ -44,6 +44,7 @@ def humanized_name
 
         def finalize
           subject_organization.audit_manifest_action(_('Manifest deleted'))
+          ::Katello::Resources::Candlepin::UpstreamCandlepinResource.reset_connection!
         end
       end
     end

app/lib/actions/katello/organization/manifest_import.rb

@@ -58,6 +58,7 @@ def humanized_input
         def finalize
           subject_organization.clear_manifest_expired_notifications
           subject_organization.audit_manifest_action(_('Manifest imported'))
+          ::Katello::Resources::Candlepin::UpstreamCandlepinResource.reset_connection!
         end
       end
     end

app/lib/actions/katello/organization/manifest_refresh.rb

@@ -98,6 +98,7 @@ def finalize
           org = ::Organization.find(input[:organization_id])
           org.clear_manifest_expired_notifications
           subject_organization.audit_manifest_action(_('Manifest refreshed'))
+          ::Katello::Resources::Candlepin::UpstreamCandlepinResource.reset_connection!
         end
       end
     end

app/lib/actions/middleware/propagate_candlepin_errors.rb

@@ -17,13 +17,15 @@ def finalize(*args)
 
       def propagate_candlepin_errors
         yield
-      rescue RestClient::ExceptionWithResponse => e
-        error_class = if e.response.request.url.include?('/candlepin')
-                        ::Katello::Errors::CandlepinError
-                      else
-                        ::Katello::Errors::UpstreamCandlepinError
-                      end
-        raise(error_class.from_exception(e) || e)
+      rescue ::Katello::Errors::CandlepinError
+        raise
+      rescue HttpResource::HttpError => e
+        display_message = e.message
+        if e.response_body.present?
+          parsed = JSON.parse(e.response_body) rescue {}
+          display_message = parsed['displayMessage'] || display_message
+        end
+        raise ::Katello::Errors::CandlepinError, display_message
       end
     end
   end

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

@@ -10,6 +10,7 @@ module ErrorHandling
           rescue_from HttpErrors::WrappedError, :with => :rescue_from_wrapped_error
 
           rescue_from RestClient::ExceptionWithResponse, :with => :rescue_from_exception_with_response
+          rescue_from HttpResource::HttpError, :with => :rescue_from_exception_with_response
           rescue_from ActiveRecord::RecordInvalid, :with => :rescue_from_record_invalid
           rescue_from ActiveRecord::RecordNotFound, :with => :rescue_from_record_not_found
 
@@ -57,11 +58,12 @@ def rescue_from_wrapped_error(exception)
 
         def rescue_from_exception_with_response(exception)
           logger.error "exception when talking to a remote client: #{exception.message} " << pp_exception(exception)
+          code = exception.respond_to?(:code) ? exception.code.to_i : 0
+          status = (code > 0) ? code : :bad_request
           if request_from_katello_cli?
-            # TODO: why not use http_code from the exception???
-            render :json => format_subsys_exception_hash(exception), :status => :bad_request
+            render :json => format_subsys_exception_hash(exception), :status => status
           else
-            respond_for_exception(exception, :status => :bad_request)
+            respond_for_exception(exception, :status => status)
           end
         end
 
@@ -149,16 +151,26 @@ def pp_exception(exception, options = {})
           message = ""
           message << "#{exception.class}: " if options[:with_class]
           message << "#{exception.message}\n"
-          message << "Body: #{exception.http_body}\n" if options[:with_body] && exception.respond_to?(:http_body)
+          body = if exception.respond_to?(:http_body)
+                   exception.http_body
+                 elsif exception.respond_to?(:response_body)
+                   exception.response_body
+                 end
+          message << "Body: #{body}\n" if options[:with_body] && body
           message << exception.backtrace.join("\n") if options[:with_backtrace]
           message
         end
 
         def format_subsys_exception_hash(exception)
-          orig_hash = JSON.parse(exception.response).with_indifferent_access rescue {}
+          raw_body = if exception.respond_to?(:response)
+                       exception.response
+                     elsif exception.respond_to?(:response_body)
+                       exception.response_body
+                     end
+          orig_hash = JSON.parse(raw_body).with_indifferent_access rescue {}
 
           orig_hash[:message] = orig_hash.delete(:displayMessage) || orig_hash[:message]
-          orig_hash[:message] = exception.response.to_s.gsub(/^"|"$/, "") if orig_hash[:message].nil? && exception.respond_to?(:response)
+          orig_hash[:message] = raw_body.to_s.gsub(/^"|"$/, "") if orig_hash[:message].nil? && raw_body
           orig_hash[:message] = exception.message if orig_hash[:message].blank?
           orig_hash[:errors] = [orig_hash[:message]] if orig_hash[:errors].nil?
           orig_hash

app/lib/katello/concerns/oauth_request_signing.rb

@@ -0,0 +1,43 @@
+require 'oauth'
+
+module Katello
+  module Concerns
+    module OauthRequestSigning
+      extend ActiveSupport::Concern
+
+      HTTP_CLASSES = {
+        get: Net::HTTP::Get,
+        post: Net::HTTP::Post,
+        put: Net::HTTP::Put,
+        patch: Net::HTTP::Patch,
+        delete: Net::HTTP::Delete,
+      }.freeze
+
+      class_methods do
+        def sign_request(req, url, method)
+          fail "#{name}: OAuth consumer_key and consumer_secret required" if self.consumer_key.blank? || self.consumer_secret.blank?
+          req.headers['Authorization'] = build_oauth_header(url, method)
+        end
+
+        private
+
+        def oauth_consumer
+          @oauth_consumer ||= OAuth::Consumer.new(
+            self.consumer_key, self.consumer_secret,
+            :site => self.site,
+            :request_token_path => "",
+            :authorize_path => "",
+            :access_token_path => "",
+            :ca_file => self.ssl_ca_file
+          )
+        end
+
+        def build_oauth_header(url, method)
+          request = HTTP_CLASSES.fetch(method).new(url)
+          oauth_consumer.sign!(request)
+          request['Authorization']
+        end
+      end
+    end
+  end
+end