katello 4.1.4 → 4.2.0.rc1

data/app/lib/actions/foreman/environment/destroy.rb

@@ -1,23 +0,0 @@
-module Actions
-  module Foreman
-    module Environment
-      class Destroy < Actions::Base
-        def plan(environment)
-          if environment.hosts.count > 0
-            names = environment.hosts.limit(5).pluck(:name).join(', ')
-            fail _("The environment %{name} is in use by %{count} Host(s) including %{names}") %
-                     {:name => environment.name, :names => names, :count => environment.hosts.count}
-          end
-
-          if environment.hostgroups.count > 0
-            names = environment.hostgroups.limit(5).pluck(:name).join(', ')
-            fail _("The environment %{name} is in use by %{count} Host Group(s) including %{names}") %
-                     {:name => environment.name, :names => names, :count => environment.hostgroups.count}
-          end
-
-          environment.destroy!
-        end
-      end
-    end
-  end
-end

data/app/lib/actions/katello/content_view/environment_create.rb

@@ -1,21 +0,0 @@
-module Actions
-  module Katello
-    module ContentView
-      class EnvironmentCreate < Actions::Base
-        def plan(content_view_environment)
-          content_view_environment.save!
-          content_view = content_view_environment.content_view
-          plan_action(Candlepin::Environment::Create,
-                      organization_label: content_view.organization.label,
-                      cp_id:              content_view_environment.cp_id,
-                      name:               content_view_environment.label,
-                      description:        content_view.description)
-        end
-
-        def humanized_name
-          _("Create")
-        end
-      end
-    end
-  end
-end

data/app/lib/actions/katello/repository/export.rb

@@ -1,85 +0,0 @@
-module Actions
-  module Katello
-    module Repository
-      class Export < Actions::EntryAction
-        input_format do
-          param :id, Integer
-          param :export_result, Hash
-        end
-
-        EXPORT_OUTPUT_BASEDIR = "/var/lib/pulp/published/yum/master/group_export_distributor/".freeze
-
-        def plan(repos, export_to_iso, since, iso_size, group_id)
-          unless File.directory?(Setting['pulp_export_destination'])
-            fail ::Foreman::Exception, N_("Unable to export, 'pulp_export_destination' setting is not set to a valid directory.")
-          end
-
-          unless File.writable?(Setting['pulp_export_destination'])
-            fail ::Foreman::Exception, N_("Unable to export. 'pulp_export_destination' setting is not a writable directory.")
-          end
-
-          repo_pulp_ids = repos.collect do |repo|
-            action_subject(repo)
-            repo.pulp_id
-          end
-
-          start_date = since ? since.iso8601 : nil
-          unless since.nil?
-            group_id += "-incremental"
-          end
-
-          # create an export path that's the same as the ISO export path. Pulp
-          # only uses this when exporting to a directory, but we want to keep
-          # things as similar as possible.
-          # Additionally, we want Pulp to export to dirs that Pulp owns, and
-          # then Katello can copy it over as needed. This is needed for SELinux
-          # reasons.
-          export_directory = File.join(EXPORT_OUTPUT_BASEDIR, group_id)
-
-          sequence do
-            copy_units(repos)
-            plan_action(Pulp::RepositoryGroup::Create, :id => group_id,
-                                                       :pulp_ids => repo_pulp_ids)
-            plan_action(Pulp::RepositoryGroup::Export, :id => group_id,
-                                                       :export_to_iso => export_to_iso,
-                                                       :iso_size => iso_size,
-                                                       :start_date => start_date,
-                                                       :export_directory => export_directory)
-            plan_self(:group_id => group_id, :export_to_iso => export_to_iso)
-            # NB: the delete will also make Pulp delete our exported data under /var/lib/pulp
-            plan_action(Pulp::RepositoryGroup::Delete, :id => group_id)
-          end
-        end
-
-        def run
-          # copy the export to a place we have permission to write to. We let
-          # Pulp do the deletion as part of repo group delete since it's under
-          # /v/l/p.
-          export_location = File.join(EXPORT_OUTPUT_BASEDIR, input[:group_id])
-          FileUtils.cp_r(export_location, Setting['pulp_export_destination'], :remove_destination => true)
-        end
-
-        def humanized_name
-          _("Export")
-        end
-
-        def copy_units(repos)
-          concurrence do
-            repos.each do |repo|
-              sequence do
-                if repo.link?
-                  plan_action(Pulp::Repository::Clear, repo, SmartProxy.pulp_primary!)
-                  plan_action(Pulp::Repository::CopyAllUnits, repo, ::SmartProxy.pulp_primary, repo.target_repository)
-                end
-              end
-            end
-          end
-        end
-
-        def rescue_strategy
-          Dynflow::Action::Rescue::Skip
-        end
-      end
-    end
-  end
-end

