katello 4.0.3 → 4.1.0.rc1

data/app/lib/actions/pulp3/content_migration_presenter.rb

@@ -1,59 +0,0 @@
-require 'katello/content_migration_progress'
-
-module Actions
-  module Pulp3
-    class ContentMigrationPresenter < Helpers::Presenter::Base
-      def initialize(migration_action)
-        @migration_action = migration_action
-      end
-
-      def humanized_output
-        if !@migration_action.done?
-          ContentMigrationTaskPresenter.new(@migration_action).humanized_output
-        else
-          task = ForemanTasks::Task.find_by(:external_id => @migration_action.execution_plan_id)
-          ::Katello::ContentMigrationProgress.find_by(:task_id => task.id)&.progress_message
-        end
-      end
-
-      class ContentMigrationTaskPresenter
-        def initialize(action)
-          @action = action
-        end
-
-        def task_progress_reports
-          if @action.pulp_tasks.empty?
-            []
-          else
-            @action.pulp_tasks[0].progress_reports
-          end
-        end
-
-        def task_group_progress_reports
-          if @action.task_groups.empty?
-            []
-          else
-            @action.task_groups[0].group_progress_reports
-          end
-        end
-
-        def humanized_output
-          report = task_progress_reports.find { |current| current['state'] == 'running' && current['total'] != 0 }
-          report ||= task_group_progress_reports.find { |current| current['total'] != 0 && current['done'] != current['total'] }
-
-          if !report.blank? && report['total'] != 0
-            "#{report['message']} #{report['done']}/#{report['total']}"
-          elsif report
-            report['message']
-          elsif task_progress_reports.empty?
-            "Content migration starting. "
-          else
-            "Initial Migration steps complete."
-          end
-        rescue
-          ""
-        end
-      end
-    end
-  end
-end

data/app/lib/actions/pulp3/content_migration_reset.rb

@@ -1,22 +0,0 @@
-module Actions
-  module Pulp3
-    class ContentMigrationReset < Pulp3::AbstractAsyncTask
-      def plan(smart_proxy)
-        plan_self(smart_proxy_id: smart_proxy.id)
-      end
-
-      def invoke_external_task
-        migration_service = ::Katello::Pulp3::Migration.new(smart_proxy)
-        migration_service.reset
-      end
-
-      def humanized_name
-        _("Content Migration Reset")
-      end
-
-      def rescue_strategy
-        Dynflow::Action::Rescue::Skip
-      end
-    end
-  end
-end

data/app/lib/katello/foreman.rb

@@ -1,32 +0,0 @@
-module Katello
-  class Foreman
-    def self.build_puppet_environment(org, env, content_view)
-      unless content_view.default?
-        Environment.find_or_build_by_katello_id(org, env, content_view)
-      end
-    end
-
-    def self.update_puppet_environment(content_view, environment)
-      User.as_anonymous_admin do
-        content_view_puppet_env = content_view.version(environment).puppet_env(environment)
-        if !content_view.default? && content_view_puppet_env
-          foreman_environment = content_view_puppet_env.puppet_environment
-
-          # Associate the puppet environment with the locations that are currently
-          # associated with the capsules that have the target lifecycle environment.
-          capsule_contents = SmartProxy.with_environment(environment, true)
-          unless capsule_contents.blank?
-            locations = capsule_contents.map(&:locations).compact.flatten.uniq
-            foreman_environment.locations = locations
-            foreman_environment.save!
-          end
-
-          foreman_smart_proxy = SmartProxy.pulp_primary
-          if foreman_smart_proxy.has_feature?('Puppet')
-            PuppetClassImporter.new(:url => foreman_smart_proxy.url, :env => foreman_environment.name).update_environment
-          end
-        end
-      end
-    end
-  end
-end

data/app/lib/katello/mapping.rb

@@ -1,31 +0,0 @@
-# various user-configurable mappings defined in /etc/katello/mapping.yml
-
-require 'yaml'
-
-module Katello
-  module Mapping
-    def self.configuration
-      return @config if @config
-      mapping_file = '/etc/katello/mapping.yml'
-      if File.readable?(mapping_file)
-        @config = YAML.load_file(mapping_file)
-      else
-        @config = {}
-      end
-    end
-
-    class ImageFactoryNaming
-      def self.translate(name = '', version = '')
-        matched_name = "#{name} #{version}"
-        naming = Mapping.configuration['imagefactory_naming'] || {}
-        naming.each do |key, values|
-          regexp_str = "^#{Regexp.escape(key).gsub('\*', '.*')}$"
-          if Regexp.new(regexp_str) =~ matched_name
-            return values.map(&:to_s)
-          end
-        end
-        return [name.to_s, version.to_s]
-      end
-    end
-  end
-end

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

@@ -1,126 +0,0 @@
-# Used exclusively by fix_hostgroup_facets.rake task
-module Katello
-  module Util
-    class HostgroupFacetsHelper
-      def initialize
-        @logger = Logger.new($stdout)
-      end
-
-      def interested_hostgroups
-        groups = ::Hostgroup.unscoped.where(
-                    id: Katello::Hostgroup::ContentFacet.
-                        where(content_source_id: nil,
-                              kickstart_repository_id: nil,
-                              content_view_id: nil,
-                              lifecycle_environment_id: nil).select(:hostgroup_id))
-        parents = groups.select { |group| group.parent.blank? }
-        children = groups.reject { |group| group.parent.blank? }
-        # we want the parents to get created before the children
-        # hence the order
-        parents + children
-      end
-
-      def pick_facet_values(hg)
-        # This call looks at the audit logs for a host group.
-        # Pries out information related to lce, ks, cv and content_source_id from the audit logs.
-        # The audit logs typically only contain updates.
-        # So if the user changed  just the content_view_id, then that is the only thing marked as audited_changes.
-        # Hence we need to go through all the audit logs until we have information on lce, ks, cv and cs.
-        # If there was only one audit log and that was during the creation of hostgroup
-        # the audited changes look like this
-        # ```ruby
-        # {
-        #  content_view_id: 10,
-        #  kickstart_repository_id: 1000
-        #  ......
-        # }
-        # ```
-        # However if you updated the hostgroup and set the kickstart_repository_id, or
-        # content_view_id then audited changes look like
-        # ```ruby
-        # {
-        #  content_view_id: [10, 11],
-        #  kickstart_repository_id: [1000, 1200]
-        #  ......
-        # }
-        # ```
-        # So the code says "if the attribute value is an array pick the last value else just keep the value as it is "
-
-        # Further along it is to be noted that `hostgroup.audits` returns the audits ordered by the version number in ascending order, so the latest audit will be `hostgroup.audits.last`
-
-        # We want to iterate though each audit from latest audit to start, and as soon as we find a  content_view_id key or kickstart_repository_id key or lifecycle environment_id key  or content_source_id key we want it to be set once.
-
-        # So if I had an audit history like
-        # ``` ruby
-        # {
-        #  content_view_id: 10,
-        #  kickstart_repository_id: 1000,
-        #  version:1
-        #  ......
-        # },
-        # {
-        #  content_view_id: [10, 11],
-        #  kickstart_repository_id: [1000, 1200],
-        #   version: 2
-        #  ......
-        # }
-        # ```
-
-        # The code would start at version 2, notice that cv_id and ks_repo were set there
-        # and keep them as the final.
-        # So when it goes to version 1 since cv_id and ks_repo are already set,
-        # it will ignore. It will finally
-        # return {content_view_id: 11, kickstart_repository_id: 1200}
-        facet_values = {}
-        hg.audits.reverse_each do |audit|
-          hg_changes = audit.audited_changes.slice("lifecycle_environment_id",
-                                                   "kickstart_repository_id",
-                                                   "content_view_id",
-                                                   "content_source_id")
-          facet_values = hg_changes.merge(facet_values)
-        end
-
-        values = facet_values.map do |k, v|
-          v = v[-1] if v.is_a? Array
-          [k, v]
-        end
-        values.to_h.with_indifferent_access
-      end
-
-      def main
-        bad_hgs = []
-        good_hgs = []
-
-        groups = interested_hostgroups.each do |hg|
-          facet = hg.content_facet
-          values = pick_facet_values(hg)
-          if !values.empty? && facet.update(values)
-            good_hgs << { hostgroup: hg, facet_values: values }
-          else
-            bad_hgs << { hostgroup: hg, facet_values: values }
-            facet.save(validate: false)
-          end
-        end
-
-        unless bad_hgs.empty?
-          @logger.warn "Some of the hostgroups reported a validation error. "\
-                        "The hostgroups have been updated. "\
-                        "Check via the Web UI."
-
-          bad_hgs.each do |bad_group|
-            @logger.warn "Hostgroup #{bad_group[:hostgroup]}"
-            @logger.warn "Facet Values #{bad_group[:facet_values]}"
-          end
-        end
-        unless good_hgs.empty?
-          @logger.info "Following hostgroups were succesfully updated."
-          good_hgs.each do |good_group|
-            @logger.info "Hostgroup #{good_group[:hostgroup]}"
-            @logger.info "Facet Values #{good_group[:facet_values]}"
-          end
-        end
-        @logger.info("#{groups.count} Hostgroup(s) were updated.")
-      end
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-module Katello
-  module Validators
-    class ContentViewPuppetModuleValidator < ActiveModel::Validator
-      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.")
-        elsif record.name && record.author &&
-          !PuppetModule.exists?(name: record.name, author: record.author)
-          record.errors[:base] << _("Puppet Module with name='%{name}' and author='%{author}' does\
-                                    not exist") % { name: record.name, author: record.author }
-        elsif record.uuid && !PuppetModule.exists?(pulp_id: record.uuid)
-          record.errors[:base] << _("Puppet Module with uuid='%{uuid}' does not\
-                                    exist") % { uuid: record.uuid }
-        else
-          puppet_modules = if record.uuid.blank?
-                             PuppetModule.where(name: record.name, author: record.author)
-                           else
-                             PuppetModule.where(pulp_id: record.uuid)
-                           end
-          repositories = puppet_modules.flat_map(&:repositories)
-
-          if repositories.present? && record.content_view.present? &&
-              !repositories.map(&:organization).include?(record.content_view.organization)
-            record.errors[:base] << _("Puppet Module does not belong to content view organization\
-                                      '%{name}'" % { name: record.content_view.organization.name })
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,74 +0,0 @@
-module Katello
-  module Concerns
-    module EnvironmentExtensions
-      extend ActiveSupport::Concern
-
-      included do
-        has_one :content_view_puppet_environment, :class_name => "Katello::ContentViewPuppetEnvironment",
-                                                  :foreign_key => :puppet_environment_id,
-                                                  :dependent => :nullify, :inverse_of => :puppet_environment
-
-        has_one :content_view, :class_name => "Katello::ContentView", :through => :content_view_puppet_environment
-        has_one :lifecycle_environment, :class_name => "Katello::KTEnvironment", :through => :content_view_puppet_environment, :source => :environment
-
-        scoped_search :relation => :content_view, :on => :name, :rename => :content_view, :complete_value => true
-        scoped_search :relation => :lifecycle_environment, :on => :name, :rename => :lifecycle_environment, :complete_value => true
-      end
-
-      def content_view
-        self.content_view_puppet_environment.try(:content_view)
-      end
-
-      def lifecycle_environment
-        self.content_view_puppet_environment.try(:environment)
-      end
-
-      def destroy!
-        unless destroy
-          fail self.errors.full_messages.join('; ')
-        end
-      end
-
-      module ClassMethods
-        def find_by_katello_id(org, env, content_view)
-          katello_id = Environment.construct_katello_id(org, env, content_view)
-          Environment.where(:katello_id => katello_id).first
-        end
-
-        def build_by_katello_id(org, env, content_view)
-          env_name = Environment.construct_name(org, env, content_view)
-          katello_id = Environment.construct_katello_id(org, env, content_view)
-          default_location_id = ::Location.default_puppet_content_location!.id
-          environment = Environment.new(:name => env_name,
-                                        :organization_ids => [org.id],
-                                        :location_ids => [default_location_id])
-          environment.katello_id = katello_id
-          environment
-        end
-
-        def find_or_build_by_katello_id(org, env, content_view)
-          Environment.find_by_katello_id(org, env, content_view) ||
-              Environment.build_by_katello_id(org, env, content_view)
-        end
-
-        def construct_katello_id(org, env, content_view)
-          fail ArgumentError, "org has to be specified" if org.nil?
-          fail ArgumentError, "env has to be specified" if env.nil?
-          [org.label, env.label, content_view.label].reject(&:blank?).join('/')
-        end
-
-        # content_view_id provides the uniqueness of the name
-        def construct_name(org, env, content_view)
-          name = ["KT",
-                  org.try(:label),
-                  env.try(:label),
-                  content_view.try(:label),
-                  content_view.try(:id)
-                 ].reject(&:blank?).join('_')
-
-          return name.tr('-', '_')
-        end
-      end
-    end
-  end
-end

data/app/models/katello/content_view_puppet_environment.rb

@@ -1,116 +0,0 @@
-module Katello
-  class ContentViewPuppetEnvironment < Katello::Model
-    include ForemanTasks::Concerns::ActionSubject
-    include Glue::Pulp::Repo
-    include Glue
-
-    belongs_to :environment, :class_name => "Katello::KTEnvironment",
-                             :inverse_of => :content_view_puppet_environments
-    belongs_to :content_view_version, :class_name => "Katello::ContentViewVersion",
-                                      :inverse_of => :content_view_puppet_environments
-
-    has_one :content_view, :through => :content_view_version, :class_name => "Katello::ContentView"
-
-    belongs_to :puppet_environment, :class_name => "Environment",
-                                    :inverse_of => :content_view_puppet_environment, :dependent => :destroy
-
-    has_many :content_view_puppet_environment_puppet_modules,
-             :class_name => "Katello::ContentViewPuppetEnvironmentPuppetModule",
-             :dependent => :destroy
-    has_many :puppet_modules,
-             :through => :content_view_puppet_environment_puppet_modules
-
-    validates_lengths_from_database
-    validates :pulp_id, :presence => true, :uniqueness => true
-    validates_with Validators::KatelloNameFormatValidator, :attributes => :name
-    validates :puppet_environment, :presence => true, :if => :environment
-
-    before_validation :set_pulp_id
-
-    scope :non_archived, -> { where('environment_id is not NULL') }
-    scope :archived, -> { where('environment_id is NULL') }
-
-    def content_type
-      Repository::PUPPET_TYPE
-    end
-
-    def mirror_on_sync?
-      true
-    end
-
-    def link?
-      false
-    end
-
-    def primary
-      true
-    end
-
-    def backend_service(smart_proxy)
-      @service ||= Katello::Pulp::Repository.instance_for_type(nonpersisted_repository, smart_proxy)
-    end
-
-    def node_syncable?
-      environment
-    end
-
-    def organization
-      if self.environment
-        self.environment.organization
-      else
-        self.content_view.organization
-      end
-    end
-
-    def content_view
-      self.content_view_version.content_view
-    end
-
-    def self.in_content_view(view_id)
-      joins(:content_view_version).where(
-          "#{Katello::ContentViewVersion.table_name}.content_view_id" => view_id)
-    end
-
-    def self.in_environment(env_id)
-      where(environment_id: env_id)
-    end
-
-    def archive?
-      self.environment.nil?
-    end
-
-    def nonpersisted_repository
-      #This creates a mock repository that can be used
-      root = ::Katello::RootRepository.new(content_type: ::Katello::Repository::PUPPET_TYPE,
-                                           name: "#{content_view.name} Puppet Environment",
-                                           mirror_on_sync: true,
-             product: Product.new(:organization => organization))
-      ::Katello::Repository.new(root: root,
-                                pulp_id: pulp_id,
-                                content_view_version: content_view_version,
-                                environment: environment)
-    end
-
-    def set_pulp_id
-      if self.environment
-        label = "#{self.content_view.label}-#{self.environment.label}-puppet-#{SecureRandom.uuid}"
-      else
-        version = self.content_view_version.version.gsub('.', '_')
-        label = "#{self.content_view.label}-v#{version}-puppet-#{SecureRandom.uuid}"
-      end
-      self.pulp_id ||= "#{self.organization.id}-#{label}"
-    end
-
-    def index_content(puppet_module_uuids)
-      associated_ids = PuppetModule.with_pulp_id(puppet_module_uuids).pluck(:id)
-      self.puppet_modules = PuppetModule.where(:id => associated_ids)
-      self.save!
-    end
-
-    def self.import_all
-      self.all.find_each do |cvpe|
-        cvpe.index_content(Katello::Pulp::PuppetModule.ids_for_repository(cvpe.pulp_id))
-      end
-    end
-  end
-end

data/app/models/katello/content_view_puppet_environment_puppet_module.rb

@@ -1,11 +0,0 @@
-module Katello
-  class ContentViewPuppetEnvironmentPuppetModule < Katello::Model
-    # Do not use active record callbacks in this join model.  Direct INSERTs and DELETEs are done
-    belongs_to :content_view_puppet_environment,
-               :inverse_of => :content_view_puppet_environment_puppet_modules,
-               :class_name => 'Katello::ContentViewPuppetEnvironment'
-    belongs_to :puppet_module,
-               :inverse_of => :content_view_puppet_environment_puppet_modules,
-               :class_name => 'Katello::PuppetModule'
-  end
-end

data/app/models/katello/content_view_puppet_module.rb

@@ -1,63 +0,0 @@
-module Katello
-  class ContentViewPuppetModule < Katello::Model
-    audited :associated_with => :content_view
-    belongs_to :content_view, :class_name => "Katello::ContentView", :inverse_of => :content_view_versions
-
-    validates_lengths_from_database
-    validates :content_view_id, :presence => true
-    validates :name, :uniqueness => { :scope => :content_view_id, :message => _('There is already a module named "%{value}" in this content view.') }
-    validates :uuid, :uniqueness => { :scope => :content_view_id }, :allow_blank => true
-
-    validates_with Validators::ContentViewPuppetModuleValidator
-
-    scoped_search :on => :name, :complete_value => true
-    scoped_search :on => :author, :complete_value => true
-    scoped_search :on => :uuid, :complete_value => true
-    scoped_search :on => :name, :relation => :content_view, :rename => :content_view_name
-
-    before_validation :set_attributes
-
-    validate :import_only_content_view
-
-    def puppet_module
-      PuppetModule.find_by(:pulp_id => self.uuid)
-    end
-
-    def computed_version
-      if self.uuid
-        puppet_module = PuppetModule.where(:pulp_id => self.uuid).first
-      else
-        puppet_module = PuppetModule.latest_module(
-          self.name,
-          self.author,
-          self.content_view.puppet_repos
-        )
-      end
-
-      puppet_module.try(:version)
-    end
-
-    def latest_in_modules_by_author?(puppet_module_list)
-      latest_from_list = puppet_module_list.where(:author => self.author).order(:sortable_version => :desc).first
-      self.computed_version.eql?(latest_from_list.try(:version))
-    end
-
-    private
-
-    def import_only_content_view
-      if self.content_view.import_only?
-        errors.add(:base, "Cannot add puppet modules to an import-only content view.")
-      end
-    end
-
-    def set_attributes
-      if self.uuid.present?
-        puppet_module = PuppetModule.with_identifiers(self.uuid).first
-        fail Errors::NotFound, _("Couldn't find Puppet Module with id '%s'") % self.uuid unless puppet_module
-
-        self.name = puppet_module.name
-        self.author = puppet_module.author
-      end
-    end
-  end
-end

