katello 3.5.2 → 3.6.0.rc1

data/app/lib/actions/candlepin/owner/upstream_regenerate_certificates.rb

@@ -1,17 +0,0 @@
-module Actions
-  module Candlepin
-    module Owner
-      class UpstreamRegenerateCertificates < Candlepin::Abstract
-        input_format do
-          param :organization_id
-          param :upstream
-        end
-
-        def run
-          organization = ::Organization.find(input[:organization_id])
-          output[:response] = organization.redhat_provider.owner_regenerate_upstream_certificates(input[:upstream])
-        end
-      end
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-module Actions
-  module Candlepin
-    module Product
-      class Update < Candlepin::Abstract
-        def plan(product)
-          product.deleted_content.each do |product_content|
-            plan_action(::Actions::Candlepin::Product::ContentRemove,
-                        :owner => product.organization.label,
-                        :product_id => product.cp_id,
-                        :content_id => product_content.content.id)
-            plan_action(::Actions::Candlepin::Product::ContentDestroy,
-                        :owner => product.organization.label,
-                        :content_id => product_content.content.id)
-          end
-
-          product.added_content.each do |pc|
-            content_create = plan_action(::Actions::Candlepin::Product::ContentCreate,
-                                         :owner => product.organization.label,
-                                         :name => pc.content.name,
-                                         :type => pc.content.type,
-                                         :label => pc.content.label,
-                                         :content_url => pc.content.contentUrl)
-            plan_action(::Actions::Candlepin::Product::ContentAdd,
-                        :owner => product.organization.label,
-                        :product_id => product.cp_id,
-                        :content_id => content_create.output[:response][:id])
-          end
-        end
-      end
-    end
-  end
-end

data/app/lib/actions/katello/event_queue/run_once_coordinator_lock.rb

@@ -1,12 +0,0 @@
-module Actions
-  module Katello
-    module EventQueue
-      class RunOnceCoordinatorLock < Dynflow::Coordinator::LockByWorld
-        def initialize(world)
-          super
-          @data[:id] = 'katello-event-queue'
-        end
-      end
-    end
-  end
-end

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

@@ -1,252 +0,0 @@
-module Katello
-  class Candlepin::Content
-    attr_accessor :name, :id, :type, :label, :vendor, :contentUrl, :gpgUrl, :modifiedProductIds
-
-    def initialize(params = {})
-      load_attributes(params)
-    end
-
-    def self.find(owner_key, id)
-      found = Resources::Candlepin::Content.get(owner_key, id)
-      Candlepin::Content.new(found)
-    end
-
-    def create
-      created = Resources::Candlepin::Content.create self
-      load_attributes(created)
-
-      self
-    end
-
-    def destroy
-      Resources::Candlepin::Content.destroy(@id)
-    end
-
-    def update(params = {})
-      return self if params.empty?
-
-      updated = Resources::Candlepin::Content.update(params.merge(:id => @id))
-      load_attributes(updated)
-
-      self
-    end
-
-    def load_attributes(params)
-      params.each_pair { |k, v| instance_variable_set("@#{k}", v) unless v.nil? }
-    end
-
-    class RepositoryMapper
-      attr_reader :product, :content, :substitutions
-
-      def initialize(product, content, substitutions)
-        @product = product
-        @content = content
-        @substitutions = substitutions.try(:with_indifferent_access)
-      end
-
-      def find_repository
-        ::Katello::Repository.where(product_id: product.id,
-                                    content_id: content.id,
-                                    environment_id: product.organization.library.id,
-                                    minor: minor,
-                                    arch: arch).first
-      end
-
-      def build_repository
-        certificate_and_key = get_certificate_and_key(product, @content.modifiedProductIds)
-
-        repository = Repository.new(
-          :environment => product.organization.library,
-          :product => product,
-          :cp_label => content.label,
-          :content_id => content.id,
-          :arch => arch,
-          :major => major,
-          :minor => minor,
-          :relative_path => relative_path,
-          :name => name,
-          :label => label,
-          :url => feed_url,
-          :feed_ca => ::Katello::Repository.feed_ca_cert(feed_url),
-          :feed_cert => certificate_and_key[:cert],
-          :feed_key => certificate_and_key[:key],
-          :content_type => katello_content_type,
-          :preserve_metadata => true, #preserve repo metadata when importing from cp
-          :unprotected => unprotected?,
-          :download_policy => download_policy,
-          :mirror_on_sync => true,
-          :content_view_version => product.organization.
-                                  library.default_content_view_version
-        )
-
-        repository
-      end
-
-      def get_certificate_and_key(product, modified_product_ids = [])
-        modified_product_ids.each do |modified_product_id|
-          modified_product = Product.where(:cp_id => modified_product_id).first
-          product = modified_product if modified_product &&
-                                        modified_product.certificate &&
-                                        modified_product.key
-        end
-        {:cert => product.certificate, :key => product.key}
-      end
-
-      def validate!
-        return if katello_content_type == Repository::OSTREE_TYPE
-        substitutor.validate_substitutions(content, substitutions)
-      end
-
-      def substitutor
-        product.cdn_resource.substitutor
-      end
-
-      def name
-        sorted_substitutions = substitutions.sort_by { |k, _| k.to_s }.map(&:last)
-        repo_name_parts = [content.name,
-                           sorted_substitutions].flatten.compact
-        repo_name_parts.join(" ").gsub(/[^a-z0-9\-\._ ]/i, "")
-      end
-
-      def path
-        substitutions.inject(content.contentUrl) do |url, (key, value)|
-          url.gsub("$#{key}", value)
-        end
-      end
-
-      def relative_path
-        ::Katello::Glue::Pulp::Repos.repo_path_from_content_path(product.organization.library, path)
-      end
-
-      def feed_url
-        product.repo_url(path)
-      end
-
-      def arch
-        substitutions[:basearch] || "noarch"
-      end
-
-      def label
-        ::Katello::Util::Model.labelize(name)
-      end
-
-      def version
-        ::Katello::Resources::CDN::Utils.parse_version(substitutions[:releasever])
-      end
-
-      def major
-        version[:major]
-      end
-
-      def minor
-        version[:minor]
-      end
-
-      def content_type
-        kickstart? ? 'yum' : content.type
-      end
-
-      def katello_content_type
-        if content_type == ::Katello::Repository::CANDLEPIN_DOCKER_TYPE
-          ::Katello::Repository::DOCKER_TYPE
-        else
-          content_type
-        end
-      end
-
-      def unprotected?
-        kickstart? || file?
-      end
-
-      def file?
-        content.type.downcase == 'file'
-      end
-
-      def kickstart?
-        content.type.downcase == 'kickstart'
-      end
-
-      def download_policy
-        if katello_content_type == Repository::YUM_TYPE
-          Setting[:default_download_policy]
-        else
-          ""
-        end
-      end
-    end
-
-    class DockerRepositoryMapper
-      attr_reader :product, :content
-      attr_accessor :container_registry_name, :registries, :registry_repo
-      def initialize(product, content, container_registry_name = nil)
-        @product = product
-        @content = content
-        @container_registry_name = container_registry_name
-      end
-
-      def registry
-        validate!
-        @registries ||= product.cdn_resource.get_docker_registries(content.contentUrl)
-        @registry_repo ||= registries.detect do |reg|
-          reg['name'] == @container_registry_name
-        end
-      end
-
-      def find_repository
-        ::Katello::Repository.where(product_id: product.id,
-                                    environment_id: product.organization.library.id,
-                                    docker_upstream_name: container_registry_name).first
-      end
-
-      def build_repository
-        unless registry
-          Rails.logger.error("Docker registry with pulp_id #{container_registry_name} was not found at #{content.contentUrl}")
-          fail _("Docker repository not found")
-        end
-        ::Katello::Repository.new(:environment => product.organization.library,
-                                 :product => product,
-                                 :cp_label => content.label,
-                                 :content_id => content.id,
-                                 :relative_path => relative_path,
-                                 :name => name,
-                                 :docker_upstream_name => registry["name"],
-                                 :label => label,
-                                 :url => feed_url,
-                                 :feed_ca => ::Katello::Repository.feed_ca_cert(feed_url),
-                                 :feed_cert => product.certificate,
-                                 :feed_key => product.key,
-                                 :content_type => ::Katello::Repository::DOCKER_TYPE,
-                                 :preserve_metadata => true, #preserve repo metadata when importing from cp
-                                 :unprotected => true,
-                                 :content_view_version => product.organization.library.default_content_view_version)
-      end
-
-      def validate!
-        fail _("Registry name cannot be blank") if @container_registry_name.blank?
-      end
-
-      def name
-        "#{content.name} - (#{registry['name']})"
-      end
-
-      def feed_url
-        cdn_uri = URI.parse(product.provider.repository_url)
-        docker_repo_uri =  URI.parse(registry["url"])
-        docker_repo_uri =  URI.parse("#{cdn_uri.scheme}://#{registry['url']}") unless docker_repo_uri.host
-        "#{docker_repo_uri.scheme}://#{docker_repo_uri.host}:#{docker_repo_uri.port}"
-      end
-
-      def label
-        ::Katello::Util::Model.labelize(name)
-      end
-
-      def katello_content_type
-        ::Katello::Repository::DOCKER_TYPE
-      end
-
-      def relative_path
-        ::Katello::Glue::Pulp::Repos.repo_path_from_content_path(product.organization.library, content.contentUrl)
-      end
-    end
-  end
-end

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

@@ -1,48 +0,0 @@
-module Katello
-  class Candlepin::ProductContent
-    include ForemanTasks::Triggers
-
-    attr_accessor :content, :enabled, :product, :product_id
-
-    def initialize(params = {}, product_id = nil)
-      params = params.with_indifferent_access
-      #controls whether repo is enabled in yum repo file on client
-      #  unrelated to enable/disable from katello
-      @enabled = params[:enabled]
-      @content = Candlepin::Content.new(params[:content])
-      @product_id = product_id
-    end
-
-    def create
-      @content.create
-    end
-
-    def destroy
-      @content.destroy
-    end
-
-    def product
-      @product ||= Product.find(@product_id) if @product_id
-      @product
-    end
-
-    def repositories
-      @repos ||= self.product.repos(self.product.organization.library).where(:content_id => self.content.id)
-    end
-
-    def content_type
-      self.content.type
-    end
-
-    def displayable?
-      case content_type
-      when ::Katello::Repository::CANDLEPIN_DOCKER_TYPE
-        false
-      when ::Katello::Repository::CANDLEPIN_OSTREE_TYPE
-        ::Katello::RepositoryTypeManager.enabled?(Repository::OSTREE_TYPE)
-      else
-        true
-      end
-    end
-  end
-end

data/lib/katello/params_parser_wrapper.rb

@@ -1,16 +0,0 @@
-module Katello
-  class ParamsParserWrapper < ActionDispatch::ParamsParser
-    def initialize(app, excludes)
-      @exclude = excludes
-      super(app)
-    end
-
-    def call(env)
-      if @exclude && @exclude.call(env)
-        @app.call(env)
-      else
-        super(env)
-      end
-    end
-  end
-end