katello 3.8.1 → 3.9.0.rc1

data/app/models/katello/glue/pulp/repos.rb

@@ -12,35 +12,6 @@ module Katello
       "#{path_prefix}/#{path}"
     end
 
-    # repo path for custom product repos (RH repo paths are derived from
-    # content url)
-    def self.custom_repo_path(environment, product, repo_label)
-      if [environment, product, repo_label].any?(&:nil?)
-        return nil # can't generate valid path
-      end
-      prefix = [environment.organization.label, environment.label].map { |x| x.gsub(/[^-\w]/, "_") }.join("/")
-      prefix + custom_content_path(product, repo_label)
-    end
-
-    def self.custom_docker_repo_path(environment, product, repo_label)
-      if [environment, product, repo_label].any?(&:nil?)
-        return nil # can't generate valid path
-      end
-      parts = [environment.organization.label, product.label, repo_label]
-      parts.map { |x| x.gsub(/[^-\w]/, "_") }.join("-").downcase
-    end
-
-    def self.custom_content_path(product, repo_label)
-      parts = []
-      # We generate repo path only for custom product content. We add this
-      # constant string to avoid collisions with RH content. RH content url
-      # begins usually with something like "/content/dist/rhel/...".
-      # There we prefix custom content/repo url with "/custom/..."
-      parts << "custom"
-      parts += [product.label, repo_label]
-      "/" + parts.map { |x| x.gsub(/[^-\w]/, "_") }.join("/")
-    end
-
     def self.prepopulate!(products, environment, repos = [], content_view = nil)
       if content_view.nil?
         if environment.library?
@@ -67,38 +38,6 @@ module Katello
         return self.repos(library).empty?
       end
 
-      def promote(from_env, to_env)
-        @orchestration_for = :promote
-
-        async_tasks = promote_repos repos(from_env), from_env, to_env
-        unless to_env.products.include? self
-          self.environments << to_env
-        end
-
-        save!
-        async_tasks
-      end
-
-      def find_packages_by_name(env, name)
-        packages = self.repos(env).collect do |repo|
-          repo.find_packages_by_name(name).collect do |p|
-            p[:repo_id] = repo.id
-            p
-          end
-        end
-        packages.flatten(1)
-      end
-
-      def find_packages_by_nvre(env, name, version, release, epoch)
-        packages = self.repos(env).collect do |repo|
-          repo.find_packages_by_nvre(name, version, release, epoch).collect do |p|
-            p[:repo_id] = repo.id
-            p
-          end
-        end
-        packages.flatten(1)
-      end
-
       def distributions(env)
         to_ret = []
         self.repos(env).each do |repo|
@@ -108,13 +47,6 @@ module Katello
         to_ret
       end
 
-      def get_distribution(env, id)
-        distribution = self.repos(env).map do |repo|
-          repo.distributions.find_all { |d| d.id == id }
-        end
-        distribution.flatten(1)
-      end
-
       def promoted_to?(target_env)
         target_env.products.include? self
       end
@@ -161,7 +93,7 @@ module Katello
         all_repos = repos(self.library, nil, false)
         ForemanTasks::Task::DynflowTask
           .select("#{ForemanTasks::Task::DynflowTask.table_name}.*")
-          .where(:label => [::Actions::Katello::Repository::Sync.name, ::Actions::Katello::Repository::ScheduledSync.name])
+          .where(:label => ::Actions::Katello::Repository::Sync.name)
           .joins(:locks).where("foreman_tasks_locks.resource_id in (?) and foreman_tasks_locks.resource_type = ?", all_repos.pluck(:id), ::Katello::Repository.name)
           .order("started_at desc")
       end
@@ -200,49 +132,7 @@ module Katello
           repo_param[:download_policy] = Setting[:default_download_policy]
         end
 
