foreman_kernel_care 1.1.1 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c0348921f3d8a92fad7474e5e6256d1f766b016f827f4e16b75afe825230f511
-  data.tar.gz: b5811ad734c679a9341b8691f21e29ead36cfc8fac6b2f568c536732a1987ee9
+  metadata.gz: d48df9124313a81b6ed28245a2a54447b1feca758c16087f5e5d638fd1208f83
+  data.tar.gz: 1af5606d485f619452eef174fe84c849225a676da2e47498364b5d1bf45c1438
 SHA512:
-  metadata.gz: 89fb27d78851ea1e38eb8add5398ecc04e9e970bcd69f5e501193ccb4f6ac6f86395e64c531b3cc92a794a0819c4aecd25f975de2d51f3f592ab99efac3462fa
-  data.tar.gz: 522e387d5dac01c5f49302eb5837132c89fe9daea5e53d8a8fd335d8a2aecfae066c9091febfde3e3eefc5f0a8e830a0d3afc6495bcbba33333d208bd1ca2283
+  metadata.gz: b5923597240288d47b3fdd6342be6450f0645f8a2c885cc07899505a8d81125c8c1dfcf97b180714c074801554c435d695f57063b951664f7eed6ed1ca0a7e14
+  data.tar.gz: 1cc8476969f489892f0708edd5d02f66ff81e0359d80da84ede35e1783609fdd073364e3c8ae84db5029dde7f340c37ca34db696ff3b3ecdf5f5185fbcbb5276

data/app/controllers/concerns/foreman_kernel_care/foreman_tasks.rb

@@ -4,19 +4,24 @@ module ForemanKernelCare
       callbacks = params.key?(:callback) ? Array(params) : params[:callbacks]
       ids = callbacks.map { |payload| payload[:callback][:task_id] }
       foreman_tasks = ::ForemanTasks::Task.where(:id => ids)
-      external_map = Hash[*foreman_tasks.pluck(:id, :external_id).flatten]
       callbacks.each do |payload|
         # We need to call .to_unsafe_h to unwrap the hash from ActionController::Parameters
         callback = payload[:callback]
         foreman_task = foreman_tasks.find { |task| task.id == callback[:task_id] }
-        if foreman_task.action.include?('Get patched kernel version')
-          version, release = payload[:data].to_unsafe_h['result'].first['output'].strip.split('-')
-          job_invocation = ::JobInvocation.where(:task_id => foreman_task.parent_task_id).first
-          job_invocation.targeting.hosts.each { |host| host.update_kernel_version(version, release) }
-        end
-        process_callback(external_map[callback[:task_id]], callback[:step_id].to_i, payload[:data].to_unsafe_h, :request_id => ::Logging.mdc['request'])
+        next unless foreman_task.action.include?('Get patched kernel version')
+        complete_output = ''
+        result = payload[:data].to_unsafe_h['result']
+        result.each { |x| complete_output += x['output'] }
+        kernel, kcare = complete_output.split(/\n/)
+        kernel = kernel.gsub('Installed kernel version: ', '')
+        kcare = kcare.gsub('Patched kernel version: ', '')
+        version, release = kcare.strip.split('-')
+        next if version.empty? || release.empty?
+        job_invocation = ::JobInvocation.where(:task_id => foreman_task.parent_task_id).first
+        job_invocation.targeting.hosts.each { |host| host.update_kernel_version(version, release, kernel) }
       end
-      render :json => { :message => 'processing' }.to_json
+
+      super
     end
   end
 end

data/app/models/concerns/foreman_kernel_care/host_managed_extensions.rb

@@ -7,57 +7,103 @@ module ForemanKernelCare
         composer.trigger!
       end
 
-      found = import_package_profile_in_bulk(simple_packages)
-      sync_package_associations(found.map(&:id).uniq)
+      super(simple_packages)
     end
 
     def import_tracer_profile(tracer_profile)
-      traces = []
-      tracer_profile.each do |trace, attributes|
-        next if attributes[:helper].blank?
+      if kernelcare?
+        new_tracer_profile = {}
+        tracer_profile.each do |trace, attributes|
+          if trace.to_s == 'kernel'
+            composer = ::JobInvocationComposer.for_feature(:update_kernel, self)
+            composer.triggering.mode = :future
+            composer.trigger!
+          else
+            new_tracer_profile[trace] = attributes
+          end
+        end
+        super(new_tracer_profile)
+      else
+        super(tracer_profile)
+      end
+    end
 
