foreman_rh_cloud 3.0.15 → 3.0.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 677c042a9d55631df79a60651ca098544507487b346ca82645fbf3496f784a9d
-  data.tar.gz: e7b272141151275e15583433d7014d46b97af88d215da7aff3ce068792887373
+  metadata.gz: 43110585639a77e33c9c4fb1fce44855b6fb4c9793db3fc624a01b567c09e400
+  data.tar.gz: '00285b699105835e629127cc96801082ece7ff41c9a93d82fcb7e7a6b2662c65'
 SHA512:
-  metadata.gz: 30697a4e16332a59135af135387de01398c1d992cb83139a49c20b0708b91b4f780009b1899727079e67b07eb43d5e3c85076f4b5f34a4c1184013b53b262a4a
-  data.tar.gz: d1600cfbfc51b6026d672d0f8a38a3523dffc0cd8eba082afdf32d7faf6c4496c07becceac6fbd3489dc341cd0d4a670e5e79260068b54891987112063a691b6
+  metadata.gz: aa89cca9fb72a26453a44cba2120c51ab3f47f67ec40ca8e539a1dfaeddae73687bd909e3f3880cd3eed94c7c5d4b509bb55e2450f5bf4e55a8db2f73ceaabe9
+  data.tar.gz: 33d4200395db6f2f9a0e2dbd8b27d8c55ff66d7da87efa9c9c39663468f0dd9c43c8949b0ce09b2158875d053375e39d03e4550b821732df4d49fb52f5872cb3

data/app/controllers/concerns/insights_cloud/candlepin_cache.rb

@@ -0,0 +1,28 @@
+module InsightsCloud
+  module CandlepinCache
+    extend ActiveSupport::Concern
+
+    def upstream_owner(org)
+      # We use a cache because owner_details is a call to Candlepin
+      Rails.cache.fetch("rh_cloud_upstream_owner_#{org.id}", expires_in: 1.minute) do
+        org.owner_details['upstreamConsumer']
+      end
+    end
+
+    def cp_owner_id(org)
+      owner = upstream_owner(org)
+      owner['uuid'] if owner
+    end
+
+    def candlepin_id_cert(org)
+      owner = upstream_owner(org)
+      return unless owner
+      id_cert = {
+        cert: owner.dig('idCert', 'cert'),
+        key: owner.dig('idCert', 'key'),
+      }
+      return unless id_cert.values.all?
+      id_cert
+    end
+  end
+end

data/app/controllers/concerns/insights_cloud/client_authentication.rb

@@ -0,0 +1,23 @@
+module InsightsCloud
+  module ClientAuthentication
+    extend ActiveSupport::Concern
+
+    include ::Katello::Authentication::ClientAuthentication
+
+    def authorize
+      client_authorized? || super
+    end
+
+    def client_authorized?
+      authenticate_client && valid_machine_user?
+    end
+
+    def valid_machine_user?
+      subscribed_host_by_uuid(User.current.uuid).present?
+    end
+
+    def subscribed_host_by_uuid(uuid)
+      @host = Host.unscoped.joins(:subscription_facet).where(:katello_subscription_facets => {:uuid => uuid }).first
+    end
+  end
+end

data/app/controllers/foreman_inventory_upload/accounts_controller.rb

@@ -10,23 +10,19 @@ module ForemanInventoryUpload
           upload_report_status = status_for(id, ForemanInventoryUpload::Async::UploadReportJob)
 
           [
-            id,
+            label,
             {
               generate_report_status: generate_report_status,
               upload_report_status: upload_report_status,
-              label: label,
+              id: id,
             },
           ]
         end
       ]
 
       render json: {
-        autoUploadEnabled: Setting[:allow_auto_inventory_upload],
-        hostObfuscationEnabled: Setting[:obfuscate_inventory_hostnames],
-        ipsObfuscationEnabled: Setting[:obfuscate_inventory_ips],
-        cloudToken: Setting[:rh_cloud_token],
-        excludePackages: Setting[:exclude_installed_packages],
         accounts: accounts,
+        CloudConnectorStatus: ForemanInventoryUpload::UploadsSettingsController.cloud_connector_status,
       }, status: :ok
     end
 

data/app/controllers/foreman_inventory_upload/tasks_controller.rb

@@ -13,12 +13,23 @@ module ForemanInventoryUpload
           message: N_('Nothing to sync, there are no hosts with subscription for this organization.'),
         }, status: :method_not_allowed
       else
-        host_statuses = InventorySync::Async::InventoryFullSync.perform_now(selected_org)
+        task = ForemanTasks.async_task(InventorySync::Async::InventoryFullSync, selected_org)
       end
