katello 3.3.2 → 3.4.0.rc1

data/app/models/katello/subscription.rb

@@ -17,6 +17,10 @@ module Katello
         where("#{Katello::Product.table_name}.id" => Product.with_subscribable_content)
     end
 
+    def self.using_virt_who
+      joins(:pools).where("#{Katello::Pool.table_name}.virt_who" => true)
+    end
+
     def redhat?
       self.products.any? { |product| product.redhat? }
     end
@@ -33,6 +37,14 @@ module Katello
       pools.any?(&:recently_expired?)
     end
 
+    def virt_who_pools
+      pools.where("#{Katello::Pool.table_name}.virt_who" => true)
+    end
+
+    def virt_who?
+      virt_who_pools.any?
+    end
+
     def self.humanize_class_name(_name = nil)
       _("Subscription")
     end

data/app/models/katello/subscription_status.rb

@@ -37,7 +37,7 @@ module Katello
 
     def to_status(_options = {})
       return UNKNOWN unless host.subscription_facet.try(:uuid)
-      case Katello::Candlepin::Consumer.new(host.subscription_facet.uuid).entitlement_status
+      case Katello::Candlepin::Consumer.new(host.subscription_facet.uuid, host.organization.label).entitlement_status
       when Katello::Candlepin::Consumer::ENTITLEMENTS_VALID
         VALID
       when Katello::Candlepin::Consumer::ENTITLEMENTS_PARTIAL

data/app/models/katello/sync_plan.rb

@@ -23,13 +23,20 @@ module Katello
     validates :interval, :inclusion => {:in => TYPES}, :allow_blank => false
     validates :enabled, :inclusion => [true, false]
     validate :validate_sync_date
+    validate :product_enabled
     validates_with Validators::KatelloNameFormatValidator, :attributes => :name
 
     scoped_search :on => :name, :complete_value => true
-    scoped_search :on => :organization_id, :complete_value => true, :only_explicit => true
+    scoped_search :on => :organization_id, :complete_value => true, :only_explicit => true, :validator => ScopedSearch::Validators::INTEGER
     scoped_search :on => :interval, :complete_value => true
     scoped_search :on => :enabled, :complete_value => true
 
+    def product_enabled
+      products.each do |product|
+        errors.add :base, _("Can not add product %s because it is disabled.") % product.name unless product.enabled?
+      end
+    end
+
     def validate_sync_date
       errors.add :base, _("Start Date and Time can't be blank") if self.sync_date.nil?
     end
@@ -53,7 +60,7 @@ module Katello
     def schedule_format
       return nil if DURATION[self.interval].nil?
       date = self.sync_date
-      date = next_sync_date if self.sync_date < DateTime.now
+      date = next_sync_date if enabled? && self.sync_date < DateTime.now
       "#{date.iso8601}/P#{DURATION[self.interval]}"
     end
 

data/app/models/katello/trace_status.rb

@@ -0,0 +1,53 @@
+module Katello
+  class TraceStatus < HostStatus::Status
+    REQUIRE_REBOOT = 2
+    REQUIRE_PROCESS_RESTART = 1
+    UP_TO_DATE = 0
+
+    def self.status_name
+      N_("Traces")
+    end
+
+    def to_label(_options = {})
+      case to_status
+      when REQUIRE_REBOOT
+        N_("Reboot required")
+      when REQUIRE_PROCESS_RESTART
+        N_("One or more processes require restarting")
+      when UP_TO_DATE
+        N_("No processes require restarting")
+      else
+        N_("Unknown traces status")
+      end
+    end
+
+    def to_global(_options = {})
+      case to_status
+      when REQUIRE_REBOOT
+        ::HostStatus::Global::ERROR
+      when REQUIRE_PROCESS_RESTART
+        ::HostStatus::Global::WARN
+      when UP_TO_DATE
+        ::HostStatus::Global::OK
+      else
+        ::HostStatus::Global::WARN
+      end
+    end
+
+    def to_status(_options = {})
+      if host.host_traces.where(:app_type => "static").any?
+        REQUIRE_REBOOT
+      elsif host.host_traces.where.not(:app_type => "session").any?
+        REQUIRE_PROCESS_RESTART
+      else
+        UP_TO_DATE
+      end
+    end
+
+    def relevant?(_options = {})
+      # traces cannot be reported from hosts lower than el7
+      return false if host.operatingsystem.try(:major).to_i.between?(1, 6)
+      host.content_facet.try(:uuid)
+    end
+  end
+end