-        rel_path = if repo_param[:content_type] == 'docker'
-                     Glue::Pulp::Repos.custom_docker_repo_path(self.library, self, repo_param[:label])
-                   else
-                     Glue::Pulp::Repos.custom_repo_path(self.library, self, repo_param[:label])
-                   end
-        Repository.new(:environment => self.organization.library,
-                       :product => self,
-                       :relative_path => rel_path,
-                       :arch => repo_param[:arch],
-                       :name => repo_param[:name],
-                       :label => repo_param[:label],
-                       :description => repo_param[:description],
-                       :url => repo_param[:url],
-                       :gpg_key => repo_param[:gpg_key],
-                       :ssl_ca_cert => repo_param[:ssl_ca_cert],
-                       :ssl_client_cert => repo_param[:ssl_client_cert],
-                       :ssl_client_key => repo_param[:ssl_client_key],
-                       :unprotected => repo_param[:unprotected],
-                       :content_type => repo_param[:content_type],
-                       :checksum_type => repo_param[:checksum_type],
-                       :download_policy => repo_param[:download_policy],
-                       :content_view_version => self.organization.library.default_content_view_version)
-      end
-
-      def setup_sync_schedule
-        schedule = (self.sync_plan && self.sync_plan.schedule_format) || nil
-        self.repos(self.library).each do |repo|
-          repo.sync_schedule(schedule)
-        end
-      end
-
-      def custom_repos_create_orchestration
-        pre_queue.create(:name => "create pulp repositories for product: #{self.label}", :priority => 1, :action => [self, :set_repos])
-      end
-
-      protected
-
-      def promote_repos(repos, from_env, to_env)
-        async_tasks = []
-        repos.each do |repo|
-          async_tasks << repo.promote(from_env, to_env)
-        end
-        async_tasks.flatten(1)
+        RootRepository.new(repo_param.merge(:product_id => self.id))
       end
     end
   end

data/app/models/katello/gpg_key.rb

@@ -8,7 +8,9 @@ module Katello
     GPG_KEY_TYPE = 'gpg_key'.freeze
     CERT_TYPE = 'cert'.freeze
 
-    has_many :repositories, :class_name => "Katello::Repository", :inverse_of => :gpg_key, :dependent => :nullify
+    has_many :root_repositories, :class_name => "Katello::RootRepository", :inverse_of => :gpg_key, :dependent => :nullify
+    has_many :repositories, :through => :root_repositories
+
     has_many :products, :class_name => "Katello::Product", :inverse_of => :gpg_key, :dependent => :nullify
     has_many :ssl_ca_products, :class_name => "Katello::Product", :foreign_key => "ssl_ca_cert_id",
                                :inverse_of => :ssl_ca_cert, :dependent => :nullify
@@ -16,11 +18,11 @@ module Katello
                                    :inverse_of => :ssl_client_cert, :dependent => :nullify
     has_many :ssl_key_products, :class_name => "Katello::Product", :foreign_key => "ssl_client_key_id",
                                 :inverse_of => :ssl_client_key, :dependent => :nullify
-    has_many :ssl_ca_repos, :class_name => "Katello::Repository", :foreign_key => "ssl_ca_cert_id",
+    has_many :ssl_ca_root_repos, :class_name => "Katello::RootRepository", :foreign_key => "ssl_ca_cert_id",
                             :inverse_of => :ssl_ca_cert, :dependent => :nullify
-    has_many :ssl_client_repos, :class_name => "Katello::Repository", :foreign_key => "ssl_client_cert_id",
+    has_many :ssl_client_root_repos, :class_name => "Katello::RootRepository", :foreign_key => "ssl_client_cert_id",
                                 :inverse_of => :ssl_client_cert, :dependent => :nullify
-    has_many :ssl_key_repos, :class_name => "Katello::Repository", :foreign_key => "ssl_client_key_id",
+    has_many :ssl_key_root_repos, :class_name => "Katello::RootRepository", :foreign_key => "ssl_client_key_id",
                              :inverse_of => :ssl_client_key, :dependent => :nullify
     belongs_to :organization, :inverse_of => :gpg_keys
 