-        if trace.to_s == 'kernel' && kernelcare?
-          composer = ::JobInvocationComposer.for_feature(:update_kernel, self)
-          composer.triggering.mode = :future
-          composer.trigger!
+    def update_kernel_version(version, release, old_kernel_version)
+      old_version, old_release = old_kernel_version.split('-')
 
-          next
-        end
+      case operatingsystem.family
+      when 'Redhat'
+        packages = find_yum_kernel_packages(old_version, old_release)
+        return if packages.empty?
 
-        traces << { host_id: id, application: trace, helper: attributes[:helper], app_type: attributes[:type] }
+        delete_yum_pkgs(packages)
+        create_new_yum_kernel_packages(packages, version, release)
+      when 'Debian'
+        old_version = "#{old_version}-#{old_release}"
+        new_version = "#{version}-#{release}"
+        packages = find_deb_kernel_packages(old_version)
+        return if packages.empty?
+
+        create_new_deb_kernel_packages(packages, new_version, old_version)
       end
-      host_traces.delete_all
-      Katello::HostTracer.import(traces, validate: false)
-      update_trace_status
     end
 
-    def update_kernel_version(version, release)
-      packages = ::Katello::InstalledPackage.where('name LIKE ?', '%kernel%').where.not(name: 'kernelcare').to_a
-      delete_ids = []
-      simple_packages = packages.map do |p|
-        delete_ids << p.id
-        ::Katello::Pulp::SimplePackage.new({
-                                             arch: p.arch,
-                                             epoch: p.epoch,
-                                             version: version,
-                                             release: release,
-                                             name: p.name
-                                           })
+    def kernelcare?
+      !installed_packages.select { |package| package.name == 'kernelcare' }.empty? ||
+        !installed_debs.select { |package| package.name == 'kernelcare' }.empty?
+    end
+
+    class ::Host::Managed::Jail < Safemode::Jail
+      allow :installed_debs, :kernelcare?
+    end
+
+    protected
+
+    def find_yum_kernel_packages(old_version, old_release)
+      installed_packages.select do |p|
+        p.name.include?('kernel') &&
+          p.name != 'kernelcare' &&
+          p.version == old_version &&
+          old_release.include?(p.release)
       end
-      found = import_package_profile_in_bulk(simple_packages)
-      sync_kernel_associations(found.map(&:id).uniq, delete_ids)
     end
 
-    def sync_kernel_associations(new_patched_kernel_ids, delete_ids)
+    def delete_yum_pkgs(packages)
+      delete_ids = packages.map(&:id)
       ::Katello::Util::Support.active_record_retry do
         table_name = host_installed_packages.table_name
-
         queries = []
 
         if delete_ids.any?
           queries << "DELETE FROM #{table_name} WHERE host_id=#{id} AND installed_package_id IN (#{delete_ids.join(', ')})"
         end
 
+        queries.each do |query|
+          ::ActiveRecord::Base.connection.execute(query)
+        end
+      end
+    end
+
+    def create_new_yum_kernel_packages(packages, version, release)
+      new_kernels = packages.map do |p|
+        ::Katello::Pulp::SimplePackage.new({
+          arch: p.arch,
+          epoch: p.epoch,
+          version: version,
+          release: release,
+          name: p.name
+        })
+      end
+      found = import_package_profile_in_bulk(new_kernels)
+      sync_yum_kernel_associations(found.map(&:id).uniq)
+    end
+
+    def sync_yum_kernel_associations(new_patched_kernel_ids)
+      ::Katello::Util::Support.active_record_retry do
+        table_name = host_installed_packages.table_name
+
+        queries = []
+
         unless new_patched_kernel_ids.empty?
           inserts = new_patched_kernel_ids.map { |unit_id| "(#{unit_id.to_i}, #{id.to_i})" }
           queries << "INSERT INTO #{table_name} (installed_package_id, host_id) VALUES #{inserts.join(', ')}"
@@ -69,10 +115,33 @@ module ForemanKernelCare
       end
     end
 
-    protected
+    def find_deb_kernel_packages(old_version)
+      installed_debs.select do |p|
+        p.name.include?('linux') && p.version.include?(old_version)
+      end
+    end
 
