katello 3.8.1 → 3.9.0.rc1

data/app/models/katello/repository_module_stream.rb

@@ -0,0 +1,7 @@
+module Katello
+  class RepositoryModuleStream < Katello::Model
+    # Do not use active record callbacks in this join model.  Direct INSERTs and DELETEs are done
+    belongs_to :repository, inverse_of: :repository_module_streams, class_name: 'Katello::Repository'
+    belongs_to :module_stream, inverse_of: :repository_module_streams, class_name: 'Katello::ModuleStream'
+  end
+end

data/app/models/katello/root_repository.rb

@@ -0,0 +1,262 @@
+module Katello
+  class RootRepository < Katello::Model
+    audited
+    serialize :ignorable_content
+    serialize :docker_tags_whitelist
+
+    include Ext::LabelFromName
+
+    IGNORABLE_CONTENT_UNIT_TYPES = %w(rpm drpm srpm distribution erratum).freeze
+    CHECKSUM_TYPES = %w(sha1 sha256).freeze
+
+    OSTREE_UPSTREAM_SYNC_POLICY_LATEST = "latest".freeze
+    OSTREE_UPSTREAM_SYNC_POLICY_ALL = "all".freeze
+    OSTREE_UPSTREAM_SYNC_POLICY_CUSTOM = "custom".freeze
+    OSTREE_UPSTREAM_SYNC_POLICIES = [OSTREE_UPSTREAM_SYNC_POLICY_LATEST, OSTREE_UPSTREAM_SYNC_POLICY_ALL, OSTREE_UPSTREAM_SYNC_POLICY_CUSTOM].freeze
+
+    SUBSCRIBABLE_TYPES = [Repository::YUM_TYPE, Repository::OSTREE_TYPE, Repository::DEB_TYPE].freeze
+
+    CONTENT_ATTRIBUTE_RESTRICTIONS = {
+      :ostree_upstream_sync_depth => [Repository::OSTREE_TYPE],
+      :ostree_upstream_sync_policy => [Repository::OSTREE_TYPE],
+      :download_policy => [Repository::YUM_TYPE]
+
+    }.freeze
+
+    belongs_to :product, :inverse_of => :root_repositories, :class_name => "Katello::Product"
+    belongs_to :gpg_key, :inverse_of => :root_repositories, :class_name => "Katello::GpgKey"
+    belongs_to :ssl_ca_cert, :class_name => "Katello::GpgKey", :inverse_of => :ssl_ca_root_repos
+    belongs_to :ssl_client_cert, :class_name => "Katello::GpgKey", :inverse_of => :ssl_client_root_repos
+    belongs_to :ssl_client_key, :class_name => "Katello::GpgKey", :inverse_of => :ssl_key_root_repos
+    has_many :repositories, :class_name => "Katello::Repository", :foreign_key => :root_id,
+                          :inverse_of => :root, :dependent => :destroy
+
+    before_validation :update_ostree_upstream_sync_policy
+
+    validates_lengths_from_database :except => [:label]
+    validates_with Validators::KatelloLabelFormatValidator, :attributes => :label
+    validates_with Validators::KatelloNameFormatValidator, :attributes => :name
+    validates_with Validators::KatelloUrlFormatValidator, :attributes => :url, :nil_allowed => proc { |repo| repo.custom? },
+                   :field_name => :url
+    validates_with Validators::RootRepositoryUniqueAttributeValidator, :attributes => :name
+    validates_with Validators::RootRepositoryUniqueAttributeValidator, :attributes => :label
+    validates_with Validators::ContainerImageNameValidator, :attributes => :docker_upstream_name, :allow_blank => true, :if => :docker?
+
+    validate :ensure_valid_docker_attributes, :if => :docker?
+    validate :ensure_docker_repo_unprotected, :if => :docker?
+    validate :ensure_ostree_repo_protected, :if => :ostree?
+    validate :ensure_compatible_download_policy, :if => :yum?
+    validate :ensure_valid_ignorable_content
+    validate :ensure_content_attribute_restrictions
+    validate :ensure_valid_upstream_authorization
+    validates :url, presence: true, if: :ostree?
+    validates :checksum_type, :inclusion => {:in => CHECKSUM_TYPES}, :allow_blank => true
+    validates :product_id, :presence => true
+    validates :ostree_upstream_sync_policy, :inclusion => {:in => OSTREE_UPSTREAM_SYNC_POLICIES, :allow_blank => true}, :if => :ostree?
+    validates :ostree_upstream_sync_depth, :presence => true, :numericality => { :only_integer => true },
+      :if => proc { |r| r.ostree? && r.ostree_upstream_sync_policy == OSTREE_UPSTREAM_SYNC_POLICY_CUSTOM }
+    validates :content_type, :inclusion => {
+      :in => ->(_) { Katello::RepositoryTypeManager.repository_types.keys },
+      :allow_blank => false,
+      :message => ->(_, _) { _("must be one of the following: %s") % Katello::RepositoryTypeManager.repository_types.keys.join(', ') }
+    }
+    validates :download_policy, inclusion: {
+      :in => ::Runcible::Models::YumImporter::DOWNLOAD_POLICIES,
+      :message => _("must be one of the following: %s") % ::Runcible::Models::YumImporter::DOWNLOAD_POLICIES.join(', ')
+    }, if: :yum?
+
+    scope :subscribable, -> { where(content_type: RootRepository::SUBSCRIBABLE_TYPES) }
+    scope :has_url, -> { where.not(:url => nil) }
+    scope :with_repository_attribute, ->(attr, value) { joins(:repositories).where("#{Katello::Repository.table_name}.#{attr}" => value) }
+    scope :in_content_view_version, ->(version) { with_repository_attribute(:content_view_version_id, version) }
+    scope :deb_type, -> { where(:content_type => Repository::DEB_TYPE) }
+    scope :yum_type, -> { where(:content_type => Repository::YUM_TYPE) }
+    scope :file_type, -> { where(:content_type => Repository::FILE_TYPE) }
+    scope :puppet_type, -> { where(:content_type => Repository::PUPPET_TYPE) }
+    scope :docker_type, -> { where(:content_type => Repository::DOCKER_TYPE) }
+    scope :ostree_type, -> { where(:content_type => Repository::OSTREE_TYPE) }
+    delegate :redhat?, :provider, :organization, to: :product
+
+    def library_instance
+      repositories.in_default_view.first
+    end
+
+    def self.repositories
+      Repository.where(:root => self)
+    end
+
+    def custom?
+      !redhat?
+    end
+
+    def self.in_organization(org)
+      joins(:product).where("#{Katello::Product.table_name}.organization_id" => org)
+    end
+
+    def ensure_content_attribute_restrictions
+      CONTENT_ATTRIBUTE_RESTRICTIONS.each do |attribute, value|
+        if self.send(attribute).present? && !value.include?(self.content_type)
+          errors.add(attribute, _("Cannot set attribute %{attr} for content type %{type}") % {:attr => attribute, :type => self.content_type})
+        end
+      end
+    end
+
+    def ensure_compatible_download_policy
+      if !url.blank? && URI(url).scheme == 'file' &&
+          [::Runcible::Models::YumImporter::DOWNLOAD_ON_DEMAND, ::Runcible::Models::YumImporter::DOWNLOAD_BACKGROUND].include?(download_policy)
+        errors.add(:download_policy, _("Cannot sync file:// repositories with On Demand or Background Download Policies"))
+      end
+    end
+
+    def ensure_valid_docker_attributes
+      if (!url.blank? && docker_upstream_name.blank?)
+        errors.add(:docker_upstream_name, N_("cannot be blank when Repository URL is provided."))
+        errors.add(:base, _("Upstream Name cannot be blank when Repository URL is provided."))
+      end
+    end
+
+    def ensure_docker_repo_unprotected
+      unless unprotected
+        errors.add(:base, _("Container Image Repositories are not protected at this time. " \
+                             "They need to be published via http to be available to containers."))
+      end
+    end
+
+    def ensure_no_download_policy
+      if !yum? && download_policy.present?
+        errors.add(:download_policy, _("cannot be set for non-yum repositories."))
+      end
+    end
+
+    def ensure_ostree_repo_protected
+      if unprotected
+        errors.add(:base, _("OSTree Repositories cannot be unprotected."))
+      end
+    end
+
+    def update_ostree_upstream_sync_policy
+      return unless ostree?
+      if self.ostree_upstream_sync_policy.blank?
+        self.ostree_upstream_sync_policy = OSTREE_UPSTREAM_SYNC_POLICY_LATEST
+      end
+
+      if self.ostree_upstream_sync_policy_changed? &&
+        previous_changes[:ostree_upstream_sync_policy].present?
+        self.ostree_upstream_sync_depth = nil unless self.ostree_upstream_sync_policy == OSTREE_UPSTREAM_SYNC_POLICY_CUSTOM
+      end
+    end
+
+    def compute_ostree_upstream_sync_depth
+      if ostree_upstream_sync_policy == OSTREE_UPSTREAM_SYNC_POLICY_CUSTOM
+        ostree_upstream_sync_depth
+      elsif ostree_upstream_sync_policy == OSTREE_UPSTREAM_SYNC_POLICY_ALL
+        -1
+      else
+        0
+      end
+    end
+
+    def ensure_no_ostree_upstream_sync_policy
+      if !ostree? && ostree_upstream_sync_policy.present?
+        errors.add(:ostree_upstream_sync_policy, N_("cannot be set for non-ostree repositories."))
+      end
+    end
+
+    def ensure_valid_ignorable_content
+      return if ignorable_content.blank?
+      if !yum?
+        errors.add(:ignorable_content, N_("Ignorable content can be only set for Yum repositories."))
+      elsif !ignorable_content.is_a?(Array)
+        errors.add(:ignorable_content, N_("Invalid value specified for ignorable content."))
+      elsif ignorable_content.any? { |item| !IGNORABLE_CONTENT_UNIT_TYPES.include?(item) }
+        errors.add(:ignorable_content, N_("Invalid value specified for ignorable content. Permissible values %s") % IGNORABLE_CONTENT_UNIT_TYPES.join(","))
+      end
+    end
+
+    def ensure_valid_upstream_authorization
+      return if (self.upstream_username.blank? && self.upstream_password.blank?)
+      if redhat?
+        errors.add(:base, N_("Upstream username and password may only be set on custom repositories."))
+      elsif self.upstream_username.blank?
+        errors.add(:base, N_("Upstream password requires upstream username be set."))
+      elsif !self.upstream_password
+        errors.add(:base, N_("Upstream username requires upstream password be set.")) # requirement of pulp
+      end
+    end
+
+    def custom_content_path
+      parts = []
+      # We generate repo path only for custom product content. We add this
+      # constant string to avoid collisions with RH content. RH content url
+      # begins usually with something like "/content/dist/rhel/...".
+      # There we prefix custom content/repo url with "/custom/..."
+      parts << "custom"
+      parts += [product.label, self.label]
+      "/" + parts.map { |x| x.gsub(/[^-\w]/, "_") }.join("/")
+    end
+
+    def custom_content_label
+      "#{organization.label} #{product.label} #{label}".gsub(/\s/, "_")
+    end
+
+    def content
+      Katello::Content.find_by(:cp_content_id => self.content_id, :organization_id => self.product.organization_id)
+    end
+
+    def docker?
+      self.content_type == Repository::DOCKER_TYPE
+    end
+
+    def puppet?
+      self.content_type == Repository::PUPPET_TYPE
+    end
+
+    def file?
+      self.content_type == Repository::FILE_TYPE
+    end
+
+    def yum?
+      self.content_type == Repository::YUM_TYPE
+    end
+
+    def ostree?
+      self.content_type == Repository::OSTREE_TYPE
+    end
+
+    def deb?
+      self.content_type == Repository::DEB_TYPE
+    end
+
+    def metadata_generate_needed?
+      (%w(unprotected checksum_type container_repsoitory_name) & previous_changes.keys).any?
+    end
+
+    def pulp_update_needed?
+      changeable_attributes = %w(url unprotected checksum_type docker_upstream_name download_policy mirror_on_sync verify_ssl_on_sync
+                                 upstream_username upstream_password ostree_upstream_sync_policy ostree_upstream_sync_depth ignore_global_proxy ignorable_content)
+      changeable_attributes += %w(name container_repository_name) if docker?
+      changeable_attributes += %w(deb_releases deb_components deb_architectures) if deb?
+      changeable_attributes.any? { |key| previous_changes.key?(key) }
+    end
+
+    def raw_content_path
+      self.content.content_url
+    end
+
+    def calculate_updated_name
+      fail _("Cannot calculate name for custom repos") if custom?
+      Katello::Candlepin::RepositoryMapper.new(self.product, self.content, self.substitutions).name
+    end
+
+    def substitutions
+      {
+        :releasever => self.minor,
+        :basearch => self.arch
+      }
+    end
+
+    class Jail < ::Safemode::Jail
+      allow :name, :label, :docker_upstream_name, :url
+    end
+  end
+end