+      return render json: { message: N_('there was an issue triggering the task') }, status: :internal_server_error unless task
 
       render json: {
-        syncHosts: host_statuses[:sync],
-        disconnectHosts: host_statuses[:disconnect],
+        task: task,
+      }, status: :ok
+    end
+
+    def show
+      task = ForemanTasks::Task.find_by(id: params[:id])
+      return render json: { message: N_('No task was found') }, status: :internal_server_error unless task
+
+      render json: {
+        endedAt: task.ended_at,
+        output: task.output,
+        result: task.result,
       }, status: :ok
     end
   end

data/app/controllers/foreman_inventory_upload/uploads_controller.rb

@@ -14,73 +14,12 @@ module ForemanInventoryUpload
       files = Dir["{#{ForemanInventoryUpload.uploads_file_path(filename)},#{ForemanInventoryUpload.done_file_path(filename)}}"]
 
       return send_file files.first, disposition: 'attachment', filename: filename unless files.empty?
-      throw_flash_error "File doesn't exist"
-    end
-
-    def throw_flash_error(message)
-      process_error(
-        :redirect => foreman_inventory_upload_index_path,
-        :error_msg => message
-      )
+      raise ::Foreman::Exception.new("The report file doesn't exist")
     end
 
     def enable_cloud_connector
       cloud_connector = ForemanRhCloud::CloudConnector.new
       render json: cloud_connector.install.to_json
     end
-
-    def cloud_connector_status
-      cloud_connector = ForemanRhCloud::CloudConnector.new
-      task_id = cloud_connector.latest_job&.task_id
-      render json: ForemanTasks::Task.where(:id => task_id).first
-    end
-
-    def auto_upload
-      Setting[:allow_auto_inventory_upload] = auto_upload_params
-      render_setting(:autoUploadEnabled, :allow_auto_inventory_upload)
-    end
-
-    def show_auto_upload
-      render_setting(:autoUploadEnabled, :allow_auto_inventory_upload)
-    end
-
-    def auto_upload_params
-      ActiveModel::Type::Boolean.new.cast(params.require(:value))
-    end
-
-    def host_obfuscation
-      Setting[:obfuscate_inventory_hostnames] = host_obfuscation_params
-      render_setting(:hostObfuscationEnabled, :obfuscate_inventory_hostnames)
-    end
-
-    def host_obfuscation_params
-      ActiveModel::Type::Boolean.new.cast(params.require(:value))
-    end
-
-    def installed_packages_inclusion
-      Setting[:exclude_installed_packages] = host_obfuscation_params
-      render_setting(:excludePackages, :exclude_installed_packages)
-    end
-
-    def installed_packages_inclusion_params
-      ActiveModel::Type::Boolean.new.cast(params.require(:value))
-    end
-
-    def ips_obfuscation
-      Setting[:obfuscate_inventory_ips] = ips_obfuscation_params
-      render_setting(:ipsObfuscationEnabled, :obfuscate_inventory_ips)
-    end
-
-    def ips_obfuscation_params
-      ActiveModel::Type::Boolean.new.cast(params.require(:value))
-    end
-
-    private
-
-    def render_setting(node_name, setting)
-      render json: {
-        node_name => Setting[setting],
-      }
-    end
   end
 end

data/app/controllers/foreman_inventory_upload/uploads_settings_controller.rb

@@ -0,0 +1,34 @@
+module ForemanInventoryUpload
+  class UploadsSettingsController < ::ApplicationController
+    def index
+      render json: {
+        autoUploadEnabled: Setting[:allow_auto_inventory_upload],
+        hostObfuscationEnabled: Setting[:obfuscate_inventory_hostnames],
+        ipsObfuscationEnabled: Setting[:obfuscate_inventory_ips],
+        excludePackagesEnabled: Setting[:exclude_installed_packages],
+        CloudConnectorStatus: ForemanInventoryUpload::UploadsSettingsController.cloud_connector_status,
+        cloudToken: !Setting[:rh_cloud_token].empty?,
+        lastSyncTask: last_successful_inventory_sync_task,
+      }, status: :ok
+    end
+
+    def set_advanced_setting
+      Setting[params.require(:setting)] = ActiveModel::Type::Boolean.new.cast(params.require(:value))
+      index
+    end
+
+    def self.cloud_connector_status
+      cloud_connector = ForemanRhCloud::CloudConnector.new
+      job = cloud_connector&.latest_job
+      return nil unless job
+      { id: job.id, task: ForemanTasks::Task.where(:id => job.task_id).first }
+    end
+
+    def last_successful_inventory_sync_task
+      task = ForemanTasks::Task.where(label: 'InventorySync::Async::InventoryFullSync', result: 'success')
+                        .reorder('ended_at desc').first
+      return nil unless task
+      { output: task.output, endedAt: task.ended_at }
+    end
+  end
+end