-    def kernelcare?
-      !installed_packages.select { |package| package.name == 'kernelcare' }.empty?
+    def create_new_deb_kernel_packages(packages, new_version, old_version)
+      old_kernel_ids = packages.map(&:id)
+      new_kernels = packages.map do |p|
+        name = if p.name.include?(old_version)
+                 p.name.sub(old_version, new_version)
+               else
+                 p.name
+               end
+        ::Katello::InstalledDeb.find_or_create_by(name: name, architecture: p.architecture, version: new_version)
+      end
+      return if new_kernels.empty? || old_kernel_ids.empty?
+
+      sync_deb_kernel_associations(new_kernels.map(&:id), old_kernel_ids)
+    end
+
+    def sync_deb_kernel_associations(new_patched_kernel_ids, old_kernel_ids)
+      new_installed_debs = installed_deb_ids.reject do |id|
+        old_kernel_ids.include?(id)
+      end
+      self.installed_deb_ids = new_installed_debs.concat(new_patched_kernel_ids)
+      save!
     end
   end
 end

data/app/services/concerns/foreman_kernel_care/profiles_uploader.rb

@@ -0,0 +1,15 @@
+module ForemanKernelCare
+  module ProfilesUploader
+    extend ActiveSupport::Concern
+
+    def import_deb_package_profile(profile)
+      if @host.kernelcare?
+        composer = ::JobInvocationComposer.for_feature(:kernel_version, @host)
+        composer.triggering.mode = :future
+        composer.trigger!
+      end
+
+      super(profile)
+    end
+  end
+end

data/app/views/foreman_kernel_care/job_templates/install_kernelcare.erb

@@ -0,0 +1,10 @@
+<%#
+kind: job_template
+name: LivePatching - Install Kernelcare
+model: JobTemplate
+job_category: LivePatching - Script Default
+description_format: Install kernelcare package
+provider_type: script
+%>
+
+<%= render_template('Package Action - Script Default', :action => 'install', :package => 'kernelcare') %>

data/app/views/foreman_kernel_care/job_templates/kernel_version.erb

@@ -1,15 +1,19 @@
 <%#
 kind: job_template
-name: Kernel version
+name: LivePatching - Kernel version
 model: JobTemplate
-job_category: Commands
+job_category: LivePatching - Script Default
 description_format: "Get patched kernel version"
-provider_type: SSH
+provider_type: script
 feature: kernel_version
 %>
 <%
-  unless @host.installed_packages.select { |package| package.name == 'kernelcare' }.empty?
-    render_error(N_('Unsupported host.'))
+  unless @host.installed_packages.map{ |package| package.name }.include?('kernelcare') || @host.installed_debs.map{ |package| package.name }.include?('kernelcare')
+    render_error(N_('The "kernelcare" package is not installed on your managed host which is required by this job template.'))
   end
 %>
+
+echo -n "Installed kernel version: "
+uname -r
+echo -n "Patched kernel version: "
 /usr/bin/kcarectl --uname

data/app/views/foreman_kernel_care/job_templates/update_kernel.erb

@@ -1,15 +1,17 @@
 <%#
 kind: job_template
-name: Update kernel
+name: LivePatching - Update kernel
 model: JobTemplate
-job_category: Commands
-description_format: "Run yum update kernel"
-provider_type: SSH
+job_category: LivePatching - Script Default
+description_format: "Update kernel"
+provider_type: script
 feature: update_kernel
 %>
+
 <%
-  unless @host.operatingsystem.family == 'Redhat'
-    render_error(N_('Unsupported operating system for this host.'))
+  unless @host.installed_packages.map{ |package| package.name }.include?('kernelcare') || @host.installed_debs.map{ |package| package.name }.include?('kernelcare')
+    render_error(N_('The "kernelcare" package is not installed on your managed host which is required by this job template.'))
   end
 %>
-yum update -y kernel*
+
+/usr/bin/kcarectl --update

data/app/views/foreman_kernel_care/job_templates/view_newest_patch.erb

@@ -0,0 +1,15 @@
+<%#
+kind: job_template
+name: LivePatching - View newest Patch
+model: JobTemplate
+job_category: LivePatching - Script Default
+description_format: "View available patches"
+provider_type: script
+%>
+<%
+  unless @host.installed_packages.map{ |package| package.name }.include?('kernelcare') || @host.installed_debs.map{ |package| package.name }.include?('kernelcare')
+    render_error(N_('The "kernelcare" package is not installed on your managed host which is required by this job template.'))
+  end
+%>
+
+/usr/bin/kcarectl --latest-patch-info --json

data/db/seeds.d/100_assign_features_with_templates.rb

@@ -10,14 +10,14 @@ User.as_anonymous_admin do
       ForemanKernelCare::Engine.register_rex_feature
     end
     JobTemplate.without_auditing do