@@ -42,16 +44,6 @@ module Katello
       content_type == GPG_KEY_TYPE && SETTINGS[:katello][:gpg_strict_validation]
     end
 
-    def as_json(options = {})
-      options ||= {}
-      ret = super(options.except(:details))
-      if options[:details]
-        ret[:products] = products.map { |p| {:name => p.name} }
-        ret[:repositories] = repositories.map { |r| {:product => {:name => r.product.name}, :name => r.name} }
-      end
-      ret
-    end
-
     def self.humanize_class_name(_name = nil)
       _("GPG Keys")
     end

data/app/models/katello/host/content_facet.rb

@@ -21,7 +21,7 @@ module Katello
 
       validates :content_view, :presence => true, :allow_blank => false
       validates :lifecycle_environment, :presence => true, :allow_blank => false
-      validates_with Validators::AssociationExistsValidator, attributes: [:content_source]
+      validates_with ::AssociationExistsValidator, attributes: [:content_source]
       validates :host, :presence => true, :allow_blank => false
       validates_with Validators::ContentViewEnvironmentValidator
 

data/app/models/katello/host/subscription_facet.rb

@@ -19,6 +19,8 @@ module Katello
 
       has_many :compliance_reasons, :class_name => "Katello::ComplianceReason", :dependent => :destroy, :inverse_of => :subscription_facet
 
+      serialize :purpose_addons, Array
+
       validates :host, :presence => true, :allow_blank => false
 
       DEFAULT_TYPE = 'system'.freeze
@@ -43,6 +45,9 @@ module Katello
         self.registered_at = consumer_params['created'] unless consumer_params['created'].blank?
         self.last_checkin = consumer_params['lastCheckin'] unless consumer_params['lastCheckin'].blank?
         self.update_installed_products(consumer_params['installedProducts']) if consumer_params.key?('installedProducts')
+        self.purpose_role = consumer_params['role'] unless consumer_params['role'].nil?
+        self.purpose_usage = consumer_params['usage'] unless consumer_params['usage'].nil?
+        self.purpose_addons = consumer_params['addOns'] unless consumer_params['addOns'].nil?
 
         unless consumer_params['releaseVer'].blank?
           release = consumer_params['releaseVer']