data/app/controllers/insights_cloud/api/machine_telemetries_controller.rb

@@ -0,0 +1,73 @@
+module InsightsCloud::Api
+  class MachineTelemetriesController < ::Api::V2::BaseController
+    layout false
+
+    include ::InsightsCloud::ClientAuthentication
+    include ::InsightsCloud::CandlepinCache
+
+    before_action :cert_uuid, :ensure_org, :ensure_branch_id, :only => [:forward_request, :branch_info]
+    before_action :ensure_telemetry_enabled_for_consumer, :only => [:forward_request]
+
+    skip_after_action :log_response_body, :only => [:forward_request]
+    skip_before_action :check_media_type, :only => [:forward_request]
+
+    # The method that "proxies" requests over to Cloud
+    def forward_request
+      certs = candlepin_id_cert @organization
+      cloud_response = ::ForemanRhCloud::CloudRequestForwarder.new.forward_request(request, controller_name, @branch_id, certs)
+
+      if cloud_response.code == 401
+        return render json: {
+          :message => 'Authentication to the Insights Service failed.',
+          :headers => {},
+        }, status: :bad_gateway
+      end
+
+      if cloud_response.headers[:content_disposition]
+        return send_data cloud_response, disposition: cloud_response.headers[:content_disposition], type: cloud_response.headers[:content_type]
+      end
+
+      assign_header(response, cloud_response, :x_resource_count, true)
+      assign_header(response, cloud_response, :x_rh_insights_request_id, false)
+
+      render json: cloud_response, status: cloud_response.code
+    end
+
+    def branch_info
+      render :json => ForemanRhCloud::BranchInfo.new.generate(@uuid, @host, @branch_id, request.host).to_json
+    end
+
+    def assign_header(res, cloud_res, header, transform)
+      header_content = cloud_res.headers[header]
+      return unless header_content
+      new_header = transform ? header.to_s.tr('_', '-') : header.to_s
+      res.headers[new_header] = header_content
+    end
+
+    private
+
+    def ensure_telemetry_enabled_for_consumer
+      render_message 'Telemetry is not enabled for your organization', :status => 403 unless telemetry_config
+    end
+
+    def telemetry_config
+      ::RedhatAccess::TelemetryConfiguration.find_or_create_by(:organization_id => @organization.id) do |conf|
+        conf.enable_telemetry = true
+      end
+    end
+
+    def cert_uuid
+      @uuid ||= User.current.login
+    end
+
+    def ensure_org
+      @organization = @host.organization
+      return render_message 'Organization not found or invalid', :status => 400 unless @organization
+    end
+
+    def ensure_branch_id
+      @branch_id = cp_owner_id(@organization)
+      return render_message "Branch ID not found for organization #{@organization.title}", :status => 400 unless @branch_id
+    end
+  end
+end

data/app/controllers/insights_cloud/hits_controller.rb

@@ -3,11 +3,11 @@ module InsightsCloud
     include Foreman::Controller::AutoCompleteSearch
 
     def index
-      hits = resource_base_search_and_page.preload(:host)
+      hits = resource_base_search_and_page.where(host: Host.authorized).preload(:host, :rule)
 
       render json: {
-        hasToken: Setting[:rh_cloud_token].length > 1,
-        hits: hits.map { |hit| hit.attributes.merge(hostname: hit.host&.name) },
+        hasToken: !Setting[:rh_cloud_token].empty?,
+        hits: hits.map { |hit| hit.attributes.merge(hostname: hit.host&.name, has_playbook: hit.has_playbook?) },
         itemCount: hits.count,
       }, status: :ok
     end

data/app/controllers/insights_cloud/tasks_controller.rb

@@ -1,7 +1,12 @@
 module InsightsCloud
   class TasksController < ::ApplicationController
     def create
-      InsightsCloud::Async::InsightsFullSync.perform_now
+      job = InsightsCloud::Async::InsightsFullSync.perform_later
+      task = ForemanTasks::Task.find_by(external_id: job.provider_job_id)
+
+      render json: {
+        task: task,
+      }, status: :ok
     end
   end
 end

data/app/models/insights_hit.rb

@@ -4,7 +4,22 @@ class InsightsHit < ApplicationRecord
   # since the facet is one-to-one association with a host, we can connect
   # through host_id column on both this model and facet.
   belongs_to :insights_facet, foreign_key: 'host_id', primary_key: 'host_id', counter_cache: :hits_count
+
+  has_one :rule, class_name: 'InsightsRule', foreign_key: 'rule_id', primary_key: 'rule_id'
+
+  scope :with_playbook, -> { joins(:rule) }
+
   scoped_search on: :title, complete_value: true
