katello 3.1.0.1 → 3.2.0.rc1

data/app/helpers/katello/system_events_helper.rb

@@ -1,4 +0,0 @@
-module Katello
-  module SystemEventsHelper
-  end
-end

data/app/helpers/katello/system_packages_helper.rb

@@ -1,42 +0,0 @@
-module Katello
-  module SystemPackagesHelper
-    def adding_package
-      _("Adding Package...")
-    end
-
-    def updating_package
-      _("Updating Package...")
-    end
-
-    def removing_package
-      _("Removing Package...")
-    end
-
-    def adding_package_group
-      _("Adding Package Group...")
-    end
-
-    def removing_package_group
-      _("Removing Package Group...")
-    end
-
-    def get_status_string(type)
-      case type
-      when "package_install"
-        adding_package
-      when "package_update"
-        updating_package
-      when "package_remove"
-        removing_package
-      when "package_group_install"
-        adding_package_group
-      when "package_group_remove"
-        removing_package_group
-      end
-    end
-
-    def row_shading
-      @shading = cycle("", "alt")
-    end
-  end
-end

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

@@ -1,61 +0,0 @@
-module Actions
-  module Katello
-    module Repository
-      class IncrementalImport < Actions::EntryAction
-        middleware.use Actions::Middleware::KeepCurrentUser
-
-        input_format do
-          param :id, Integer
-        end
-
-        # @param repo
-        # @param import_location location of files to import
-        def plan(repo, import_location)
-          action_subject(repo)
-
-          rpm_files = Dir.glob(File.join(import_location, "*rpm"))
-
-          rpm_filepaths = rpm_files.collect do |filepath|
-            {path: filepath, filename: File.basename(filepath)}
-          end
-
-          json_files = Dir.glob(File.join(import_location, "*json"))
-          pulp_units = json_files.map { |json_file| JSON.parse(File.read(json_file)) }
-          errata = pulp_units.select { |pulp_unit| erratum? pulp_unit }
-
-          sequence do
-            # NB: UploadFiles may time out during plan phase, it copies
-            # everything to /tmp. It is better to just have Pulp generate
-            # incrementals in the same way it publishes normally, vs optimizing
-            # this call. https://pulp.plan.io/issues/1543
-            plan_action(Katello::Repository::UploadFiles, repo, rpm_filepaths)
-            plan_action(Katello::Repository::UploadErrata, repo, errata)
-          end
-
-          plan_self
-        end
-
-        def run
-          # Assume contents changed. This type of upload does not need the same
-          # level of optimization as sync because it is not called frequently.
-          output[:contents_changed] = true
-        end
-
-        def rescue_strategy
-          Dynflow::Action::Rescue::Skip
-        end
-
-        private
-
-        def erratum?(obj)
-          # There is no metadata that says "this json is an erratum" so you
-          # have to use this heuristic. Returns true if erratum fields are
-          # present, false otherwise
-          obj.try(:[], 'unit_key').try(:[], 'id') &&
-            obj.try(:[], 'unit_metadata').try(:[], 'type') &&
-            obj.try(:[], 'unit_metadata').try(:[], 'issued')
-        end
-      end
-    end
-  end
-end

data/app/lib/actions/katello/subscription/subscribe.rb

@@ -1,26 +0,0 @@
-module Actions
-  module Katello
-    module Subscription
-      class Subscribe < Actions::Base
-        def plan(system_id, cp_id, quantity)
-          plan_self(:user_id => ::User.current.id,
-                    :quantity => quantity,
-                    :cp_id => cp_id,
-                    :system_id => system_id)
-        end
-
-        def run
-          ::User.current = User.find(input[:user_id])
-          ::Katello::System.find(input[:system_id]).subscribe(input[:cp_id], input[:quantity])
-        end
-
-        def finalize
-          ::User.current = User.find(input[:user_id])
-          ::Katello::Pool.find_by(:cp_id => input[:cp_id]).import_data
-        ensure
-          ::User.current = nil
-        end
-      end
-    end
-  end
-end

