katello 3.11.2 → 3.12.0.rc1

data/app/lib/katello/concerns/base_template_scope_extensions.rb

@@ -6,7 +6,7 @@ module Katello
       module Overrides
         def allowed_helpers
           super + [:errata, :host_subscriptions, :host_applicable_errata_ids, :host_applicable_errata_filtered,
-                   :host_latest_applicable_rpm_version, :load_pools]
+                   :host_latest_applicable_rpm_version, :load_pools, :load_errata_applications]
         end
       end
 
@@ -37,6 +37,79 @@ module Katello
       def load_pools(search: '', includes: nil)
         load_resource(klass: Pool.readable, search: search, permission: nil, includes: includes)
       end
+
+      # rubocop:disable Metrics/MethodLength
+      def load_errata_applications(filter_errata_type: 'all', include_last_reboot: 'yes', since: nil, up_to: nil, status: nil)
+        result = []
+        search_up_to = up_to.present? ? "ended_at < \"#{up_to}\"" : nil
+        search_since = since.present? ? "ended_at > \"#{since}\"" : nil
+        search_result = status.present? ? "result = #{status}" : nil
+
+        search = [search_up_to, search_since, search_result].compact.join(' and ')
+
+        tasks = load_resource(klass: ForemanTasks::Task,
+                              where: ["state != 'stoppped' AND (label = 'Actions::RemoteExecution::RunHostJob' AND templates.id = ?) OR label = 'Actions::Katello::Host::Erratum::Install'", RemoteExecutionFeature.feature('katello_errata_install').job_template_id],
+                              permission: 'view_tasks',
+                              joins: 'LEFT OUTER JOIN template_invocations ON foreman_tasks_tasks.id = template_invocations.run_host_job_task_id LEFT OUTER JOIN templates ON template_invocations.template_id = templates.id',
+                              select: 'foreman_tasks_tasks.*,template_invocations.id AS template_invocation_id',
+                              search: search
+        )
+
+        # batch of 1_000 records
+        tasks.each do |batch|
+          @_tasks_errata_cache = {}
+          seen_errata_ids = []
+          seen_host_ids = []
+
+          batch.each do |task|
+            seen_errata_ids = (seen_errata_ids + parse_errata(task)).uniq
+            seen_host_ids << task.input['host']['id'] if include_last_reboot == 'yes'
+          end
+
+          # preload errata in one query for this batch
+          preloaded_errata = Katello::Erratum.where(:errata_id => seen_errata_ids).pluck(:errata_id, :errata_type)
+          preloaded_hosts = ::Host.where(:id => seen_host_ids).includes(:uptime_fact)
+
+          batch.each do |task|
+            parse_errata(task).each do |erratum_id|
+              current_erratum_errata_type = preloaded_errata.find { |k, _| k == erratum_id }.last
+
+              if filter_errata_type != 'all'
+                next unless filter_errata_type == current_erratum_errata_type
+              end
+
+              hash = {
+                :date => task.ended_at,
+                :hostname => task.input['host']['name'],
+                :erratum_id => erratum_id,
+                :erratum_type => current_erratum_errata_type,
+                :status => task.result
+              }
+
+              if include_last_reboot == 'yes'
+                hash[:last_reboot_time] = preloaded_hosts.find { |k, _| k.id == task.input['host']['id'] }.uptime_seconds&.seconds&.ago
+              end
+
+              result << hash
+            end
+          end
+        end
+
+        result
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      private
+
+      def parse_errata(task)
+        @_tasks_errata_cache[task.id] ||= if task.input['errata'].present?
+                                            # katello agent errata
+                                            task.input['errata']
+                                          else
+                                            # rex errata
+                                            TemplateInvocationInputValue.where(:template_invocation_id => task.template_invocation_id).limit(1).pluck(:value).first.split(',')
+                                          end
+      end
     end
   end
 end

data/app/lib/katello/foreman.rb

@@ -14,14 +14,14 @@ module Katello
 
           # Associate the puppet environment with the locations that are currently
           # associated with the capsules that have the target lifecycle environment.
-          capsule_contents = Katello::CapsuleContent.with_environment(environment, true)
+          capsule_contents = SmartProxy.with_environment(environment, true)
           unless capsule_contents.blank?
