katello 3.18.0.rc1 → 4.0.0.rc1

data/app/lib/katello/event_daemon/runner.rb

@@ -0,0 +1,99 @@
+module Katello
+  module EventDaemon
+    class Runner
+      STATUS_CACHE_KEY = "katello_event_daemon_status".freeze
+      @services = {}
+      @cache = ActiveSupport::Cache::MemoryStore.new
+
+      class << self
+        def initialize
+          FileUtils.touch(lock_file)
+        end
+
+        def settings
+          SETTINGS[:katello][:event_daemon]
+        end
+
+        def pid
+          return unless pid_file && File.exist?(pid_file)
+
+          File.open(pid_file) { |f| f.read.to_i }
+        end
+
+        def pid_file
+          pid_dir.join('katello_event_daemon.pid')
+        end
+
+        def pid_dir
+          Rails.root.join('tmp', 'pids')
+        end
+
+        def lock_file
+          Rails.root.join('tmp', 'katello_event_daemon.lock')
+        end
+
+        def write_pid_file
+          return unless pid_file
+
+          FileUtils.mkdir_p(pid_dir)
+          File.open(pid_file, 'w') { |f| f.puts Process.pid }
+        end
+
+        def stop
+          return unless pid == Process.pid
+          @monitor_thread.kill
+          @cache.clear
+          @services.values.each(&:close)
+          File.unlink(pid_file) if pid_file && File.exist?(pid_file)
+        end
+
+        def start
+          return unless runnable?
+          lockfile = File.open(lock_file, 'r')
+          begin
+            lockfile.flock(File::LOCK_EX)
+            return if started? # ensure it wasn't started while we waited for the lock
+            start_monitor_thread
+            write_pid_file
+
+            at_exit do
+              stop
+            end
+
+            Rails.logger.info("Katello event daemon started process=#{Process.pid}")
+          ensure
+            lockfile.flock(File::LOCK_UN)
+          end
+        end
+
+        def started?
+          Process.kill(0, pid)
+          true
+        rescue Errno::ESRCH, TypeError # process no longer exists or we had no PID cached
+          false
+        end
+
+        def start_monitor_thread
+          @monitor_thread = Thread.new do
+            Katello::EventDaemon::Monitor.new(@services).start
+          end
+        end
+
+        def runnable?
+          # avoid accessing the disk on each request
+          @cache.fetch('katello_event_daemon_runnable', expires_in: 1.minute) do
+            !started? && settings[:enabled] && !::Foreman.in_rake? && !Rails.env.test?
+          end
+        end
+
+        def register_service(name, klass)
+          @services[name] = klass
+        end
+
+        def service_status(service_name = nil)
+          Rails.cache.read(STATUS_CACHE_KEY)&.dig(service_name)
+        end
+      end
+    end
+  end
+end

data/app/lib/katello/logging.rb

@@ -10,5 +10,37 @@ module Katello
 
       logger.send(level, "#{message} #{data_string}")
     end
+
+    class Timer
+      def initialize(key = "default")
+        @key = key
+        @start_time = Time.now
+        Thread.current[:timers] ||= {}
+        Thread.current[:timers][key] = self
+      end
+
+      def start
+        Rails.logger.info "Timer #{@key} already started; resetting start time" if @start_time
+        Rails.logger.info "Timer #{@key} starting at #{Time.now}"
+        @start_time = Time.now
+        self
+      end
+
+      def stop
+        fail ::StandardError, "Timer #{@key} is not started" unless @start_time
+        duration = (Time.now - @start_time).truncate(2)
+        @start_time = nil
+        Rails.logger.info "Timer #{@key} stopping at #{Time.now}: #{duration} sec"
+      end
+
+      def self.find_by_key(key)
+        if Thread.current&.[](:timers)&.[](key)
+          Thread.current[:timers][key]
+        else
+          Rails.logger.warn "Timer #{key} not found on current thread; creating a new timer"
+          self.new(key)
+        end
+      end
+    end
   end
 end

data/app/lib/katello/messaging/connection.rb

@@ -2,13 +2,7 @@ module Katello
   module Messaging
     class Connection
       def self.create(connection_class:, settings:)
-        connection = connection_class.new(settings: settings)
-
-        at_exit do
-          connection.close
-        end
-
-        connection
+        connection_class.new(settings: settings)
       end
     end
   end

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

@@ -1,7 +1,7 @@
 module Katello
   module Validators
     class ContentViewPuppetModuleValidator < ActiveModel::Validator
-      def validate(record)
+      def validate(record) # rubocop:disable Metrics/CyclomaticComplexity
         if record.uuid.blank? && (record.name.blank? || record.author.blank?)
           record.errors[:base] << _("Invalid puppet module parameters specified. \
                                     Either 'uuid' or 'name' and 'author' must be specified.")

data/app/models/katello/activation_key.rb

@@ -1,8 +1,8 @@
 module Katello
   class ActivationKey < Katello::Model
     audited :except => [:cp_id], :associations => [:host_collections]
-    include Glue::Candlepin::ActivationKey if SETTINGS[:katello][:use_cp]
-    include Glue if SETTINGS[:katello][:use_cp]
+    include Glue::Candlepin::ActivationKey
+    include Glue
     include Katello::Authorization::ActivationKey
     include ForemanTasks::Concerns::ActionSubject
     include ScopedSearchExtensions

data/app/models/katello/authorization/content_view_filter.rb

@@ -0,0 +1,15 @@
+module Katello
+  module Authorization::ContentViewFilter
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def readable
+        where(:content_view_id => ::Katello::ContentView.readable)
+      end
+
+      def editable
+        where(:content_view_id => ::Katello::ContentView.editable)
+      end
+    end
+  end
+end

data/app/models/katello/authorization/content_view_version.rb

@@ -10,9 +10,32 @@ module Katello
     end
 
     module ClassMethods
+      def with_content_view_scope(scope)
+        joins(:content_view).merge(Katello::ContentView.send(scope))
+      end
+
       def readable
-        view_ids = ::Katello::ContentView.readable.collect { |v| v.id }
-        joins(:content_view).where("#{Katello::ContentView.table_name}.id" => view_ids)
+        with_content_view_scope(:readable)
+      end
+
+      def exportable
+        with_content_view_scope(:exportable)
+      end
+
+      def editable
+        with_content_view_scope(:editable)
+      end
+
+      def publishable
+        with_content_view_scope(:publishable)
+      end
+
+      def deletable
+        with_content_view_scope(:deletable)
+      end
+
+      def promotable_or_removable
+        with_content_view_scope(:promotable_or_removable)
       end
     end
   end

data/app/models/katello/authorization/content_view_version_export_history.rb

@@ -4,7 +4,7 @@ module Katello
 
     module ClassMethods
       def readable
-        where(:content_view_version_id => Katello::ContentViewVersion.readable)
+        joins(:content_view_version).merge(Katello::ContentViewVersion.readable)
       end
     end
   end

data/app/models/katello/authorization/organization.rb

@@ -12,6 +12,14 @@ module Katello
       authorized?(:import_manifest)
     end
 
+    def can_import_library_content?
+      authorized?(:import_library_content)
+    end
+
+    def can_export_library_content?
+      authorized?(:export_library_content)
+    end
+
     def readable_promotion_paths
       permissible_promotion_paths(KTEnvironment.readable)
     end

data/app/models/katello/candlepin/repository_mapper.rb

@@ -114,7 +114,7 @@ module Katello
       end
 
       def suse?
-        content.content_type == Repository::YUM_TYPE && !!path.downcase.match(/suse/) # rubocop:disable Style/DoubleNegation
+        content.content_type == Repository::YUM_TYPE && !!path.downcase.match(/suse/)
       end
 
       def file?

data/app/models/katello/concerns/operatingsystem_extensions.rb

@@ -17,6 +17,8 @@ module Katello
           TemplateKind.all.each do |kind|
             if name == ::Operatingsystem::REDHAT_ATOMIC_HOST_OS && kind.name == "provision"
               provisioning_template_name = Setting["katello_default_atomic_provision"]
+            elsif kind.name == 'registration'
+              provisioning_template_name = 'Linux registration default'
             else
               provisioning_template_name = Setting["katello_default_#{kind.name}"]
             end

data/app/models/katello/concerns/organization_extensions.rb

@@ -9,8 +9,8 @@ module Katello
 
         include ForemanTasks::Concerns::ActionSubject
         prepend ForemanTasks::Concerns::ActionTriggering
-        include Glue::Candlepin::Owner if SETTINGS[:katello][:use_cp]
-        include Glue if SETTINGS[:katello][:use_cp]
+        include Glue::Candlepin::Owner
+        include Glue
 
         include Katello::Authorization::Organization
         include Ext::LabelFromName

data/app/models/katello/concerns/pulp_database_unit.rb

@@ -91,6 +91,13 @@ module Katello
         service_class.pulp_units_batch_all(pulp_ids).each do |units|
           units.each do |unit|
             unit = unit.with_indifferent_access
+            if content_type == 'rpm' && repository
+              rpms_to_disassociate = ::Katello::Rpm.where(name: unit[:name], version: unit[:version], release: unit[:release],
+                                                          epoch: unit[:epoch], arch: unit[:arch]).select(:id)
+              if rpms_to_disassociate.any?
+                ::Katello::RepositoryRpm.where(rpm_id: rpms_to_disassociate, repository_id: repository.id).destroy_all
+              end
+            end
             model = Katello::Util::Support.active_record_retry do
               self.where(:pulp_id => unit[service_class.unit_identifier]).first_or_create
             end

data/app/models/katello/concerns/redhat_extensions.rb

@@ -44,8 +44,8 @@ module Katello
 
       def kickstart_repos(host)
         distros = distribution_repositories(host).where(distribution_bootable: true)
-        if distros && host.content_source
-          distros.map { |distro| distro.to_hash(host.content_source) }
+        if distros && host&.content_facet&.content_source
+          distros.map { |distro| distro.to_hash(host.content_facet.content_source) }
         else
           []
         end

data/app/models/katello/concerns/smart_proxy_extensions.rb

@@ -49,6 +49,8 @@ module Katello
         has_many :content_facets, :class_name => "::Katello::Host::ContentFacet", :foreign_key => :content_source_id,
                                   :inverse_of => :content_source, :dependent => :nullify
 
+        has_many :smart_proxy_sync_histories, :class_name => "::Katello::SmartProxySyncHistory", :inverse_of => :smart_proxy, dependent: :delete_all
+
         has_many :hostgroup_content_facets, :class_name => "::Katello::Hostgroup::ContentFacet", :foreign_key => :content_source_id,
                               :inverse_of => :content_source, :dependent => :nullify
         has_many :hostgroups, :class_name => "::Hostgroup", :through => :hostgroup_content_facets
@@ -95,19 +97,23 @@ module Katello
         end
 
         def self.sync_needed?(environment)
-          unscoped.with_environment(environment).any?
+          Setting[:foreman_proxy_content_auto_sync] && unscoped.with_environment(environment).any?
         end
       end
 
+      def update_unauthenticated_repo_list(repo_names)
+        ProxyAPI::ContainerGateway.new(url: self.url).unauthenticated_repository_list("repositories": repo_names)
+      end
+
       def puppet_path
         self[:puppet_path] || update_puppet_path
       end
 
       def update_puppet_path
         if has_feature?(PULP_FEATURE)
-          path = ProxyAPI::Pulp.new(:url => self.url).capsule_puppet_path['puppet_content_dir']
+          path = ::ProxyAPI::Pulp.new(:url => self.url).capsule_puppet_path['puppet_content_dir']
         elsif has_feature?(PULP_NODE_FEATURE)
-          path = ProxyAPI::PulpNode.new(:url => self.url).capsule_puppet_path['puppet_content_dir']
+          path = ::ProxyAPI::PulpNode.new(:url => self.url).capsule_puppet_path['puppet_content_dir']
         end
         self.update_attribute(:puppet_path, path || '') if persisted?
         path
@@ -128,7 +134,7 @@ module Katello
           config.host = uri.host
           config.scheme = uri.scheme
           pulp3_ssl_configuration(config)
-          config.debugging = true
+          config.debugging = false
           config.logger = ::Foreman::Logging.logger('katello/pulp_rest')
           config.username = self.setting(PULP3_FEATURE, 'username')
           config.password = self.setting(PULP3_FEATURE, 'password')
@@ -177,7 +183,9 @@ module Katello
       end
 
       def fix_pulp3_capabilities(type)
-        if missing_pulp3_capabilities? && !pulp2_preferred_for_type?(type)
+        repository_type_obj = type.is_a?(String) ||  type.is_a?(Symbol) ? Katello::RepositoryTypeManager.repository_types[type] : type
+
+        if missing_pulp3_capabilities? && repository_type_obj.pulp3_plugin && !pulp2_preferred_for_type?(repository_type_obj.id)
           self.refresh
           if self.capabilities(::SmartProxy::PULP3_FEATURE).empty?
             fail Katello::Errors::PulpcoreMissingCapabilities
@@ -344,6 +352,26 @@ module Katello
         end
       end
 
+      def repos_in_env_cv(environment = nil, content_view = nil)
+        repos = Katello::Repository
+        repos = repos.in_environment(environment) if environment
+        repos = repos.in_content_views([content_view]) if content_view
+        repos
+      end
+
+      def repos_in_sync_history
+        smart_proxy_sync_histories.map { |sync_history| sync_history.repository }
+      end
+
+      def current_repositories_data(environment = nil, content_view = nil)
+        return repos_in_sync_history unless (environment || content_view)
+        repos_in_sync_history & repos_in_env_cv(environment, content_view)
+      end
+
+      def repos_pending_sync(environment = nil, content_view = nil)
+        repos_in_env_cv(environment, content_view) - repos_in_sync_history
+      end
+
       def smart_proxy_service
         @smart_proxy_service ||= Pulp::SmartProxyRepository.new(self)
       end

data/app/models/katello/content_migration_progress.rb

@@ -0,0 +1,4 @@
+module Katello
+  class ContentMigrationProgress < Katello::Model
+  end
+end

data/app/models/katello/content_view.rb

@@ -8,6 +8,7 @@ module Katello
     include ForemanTasks::Concerns::ActionSubject
 
     CONTENT_DIR = "content_views".freeze
+    IMPORT_LIBRARY = "Import-Library".freeze
 
     belongs_to :organization, :inverse_of => :content_views, :class_name => "::Organization"
 
@@ -67,6 +68,14 @@ module Katello
     validates :composite,
               inclusion: { in: [false], message: "Composite Content Views can not solve dependencies"},
               if: :solve_dependencies
+    validates :import_only, :inclusion => [true, false]
+    validates :import_only,
+              inclusion: { in: [false], message: "Import-only Content Views can not be Composite"},
+              if: :composite
+    validates :import_only,
+              inclusion: { in: [false], message: "Import-only Content Views can not solve dependencies"},
+              if: :solve_dependencies
+    validate :import_only_immutable
 
     validates_with Validators::KatelloNameFormatValidator, :attributes => :name
     validates_with Validators::KatelloLabelFormatValidator, :attributes => :label
@@ -94,6 +103,10 @@ module Katello
       name
     end
 
+    def library_import?
+      name == IMPORT_LIBRARY
+    end
+
     def content_host_count
       hosts.count
     end
@@ -228,6 +241,10 @@ module Katello
       environments.include?(env)
     end
 
+    apipie :method, 'Returns the Katello::ContentViewVersion for a given Lifecycle Environment' do
+      required :env, 'Katello::KTEnvironment', desc: 'a __Katello::KTEnvironment__ object for which we load the __Katello::ContentViewVersion__ object'
+      returns 'Katello::ContentViewVersion'
+    end
     def version(env)
       self.versions.in_environment(env).order("#{Katello::ContentViewVersion.table_name}.id ASC").readonly(false).last
     end
@@ -580,16 +597,23 @@ module Katello
     end
 
     def check_ready_to_import!
-      fail _("User must be logged in.") if ::User.current.nil?
       fail _("Cannot import a composite content view") if composite?
+      fail _("This Content View must be set to Import-only before performing an import") unless import_only?
       true
     end
 
-    def check_ready_to_publish!
+    def check_ready_to_publish!(importing: false)
       fail _("User must be logged in.") if ::User.current.nil?
       fail _("Cannot publish default content view") if default?
-      check_composite_action_allowed!(organization.library)
-      check_docker_repository_names!([organization.library])
+
+      if importing
+        check_ready_to_import!
+      else
+        fail _("Import-only content views can not be published directly") if import_only?
+        check_composite_action_allowed!(organization.library)
+        check_docker_repository_names!([organization.library])
+      end
+
       true
     end
 
@@ -698,6 +722,12 @@ module Katello
 
     private
 
+    def import_only_immutable
+      if import_only_changed? && self.persisted?
+        errors.add(:import_only, _("Import-only can not be changed after creation"))
+      end
+    end
+
     def generate_cp_environment_label(env)
       # The label for a default view, will simply be the env label; otherwise, it
       # will be a combination of env and view label.  The reason being, the label
@@ -734,7 +764,7 @@ module Katello
       prop_group :katello_basic_props, Katello::Model, meta: { friendly_name: 'Content View' }
     end
     class Jail < ::Safemode::Jail
-      allow :name, :label
+      allow :name, :label, :version
     end
   end
 end