-  scoped_search on: :total_risk, complete_value: :true
+  scoped_search on: :total_risk, complete_value: true
+  scoped_search on: :rule_id, complete_value: true, only_explicit: true
   scoped_search relation: :host, on: :name, rename: :hostname, complete_value: true
+  scoped_search on: :rule_id, rename: :with_playbook, only_explicit: true, complete_value: false, ext_method: :find_with_playbook
+
+  def self.find_with_playbook(key, operator, value)
+    { joins: :rule }
+  end
+
+  def has_playbook?
+    !rule.nil?
+  end
 end

data/app/models/insights_resolution.rb

@@ -0,0 +1,3 @@
+class InsightsResolution < ApplicationRecord
+  belongs_to :rule, class_name: 'InsightsRule', primary_key: 'rule_id', inverse_of: :resolutions
+end

data/app/models/insights_rule.rb

@@ -0,0 +1,3 @@
+class InsightsRule < ApplicationRecord
+  has_many :resolutions, class_name: 'InsightsResolution', dependent: :destroy, foreign_key: 'rule_id', primary_key: 'rule_id', inverse_of: :rule
+end

data/app/models/setting/rh_cloud.rb

@@ -1,16 +1,26 @@
 class Setting::RhCloud < Setting
   ::Setting::BLANK_ATTRS.concat %w{rh_cloud_token}
 
+  def self.load_defaults
+    return false unless table_exists?
+    transaction do
+      # If the user had auto_upload default setting, we will not surprise him, and force the value to false
+      # for new users, the default will be set to true and the value will remain nil
+      Setting.where(name: 'allow_auto_inventory_upload', value: nil).where("settings.default LIKE '%false%'").update_all(value: "--- false\n...")
+      super
+    end
+  end
+
   def self.default_settings
     return unless ActiveRecord::Base.connection.table_exists?('settings')
-    return unless super
     [
-      set('allow_auto_inventory_upload', N_('Allow automatic upload of the host inventory to the Red Hat cloud'), false, N_('Allow automatic inventory uploads')),
+      set('allow_auto_inventory_upload', N_('Allow automatic upload of the host inventory to the Red Hat cloud'), true, N_('Allow automatic inventory uploads')),
       set('allow_auto_insights_sync', N_('Allow recommendations synchronization from Red Hat cloud'), false, N_('Allow recommendations synchronization')),
       set('obfuscate_inventory_hostnames', N_('Obfuscate host names sent to Red Hat cloud'), false, N_('Obfuscate host names')),
       set('obfuscate_inventory_ips', N_('Obfuscate ip addresses sent to Red Hat cloud'), false, N_('Obfuscate IPs')),
       set('rh_cloud_token', N_('Authentication token to Red Hat cloud services. Used to authenticate requests to cloud APIs'), nil, N_('Red Hat Cloud token'), nil, encrypted: true),
       set('exclude_installed_packages', N_('Exclude installed packages from Red Hat cloud inventory report'), false, N_("Don't upload installed packages")),
+      set('include_parameter_tags', N_('Should import include parameter tags from Foreman?'), false, N_('Include parameters in insights-client reports')),
     ]
   end
 

data/app/services/foreman_rh_cloud/branch_info.rb

@@ -0,0 +1,46 @@
+module ForemanRhCloud
+  class BranchInfo
+    def generate(uuid, host, branch_id, request_hostname)
+      {
+        :remote_leaf => uuid,
+        :remote_branch => branch_id,
+        :display_name => host.organization.name,
+        :hostname => request_hostname,
+        :product => {
+          :type => core_app_name,
+          :major_version => core_app_version.major,
+          :minor_version => core_app_version.minor,
+        },
+        :organization_id => host.organization.id,
+        :satellite_instance_id => Foreman.instance_id,
+        :labels => host_labels(host),
+      }
+    end
+
+    def core_app_name
+      'Foreman'
+    end
+
+    def core_app_version
+      Foreman::Version.new
+    end
+
+    def new_label(key, value, namespace)
+      {
+        :namespace => namespace,
+        :key => key,
+        :value => value,
+      }
+    end
+
+    def labels_from_items(items, label_namespace, label_lamb, label_value_method = :to_s)
+      items.map { |item| new_label(label_lamb.call(item), item.public_send(label_value_method), label_namespace) }
+    end
+
+    def host_labels(host)
+      tags_generator = ForemanInventoryUpload::Generators::Tags.new(host)
+      tags_generator.generate.map { |key, value| new_label(key, value, ForemanInventoryUpload::Generators::Slice::SATELLITE_NAMESPACE) } +
+        tags_generator.generate_parameters.map { |key, value| new_label(key, value, ForemanInventoryUpload::Generators::Slice::SATELLITE_PARAMS_NAMESPACE) }
+    end
+  end
+end