data/app/models/katello/subscription_status.rb

@@ -38,7 +38,7 @@ module Katello
 
     def to_status(options = {})
       return UNKNOWN unless host.subscription_facet.try(:uuid)
-      status_override = 'unsubscribed_hypervisor' if host.subscription_facet.hypervisor && host.subscription_facet.candlepin_consumer.entitlements.empty?
+      status_override = 'unsubscribed_hypervisor' if host.subscription_facet.hypervisor && !host.subscription_facet.candlepin_consumer.entitlements?
       status_override ||= options.fetch(:status_override, nil)
       status = status_override || Katello::Candlepin::Consumer.new(host.subscription_facet.uuid, host.organization.label).entitlement_status
 

data/app/models/katello/sync_plan.rb

@@ -10,12 +10,14 @@ module Katello
     HOURLY = 'hourly'.freeze
     DAILY = 'daily'.freeze
     WEEKLY = 'weekly'.freeze
-    TYPES = [HOURLY, DAILY, WEEKLY].freeze
+    CUSTOM_CRON = 'custom cron'.freeze
+    TYPES = [HOURLY, DAILY, WEEKLY, CUSTOM_CRON].freeze
     DURATION = {HOURLY => 'T1H', DAILY => 'T24H', WEEKLY => '7D' }.freeze
     WEEK_DAYS = %w(Sunday Monday Tuesday Wednesday Thursday Friday).collect { |d| N_(d) }
 
     belongs_to :organization, :inverse_of => :sync_plans
     has_many :products, :class_name => "Katello::Product", :dependent => :nullify