data/app/lib/actions/katello/repository/purge_empty_content.rb

@@ -1,16 +0,0 @@
-module Actions
-  module Katello
-    module Repository
-      class PurgeEmptyContent < Pulp::AbstractAsyncTask
-        input_format do
-          param :id, Integer
-        end
-
-        def invoke_external_task
-          repo = ::Katello::Repository.find(input[:id])
-          repo.backend_service(SmartProxy.pulp_primary).purge_empty_contents
-        end
-      end
-    end
-  end
-end

data/app/lib/actions/katello/repository/upload_errata.rb

@@ -1,38 +0,0 @@
-require 'fileutils'
-require 'English'
-
-module Actions
-  module Katello
-    module Repository
-      class UploadErrata < Actions::EntryAction
-        def plan(repository, errata)
-          action_subject(repository)
-          sequence do
-            errata.each do |erratum|
-              sequence do
-                upload_request = plan_action(Pulp::Repository::CreateUploadRequest)
-                plan_action(Pulp::Repository::UploadFile,
-                            upload_id: upload_request.output[:upload_id])
-                # this call is tightly coupled to Pulp's internal data
-                # structure; we are rehydrating an object from json.
-                plan_action(Pulp::Repository::ImportUpload,
-                            pulp_id: repository.pulp_id,
-                            unit_type_id: 'erratum',
-                            unit_metadata: erratum["unit_metadata"],
-                            unit_key: erratum["unit_key"],
-                            upload_id: upload_request.output[:upload_id])
-                plan_action(Pulp::Repository::DeleteUploadRequest,
-                            upload_id: upload_request.output[:upload_id])
-              end
-            end
-            plan_action(FinishUpload, repository)
-          end
-        end
-
-        def humanized_name
-          _("Upload errata into")
-        end
-      end
-    end
-  end
-end

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

@@ -1,64 +0,0 @@
-#
-# The Ruby URI parser doesn't decode the percent encoded characters in the URI, in particular it
-# doesn't decode the password which is frequently used when specifying proxy addresses and
-# authentication. For example, the following code:
-#
-#   require 'uri'
-#   proxy = URI.parse('http://myuser:%24%3fxxxx@192.168.100.10:3128')
-#   puts proxy.password
-#
-# Produces the following output:
-#
-#   %24%3fxxxx
-#
-# But some gems, in particular `rest-client` and `kubeclient`, expect it to decode those characters,
-# as they use the value returned by the `password` method directly, and thus they fail to
-# authenticate against the proxy server when the password contains percent encoded characters.
-#
-# To address this issue this file adds a new `proxy` URI schema that almost identical to the `http`
-# schema, but that decodes the password before returning it. Users can use this schema instead of
-# `http` when they need to use percent encoded characters in the password. For example, the user
-# can type in the UI the following proxy URL:
-#
-#   proxy://myuser:%24%3fxxxx@192.168.100.10:3128
-#
-# And the new schema will automatically translate `%24%3fxxxx` into `$?xxxx`.
-# This fix is derived from: https://github.com/ManageIQ/manageiq/pull/17318
-require 'cgi'
-require 'uri'
-
-module URI
-  class ProxyUri < HTTP
-    def password
-      value = super
-      value = CGI.unescape(value) if value
-      value
-    end
-
-    def user
-      value = super
-      value = CGI.unescape(value) if value
-      value
-    end
-  end
-
-  @@schemes['PROXY'] = ProxyUri
-end
-
-module URI
-  class ProxysUri < HTTP
-    def password
-      value = super
-      value = CGI.unescape(value) if value
-      value
-    end
-
-    def user
-      value = super
-      value = CGI.unescape(value) if value
-      value
-    end
-  end
-
-  @@schemes['PROXYS'] = ProxysUri
-end

data/app/models/katello/rhsm_fact_importer.rb