data/app/lib/actions/katello/system/destroy.rb

@@ -1,17 +0,0 @@
-module Actions
-  module Katello
-    module System
-      class Destroy < Actions::EntryAction
-        middleware.use ::Actions::Middleware::RemoteAction
-
-        def plan(system, options = {})
-          plan_action(Katello::Host::Destroy, system.foreman_host, options)
-        end
-
-        def humanized_name
-          _("Destroy Content Host")
-        end
-      end
-    end
-  end
-end

data/app/lib/actions/katello/system/reassign.rb

@@ -1,14 +0,0 @@
-module Actions
-  module Katello
-    module System
-      class Reassign < Actions::Base
-        def plan(system, content_view_id, environment_id)
-          system.foreman_host.content_facet.content_view = ::Katello::ContentView.find(content_view_id)
-          system.foreman_host.content_facet.lifecycle_environment = ::Katello::KTEnvironment.find(environment_id)
-
-          plan_action(::Actions::Katello::Host::Update, system.foreman_host)
-        end
-      end
-    end
-  end
-end

data/app/models/katello/authorization/system.rb

@@ -1,53 +0,0 @@
-module Katello
-  module Authorization::System
-    extend ActiveSupport::Concern
-
-    include Authorizable
-
-    def readable?
-      authorized?(:view_content_hosts)
-    end
-
-    def editable?
-      authorized?(:edit_content_hosts)
-    end
-
-    def deletable?
-      authorized?(:destroy_content_hosts)
-    end
-
-    module ClassMethods
-      def readable_search_filters(_org)
-        {:or => [
-          {:terms => {:environment_id => KTEnvironment.readable.pluck(:id) }}
-        ]
-        }
-      end
-
-      def readable
-        authorized(:view_content_hosts)
-      end
-
-      def readable?
-        User.current.can?(:view_content_hosts)
-      end
-
-      def editable
-        authorized(:edit_content_hosts)
-      end
-
-      def deletable
-        authorized(:destroy_content_hosts)
-      end
-
-      def any_editable?
-        authorized(:edit_content_hosts).count > 0
-      end
-
-      def all_editable?(content_view, environments)
-        systems_query = System.where(:content_view_id => content_view, :environment_id => environments)
-        systems_query.count == systems_query.editable.count
-      end
-    end
-  end
-end

data/app/models/katello/glue/candlepin/consumer.rb