+    belongs_to :foreman_tasks_recurring_logic, :inverse_of => :sync_plan, :class_name => "ForemanTasks::RecurringLogic", :dependent => :destroy
 
     validates_lengths_from_database
     validates :name, :presence => true, :uniqueness => {:scope => :organization_id}
@@ -23,8 +25,11 @@ module Katello
     validates :enabled, :inclusion => [true, false]
     validate :validate_sync_date
     validate :product_enabled
+    validate :custom_cron_interval_expression
     validates_with Validators::KatelloNameFormatValidator, :attributes => :name
 
+    before_destroy :cancel_recurring_logic
+
     scoped_search :on => :name, :complete_value => true
     scoped_search :on => :organization_id, :complete_value => true, :only_explicit => true, :validator => ScopedSearch::Validators::INTEGER
     scoped_search :on => :interval, :complete_value => true
@@ -36,6 +41,53 @@ module Katello
       end
     end
 
+    def custom_cron_interval_expression
+      errors.add :base, _("Custom cron expression only needs to be set for interval value of custom cron") if cron_status_mismatch?
+    end
+
+    def save_with_logic!
+      associate_recurring_logic
+      self.save!
+      start_recurring_logic
+    end
+
+    def update_attributes_with_logics!(params)
+      transaction do
+        params["cron_expression"] = '' unless params["interval"].eql? CUSTOM_CRON
+        self.update_attributes!(params)
+        if rec_logic_changed?
+          old_rec_logic = self.foreman_tasks_recurring_logic
+          associate_recurring_logic
+          self.save!
+          old_rec_logic.cancel
+          start_recurring_logic
+        end
+        toggle_enabled if enabled_toggle?
+      end
+    end
+
+    def associate_recurring_logic
+      self.foreman_tasks_recurring_logic = add_recurring_logic_to_sync_plan(self.sync_date, self.interval, self.cron_expression)
+    end
+
+    def toggle_enabled
+      self.foreman_tasks_recurring_logic.enabled = self.enabled
+    end
+
+    def start_recurring_logic
+      User.as_anonymous_admin do
+        if self.sync_date.to_time < Time.now
+          self.foreman_tasks_recurring_logic.start(::Actions::Katello::SyncPlan::Run, self)
+        else
+          self.foreman_tasks_recurring_logic.start_after(::Actions::Katello::SyncPlan::Run, self.sync_date, self)
+        end
+      end
+    end
+
+    def cancel_recurring_logic
+      self.foreman_tasks_recurring_logic.cancel if self.foreman_tasks_recurring_logic
+    end
+
     def validate_sync_date
       errors.add :base, _("Start Date and Time can't be blank") if self.sync_date.nil?
     end