@@ -114,6 +119,9 @@ module Katello
       def consumer_attributes
         attrs = {
           :autoheal => autoheal,
+          :usage => purpose_usage,
+          :role => purpose_role,
+          :addOns => purpose_addons,
           :serviceLevel => service_level,
           :releaseVer => release_version,
           :environment => {:id => self.candlepin_environment_id},
@@ -145,13 +153,17 @@ module Katello
       end
 
       def update_subscription_status(status_override = nil)
-        status = host.get_status(::Katello::SubscriptionStatus)
-        if status_override
-          status.status = status.to_status(:status_override => status_override)
-          status.save!
-        else
-          host.get_status(::Katello::SubscriptionStatus).refresh!
-        end
+        update_status(::Katello::SubscriptionStatus, status_override: status_override)
+
+        host.refresh_global_status!
+      end
+
+      def update_purpose_status(valid_sla: nil, valid_role: nil, valid_usage: nil, valid_addons: nil)
+        update_status(::Katello::PurposeSlaStatus, status_override: valid_sla)
+        update_status(::Katello::PurposeRoleStatus, status_override: valid_role)
+        update_status(::Katello::PurposeUsageStatus, status_override: valid_usage)
+        update_status(::Katello::PurposeAddonsStatus, status_override: valid_addons)
+        update_status(::Katello::PurposeStatus)
 
         host.refresh_global_status!
       end
@@ -246,7 +258,7 @@ module Katello
       end
 
       def backend_update_needed?
-        %w(release_version service_level autoheal).each do |method|
+        %w(release_version service_level autoheal purpose_role purpose_usage purpose_addons).each do |method|
           return true if self.send("#{method}_changed?")
         end
         if self.host.content_facet
@@ -254,6 +266,18 @@ module Katello
         end
         false
       end
+
+      private
+
+      def update_status(status_class, **args)
+        status = host.get_status(status_class)
+        if args[:status_override].nil?
+          host.get_status(status_class).refresh!
+        else
+          status.status = status.to_status(**args)
+          status.save!
+        end
+      end
     end
   end
 end

data/app/models/katello/kt_environment.rb

@@ -61,6 +61,7 @@ module Katello
 
     # RAILS3458: before_destroys before associations. see http://tinyurl.com/rails3458
     before_destroy :assert_deletable, :prepend => true
+    before_destroy :remove_from_path, :prepend => true
 
     scope(:not_in_capsule,
       lambda do |capsule|
@@ -173,8 +174,6 @@ module Katello
 
       if library?
         errors.add :base, _("Library lifecycle environments may not be deleted.")
-      elsif !successor.nil?
-        errors.add :base, _("Lifecycle Environment %s has a successor.  Only the last lifecycle environment on a path can be deleted") % self.name
       end
 
       if content_facets.any?
@@ -218,7 +217,7 @@ module Katello
     end
 
     def puppet_repositories
-      self.repositories.readable.where(:content_type => Katello::Repository::PUPPET_TYPE)
+      self.repositories.readable.puppet_type
     end
 
     def as_json(_options = {})
@@ -229,35 +228,16 @@ module Katello
       to_ret
     end
 
-    def key_for(item)
-      "environment_#{id}_#{item}"
-    end
-
-    def find_packages_by_name(name)
-      products = self.products.collect do |prod|
-        prod.find_packages_by_name(self, name).collect do |p|
-          p[:product_id] = prod.cp_id
-          p
-        end
-      end
-      products.flatten(1)
-    end
-
-    def find_packages_by_nvre(name, version, release, epoch)
-      products = self.products.collect do |prod|
-        prod.find_packages_by_nvre(self, name, version, release, epoch).collect do |p|
-          p[:product_id] = prod.cp_id
-          p
-        end
+    def remove_from_path
+      if self.successor && self.prior
+        prior_env = self.prior
+        self.env_priors.destroy_all
+        self.successor.env_priors.first.update_attributes!(:prior_id => prior_env.id)
       end
-      products.flatten(1)
     end
 
-    def get_distribution(id)
-      distribution = self.products.collect do |prod|
-        prod.get_distribution(self, id)
-      end
-      distribution.flatten(1)
+    def key_for(item)
+      "environment_#{id}_#{item}"
     end
 
     def add_to_default_capsule

data/app/models/katello/module_profile.rb

@@ -0,0 +1,6 @@
+module Katello
+  class ModuleProfile < Katello::Model
+    belongs_to :module_stream, class_name: "Katello::ModuleStream", inverse_of: :profiles
+    has_many :rpms, class_name: "Katello::ModuleProfileRpm", dependent: :destroy, inverse_of: :module_profile
+  end
+end

data/app/models/katello/module_profile_rpm.rb

@@ -0,0 +1,5 @@
+module Katello
+  class ModuleProfileRpm < Katello::Model
+    belongs_to :module_profile, class_name: "Katello::ModuleProfile", inverse_of: :rpms
+  end
+end

data/app/models/katello/module_stream.rb

@@ -0,0 +1,112 @@
+module Katello
+  class ModuleStream < Katello::Model
+    include Concerns::PulpDatabaseUnit
+    include ScopedSearchExtensions
+    has_many :repository_module_streams, class_name: "Katello::RepositoryModuleStream",
+      dependent: :destroy, inverse_of: :module_stream
+    has_many :repositories, through: :repository_module_streams, class_name: "Katello::Repository"
+    has_many :profiles, class_name: "Katello::ModuleProfile", dependent: :destroy, inverse_of: :module_stream
+    has_many :artifacts, class_name: "Katello::ModuleStreamArtifact", dependent: :destroy, inverse_of: :module_stream
+
+    scoped_search on: :name, complete_value: true
+    scoped_search on: :uuid, complete_value: true
+    scoped_search on: :stream, complete_value: true
+    scoped_search on: :version, complete_value: true
+    scoped_search on: :context, complete_value: true
+    scoped_search on: :arch, complete_value: true
+    scoped_search on: :host, rename: :host,
+                  only_explicit: true,
+                  ext_method: :find_by_host_name,
+                  complete_value: false
+
+    scoped_search on: :module_spec, rename: :module_spec,
+                   only_explicit: true,
+                   ext_method: :find_by_module_spec,
+                   complete_value: false,
+                   operators: ["=", "~"]
+
+    CONTENT_TYPE = Pulp::ModuleStream::CONTENT_TYPE
+    MODULE_STREAM_DEFAULT_CONTENT_TYPE = "modulemd_defaults".freeze
+
+    def self.default_sort
+      order(:name)
+    end
+
+    def self.repository_association_class
+      RepositoryModuleStream
+    end
+
+    def update_from_json(json)
+      shared_attributes = json.keys & self.class.column_names
+      shared_json = json.select { |key, _v| shared_attributes.include?(key) }
+      self.update_attributes!(shared_json)
+
+      create_stream_artifacts(json['artifacts']) if json.key?('artifacts')
+      create_profiles(json['profiles']) if json.key?('profiles')
+    end
+
+    def create_stream_artifacts(artifacts)
+      artifacts.each do |name|
+        self.artifacts.where(name: name).first_or_create!
+      end
+    end
+
+    def create_profiles(profiles)
+      profiles.select do |profile, rpms|
+        profile = self.profiles.where(name: profile).first_or_create!
+        rpms.each do |rpm|
+          profile.rpms.where(name: rpm).first_or_create!
+        end
+      end
+    end
+
+    def library_repositories
+      self.repositories.where(library_instance: nil)
+    end
+
+    def self.available_for_hosts(hosts)
+      where("#{table_name}.id" => ::Katello::ModuleStream.joins(repositories: :content_facets).
+            select("#{table_name}.id").
+            merge(::Katello::Host::ContentFacet.where(host_id: hosts)))
+    end
+
+    def module_spec
+      # NAME:STREAM:VERSION:CONTEXT:ARCH
+      items = []
+      ["name", "stream", "version", "context", "arch"].each do |item|
+        if attributes[item]
+          items << attributes[item]
+        else
+          break
+        end
+      end
+      items.join(":")
+    end
+
+    def self.parse_module_spec(module_spec)
+      # NAME:STREAM:VERSION:CONTEXT:ARCH/PROFILE
+      spec = module_spec.split("/").first
+      name, stream, version, context, arch = spec.split(":")
+      {:name => name, :stream => stream, :version => version, :context => context, :arch => arch}.compact
+    end
+
+    def self.find_by_host_name(_key, operator, value)
+      conditions = sanitize_sql_for_conditions(["#{::Host::Managed.table_name}.name #{operator} ?", value_to_sql(operator, value)])
+      hosts = ::Host::Managed.authorized("view_hosts").where(conditions).select(:id)
+      if hosts.empty?
+        { :conditions => "1=0" }
+      else
+        { :conditions => "#{::Katello::ModuleStream.table_name}.id in (#{available_for_hosts(hosts).select(:id).to_sql})" }
+      end
+    end
+
+    def self.find_by_module_spec(_key, _operator, value)
+      spec = parse_module_spec(value)
+      if spec.empty?
+        { :conditions => "1=0" }
+      else
+        { :conditions => "#{::Katello::ModuleStream.table_name}.id in (#{select(:id).where(spec).to_sql})" }
+      end
+    end
+  end
+end