-      module_template = JobTemplate.find_by(name: 'Update kernel')
+      module_template = JobTemplate.find_by(name: 'LivePatching - Update kernel')
       if module_template && !Rails.env.test? && Setting[:remote_execution_sync_templates]
         module_template.sync_feature('update_kernel')
         module_template.organizations << Organization.unscoped.all if module_template.organizations.empty?
         module_template.locations << Location.unscoped.all if module_template.locations.empty?
       end
 
-      module_template = JobTemplate.find_by(name: 'Kernel version')
+      module_template = JobTemplate.find_by(name: 'LivePatching - Kernel version')
       if module_template && !Rails.env.test? && Setting[:remote_execution_sync_templates]
         module_template.sync_feature('kernel_version')
         module_template.organizations << Organization.unscoped.all if module_template.organizations.empty?

data/lib/foreman_kernel_care/engine.rb

@@ -1,3 +1,5 @@
+require 'katello'
+require 'foreman_tasks'
 require 'foreman_kernel_care/remote_execution'
 
 module ForemanKernelCare
@@ -6,22 +8,20 @@ module ForemanKernelCare
     engine_name 'foreman_kernel_care'
 
     config.autoload_paths += Dir["#{config.root}/app/models/concerns"]
+    config.autoload_paths += Dir["#{config.root}/app/services/concerns"]
 
     initializer 'foreman_kernel_care.register_plugin', :before => :finisher_hook do |_app|
       Foreman::Plugin.register :foreman_kernel_care do
         requires_foreman '>= 1.19.0'
-
-        # Add a new role called 'Discovery' if it doesn't exist
         role 'Foreman KernelCare', [:view_job_templates]
       end
     end
 
-    # Include concerns in this config.to_prepare block
-    config.to_prepare do
-      Katello::Concerns::HostManagedExtensions.prepend ForemanKernelCare::HostManagedExtensions
-      ForemanTasks::Api::TasksController.prepend ForemanKernelCare::ForemanTasks
-    rescue StandardError => e
-      Rails.logger.warn "ForemanKernelCare: skipping engine hook (#{e})"
+    # make sure the plugin is initialized before katello loads the host extensions
+    initializer 'foreman_kernel_care.load_kernelcare_override', :before => :finisher_hook, :after => ['katello.register_plugin', 'foreman_tasks.register_plugin'] do
+      ::Katello::Concerns::HostManagedExtensions.prepend ForemanKernelCare::HostManagedExtensions
+      ::Katello::Host::ProfilesUploader.prepend ForemanKernelCare::ProfilesUploader
+      ::ForemanTasks::Api::TasksController.prepend ForemanKernelCare::ForemanTasks
     end
 
     rake_tasks do

data/lib/foreman_kernel_care/remote_execution.rb

@@ -5,6 +5,10 @@ require 'foreman_remote_execution'
 module ForemanKernelCare
   # Dependencies related with the remote execution plugin
   class Engine < ::Rails::Engine