@@ -56,13 +108,6 @@ module Katello
       self.sync_date.strftime('%Y/%m/%d %H:%M:%S %z')
     end
 
-    def schedule_format
-      return nil if DURATION[self.interval].nil?
-      date = self.sync_date
-      date = next_sync_date if enabled? && self.sync_date < Time.now
-      "#{date.iso8601}/P#{DURATION[self.interval]}"
-    end
-
     def plan_zone
       self.sync_date.strftime('%Z')
     end
@@ -72,38 +117,8 @@ module Katello
     end
 
     def next_sync_date
-      return nil unless self.enabled
-      now = Time.current
-      next_sync = self.sync_date
-
-      if self.sync_date < now
-        hours = self.sync_date.hour - now.hour
-        minutes = self.sync_date.min - now.min
-        seconds = self.sync_date.sec - now.sec
-
-        next_sync = nil
-        now_time = now.utc.strftime('%H%M%S%N')
-
-        case self.interval
-        when HOURLY
-          if self.sync_date.min < now.min
-            minutes += 60
-          end
-          next_sync = now.advance(:minutes => minutes, :seconds => seconds)
-        when DAILY
-          if self.sync_time < now_time
-            hours += 24
-          end
-          next_sync = now.advance(:hours => hours, :minutes => minutes, :seconds => seconds)
-        when WEEKLY
-          days = self.sync_date.wday - now.wday
-          days += 7 if days < 0 || (days == 0 && self.sync_time <= now_time)
-          next_sync = now.change(:hour => self.sync_date.hour, :min => self.sync_date.min,
-                                 :sec => self.sync_date.sec).advance(:days => days)
-        end
-      end
-
-      next_sync
+      return nil unless (self.enabled || !self.foreman_tasks_recurring_logic.tasks.nil?)
+      self.foreman_tasks_recurring_logic.tasks.order(:start_at).last.try(:start_at)
     end
 
     def next_sync