-            locations = capsule_contents.map(&:capsule).map(&:locations).compact.flatten.uniq
+            locations = capsule_contents.map(&:locations).compact.flatten.uniq
             foreman_environment.locations = locations
             foreman_environment.save!
           end
 
-          if (foreman_smart_proxy = SmartProxy.default_capsule)
+          if (foreman_smart_proxy = SmartProxy.pulp_master)
             PuppetClassImporter.new(:url => foreman_smart_proxy.url, :env => foreman_environment.name).update_environment
           end
         end

data/app/lib/katello/lazy_accessor.rb

@@ -36,22 +36,6 @@ module Katello
           options[:in_group] = args.size > 1
           @lazy_attributes_options[symbol.to_s] = options
 
-          send :define_method, "#{symbol}_will_change!" do
-            lazy_attribute_will_change!(symbol)
-          end
-
-          send :define_method, "#{symbol.to_s}_changed?" do
-            remote_attribute_changed?(symbol.to_s)
-          end
-
-          send :define_method, "#{symbol.to_s}_change" do
-            lazy_attribute_change(symbol)
-          end
-
-          send :define_method, "#{symbol.to_s}_was" do
-            lazy_attribute_was(symbol)
-          end
-
           send :define_method, "#{symbol.to_s}=" do |val|
             lazy_attribute_set(symbol, val)
           end
@@ -72,10 +56,6 @@ module Katello
         @changed_remote_attributes = val
       end
 
-      def remote_attribute_changed?(attr)
-        changed_remote_attributes.key?(attr)
-      end
-
       def save(*)
         if (status = super)
           changed_remote_attributes.clear
@@ -103,30 +83,8 @@ module Katello
 
       private
 
-      def lazy_attribute_will_change!(attr)
-        changed_remote_attributes[attr.to_s] ||=
-          instance_variable_get("@#{attr}").nil? ? remote_attribute_value(attr) : instance_variable_get("@#{attr}")
-      end
-
-      def lazy_attribute_change(attr)
-        attr = attr.to_s
-        if remote_attribute_changed?(attr)
-          return [changed_remote_attributes[attr], __send__(attr)]
-        end
-      end
-
-      def lazy_attribute_was(attr)
-        attr = attr.to_s
-        remote_attribute_changed?(attr) ? changed_remote_attributes[attr] : __send__(attr)
-      end
-
       def lazy_attribute_set(attr, val)
-        attr = attr.to_s
-
-        old = instance_variable_get("@#{attr}").nil? ? self.send(attr) : instance_variable_get("@#{attr}")
-        changed_remote_attributes[attr] = old if old != val
-
-        instance_variable_set("@#{attr}", val)
+        instance_variable_set("@#{attr.to_s}", val)
       end
 
       def lazy_attribute_get(attr)

data/app/lib/katello/repo_discovery.rb

@@ -59,13 +59,20 @@ module Katello
     end
 
     def http_crawl(resume_point)
-      Anemone.crawl(resume_point, @proxy) do |anemone|
+      resume_point_uri = URI(resume_point)
+      resume_point_uri.user = @upstream_username if @upstream_username
+      resume_point_uri.password = @upstream_password if @upstream_password
+
+      Anemone.crawl(resume_point_uri, @proxy) do |anemone|
         anemone.focus_crawl do |page|
           @crawled << page.url.path
 
           page.links.each do |link|
             if link.path.ends_with?('/repodata/')
-              @found << page.url.to_s
+              page_url = page.url.clone
+              page_url.user = nil
+              page_url.password = nil
+              @found << page_url.to_s
             else
               @to_follow << link.to_s if should_follow?(link.path)
             end

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

@@ -41,7 +41,7 @@ module Katello
                      'content-type' => 'application/json'}
 
           request_id = ::Logging.mdc['request']
-          headers['X-Correlation-ID'] = request_id.split('-')[0] if request_id
+          headers['X-Correlation-ID'] = request_id if request_id
 
           headers.merge!(cp_oauth_header)
         end

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

@@ -12,9 +12,8 @@ module Katello
             JSON.parse(content_json).with_indifferent_access
           end
 
-          def all(owner_label, include_only: nil)
-            includes = include_only ? "?#{included_list(include_only)}" : ""
-            content_json = Candlepin::CandlepinResource.get(path(owner_label) + includes, self.default_headers).body
+          def all(owner_label)
+            content_json = Candlepin::CandlepinResource.get(path(owner_label), self.default_headers).body
             JSON.parse(content_json)
           end
 

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

@@ -77,8 +77,8 @@ module Katello
 
             pool = {
               'startDate' => start_date,
-              'endDate'   => end_date,
-              'quantity'  =>  -1,
+              'endDate' => end_date,
+              'quantity' => -1,
               'accountNumber' => '',
               'productId' => product_id,
               'providedProducts' => [],

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

@@ -1,12 +1,23 @@
+require 'katello/util/proxy_uri'
+
 module Katello
   module Util
     module HttpProxy
       def proxy_uri
-        URI("#{proxy_scheme}://#{proxy_user_info}@#{proxy_host}:#{proxy_port}").to_s if proxy_host
-      end
+        #Reset the scheme to proxy(s) based on http or https to handle cgi unescaping in rest-client
+        # this relies on katello/util/proxy_uri
+        if proxy_host
+          scheme = 'proxy' if proxy_scheme == 'http'
+          scheme = 'proxys' if proxy_scheme == 'https'
+
+          uri = URI("#{scheme}://#{proxy_host}:#{proxy_port}")
+          if proxy_config && proxy_config[:user]
+            uri.user = CGI.escape(proxy_config[:user])
+            uri.password = CGI.escape(proxy_config[:password])
+          end
 
-      def proxy_user_info
-        "#{proxy_config[:user]}:#{proxy_config[:password]}" if proxy_config && proxy_config[:user]
+          uri.to_s
+        end
       end
 
       def proxy_config

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

@@ -1,10 +1,10 @@
 module Katello
   module Util
     module Package
-      SUFFIX_RE = /\.(rpm)$/
-      ARCH_RE = /\.([^.\-]*)$/
-      NVRE_RE = /^(.*)-(?:([0-9]+):)?([^-]*)-([^-]*)$/
-      EVR_RE = /^(?:([0-9]+):)?(.*?)(?:-([^-]*))?$/
+      SUFFIX_RE = /\.(rpm)$/.freeze
+      ARCH_RE = /\.([^.\-]*)$/.freeze
+      NVRE_RE = /^(.*)-(?:([0-9]+):)?([^-]*)-([^-]*)$/.freeze
+      EVR_RE = /^(?:([0-9]+):)?(.*?)(?:-([^-]*))?$/.freeze
       SUPPORTED_ARCHS = %w(noarch i386 i686 ppc64 s390x x86_64 ia64).freeze
 
       # is able to take both nvre and nvrea and parse it correctly

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

@@ -14,10 +14,14 @@ module Katello
         @resolved = []
       end
 
+      def split_path
+        @split ||= path.split('/')
+      end
+
       def substitutions_needed
         # e.g. if content_url = "/content/dist/rhel/server/7/$releasever/$basearch/kickstart"
         #      return ['releasever', 'basearch']
-        path.split('/').map { |word| word.start_with?('$') ? word[1..-1] : nil }.compact
+        split_path.map { |word| word.start_with?('$') ? word[1..-1] : nil }.compact
       end
 
       def substitutable?
@@ -38,7 +42,7 @@ module Katello
 
       def unused_substitutions
         substitutions.keys.reject do |key|
-          path.include?("$#{key}")
+          path.include?("$#{key}") || split_path.include?(substitutions[key])
         end
       end
 

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

@@ -0,0 +1,64 @@
+#
+# The Ruby URI parser doesn't decode the percent encoded characters in the URI, in particular it
+# doesn't decode the password which is frequently used when specifying proxy addresses and
+# authentication. For example, the following code:
+#
+#   require 'uri'
+#   proxy = URI.parse('http://myuser:%24%3fxxxx@192.168.100.10:3128')
+#   puts proxy.password
+#
+# Produces the following output:
+#
+#   %24%3fxxxx
+#
+# But some gems, in particular `rest-client` and `kubeclient`, expect it to decode those characters,
+# as they use the value returned by the `password` method directly, and thus they fail to
+# authenticate against the proxy server when the password contains percent encoded characters.
+#
+# To address this issue this file adds a new `proxy` URI schema that almost identical to the `http`
+# schema, but that decodes the password before returning it. Users can use this schema instead of
+# `http` when they need to use percent encoded characters in the password. For example, the user
+# can type in the UI the following proxy URL:
+#
+#   proxy://myuser:%24%3fxxxx@192.168.100.10:3128
+#
+# And the new schema will automatically translate `%24%3fxxxx` into `$?xxxx`.
+# This fix is derived from: https://github.com/ManageIQ/manageiq/pull/17318
+require 'cgi'
+require 'uri'
+
+module URI
+  class ProxyUri < HTTP
+    def password
+      value = super
+      value = CGI.unescape(value) if value
+      value
+    end
+
+    def user
+      value = super
+      value = CGI.unescape(value) if value
+      value
+    end
+  end
+
+  @@schemes['PROXY'] = ProxyUri
+end
+
+module URI
+  class ProxysUri < HTTP
+    def password
+      value = super
+      value = CGI.unescape(value) if value
+      value
+    end
+
+    def user
+      value = super
+      value = CGI.unescape(value) if value
+      value
+    end
+  end
+
+  @@schemes['PROXYS'] = ProxysUri
+end

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

@@ -6,13 +6,13 @@ module Katello
       def self.custom_analyzers
         {
           "kt_name_analyzer" => {
-            "type"      => "custom",
+            "type" => "custom",
             "tokenizer" => "keyword"
           },
           "autcomplete_name_analyzer" => {
-            "type"      => "custom",
+            "type" => "custom",
             "tokenizer" => "keyword",
-            "filter"    => %w(standard lowercase ngram_filter)
+            "filter" => %w(standard lowercase ngram_filter)
           }
         }
       end
@@ -20,10 +20,10 @@ module Katello
       def self.custom_filters
         {
           "ngram_filter" => {
-            "type"      => "edgeNGram",
-            "side"      => "front",
-            "min_gram"  => 1,
-            "max_gram"  => 30
+            "type" => "edgeNGram",
+            "side" => "front",
+            "min_gram" => 1,
+            "max_gram" => 30
           }
         }
       end

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

@@ -76,7 +76,7 @@ module Katello
       #  RecordNotUnique exceptions
       def self.active_record_retry(retries = 3)
         yield
-      rescue ActiveRecord::RecordNotUnique, ActiveRecord::RecordInvalid => e
+      rescue ActiveRecord::RecordNotUnique, PG::UniqueViolation, ActiveRecord::RecordInvalid => e
         retries -= 1
         if retries == 0
           raise e

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

@@ -42,32 +42,14 @@ module Katello
       end
 
       def test_repository
-        Katello::Validators::EnvironmentDockerRepositoriesValidator::RepositoryOpenStruct.new(
-            name: "bad name!", label: "good_label", docker_upstream_name: "image/name", url: "https://registry.example.com",
-            organization: SafeOpenStruct.new(name: "bad name!", label: "good_label"),
-            product: SafeOpenStruct.new(name: "bad name!", label: "good_label"),
-            environment: SafeOpenStruct.new(name: "bad name!", label: "good_label"),
-            content_view_version: OpenStruct.new(content_view: ContentViewOpenStruct.new(name: "bad name!", label: "good_label", version: "1.2"))
+        Katello::Repository.new(
+          root: ::Katello::RootRepository.new(name: "bad name!", label: "good_label", docker_upstream_name: "image/name", url: "https://registry.example.com"),
+          product: ::Katello::Product.new(name: "bad name!", label: "good_label"),
+          environment: ::Katello::KTEnvironment.new(name: "bad name!", label: "good_label",
+                                                    organization: Organization.new(name: "bad name!", label: "good_label")),
+          content_view_version: ::Katello::ContentViewVersion.new(major: 1, minor: 20, content_view: Katello::ContentView.new(name: "bad name!", label: "good_label"))
         )
       end
-
-      class RepositoryOpenStruct < OpenStruct
-        class Jail < ::Safemode::Jail
-          allow :name, :label, :version, :docker_upstream_name, :url
-        end
-      end
-
-      class ContentViewOpenStruct < OpenStruct
-        class Jail < ::Safemode::Jail
-          allow :name, :label, :version
-        end
-      end
-
-      class SafeOpenStruct < OpenStruct
-        class Jail < ::Safemode::Jail
-          allow :name, :label
-        end
-      end
     end
   end
 end