+    config.to_prepare do
+      ForemanKernelCare::Engine.register_rex_feature
+    end
+
     def self.register_rex_feature
       RemoteExecutionFeature.register(
         :update_kernel,

data/lib/foreman_kernel_care/version.rb

@@ -1,3 +1,3 @@
 module ForemanKernelCare
-  VERSION = '1.1.1'.freeze
+  VERSION = '1.2.1'.freeze
 end

data/test/factories/foreman_kernel_care_factories.rb

@@ -1,5 +1,14 @@
 FactoryBot.modify do
   factory :host do
+    trait :debian_with_kernelcare do
+      after(:create) do |host|
+        installed_deb_id = ::Katello::InstalledDeb.find_or_create_by(name: 'kernelcare',
+                                                                     architecture: 'x86_64',
+                                                                     version: '2.54-1').id
+        host.installed_deb_ids = installed_deb_id
+        host.save!
+      end
+    end
     trait :with_kernelcare do
       after(:create) do |host|
         package_json = {

data/test/unit/host_managed_extensions_test.rb

@@ -9,25 +9,64 @@ module ForemanKernelCare
       feature = RemoteExecutionFeature.register('kernel_version', 'Kernel version')
       template = FactoryBot.create(:job_template, name: 'Kernel versionl')
       template.sync_feature(feature.label)
-
-      @host = FactoryBot.create(:host, :with_kernelcare)
-      package_json = {:name => "kernel", :version => "1", :release => "1.el7", :arch => "x86_64", :epoch => "1",
-                      :nvra => "kernel-1-1.el7.x86_64"}
-      @host.import_package_profile([::Katello::Pulp::SimplePackage.new(package_json)])
-      @nvra = 'kernel-1-1.el7.x86_64'
-      @host.reload
     end
 
     def test_update_kernel_version
+      host = FactoryBot.create(:host, :with_kernelcare,
+        :operatingsystem => FactoryBot.create(:operatingsystem,
+          :family => 'Redhat'))
+      package_json = { :name => 'kernel', :version => '1',
+                       :release => '1.el7', :arch => 'x86_64', :epoch => '1',
+                       :nvra => 'kernel-1-1.el7.x86_64' }
+      host.import_package_profile([::Katello::Pulp::SimplePackage.new(package_json)])
+      nvra = 'kernel-1-1.el7.x86_64'
+      host.reload
       version = '2'
       release = '2.el7'
-      @host.update_kernel_version(version, release)
-      kernel_package = @host.installed_packages.where(name: 'kernel').first
+      old_kernel_version = '1-1.el7.x86_64'
+      host.update_kernel_version(version, release, old_kernel_version)
+      kernel_package = host.installed_packages.where(name: 'kernel').first
 
-      assert_not_equal kernel_package.nvra, @nvra
+      assert_not_equal kernel_package.nvra, nvra
       assert_equal kernel_package.version, version
       assert_equal kernel_package.release, release
     end
+
+    def test_update_kernel_version_debian
+      host = FactoryBot.create(:host, :debian_with_kernelcare,
+        :operatingsystem => FactoryBot.create(:operatingsystem,
+          :major => '10',
+          :release_name => 'rn10',
+          :family => 'Debian'))
+      kernels = [
+        { architecture: 'x86_64', version: '1-1', name: 'linux-image-generic' },
+        { architecture: 'x86_64', version: '1-1', name: 'linux-headers-generic ' },
+        { architecture: 'x86_64', version: '1-1', name: 'linux-generic' },
+        { architecture: 'x86_64', version: '1-1', name: 'linux-signed-generic' },
+        { architecture: 'x86_64', version: '1-1', name: 'linux-image-1-1-generic' }
+      ]
+      kernel_deb_ids = kernels.map do |kernel|
+        ::Katello::InstalledDeb.find_or_create_by(name: kernel[:name],
+                                                  architecture: kernel[:architecture],
+                                                  version: kernel[:version]).id
+      end
+      kernelcare_id = host.installed_deb_ids.first
+      installed_deb_ids = kernel_deb_ids << kernelcare_id
+      host.installed_deb_ids = installed_deb_ids
+      host.save!
+
+      version = '2'
+      release = '2'
+      old_kernel_version = '1-1-generic'
+      host.update_kernel_version(version, release, old_kernel_version)
+      debian_kernel_packages = host.installed_debs.select do |p|
+        p.name.include?('generic')
+      end
+      debian_kernel_packages.each do |p|
+        assert_not_equal p.name, 'linux-image-1-1-generic'
+        assert_equal p.version, "#{version}-#{release}"
+      end
+    end
   end
 
   class HostTracerTest < HostManagedExtensionsTestBase

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: foreman_kernel_care
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.2.1
 platform: ruby
 authors:
 - Maxim Petukhov
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-04-01 00:00:00.000000000 Z
+date: 2023-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: foreman_remote_execution
@@ -42,30 +42,50 @@ dependencies:
   name: rdoc
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 6.3.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 6.3.1
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.87.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.87.0
+- !ruby/object:Gem::Dependency
+  name: rubocop-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.8.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.8.1
 description: This plugin removes kernel trace and update the kernel package version
   if KernelCare package is installed on host
 email:
@@ -79,8 +99,11 @@ files:
 - Rakefile
 - app/controllers/concerns/foreman_kernel_care/foreman_tasks.rb
 - app/models/concerns/foreman_kernel_care/host_managed_extensions.rb
+- app/services/concerns/foreman_kernel_care/profiles_uploader.rb
+- app/views/foreman_kernel_care/job_templates/install_kernelcare.erb
 - app/views/foreman_kernel_care/job_templates/kernel_version.erb
 - app/views/foreman_kernel_care/job_templates/update_kernel.erb
+- app/views/foreman_kernel_care/job_templates/view_newest_patch.erb
 - db/seeds.d/100_assign_features_with_templates.rb
 - db/seeds.d/70_job_templates.rb
 - lib/foreman_kernel_care.rb
@@ -95,7 +118,7 @@ homepage: https://github.com/maccelf/foreman_kernel_care
 licenses:
 - GPL-3.0
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -103,15 +126,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 3.2.33
+signing_key:
 specification_version: 4
 summary: Plugin for KernelCare
 test_files: