katello 3.7.0.rc1 → 3.7.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 147daad6f060ba123d7cb4ccf889e33540fd1224
-  data.tar.gz: 0a970ddfacc20136330150f3d535fb06473210c4
+  metadata.gz: 9a4f6bd736dcb2608d0f0eb09fc42a3365633e81
+  data.tar.gz: d4d554bed1a2b7d416f8c57cf6e786fc2188aaa5
 SHA512:
-  metadata.gz: a577fcdf1949cd2b761cb098dc2cdf809c39daf235ba45e1e27f1d5c9fb101a63bd47280eaca2ecfffff8a42e98e082216ab50383572d4fab3090e0913d7461e
-  data.tar.gz: a7bd9315164c9fac9f35c07e81f33ec3095f944392412d1fe17decc664aa707017fe8b5694e5249126bcb79ea5fdd2393633ce0b08bbc685dc3cbeabc93dc87b
+  metadata.gz: b4e75ade9c719b6f7ba594591fdef8e7665440bf5781802ad5c80dc42d413bb8c2ce71ab17c7805665dfef6dc56e270d30227cbc6127e3f0db3956a0b5ea45d5
+  data.tar.gz: 3318e9625546af01d1f72dc7dc30f998d0213f124189cdb2cc4572652a644648d84935fc114e5d98c1c8368f979319929bb29b033a2c8f05519e717cbaeea9ce

data/app/controllers/katello/api/v2/content_views_controller.rb

@@ -208,9 +208,12 @@ module Katello
     end
 
     def view_params
-      attrs = [:name, :description, :force_puppet_environment, {:repository_ids => []}, {:component_ids => []}]
+      attrs = [:name, :description, :force_puppet_environment, {:component_ids => []}]
       attrs.push(:label, :composite) if action_name == "create"
-      attrs.push(:component_ids, :repository_ids, :auto_publish) # For deep_munge; Remove for Rails 5
+      attrs.push(:component_ids, :auto_publish) # For deep_munge; Remove for Rails 5
+      if (!@view || !@view.composite?)
+        attrs.push({:repository_ids => []}, :repository_ids)
+      end
       params.require(:content_view).permit(*attrs).to_h
     end
 

data/app/controllers/katello/api/v2/environments_controller.rb

@@ -13,7 +13,7 @@ module Katello
 
         ## Chains
 
-        Environments are ordered into chains and their content (propducts,
+        Environments are ordered into chains and their content (products,
         repositories, tempaltes, packages) can be moved to an environment only from its
         prior environment. You can have for example chain like:
 
@@ -39,6 +39,7 @@ module Katello
     before_action :find_prior, :only => [:create]
     before_action :find_environment, :only => [:show, :update, :destroy, :repositories]
     before_action :find_content_view, :only => [:repositories]
+    before_action :find_path, :only => [:create]
 
     wrap_parameters :include => (KTEnvironment.attribute_names + %w(prior prior_id new_name))
 
@@ -83,8 +84,7 @@ module Katello
       create_params = environment_params
       create_params[:label] = labelize_params(create_params)
       create_params[:organization] = @organization
-      create_params[:prior] = @prior
-      @environment = KTEnvironment.create!(create_params)
+      @environment = @prior.insert_successor(create_params, @path)
       respond
     end
 
@@ -168,6 +168,11 @@ module Katello
       @prior
     end
 
+    def find_path
+      path = params[:environment][:path_id] || params[:path_id]
+      path ? @path = KTEnvironment.readable.find(path).path : @path = nil
+    end
+
     def environment_params
       if @environment && @environment.library?
         attrs = [:registry_name_pattern]

data/app/controllers/katello/api/v2/host_tracer_controller.rb

@@ -9,7 +9,7 @@ module Katello
       api_base_url "/api"
     end
 
-    api :GET, "/hosts/:host_id/tracer", N_("List servises that need restarting on the host")
+    api :GET, "/hosts/:host_id/traces", N_("List services that need restarting on the host")
     param :host_id, :number, :required => true, :desc => N_("ID of the host")
     def index
       collection = scoped_search(index_relation, :application, :asc, :resource_class => ::Katello::HostTracer)

data/app/controllers/katello/api/v2/upstream_subscriptions_controller.rb

@@ -18,7 +18,7 @@ module Katello
       N_("List available subscriptions from Red Hat Subscription Management")
     param :organization_id, :number, :desc => N_("Organization ID"), :required => true
     param_group :cp_search
-    param :pool_ids, Array, desc: N_("Return only the upstream pools which map to the given local pool IDs")
+    param :pool_ids, Array, desc: N_("Return only the upstream pools which map to the given Katello pool IDs")
     param :quantities_only, :bool, desc: N_("Only returns id and quantity fields")
     param :attachable, :bool, desc: N_("Return only subscriptions which can be attached to the upstream allocation")
     def index
@@ -35,7 +35,7 @@ module Katello
       N_("Update the quantity of one or more subscriptions on an upstream allocation")
     param :organization_id, :number, :desc => N_("Organization ID"), :required => true
     param :pools, Array, desc: N_("Array of Pools to be updated. Only pools originating upstream are accepted."), required: true do
-      param :id, String, desc: N_("ID of local pool to update"), required: true
+      param :id, String, desc: N_("Katello ID of local pool to update"), required: true
       param :quantity, Integer, desc: N_("Desired quantity of the pool"), required: true
     end
     def update
@@ -55,7 +55,7 @@ module Katello
     api :POST, "/organizations/:organization_id/upstream_subscriptions",
       N_("Add subscriptions consumed by a manifest from Red Hat Subscription Management")
     param :pools, Array, desc: N_("Array of pools to add"), required: true do
-      param :id, String, desc: N_("Pool ID"), required: true
+      param :id, String, desc: N_("Candlepin ID of pool to add"), required: true
       param :quantity, :number, desc: N_("Quantity of entitlements to bind"), required: true
     end
     param :organization_id, :number, :desc => N_("Organization ID"), :required => true
@@ -74,7 +74,7 @@ module Katello
     def upstream_pool_params
       upstream_params = params.permit(:page, :per_page, :order, :sort_by, :quantities_only, :attachable, pool_ids: []).to_h
 
-      if params[:full_result]
+      if params[:full_result] || !upstream_params[:pool_ids].empty?
         upstream_params.delete(:per_page)
         upstream_params.delete(:page)
       elsif !params[:per_page]

data/app/helpers/katello/hosts_and_hostgroups_helper.rb

@@ -14,14 +14,6 @@ module Katello
       %(<option data-id="#{inherited_value}" value="">#{blank_or_inherit_f(f, attr)}</option>)
     end
 
-    def content_view(host)
-      if host.is_a?(Hostgroup)
-        host.content_view
-      else
-        host.content_facet.try(:content_view)
-      end
-    end
-
     def organizations(host)
       if host.is_a?(Hostgroup)
         host.organizations
@@ -30,14 +22,6 @@ module Katello
       end
     end
 
-    def lifecycle_environment(host)
-      if host.is_a?(Hostgroup)
-        host.lifecycle_environment
-      else
-        host.content_facet.try(:lifecycle_environment)
-      end
-    end
-
     def use_install_media(host, options = {})
       return true if host && host.errors && host.errors.include?(:medium_id)
       kickstart_repository_id(host, options).blank?
@@ -77,20 +61,19 @@ module Katello
     end
 
     def fetch_lifecycle_environment(host, options = {})
+      return host.lifecycle_environment if host.lifecycle_environment.present?
       selected_host_group = options.fetch(:selected_host_group, nil)
-      return lifecycle_environment(selected_host_group) if selected_host_group.present?
-      selected_env = lifecycle_environment(host)
-      return selected_env if selected_env.present?
+      return selected_host_group.lifecycle_environment if selected_host_group.present?
     end
 
     def fetch_content_view(host, options = {})
+      return host.content_view if host.content_view.present?
       selected_host_group = options.fetch(:selected_host_group, nil)
-      return content_view(selected_host_group) if selected_host_group.present?
-      content_view(host)
+      return selected_host_group.content_view if selected_host_group.present?
     end
 
     def accessible_lifecycle_environments(org, host)
-      selected = lifecycle_environment(host)
+      selected = host.lifecycle_environment
       envs = org.kt_environments.readable
       envs |= [selected] if selected.present? && org == selected.organization
       envs

data/app/lib/actions/katello/host/update_content_overrides.rb

@@ -6,6 +6,7 @@ module Actions
 
         def plan(host, content_override_params, prune_invalid_content_overrides = true)
           action_subject(host)
+          fail _("This Host is not currently registered with subscription-manager.") unless host.subscription_facet
           plan_self(:host_id => host.id, :host_name => host.name, :content_overrides => content_override_params,
                     :prune_invalid_content_overrides => prune_invalid_content_overrides)
         end

data/app/lib/actions/katello/product/content_create.rb

@@ -45,6 +45,7 @@ module Actions
           repository.save!
 
           content = ::Katello::Content.create!(name: repository.name,
+                                               organization_id: repository.product.organization_id,
                                                cp_content_id: repository.content_id,
                                                content_type: repository.content_type,
                                                label: repository.custom_content_label,

data/app/lib/actions/katello/product/repositories_certs_reset.rb

@@ -0,0 +1,25 @@
+module Actions
+  module Katello
+    module Product
+      class RepositoriesCertsReset < Actions::AbstractAsyncTask
+        def plan(product)
+          ssl_ca_cert_id = product.ssl_ca_cert_id
+          ssl_client_cert_id = product.ssl_client_cert_id
+          ssl_client_key_id = product.ssl_client_key_id
+          # Plan Repository::Update only for repositories which have different certs key
+          product.repositories.each do |repo|
+            if (repo.ssl_ca_cert_id != ssl_ca_cert_id ||
+                repo.ssl_client_cert_id != ssl_client_cert_id ||
+                repo.ssl_client_key_id != ssl_client_key_id)
+              plan_action(::Actions::Katello::Repository::Update,
+                          repo,
+                          :ssl_ca_cert_id => ssl_ca_cert_id,
+                          :ssl_client_cert_id => ssl_client_cert_id,
+                          :ssl_client_key_id => ssl_client_key_id)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/katello/product/update.rb

@@ -8,7 +8,13 @@ module Actions
           if product.previous_changes.key?('gpg_key_id')
             plan_action(::Actions::Katello::Product::RepositoriesGpgReset, product)
           end
+          if (product.previous_changes.key?('ssl_ca_cert_id') ||
+              product.previous_changes.key?('ssl_client_cert_id') ||
+              product.previous_changes.key?('ssl_client_key_id'))
+            plan_action(::Actions::Katello::Product::RepositoriesCertsReset, product)
+          end
 
+          product.reload
           plan_action(::Actions::Pulp::Repos::Update, product) if ::SETTINGS[:katello][:use_pulp]
         end
       end

data/app/lib/katello/resources/candlepin/activation_key.rb

@@ -3,8 +3,8 @@ module Katello
     module Candlepin
       class ActivationKey < CandlepinResource
         class << self
-          def get(id = nil, params = '')
-            akeys_json = super(path(id) + params, self.default_headers).body
+          def get(id = nil, params = '', owner = nil)
+            akeys_json = super(path(id, owner) + params, self.default_headers).body
             akeys = JSON.parse(akeys_json)
             akeys = [akeys] unless id.nil?
             ::Katello::Util::Data.array_with_indifferent_access akeys
@@ -91,8 +91,12 @@ module Katello
             ::Katello::Util::Data.array_with_indifferent_access(JSON.parse(result || '{}'))
           end
 
-          def path(id = nil)
-            "/candlepin/activation_keys/#{id}"
+          def path(id = nil, owner_id = nil)
+            if owner_id
+              "/candlepin/owners/#{owner_id}/activation_keys/#{id}"
+            else
+              "/candlepin/activation_keys/#{id}"
+            end
           end
         end
       end

data/app/lib/katello/resources/candlepin/product.rb

@@ -4,7 +4,8 @@ module Katello
       class Product < CandlepinResource
         class << self
           def all(owner_label, included = [])
-            JSON.parse(Candlepin::CandlepinResource.get(path(owner_label) + "?#{included_list(included)}", self.default_headers).body)
+            products = JSON.parse(Candlepin::CandlepinResource.get(path(owner_label) + "?#{included_list(included)}", self.default_headers).body)
+            ::Katello::Util::Data.array_with_indifferent_access products
           end
 
           def find_for_stacking_id(owner_key, stacking_id)

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

@@ -28,9 +28,11 @@ module Katello
         needed_substitutions = PathWithSubstitutions.new(real_path, {}).substitutions_needed
 
         if unused_substitutions.any?
-          fail Errors::CdnSubstitutionError, _("%{unused_substitutes} cannot be specified for %{content_name}"\
-                 " as that information is not substitutable in %{content_url} ") %
-              { unaccepted_substitutions: unused_substitutions, content_name: content.name, content_url: content.content_url }
+          fail Errors::CdnSubstitutionError, _("%{unused_substitutions} cannot be specified for %{content_name}"\
+            " as that information is not substitutable in %{content_url} ") %
+            { unused_substitutions: unused_substitutions.join(','),
+              content_name: content.name,
+              content_url: content.content_url }
         end
 
         if needed_substitutions.any?

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

@@ -3,12 +3,22 @@ module Katello
     module Package
       SUFFIX_RE = /\.(rpm)$/
       ARCH_RE = /\.([^.\-]*)$/
-      EPOCH_RE = /([0-9]+):/
-      NVRE_RE = /^(?:([0-9]+):)?(.*)-([^-]*)-([^-]*)$/
+      NVRE_RE = /^(.*)-(?:([0-9]+):)?([^-]*)-([^-]*)$/
+      EVR_RE = /^(?:([0-9]+):)?(.*?)(?:-([^-]*))?$/
       SUPPORTED_ARCHS = %w(noarch i386 i686 ppc64 s390x x86_64 ia64).freeze
 
+      # is able to take both nvre and nvrea and parse it correctly
+      def self.parse_nvrea_nvre(name)
+        package = self.parse_nvrea(name)
+        if package && SUPPORTED_ARCHS.include?(package[:arch])
+          return package
+        else
+          return self.parse_nvre(name)
+        end
+      end
+
       #parses package nvrea and stores it in a hash
-      #epoch:name-ve.rs.ion-rel.e.ase.arch.rpm
+      #name-epoch:ve.rs.ion-rel.e.ase.arch.rpm
       def self.parse_nvrea(name)
         name, suffix = extract_suffix(name)
         name, arch = extract_arch(name)
@@ -20,26 +30,24 @@ module Katello
       end
 
       #parses package nvre and stores it in a hash
-      #epoch:name-ve.rs.ion-rel.e.ase.rpm
+      #name-epoch:ve.rs.ion-rel.e.ase.rpm
       def self.parse_nvre(name)
         name, suffix = extract_suffix(name)
 
         if (match = NVRE_RE.match(name))
           {:suffix => suffix,
-           :epoch => match[1],
-           :name => match[2],
+           :name => match[1],
+           :epoch => match[2],
            :version => match[3],
            :release => match[4]}.delete_if { |_k, v| v.nil? }
         end
       end
 
-      # is able to take both nvre and nvrea and parse it correctly
-      def self.parse_nvrea_nvre(name)
-        package = self.parse_nvrea(name)
-        if package && SUPPORTED_ARCHS.include?(package[:arch])
-          return package
-        else
-          return self.parse_nvre(name)
+      def self.parse_evr(evr)
+        if (match = EVR_RE.match(evr))
+          {:epoch => match[1],
+           :version => match[2],
+           :release => match[3]}.delete_if { |_k, v| v.nil? }
         end
       end
 

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

@@ -15,53 +15,55 @@ module Katello
       end
 
       def extract_epoch_version_release(evr)
-        match = case evr
-                when /\A(\d+):(.*)-(.*)\z/
-                  evr.match(/\A(?<epoch>\d+):(?<version>.*)-(?<release>.*)\z/)
-                when /\A(\d+):(.*)\z/
-                  evr.match(/\A(?<epoch>\d+):(?<version>.*)\z/)
-                when /\A(.*)-(.*)\z/
-                  evr.match(/\A(?<version>.*)-(?<release>.*)\z/)
-                else
-                  evr.match(/\A(?<version>.*)\z/)
-                end
-        self.version = Package.sortable_version(match[:version])
-        self.epoch = match[:epoch] rescue nil
-        self.release = (match[:release] rescue nil) ? Package.sortable_version(match[:release]) : nil
+        parsed = Package.parse_evr(evr)
+        self.epoch = parsed[:epoch].to_i # nil or blank becomes 0
+        v = parsed[:version]
+        self.version = (v.nil? || v.blank?) ? '' : Package.sortable_version(v)
+        r = parsed[:release]
+        self.release = (r.nil? || r.blank?) ? '' : Package.sortable_version(r)
       end
 
       def results
-        version_clause = "#{convert(:version_sortable)} #{operator} #{convert(':version')}"
-        version_clause = add_release_clause(version_clause) unless release.blank?
-        version_clause = add_epoch_clause(version_clause) unless epoch.blank?
+        if operator == EQUAL
+          conditions = epoch_clause(operator)
+          conditions += ' AND ' + version_clause(operator) unless version.blank?
+          conditions += ' AND ' + release_clause(operator) unless release.blank?
+        else
+          conditions = ''
+          unless version.blank?
+            unless release.blank?
+              conditions = " OR (#{version_clause('=')} AND #{release_clause(operator)})"
+            end
+            conditions = " OR (#{epoch_clause('=')} AND (#{version_clause(operator)}#{conditions}))"
+          end
+          conditions = "#{epoch_clause(operator)}#{conditions}"
+        end
 
-        self.relation.where(version_clause, :version => version, :release => release, :epoch => epoch)
+        self.relation.where(conditions, :version => version, :release => release, :epoch => epoch)
       end
 
-      def add_release_clause(version_clause)
-        clause = "(#{convert(:version_sortable)} = #{convert(':version')} AND #{convert(:release_sortable)} #{operator} #{convert(':release')})"
+      def epoch_clause(op)
+        "CAST(epoch AS INT) #{op} :epoch"
+      end
 
-        # if we're using EQUAL, match: version = X AND release = Y
-        # else if we're using something like greater than, we need:
-        #   (version > X) OR (version = X AND release > Y)
-        if operator == EQUAL
-          clause
+      def version_clause(op)
+        if op == '='
+          "version_sortable = :version"
         else
-          "#{version_clause} OR #{clause}"
+          "#{convert(:version_sortable)} #{op} #{convert(':version')}"
         end
       end
 
-      def add_epoch_clause(version_clause)
-        if operator == EQUAL
-          clause = "(epoch = :epoch AND (%s))"
+      def release_clause(op)
+        if op == '='
+          "release_sortable = :release"
         else
-          clause = "epoch #{operator} :epoch OR (epoch = :epoch AND (%s))"
+          "#{convert(:release_sortable)} #{op} #{convert(':release')}"
         end
-        clause % version_clause
       end
 
       def convert(name = '?')
-        "convert_to(#{name}, 'SQL_ASCII')"
+        "#{name} COLLATE \"C\""
       end
     end
   end

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

@@ -2,18 +2,14 @@ module Katello
   module Validators
     class PriorValidator < ActiveModel::Validator
       def validate(record)
-        #need to ensure that prior
-        #environment already does not have a successor
-        #this is because in v1.0 we want
+        # need to ensure that prior
+        # environment already does not have a successor
+        # this is because in v1.0 we want
         # prior to have only one child (unless its the Library)
-        has_no_prior = true
-        if record.organization
-          has_no_prior = record.organization.kt_environments.reject { |env| env == record || env.prior != record.prior || env.prior == env.organization.library }.empty?
+        ancestor = record.prior
+        if ancestor && !ancestor.library?
+          record.errors[:prior] << _("prior environment can only have one child") if ancestor.successors.count == 1 && !ancestor.successors.include?(record)
         end
-        record.errors[:prior] << _("environment can only have one child") unless has_no_prior
-
-        # only Library can have prior=nil
-        record.errors[:prior] << _("environment required") unless !record.prior.nil? || record.library?
       end
     end
   end