@@ -113,5 +128,43 @@ module Katello
     def self.humanize_class_name(_name = nil)
       _("Sync Plans")
     end
+
+    def add_recurring_logic_to_sync_plan(sync_date, interval, cron_expression)
+      sync_date_local_zone = sync_date
+      min, hour, day = sync_date_local_zone.min, sync_date_local_zone.hour, sync_date_local_zone.wday
+      if interval.nil?
+        fail _("Interval cannot be nil")
+      end
+      if (interval.downcase.eql? "hourly")
+        cron = min.to_s + " * * * *"
+      elsif (interval.downcase.eql? "daily")
+        cron = min.to_s + " " + hour.to_s + " * * *"
+      elsif (interval.downcase.eql? "weekly")
+        cron = min.to_s + " " + hour.to_s + " * * " + day.to_s
+      elsif (interval.downcase.eql? CUSTOM_CRON)
+        cron = cron_expression
+      else
+        fail _("Interval not set correctly")
+      end
+
+      recurring_logic = ForemanTasks::RecurringLogic.new_from_cronline(cron)
+      unless recurring_logic.valid_cronline?
+        fail _("Cron expression is not valid!")
+      end
+      recurring_logic.save!
+      return recurring_logic
+    end
+
+    def rec_logic_changed?
+      saved_change_to_attribute?(:sync_date) || saved_change_to_attribute?(:interval) || saved_change_to_attribute?(:cron_expression)
+    end
+
+    def enabled_toggle?
+      saved_change_to_attribute?(:enabled)
+    end
+
+    def cron_status_mismatch?
+      self.interval != CUSTOM_CRON && !(self.cron_expression.nil? || self.cron_expression.eql?(''))
+    end
   end
 end