data/app/models/setting/content.rb

@@ -4,44 +4,74 @@ class Setting::Content < Setting
   def self.load_defaults
     return unless super
 
-    BLANK_ATTRS << 'register_hostname_fact'
+    BLANK_ATTRS.concat %w(register_hostname_fact default_location_subscribed_hosts
+                          default_location_puppet_content)
 
     download_policies = proc { Hash[::Runcible::Models::YumImporter::DOWNLOAD_POLICIES.map { |p| [p, p] }] }
     proxy_download_policies = proc { Hash[::SmartProxy::DOWNLOAD_POLICIES.map { |p| [p, p] }] }
 
     self.transaction do
       [
-        self.set('katello_default_provision', N_("Default provisioning template for new Operating Systems"), 'Katello Kickstart Default'),
-        self.set('katello_default_finish', N_("Default finish template for new Operating Systems"), 'Katello Kickstart Default Finish'),
-        self.set('katello_default_user_data', N_("Default user data for new Operating Systems"), 'Katello Kickstart Default User Data'),
-        self.set('katello_default_PXELinux', N_("Default PXElinux template for new Operating Systems"), 'Kickstart default PXELinux'),
-        self.set('katello_default_iPXE', N_("Default iPXE template for new Operating Systems"), 'Kickstart default iPXE'),
-        self.set('katello_default_ptable', N_("Default partitioning table for new Operating Systems"), 'Kickstart default'),
-        self.set('katello_default_kexec', N_("Default kexec template for new Operating Systems"), 'Discovery Red Hat kexec'),
-        self.set('katello_default_atomic_provision', N_("Default provisioning template for new Atomic Operating Systems"), 'Katello Atomic Kickstart Default'),
-        self.set('content_action_accept_timeout', N_("Time in seconds to wait for a Host to pickup a remote action"), 20),
-        self.set('content_action_finish_timeout', N_("Time in seconds to wait for a Host to finish a remote action"), 3600),
-        self.set('errata_status_installable', N_("Calculate errata host status based only on errata in a Host's Content View and Lifecycle Environment"), false),
+        self.set('katello_default_provision', N_("Default provisioning template for Operating Systems created from synced content"),
+                 'Katello Kickstart Default', N_('Default synced OS provisioning template')),
+        self.set('katello_default_finish', N_("Default finish template for new Operating Systems created from synced content"),
+                 'Katello Kickstart Default Finish', N_('Default synced OS finish template')),
+        self.set('katello_default_user_data', N_("Default user data for new Operating Systems created from synced content"),
+                 'Katello Kickstart Default User Data', N_('Default synced OS user-data')),
+        self.set('katello_default_PXELinux', N_("Default PXElinux template for new Operating Systems created from synced content"),
+                 'Kickstart default PXELinux', N_('Default synced OS PXELinux template')),
+        self.set('katello_default_iPXE', N_("Default iPXE template for new Operating Systems created from synced content"),
+                 'Kickstart default iPXE', N_('Default synced OS iPXE template')),
+        self.set('katello_default_ptable', N_("Default partitioning table for new Operating Systems created from synced content"),
+                 'Kickstart default', N_('Default synced OS partition table')),
+        self.set('katello_default_kexec', N_("Default kexec template for new Operating Systems created from synced content"),
+                 'Discovery Red Hat kexec', N_('Default synced OS kexec template')),
+        self.set('katello_default_atomic_provision', N_("Default provisioning template for new Atomic Operating Systems created from synced content"),
+                 'Katello Atomic Kickstart Default', N_('Default synced OS Atomic template')),
+        self.set('content_action_accept_timeout', N_("Time in seconds to wait for a Host to pickup a remote action"),
+                 20, N_('Accept action timeout')),
+        self.set('content_action_finish_timeout', N_("Time in seconds to wait for a Host to finish a remote action"),
+                 3600, N_('Finish action timeout')),
+        self.set('errata_status_installable', N_("Calculate errata host status based only on errata in a Host's Content View and Lifecycle Environment"),
+                 false, N_('Installable errata from Content View')),
         self.set('restrict_composite_view', N_("If set to true, a composite content view may not be published or "\
-                 "promoted, unless the component content view versions that it includes exist in the target environment."), false),
-        self.set('pulp_sync_node_action_accept_timeout', N_("Time in seconds to wait for a pulp node to remote action"), 20),
-        self.set('pulp_sync_node_action_finish_timeout', N_("Time in seconds to wait for a pulp node to finish sync"), 12.hours.to_i),
-        self.set('check_services_before_actions', N_("Whether or not to check the status of backend services such as pulp and candlepin prior to performing some actions."), true),
-        self.set('force_post_sync_actions', N_("Force post sync actions such as indexing and email even if no content was available."), false),
+                 "promoted, unless the component content view versions that it includes exist in the target environment."),
+                 false, N_('Restrict Composite Content View promotion')),
+        self.set('check_services_before_actions', N_("Whether or not to check the status of backend services such as pulp and candlepin prior to performing some actions."),
+                 true, N_('Check services before actions')),
+        self.set('force_post_sync_actions', N_("Force post sync actions such as indexing and email even if no content was available."),
+                 false, N_('Force post-sync actions')),
         self.set('default_download_policy', N_("Default download policy for repositories (either 'immediate', 'on_demand', or 'background')"), "on_demand",
                  N_('Default Repository download policy'), nil, :collection => download_policies),
         self.set('default_proxy_download_policy', N_("Default download policy for Smart Proxy syncs (either 'inherit', immediate', 'on_demand', or 'background')"), "on_demand",
                  N_('Default Smart Proxy download policy'), nil, :collection => proxy_download_policies),