@@ -1,20 +0,0 @@
-module Katello
-  class RhsmFactImporter < ::StructuredFactImporter
-    def fact_name_class
-      Katello::RhsmFactName
-    end
-
-    def normalize(facts)
-      facts = change_separator(facts)
-      super(facts)
-    end
-
-    def change_separator(facts)
-      to_ret = {}
-      facts.each do |key, value|
-        to_ret[key.split('.').join(RhsmFactName::SEPARATOR)] = value
-      end
-      to_ret
-    end
-  end
-end

data/app/models/katello/rhsm_fact_name.rb

@@ -1,17 +0,0 @@
-module Katello
-  class RhsmFactName < ::FactName
-    FACT_TYPE = :rhsm
-
-    def set_name
-      self.short_name = self.name.split(SEPARATOR).last
-    end
-
-    def origin
-      'RHSM'
-    end
-
-    def icon_path
-      "icons16x16/redhat.png"
-    end
-  end
-end

data/app/models/katello/rhsm_fact_parser.rb

@@ -1,120 +0,0 @@
-module Katello
-  class RhsmFactParser < ::FactParser
-    def architecture
-      name = facts['lscpu.architecture'] || facts['uname.machine']
-      name = "x86_64" if name == "amd64"
-      name = "i386" if name == "i686"
-      Architecture.where(:name => name).first_or_create unless name.blank?
-    end
-
-    def model
-      if facts['virt::is_guest'] == "true"
-        name = facts['lscpu.hypervisor_vendor']
-      else
-        name = facts['dmi.system.product_name']
-      end
-      ::Model.where(:name => name.strip).first_or_create unless name.blank?
-    end
-
-    def support_interfaces_parsing?
-      true
-    end
-
-    def get_facts_for_interface(interface)
-      {
-        'link' => true,
-        'macaddress' => get_rhsm_mac(interface),
-        'ipaddress' => get_rhsm_ip(interface)
-      }
-    end
-
-    def interfaces
-      virtual_interface_regexp = /\A([^.]*?)\.(\d+)\z/
-      super.tap do |interfaces|
-        interfaces.each do |name, attributes|
-          attributes[:virtual] = true if name =~ virtual_interface_regexp
-        end
-      end
-    end
-
-    # rubocop:disable Naming/AccessorMethodName:
-    def get_interfaces
-      mac_keys = facts.keys.select { |f| f =~ /net\.interface\..*\.mac_address/ }
-      names = mac_keys.map do |key|
-        key.sub('net.interface.', '').sub('.mac_address', '') if facts[key] != 'none'
-      end
-      names.compact
-    end
-
-    def operatingsystem
-      name = facts['distribution.name']
-      version = facts['distribution.version']
-      return nil if name.nil? || version.nil?
-
-      os_name = ::Katello::Candlepin::Consumer.distribution_to_puppet_os(name)
-      major, minor = version.split('.')
-      unless facts['ignore_os']
-        os_attributes = {:major => major, :minor => minor || '', :name => os_name}
-
-        release_name = os_release_name(os_name)
-        if release_name
-          os_attributes[:release_name] = release_name
-        end
-
-        if facts['distribution.name'] == 'Red Hat Enterprise Linux Workstation'
-          os_attributes[:name] = os_name + '_Workstation'
-        end
-
-        ::Operatingsystem.find_by(os_attributes) || ::Operatingsystem.create!(os_attributes)
-      end
-    end
-
-    def os_release_name(os_name)
-      if os_name&.match(::Operatingsystem::FAMILIES['Debian'])
-        facts['distribution.id']&.split&.first&.downcase
-      end
-    end
-
-    #required to be defined, even if they return nil
-    def domain
-    end
-
-    def environment
-    end
-
-    def ipmi_interface
-    end
-
-    def boot_timestamp
-      facts['proc_stat.btime']&.to_i
-    end
-
-    def virtual
-      facts['virt.is_guest']
-    end
-
-    def ram
-      facts['memory.memtotal'].to_i / 1024 if facts['memory.memtotal']
-    end
-
-    def sockets
-      facts['cpu.cpu_socket(s)']
-    end
-
-    def cores
-      facts['cpu.core(s)_per_socket']
-    end
-
-    private
-
-    def get_rhsm_ip(interface)
-      ip = facts["net.interface.#{interface}.ipv4_address"]
-      Net::Validations.validate_ip(ip) ? ip : nil
-    end
-
-    def get_rhsm_mac(interface)
-      # if secondary then permanent_mac_address contains the physical mac
-      facts["net.interface.#{interface}.permanent_mac_address"] || facts["net.interface.#{interface}.mac_address"]
-    end
-  end
-end