data/app/models/katello/puppet_module.rb

@@ -1,77 +0,0 @@
-require 'rubygems/package'
-require 'zlib'
-
-module Katello
-  class PuppetModule < Katello::Model
-    include Concerns::PulpDatabaseUnit
-
-    CONTENT_TYPE = "puppet_module".freeze
-
-    has_many :content_view_puppet_environment_puppet_modules,
-             :class_name => "Katello::ContentViewPuppetEnvironmentPuppetModule",
-             :dependent => :destroy,
-             :inverse_of => :puppet_module
-    has_many :content_view_puppet_environments,
-             :through => :content_view_puppet_environment_puppet_modules,
-             :class_name => "Katello::ContentViewPuppetEnvironment"
-
-    scoped_search :on => :id, :only_explicit => true
-    scoped_search :on => :name, :complete_value => true
-    scoped_search :on => :author, :complete_value => true
-    scoped_search :on => :version, :complete_value => true
-    scoped_search :on => :summary
-
-    validates :pulp_id, :presence => true
-    validates :name, :presence => true
-    validates :author, :presence => true
-
-    before_save :set_sortable_version
-
-    def self.latest_module(name, author, repositories)
-      in_repositories(repositories).where(:name => name, :author => author).
-        order(:sortable_version => :desc).first
-    end
-
-    def self.parse_metadata(filepath)
-      metadata = nil
-
-      tar_extract = Gem::Package::TarReader.new(Zlib::GzipReader.open(filepath))
-      tar_extract.rewind # The extract has to be rewinded after every iteration
-      tar_extract.each do |entry|
-        next unless entry.file? && entry.full_name =~ %r{\A[^/]+/metadata.json\z}
-        metadata = entry.read
-      end
-
-      if metadata
-        return JSON.parse(metadata).with_indifferent_access
-      else
-        fail Katello::Errors::InvalidPuppetModuleError, _("Invalid puppet module. Please make sure the puppet module contains a metadata.json file and is properly compressed.")
-      end
-    rescue Zlib::GzipFile::Error, Gem::Package::TarInvalidError
-      raise Katello::Errors::InvalidPuppetModuleError, _("Could not unarchive puppet module. Please make sure the puppet module has been compressed properly.")
-    ensure
-      tar_extract&.close
-    end
-
-    def self.group_by_repoid(puppet_modules)
-      puppet_modules.each_with_object({}) do |puppet_module, result|
-        repo = puppet_module.repositories.first
-
-        if repo
-          result[repo.id] ||= []
-          result[repo.id] << puppet_module
-        else
-          fail _("Could not find Repository for module %s.") % puppet_module.name
-        end
-      end
-    end
-
-    private
-
-    def set_sortable_version
-      if version_changed? && !version.nil?
-        self.sortable_version = Util::Package.sortable_version(version)
-      end
-    end
-  end
-end

data/app/models/katello/repository_puppet_module.rb

@@ -1,7 +0,0 @@
-module Katello
-  class RepositoryPuppetModule < Katello::Model
-    # Do not use active record callbacks in this join model.  Direct INSERTs and DELETEs are done
-    belongs_to :repository, :inverse_of => :repository_puppet_modules, :class_name => 'Katello::Repository'
-    belongs_to :puppet_module, :inverse_of => :repository_puppet_modules, :class_name => 'Katello::PuppetModule'
-  end
-end

data/app/services/katello/pulp/puppet_module.rb

@@ -1,21 +0,0 @@
-module Katello
-  module Pulp
-    class PuppetModule < PulpContentUnit
-      include LazyAccessor
-
-      CONTENT_TYPE = "puppet_module".freeze
-
-      lazy_accessor :pulp_facts, :initializer => :backend_data
-
-      lazy_accessor :_storage_path, :tag_list, :description, :license,
-                    :_ns, :project_page, :source, :dependencies,
-                    :_content_type_id, :checksums, :_id, :types,
-                    :initializer => :pulp_facts
-
-      def update_model(model)
-        custom_json = backend_data.slice('name', 'author', 'title', 'version', 'summary')
-        model.update!(custom_json)
-      end
-    end
-  end
-end