-        self.set('pulp_docker_registry_port', N_("The port used by Pulp Crane to provide Docker Registries"), 5000),
-        self.set('pulp_export_destination', N_("On-disk location for exported repositories"), N_("/var/lib/pulp/katello-export")),
-        self.set('pulp_client_key', N_("Path for ssl key used for pulp server auth"), "/etc/pki/katello/private/pulp-client.key"),
-        self.set('pulp_client_cert', N_("Path for ssl cert used for pulp server auth"), "/etc/pki/katello/certs/pulp-client.crt"),
-        self.set('remote_execution_by_default', N_("If set to true, use the remote execution over katello-agent for remote actions"), false),
-        self.set('use_pulp_oauth', N_("use oauth authentication for pulp instead of the default cert based authentication"), false),
+        self.set('pulp_docker_registry_port', N_("The port used by Pulp Crane to provide Docker Registries"),
+                 5000, N_('Pulp Docker registry port')),
+        self.set('pulp_export_destination', N_("On-disk location for exported repositories"),
+                 "/var/lib/pulp/katello-export", N_('Pulp export destination filepath')),
+        self.set('pulp_client_key', N_("Path for ssl key used for pulp server auth"),
+                 "/etc/pki/katello/private/pulp-client.key", N_('Pulp client key')),
+        self.set('pulp_client_cert', N_("Path for ssl cert used for pulp server auth"),
+                 "/etc/pki/katello/certs/pulp-client.crt", N_('Pulp client cert')),
+        self.set('remote_execution_by_default', N_("If set to true, use the remote execution over katello-agent for remote actions"),
+                 false, N_('Use remote execution by default')),
+        self.set('use_pulp_oauth', N_("use oauth authentication for pulp instead of the default cert based authentication"),
+                 false, N_('Use Pulp OAuth authentication')),
         self.set('unregister_delete_host', N_("When unregistering a host via subscription-manager, also delete the host record. Managed resources linked to host " \
-                                              "such as virtual machines and DNS records may also be deleted."), false),
+                                              "such as virtual machines and DNS records may also be deleted."),
+                 false, N_('Delete Host upon unregister')),
         self.set('register_hostname_fact', N_("When registering a host via subscription-manager, force use the specified fact (in the form of 'fact.fact')"),
-                  '', N_('Subscription manager name registration fact'), nil)
+                 '', N_('Subscription manager name registration fact'), nil),
+        self.set('erratum_install_batch_size', N_("Errata installed via katello-agent will be triggered in batches of this size. Set to 0 to install all errata in one batch."),
+                 0, N_('Erratum Install Batch Size')),
+        self.set('default_location_subscribed_hosts',
+                 N_('Default Location where new subscribed hosts will put upon registration'),
+                 nil, N_('Default Location subscribed hosts'), nil,
+                 :collection => proc { Hash[Location.unscoped.all.map { |loc| [loc[:title], loc[:title]] }] }),
+        self.set('default_location_puppet_content',
+                 N_('Default Location where new Puppet content will be put upon Content View publish'),
+                 nil, N_('Default Location Puppet content'), nil,
+                 :collection => proc { Hash[Location.unscoped.all.map { |loc| [loc[:title], loc[:title]] }] })
       ].each { |s| self.create! s.update(:category => "Setting::Content") }
     end
     true