@@ -1,386 +0,0 @@
-module Katello
-  module Glue::Candlepin::Consumer
-    SYSTEM = "system".freeze
-    HYPERVISOR = "hypervisor".freeze
-    CANDLEPIN = "candlepin".freeze
-    CP_TYPES = [SYSTEM, HYPERVISOR, CANDLEPIN].freeze
-
-    # TODO: break up method
-    def self.included(base) # rubocop:disable MethodLength
-      base.send :include, LazyAccessor
-      base.send :include, InstanceMethods
-      base.send :extend, ClassMethods
-
-      base.class_eval do
-        lazy_accessor :href, :facts, :cp_type, :idCert, :owner, :lastCheckin, :created, :guestIds,
-        :installedProducts, :autoheal, :releaseVer, :serviceLevel, :capabilities, :entitlementStatus,
-        :initializer => :candlepin_consumer_info
-
-        lazy_accessor :candlepin_consumer_info, :initializer =>
-                        (lambda do |_s|
-                          if uuid
-                            consumer_json = Resources::Candlepin::Consumer.get(uuid)
-                            convert_from_cp_fields(consumer_json)
-                          end
-                        end)
-
-        lazy_accessor :entitlements, :initializer => lambda { |_s| Resources::Candlepin::Consumer.entitlements(uuid) }
-        lazy_accessor :pools, :initializer => lambda { |_s| entitlements.collect { |ent| Resources::Candlepin::Pool.find ent["pool"]["id"] } }
-        lazy_accessor :virtual_host, :initializer => (lambda do |_s|
-                                                        host_attributes = Resources::Candlepin::Consumer.virtual_host(self.uuid)
-                                                        (System.find_by(:uuid => host_attributes['uuid']) || System.new(host_attributes)) if host_attributes
-                                                      end)
-        lazy_accessor :virtual_guests, :initializer => (lambda do |_s|
-                                                          guests_attributes = Resources::Candlepin::Consumer.virtual_guests(self.uuid)
-                                                          guests_attributes.map do |attr|
-                                                            System.find_by(:uuid => attr['uuid']) || System.new(attr)
-                                                          end
-                                                        end)
-        lazy_accessor :compliance, :initializer => lambda { |_s| Resources::Candlepin::Consumer.compliance(uuid) }
-        lazy_accessor :events, :initializer => lambda { |_s| Resources::Candlepin::Consumer.events(uuid) }
-
-        validates :cp_type, :inclusion => {:in => CP_TYPES},
-                            :if => :new_record?
-        validates :facts, :presence => true, :if => :new_record?
-      end
-    end
-
-    module InstanceMethods
-      def initialize(attrs = nil, options = {})
-        if attrs.nil?
-          super
-        else
-          type_key = attrs.key?('type') ? 'type' : :type
-          #rename "type" to "cp_type" (activerecord and candlepin variable name conflict)
-          if attrs.key?(type_key) && !(attrs.key?(:cp_type) || attrs.key?('cp_type'))
-            attrs[:cp_type] = attrs[type_key]
-          end
-
-          attrs_used_by_model = attrs.reject do |k, _v|
-            !self.class.column_defaults.keys.member?(k.to_s) && (!respond_to?(:"#{k.to_s}=") rescue true)
-          end
-          if attrs_used_by_model["environment"].is_a? Hash
-            attrs_used_by_model.delete("environment")
-          end
-
-          super(attrs_used_by_model, options)
-        end
-      end
-
-      def load_from_cp(consumer_json)
-        self.uuid = consumer_json[:uuid]
-        consumer_json[:facts] ||= {'sockets' => 0}
-        convert_from_cp_fields(consumer_json).each do |k, v|
-          instance_variable_set("@#{k}", v) if respond_to?("#{k}=")
-        end
-      end
-
-      def checkin(checkin_time)
-        Rails.logger.debug "Updating consumer check-in time: #{name}"
-        Resources::Candlepin::Consumer.checkin(self.uuid, checkin_time)
-      rescue => e
-        Rails.logger.error "Failed to update consumer check-in time in candlepin for #{name}: #{e}, #{e.backtrace.join("\n")}"
-        raise e
-      end
-
-      def regenerate_identity_certificates
-        Rails.logger.debug "Regenerating consumer identity certificates: #{name}"
-        Resources::Candlepin::Consumer.regenerate_identity_certificates(self.uuid)
-      rescue => e
-        Rails.logger.debug e.backtrace.join("\n\t")
-        raise e
-      end
-
-      def get_pool(id)
-        Resources::Candlepin::Pool.find id
-      rescue => e
-        Rails.logger.debug e.backtrace.join("\n\t")
-        raise e
-      end
-
-      def subscribe(pool, quantity = nil)
-        quantity = quantity.to_i unless quantity.nil?
-        Rails.logger.debug "Subscribing to pool '#{pool}' for : #{name}"
-        Resources::Candlepin::Consumer.consume_entitlement self.uuid, pool, quantity
-      rescue => e
-        Rails.logger.debug e.backtrace.join("\n\t")
-        raise e
-      end
-
-      def export
-        Rails.logger.debug "Exporting manifest"
-        Resources::Candlepin::Consumer.export self.uuid
-      rescue => e
-        Rails.logger.debug e.backtrace.join("\n\t")
-        raise e
-      end
-
-      def to_json(options = {})
-        super(options.merge(:methods => [:href, :facts, :idCert, :owner, :autoheal, :release, :releaseVer, :checkin_time,
-                                         :installedProducts, :capabilities]))
-      end
-
-      def convert_from_cp_fields(cp_json)
-        cp_json.merge!(:cp_type => cp_json.delete(:type)[:label]) if cp_json.key?(:type)
-        cp_json = reject_db_columns(cp_json)
-
-        cp_json[:guestIds] = remove_hibernate_fields(cp_json[:guestIds]) if cp_json.key?(:guestIds)
-        cp_json[:installedProducts] = remove_hibernate_fields(cp_json[:installedProducts]) if cp_json.key?(:installedProducts)
-
-        cp_json
-      end
-
-      # Candlepin sends back its internal hibernate fields in the json. However it does not accept them in return
-      # when updating (PUT) objects.
-      def remove_hibernate_fields(elements)
-        return nil unless elements
-        elements.collect { |e| e.except(:id, :created, :updated) }
-      end
-
-      def reject_db_columns(cp_json)
-        cp_json.reject { |k, _v| self.class.column_defaults.keys.member?(k.to_s) }
-      end
-
-      def cp_environment_id
-        if self.content_view
-          self.content_view.cp_environment_id(self.environment)
-        else
-          self.environment_id
-        end
-      end
-
-      def hostname
-        facts["network.hostname"]
-      end
-
-      def interfaces
-        Katello::System.interfaces(facts)
-      end
-
-      def ip
-        facts['network.ipv4_address']
-      end
-
-      def kernel
-        facts["uname.release"]
-      end
-
-      def arch
-        facts["uname.machine"] if @facts
-      end
-
-      def arch=(arch)
-        facts["uname.machine"] = arch if @facts
-      end
-
-      # Sockets are required to have a value in katello for searching as well as for checking subscription limits
-      # Force always to an integer value for consistency
-      def sockets
-        @facts ? Integer(facts["cpu.cpu_socket(s)"]) : 0
-      rescue
-        0
-      end
-
-      def sockets=(sock)
-        s = Integer(sock) rescue 0
-
-        facts["cpu.cpu_socket(s)"] = s if @facts
-      end
-
-      def virtual_guest
-        ::Foreman::Cast.to_bool(facts["virt.is_guest"])
-      end
-
-      def virtual_guest=(val)
-        facts["virt.is_guest"] = val if @facts
-      end
-
-      def name=(val)
-        super(val)
-        facts["network.hostname"] = val if @facts
-      end
-
-      def distribution_name
-        facts["distribution.name"]
-      end
-
-      def distribution_version
-        facts["distribution.version"]
-      end
-
-      def distribution
-        "#{distribution_name} #{distribution_version}"
-      end
-
-      def memory
-        if facts
-          mem = facts["memory.memtotal"]
-          # dmi.memory.size is on older clients
-          mem ||= facts["dmi.memory.size"]
-        else
-          mem = '0'
-        end
-        memory_in_gigabytes(mem.to_s)
-      end
-
-      def memory=(mem)
-        mem = "#{mem.to_i} MB"
-        facts["memory.memtotal"] = mem
-      end
-
-      def entitlements_valid?
-        "true" == facts["system.entitlements_valid"]
-      end
-
-      def checkin_time
-        if lastCheckin
-          convert_time(lastCheckin)
-        end
-      end
-
-      def created_time
-        if created
-          convert_time(created)
-        end
-      end
-
-      def convert_time(item)
-        Time.parse(item)
-      end
-
-      def release
-        if self.releaseVer.is_a? Hash
-          self.releaseVer["releaseVer"]
-        else
-          self.releaseVer
-        end
-      end
-
-      def memory_in_gigabytes(mem_str)
-        # convert total memory into gigabytes
-        return 0 if mem_str.nil?
-        mem, unit = mem_str.split
-        total_mem = mem.to_f
-        case unit
-        when 'B'  then total_mem = 0
-        when 'kB' then total_mem = 0
-        when 'MB' then total_mem /= 1024
-        when 'GB' then total_mem *= 1
-        when 'TB' then total_mem *= 1024
-          # default memtotal is in kB
-        else total_mem = (total_mem / (1024 * 1024))
-        end
-        total_mem.round(2)
-      end
-
-      def set_content_override(content_label, name, value = nil)
-        Resources::Candlepin::Consumer.update_content_override(self.uuid, content_label, name, value)
-      end
-
-      def content_overrides
-        Resources::Candlepin::Consumer.content_overrides(self.uuid)
-      end
-
-      def compliant?
-        self.compliance['compliant']
-      end
-
-      # As a convenience and common terminology
-      def compliance_color
-        return 'green' if self.compliance['status'] == 'valid'
-        return 'red' if self.compliance['status'] == 'invalid'
-        return 'yellow' if self.compliance['status'] == 'partial'
-        return 'red'
-      end
-
-      def compliant_until
-        if self.compliance['compliantUntil']
-          Date.parse(self.compliance['compliantUntil'])
-        end
-      end
-
-      def product_compliance_color(product_id)
-        return 'green' if self.compliance['compliantProducts'].include? product_id
-        return 'yellow' if self.compliance['partiallyCompliantProducts'].include? product_id
-        return 'red'
-      end
-
-      def import_candlepin_tasks
-        self.events.each do |event|
-          event_status = {:task_id => event[:id],
-                          :state => event[:type],
-                          :start_time => event[:timestamp],
-                          :finish_time => event[:timestamp],
-                          :progress => "100",
-                          :result => event[:messageText]}
-          unless self.task_statuses.where('katello_task_statuses.uuid' => event_status[:task_id]).exists?
-            TaskStatus.make(self, event_status, :candlepin_event, :event => event)
-          end
-        end
-      end
-
-      def populate_from(candlepin_systems)
-        found = candlepin_systems.find { |system| system['uuid'] == self.uuid }
-        prepopulate(found.with_indifferent_access) if found
-        !found.nil?
-      end
-
-      def products
-        pool_ids = self.entitlements.map { |entitlement| entitlement['pool']['id'] }
-        Katello::Product.joins(:subscriptions => :pools).where("#{Katello::Pool.table_name}.cp_id" => pool_ids).enabled.uniq
-      end
-
-      def find_entitlement(pool_id)
-        entitlements = self.entitlements.collect { |ent| ent['id'] if ent["pool"]["id"] == pool_id }
-        entitlements.compact!
-        entitlements.first
-      end
-    end
-
-    module ClassMethods
-      def prepopulate!(systems)
-        uuids = systems.collect { |system| [:uuid, system.uuid] }
-        items = Resources::Candlepin::Consumer.get(uuids)
-        systems.each { |system| system.populate_from(items) }
-      end
-
-      def all_by_pool(pool_id)
-        entitlements = Resources::Candlepin::Entitlement.get
-        system_uuids = entitlements.delete_if { |ent| ent["pool"]["id"] != pool_id }.map { |ent| ent["consumer"]["uuid"] }
-        return where(:uuid => system_uuids)
-      end
-
-      def all_by_pool_uuid(pool_id)
-        entitlements = Resources::Candlepin::Entitlement.get
-        system_uuids = entitlements.delete_if { |ent| ent["pool"]["id"] != pool_id }.map { |ent| ent["consumer"]["uuid"] }
-        return system_uuids
-      end
-
-      # interface listings come in the form of
-      #
-      # net.interface.em1.ipv4_address
-      # net.interface.eth0.ipv4_broadcast
-      #
-      # there are multiple entries for each interface, but
-      # we only need the ipv4 and mac addresses
-      def interfaces(facts)
-        interfaces = []
-        facts.keys.each do |key|
-          match = /net\.interface\.([^\.]*)/.match(key)
-          if !match.nil? && !match[1].nil?
-            interfaces << match[1]
-          end
-        end
-        interface_set = []
-        interfaces.uniq.each do |interface|
-          addr = facts["net.interface.#{interface}.ipv4_address"]
-          # older subman versions report .ipaddr
-          addr ||= facts["net.interface.#{interface}.ipaddr"]
-          mac = facts["net.interface.#{interface}.mac_address"]
-          interface_set << { :name => interface, :addr => addr, :mac => mac } if !addr.nil? || !mac.nil?
-        end
-        interface_set
-      end
-    end
-  end
-end