data/app/overrides/add_activation_keys_input.rb

@@ -13,11 +13,6 @@ Deface::Override.new(:virtual_path => "hostgroups/_form",
                      :insert_before => 'erb[loud]:contains("hostgroup_puppet_environment_field")',
                      :partial => 'overrides/activation_keys/host_environment_select')
 
-Deface::Override.new(:virtual_path => "hosts/_form",
-                     :name => "hosts_update_environments_select",
-                     :insert_before => 'erb[loud]:contains("host_puppet_environment_field")',
-                     :partial => 'overrides/activation_keys/host_environment_select')
-
 Deface::Override.new(:virtual_path => "common/os_selection/_operatingsystem",
                      :name => "hosts_select_media_type",
                      :insert_before => 'erb[loud]:contains("select_f"):contains(":medium_id")',

data/app/presenters/katello/product_content_presenter.rb

@@ -8,9 +8,17 @@ module Katello
       @overrides = overrides
     end
 
-    def enabled_override
-      override = overrides.find { |pc| pc[:contentLabel] == content.label }
-      override.nil? ? 'default' : override[:value]
+    def override
+      override = overrides.find { |pc| pc.content_label == content.label && pc.name == "enabled" }
+      override.nil? ? 'default' : override.value
+    end
+
+    def enabled_content_override
+      overrides.find { |pc| pc.content_label == content.label && pc.name == "enabled" }
+    end
+
+    def content_overrides
+      overrides.select { |pc| pc.content_label == content.label }
     end
   end
 end

data/app/services/katello/candlepin/consumer.rb

@@ -16,14 +16,19 @@ module Katello
       lazy_accessor :events, :initializer => lambda { |_s| Resources::Candlepin::Consumer.events(uuid) }
       lazy_accessor :consumer_attributes, :initializer => lambda { |_s| Resources::Candlepin::Consumer.get(uuid) }
       lazy_accessor :installed_products, :initializer => lambda { |_s| consumer_attributes['installedProducts'] }
-      lazy_accessor :available_pools, :initializer => lambda { |_s| Resources::Candlepin::Consumer.available_pools(uuid, false) }
-      lazy_accessor :all_available_pools, :initializer => lambda { |_s| Resources::Candlepin::Consumer.available_pools(uuid, true) }
-      lazy_accessor :content_overrides, :initializer => lambda { |_s| Resources::Candlepin::Consumer.content_overrides(uuid) }
+      lazy_accessor :available_pools, :initializer => lambda { |_s| Resources::Candlepin::Consumer.available_pools(owner_label, uuid, false) }
+      lazy_accessor :all_available_pools, :initializer => lambda { |_s| Resources::Candlepin::Consumer.available_pools(owner_label, uuid, true) }
+      lazy_accessor :content_overrides, :initializer => (lambda do |_s|
+                                                           Resources::Candlepin::Consumer.content_overrides(uuid).map do |override|
+                                                             ::Katello::ContentOverride.from_entitlement_hash(override)
+                                                           end
+                                                         end)
 
-      attr_accessor :uuid
+      attr_accessor :uuid, :owner_label
 
-      def initialize(uuid)
+      def initialize(uuid, owner_label)
         self.uuid = uuid
+        self.owner_label = owner_label
       end
 
       def regenerate_identity_certificates
@@ -67,8 +72,8 @@ module Katello
           pools = pools.select do |pool|
             pool['providedProducts'].all? do |provided_product|
               self.entitlements.all? do |consumed_entitlement|
-                consumed_entitlement.providedProducts.all? do |consumed_product|
-                  consumed_product.cp_id != provided_product['productId']
+                consumed_entitlement['pool']['providedProducts'].all? do |consumed_product|
+                  consumed_product['cp_id'] != provided_product['productId']
                 end
               end
             end
@@ -99,20 +104,18 @@ module Katello
       end
 
       def virtual_guests
+        return [] if self.uuid.nil?
         guest_uuids = Resources::Candlepin::Consumer.virtual_guests(self.uuid).map { |guest| guest['uuid'] }
         ::Host.joins(:subscription_facet).where("#{Katello::Host::SubscriptionFacet.table_name}.uuid" => guest_uuids)
       end
 
       def virtual_host
+        return nil if self.uuid.nil?
         if (virtual_host_info = Resources::Candlepin::Consumer.virtual_host(self.uuid))
           ::Host.joins(:subscription_facet).where("#{Katello::Host::SubscriptionFacet.table_name}.uuid" => virtual_host_info[:uuid]).first
         end
       end
 
-      def set_content_override(content_label, name, value = nil)
-        Resources::Candlepin::Consumer.update_content_override(self.uuid, content_label, name, value)
-      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
@@ -130,11 +133,16 @@ module Katello
 
       def self.orphaned_consumer_ids
         #returns consumer ids in candlepin with no matching katello entry
-        cp_consumers = ::Katello::Resources::Candlepin::Consumer.get({})
-        cp_consumers.reject! { |consumer| consumer['type']['label'] == 'uebercert' }
-        cp_consumer_ids = cp_consumers.map { |cons| cons["uuid"] }
-        katello_consumer_ids = ::Katello::Host::SubscriptionFacet.pluck(:uuid)
-        cp_consumer_ids - katello_consumer_ids
+        orphaned_ids = []
+        User.as_anonymous_admin do
+          cp_consumers = Organization.all.collect { |org| ::Katello::Resources::Candlepin::Consumer.get('owner' => org.label) }
+          cp_consumers.flatten!
+          cp_consumers.reject! { |consumer| consumer['type']['label'] == 'uebercert' }
+          cp_consumer_ids = cp_consumers.map { |consumer| consumer["uuid"] }
+          katello_consumer_ids = ::Katello::Host::SubscriptionFacet.pluck(:uuid)
+          orphaned_ids = cp_consumer_ids - katello_consumer_ids
+        end
+        orphaned_ids
       end
 
       def self.distribution_to_puppet_os(name)

data/app/services/katello/pulp/erratum.rb

@@ -1,6 +1,7 @@
 module Katello
   module Pulp
     class Erratum < PulpContentUnit
+      PULP_SELECT_FIELDS = %w(id).freeze
       CONTENT_TYPE = "erratum".freeze
 
       def self.unit_handler

data/app/services/katello/pulp/file_unit.rb

@@ -5,7 +5,7 @@ module Katello
 
       PULP_SELECT_FIELDS = %w(name checksum).freeze
       PULP_INDEXED_FIELDS = %w(name checksum _id).freeze
-      CONTENT_TYPE = "file".freeze
+      CONTENT_TYPE = "iso".freeze
 
       lazy_accessor :pulp_facts, :initializer => :backend_data
     end

data/app/views/dashboard/_errata_widget.html.erb

@@ -23,8 +23,8 @@
         <tr>
           <th class="" title="<%= erratum.errata_type %>"><%= erratum.errata_type %></th>
           <th>
-            <a href="/errata/<%= erratum.uuid %>/info">
-              <%= erratum.errata_id %> (<%= hosts.length %> <%= _('Hosts') %>)
+            <a href="/errata/<%= erratum.uuid %>">
+              <%= erratum.errata_id %> (<%= n_("%s Host", "%s Hosts", hosts.length) % hosts.length %>)
             </a>
           </th>
         </tr>

data/app/views/foreman/unattended/kickstart-katello.erb

@@ -39,7 +39,7 @@ network --bootproto <%= dhcp ? 'dhcp' : "static --ip=#{@host.ip} --netmask=#{sub
 
 rootpw --iscrypted <%= root_pass %>
 firewall --<%= os_major >= 6 ? 'service=' : '' %>ssh
-authconfig --useshadow --passalgo=sha256 --kickstart
+authconfig --useshadow --passalgo=<%= @host.operatingsystem.password_hash || 'sha256' %> --kickstart
 timezone --utc <%= @host.params['time-zone'] || 'UTC' %>
 
 <% if @host.operatingsystem.name == 'Fedora' and os_major <= 16 -%>

data/app/views/katello/api/v2/activation_keys/product_content.json.rabl

@@ -9,10 +9,23 @@ child @collection[:results] => :results do
 
   child :content => :content do
     attributes :id, :name, :label
+    attribute :contentUrl => :content_url
   end
 
   node :override do |pc|
-    pc.content_override(@activation_key)
+    pc.legacy_content_override(@activation_key)
   end
+
+  node :overrides do |pc|
+    pc.content_overrides(@activation_key).map do |override|
+      {:name => override.name, :value => override.computed_value}
+    end
+  end
+
+  node :enabled_content_override do |pc|
+    override = pc.enabled_content_override(@activation_key)
+    override.computed_value if override
+  end
+
   attributes :enabled
 end

data/app/views/katello/api/v2/host_subscriptions/product_content.json.rabl

@@ -9,7 +9,21 @@ child @collection[:results] => :results do
 
   child :content => :content do
     attributes :id, :name, :label
+    attribute :contentUrl => :content_url
   end
 
-  attributes :enabled_override, :enabled
+  child :content_overrides => :overrides do
+    attributes :name
+    attribute :computed_value => :value
+  end
+
+  node :enabled_content_override do |pc|
+    override = pc.enabled_content_override
+    override.computed_value if override
+  end
+
+  attributes :override, :enabled
+
+  #TODO: deprecate with 6.4
+  attributes :override => :enabled_override
 end

data/app/views/katello/api/v2/repositories/base.json.rabl

@@ -3,6 +3,7 @@ object @resource
 extends 'katello/api/v2/common/identifier'
 
 attributes :content_type, :url, :relative_path
+attributes :pulp_id => :backend_identifier
 
 child :product do |_product|
   attributes :id, :cp_id, :name

data/app/views/katello/api/v2/repositories/show.json.rabl

@@ -19,6 +19,7 @@ attributes :product_type
 attributes :promoted? => :promoted
 attributes :ostree_branch_names => :ostree_branches
 attributes :upstream_username
+attributes :ostree_upstream_sync_policy, :ostree_upstream_sync_depth, :compute_ostree_upstream_sync_depth => :computed_ostree_upstream_sync_depth
 
 if @resource.is_a?(Katello::Repository)
   if @resource.distribution_version || @resource.distribution_arch || @resource.distribution_family || @resource.distribution_variant
@@ -41,6 +42,10 @@ child :gpg_key do |_gpg|
   attribute :id
 end
 
+node :upstream_password_exists do |repo|
+  repo.upstream_password.present?
+end
+
 if @object && @object.library_instance_id.nil?
 
   node :content_view_environments do |repository|