foreman_content 0.2 → 0.3

data/app/models/content/operatingsystem_repository.rb

@@ -1,14 +1,3 @@
-#
-# Copyright 2013 Red Hat, Inc.
-#
-# This software is licensed to you under the GNU General Public
-# License as published by the Free Software Foundation; either version
-# 2 of the License (GPLv2) or (at your option) any later version.
-# There is NO WARRANTY for this software, express or implied,
-# including the implied warranties of MERCHANTABILITY,
-# NON-INFRINGEMENT, or FITNESS FOR A PARTICULAR PURPOSE. You should
-# have received a copy of GPLv2 along with this software; if not, see
-# http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
 module Content
   class OperatingsystemRepository < ActiveRecord::Base
     belongs_to :operatingsystem

data/app/models/content/product.rb

@@ -3,11 +3,8 @@ module Content
     include ::Taxonomix
 
     has_many :repositories
-    has_many :environment_products, :dependent => :destroy, :uniq=>true
-    has_many :environments, :through => :environment_products
-
-    has_many :product_operatingsystems, :dependent => :destroy, :uniq=>true
-    has_many :operatingsystems, :through => :product_operatingsystems
+    has_many :repository_clones, :through => :repositories
+    has_many :content_views, :as => :originator
 
     has_many :hostgroup_products, :dependent => :destroy, :uniq=>true
     has_many :hostgroups, :through => :hostgroup_products
@@ -15,6 +12,10 @@ module Content
     has_many :host_products, :dependent => :destroy, :uniq=>true
     has_many :hosts, :through => :host_products
 
+    before_destroy EnsureNotUsedBy.new(:hostgroups, :hosts, :repositories)
+
+    scope :has_repos, joins(:repositories).uniq
+
     validates_with Validators::DescriptionFormat, :attributes => :description
     validates :name, :presence => true
     validates_with Validators::NameFormat, :attributes => :name

data/app/models/content/repository/operating_system.rb

@@ -0,0 +1,14 @@
+module Content
+  class Repository::OperatingSystem < Repository
+
+    validates_presence_of :operatingsystem
+
+    def self.model_name
+      Repository.model_name
+    end
+
+    def entity_name
+      operatingsystem.to_label
+    end
+  end
+end

data/app/models/content/repository/product.rb

@@ -0,0 +1,21 @@
+module Content
+  class Repository::Product < Repository
+
+    has_many :operatingsystem_repositories, :foreign_key => :repository_id, :dependent => :destroy, :uniq => true
+    has_many :operatingsystems, :through => :operatingsystem_repositories
+
+    validates_presence_of :product
+
+    def self.model_name
+      Repository.model_name
+    end
+
+    def content_types
+      TYPES - [KICKSTART_TYPE]
+    end
+
+    def entity_name
+      product.name
+    end
+  end
+end

data/app/models/content/repository.rb

@@ -1,29 +1,25 @@
-require 'content/orchestration/pulp'
-# TODO: split into a custom and red hat repositories:
-# as handling of repo creation/updates is different between them
 module Content
   class Repository < ActiveRecord::Base
-    include CustomRepositoryPaths
-    include Content::Remote::Pulp::Repository
-    include ::Orchestration
-    include Content::Orchestration::Pulp
+    include Content::Orchestration::Pulp::Sync
+    include Foreman::STI
 
     YUM_TYPE       = 'yum'
     KICKSTART_TYPE = 'kickstart'
     FILE_TYPE      = 'iso'
     TYPES          = [YUM_TYPE, KICKSTART_TYPE, FILE_TYPE]
 
-    REPO_PREFIX = '/pulp/repos/'
-
-    belongs_to :product
+    belongs_to :product, :class_name => 'Content::Product'
+    belongs_to :operatingsystem
     belongs_to :gpg_key
     belongs_to :architecture
-    has_many :operatingsystem_repositories, :dependent => :destroy, :uniq => true
-    has_many :operatingsystems, :through => :operatingsystem_repositories
+    has_many :repository_clones
+
+    before_destroy EnsureNotUsedBy.new(:repository_clones)
+
+    validates_presence_of :type # can't create this object, only child
 
-    validates :product, :presence => true
     validates :name, :presence => true
-    validates_uniqueness_of :name, :scope => :product_id
+    validates_uniqueness_of :name, :scope => [:operatingsystem_id, :product_id]
     validates_inclusion_of :content_type,
                            :in          => TYPES,
                            :allow_blank => false,
@@ -31,40 +27,33 @@ module Content
 
     scoped_search :on => [:name, :enabled], :complete_value => :true
     scoped_search :in => :architecture, :on => :name, :rename => :architecture, :complete_value => :true
-    scoped_search :in => :operatingsystems, :on => :name, :rename => :os, :complete_value => :true
+    scoped_search :in => :operatingsystem, :on => :name, :rename => :os, :complete_value => :true
     scoped_search :in => :product, :on => :name, :rename => :product, :complete_value => :true
 
-    # Repositories filtered by operating system architecture and environment.
-    # architecture_id is nil for noarch repositories.
-    scope :available_for_host, lambda { |host|
-      joins(:operatingsystems => :operatingsystem_repositories , :product => :environments).
-      where(:architecture_id => [nil, host.architecture_id],
-            :content_operatingsystem_repositories => { :operatingsystem_id => host.operatingsystem_id},
-            :content_environment_products => { :environment_id => host.environment_id }).
-      uniq}
-
-    #
-    scope :attached_to_host, lambda { |host|
-      where(:product_id => host.all_product_ids).available_for_host(host)
-    }
-
     scope :kickstart, where(:content_type => KICKSTART_TYPE)
     scope :yum, where(:content_type => YUM_TYPE)
 
-    def update_cache
-      nil
-    end
-
-    def full_path
-      pulp_url = URI.parse(Setting.pulp_url)
-      scheme   = (unprotected ? 'http' : 'https')
-      port     = (pulp_url.port == 443 || pulp_url.port == 80 ? "" : ":#{pulp_url.port}")
-      "#{scheme}://#{pulp_url.host}#{port}#{REPO_PREFIX}#{relative_path}"
+    def content_types
+      TYPES
     end
 
     # The label is used as a repository label in a yum repo file.
     def to_label
-      "#{product.name}-#{name}".parameterize
+      "#{entity_name}-#{name}".parameterize
+    end
+
+    #inhariters are expected to override this method
+    def entity_name
+      ''
     end
+
+    def publish content_view
+      repository_clones.create!(
+        :content_views => [content_view],
+        :name => self.name + "_clone",
+        :relative_path => "content_views/#{to_label}/#{Foreman.uuid}"
+      )
+    end
+
   end
 end

data/app/models/content/repository_clone.rb

@@ -0,0 +1,29 @@
+module Content
+  class RepositoryClone < ActiveRecord::Base
+    include Content::Orchestration::Pulp::Clone
+
+    REPO_PREFIX = '/pulp/repos/'
+
+    belongs_to :repository
+    has_many :content_view_repository_clones, :dependent => :destroy
+    has_many :content_views, :through => :content_view_repository_clones
+    before_destroy EnsureNotUsedBy.new(:content_views)
+
+    attr_accessible :description, :last_published, :name, :pulp_id, :relative_path, :status, :content_views
+    validate :relative_path, :repository_id, :presence => true
+
+    delegate :content_type, :architecture, :unprotected, :gpg_key, :product, :to => :repository
+
+    scope :for_content_views, lambda { |ids|
+      joins(:content_view_repository_clones).
+        where('content_content_view_repository_clones' => {:content_view_id => ids})
+    }
+
+    def full_path
+      pulp_url = URI.parse(Setting.pulp_url)
+      scheme   = (unprotected ? 'http' : 'https')
+      port     = (pulp_url.port == 443 || pulp_url.port == 80 ? "" : ":#{pulp_url.port}")
+      "#{scheme}://#{pulp_url.host}#{port}#{REPO_PREFIX}#{relative_path}"
+    end
+  end
+end

data/app/models/content/validators/content_validator.rb

@@ -1,15 +1,3 @@
-#
-# Copyright 2013 Red Hat, Inc.
-#
-# This software is licensed to you under the GNU General Public
-# License as published by the Free Software Foundation; either version
-# 2 of the License (GPLv2) or (at your option) any later version.
-# There is NO WARRANTY for this software, express or implied,
-# including the implied warranties of MERCHANTABILITY,
-# NON-INFRINGEMENT, or FITNESS FOR A PARTICULAR PURPOSE. You should
-# have received a copy of GPLv2 along with this software; if not, see
-# http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
-
 module Content
   module Validators
     class ContentValidator < ActiveModel::EachValidator

data/app/models/content/validators/description_format.rb

@@ -1,15 +1,3 @@
-#
-# Copyright 2013 Red Hat, Inc.
-#
-# This software is licensed to you under the GNU General Public
-# License as published by the Free Software Foundation; either version
-# 2 of the License (GPLv2) or (at your option) any later version.
-# There is NO WARRANTY for this software, express or implied,
-# including the implied warranties of MERCHANTABILITY,
-# NON-INFRINGEMENT, or FITNESS FOR A PARTICULAR PURPOSE. You should
-# have received a copy of GPLv2 along with this software; if not, see
-# http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
-
 module Content
   module Validators
     class DescriptionFormat < ActiveModel::EachValidator

data/app/models/content/validators/no_trailing_space.rb

@@ -1,15 +1,3 @@
-#
-# Copyright 2013 Red Hat, Inc.
-#
-# This software is licensed to you under the GNU General Public
-# License as published by the Free Software Foundation; either version
-# 2 of the License (GPLv2) or (at your option) any later version.
-# There is NO WARRANTY for this software, express or implied,
-# including the implied warranties of MERCHANTABILITY,
-# NON-INFRINGEMENT, or FITNESS FOR A PARTICULAR PURPOSE. You should
-# have received a copy of GPLv2 along with this software; if not, see
-# http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
-
 module  Content
   module Validators
     class NoTrailingSpace < ActiveModel::EachValidator

data/app/models/setting/content.rb

@@ -21,22 +21,4 @@ class Setting::Content< ::Setting
 
   end
 
-  def self.ensure_sync_notification
-    include Rails.application.routes.url_helpers
-
-    resource = Runcible::Resources::EventNotifier
-    url      = events_repositories_url(:only_path => false, :host => Setting[:foreman_url])
-    type     = '*' #resource::EventTypes::REPO_SYNC_COMPLETE
-    notifs   = resource.list
-
-    #delete any similar tasks with the wrong url (in case it changed)
-    notifs.select { |n| n['event_types'] == [type] && n['notifier_config']['url'] != url }.each do |e|
-      resource.delete(e['id'])
-    end
-
-    #only create a notifier if one doesn't exist with the correct url
-    exists = notifs.select { |n| n['event_types'] == [type] && n['notifier_config']['url'] == url }
-    resource.create(resource::NotifierTypes::REST_API, { :url => url }, [type]) if exists.empty?
-  end
-
 end

data/app/overrides/{add_host_conent_tab.rb → add_host_content_tab.rb}

@@ -1,9 +1,9 @@
 Deface::Override.new(:virtual_path => "hosts/_form",
                      :name => "add_content_tab",
                      :insert_after => 'ul.nav > li a#params-tab',
-                     :partial => 'content/products/form_tab')
+                     :partial => 'content/content_views/form_tab')
 
 Deface::Override.new(:virtual_path => "hosts/_form",
                      :name => "add_content_tab_pane",
                      :insert_after => 'div.tab-pane#params',
-                     :partial => 'content/products/host_tab_pane')
+                     :partial => 'content/content_views/host_tab_pane')

data/app/overrides/{add_hostgroup_conent_tab.rb → add_hostgroup_content_tab.rb}

@@ -6,4 +6,4 @@ Deface::Override.new(:virtual_path => "hostgroups/_form",
 Deface::Override.new(:virtual_path => "hostgroups/_form",
                      :name => "add_content_tab_pane",
                      :insert_after => 'div.tab-pane#params',
-                     :partial => 'content/products/hostgroup_tab_pane')
+                     :partial => 'content/products/hostgroup_tab_pane')

data/app/services/content/content_view_factory.rb

@@ -0,0 +1,41 @@
+module Content
+  class ContentViewFactory
+    include ActiveModel::Conversion
+    extend  ActiveModel::Naming
+
+    attr_accessor :type, :originator_id, :parent_cv, :product_cv, :os_cv
+    # create a content view of a single product
+    def self.create_product_content_view(product_id)
+      product = Product.find_by_id(product_id)
+      ContentView.new(:source_repositories => product.repositories, :originator => product)
+    end
+
+    # create a content view of an operating system
+    def self.create_os_content_view(operatingsystem_id)
+      os = Operatingsystem.find_by_id(operatingsystem_id)
+      ContentView.new(:source_repositories => os.repositories, :originator => os)
+    end
+
+    # create a composite content view of a hostgroup (the hostgroup may have a list of products) and a parent
+    # content view. The parent content view is one of the hostgroup parent content views.
+    # A hostgroup may have number of content views representing different versions of that hostgroup content.
+    def self.create_composite_content_view(options = {})
+      factory   = new(options)
+      hostgroup = Hostgroup.find_by_id(factory.originator_id)
+      clone_ids = Content::RepositoryClone.for_content_views([factory.product_cv, factory.os_cv]).
+        pluck(:id)
+      ContentView.new(:source_repositories=> [], :originator => hostgroup,
+                      :repository_clone_ids => clone_ids, :parent_id => factory.parent_cv)
+    end
+
+    def initialize(attributes = {})
+      attributes.each do |name, value|
+        instance_variable_set("@#{name}", value) if respond_to?("#{name}".to_sym)
+      end
+    end
+
+    def persisted?
+      false
+    end
+  end
+end

data/app/services/content/{pulp_configuration.rb → pulp/configuration.rb}

@@ -1,7 +1,7 @@
 require 'runcible'
 require 'uri'
 
-class Content::PulpConfiguration
+class Content::Pulp::Configuration
   def initialize options = {}
     Runcible::Base.config = runcible_config.merge(options)
   end

data/app/services/content/pulp/event_handler.rb

@@ -0,0 +1,61 @@
+class Content::Pulp::EventHandler
+  attr_reader :type, :status
+  delegate :name, :to => :repo
+  delegate :logger, :to => :Rails
+
+  def initialize(pulp_id, params)
+    @pulp_id      = pulp_id
+    @params        = params
+    @type, @status = parse_type
+    return nil unless repo
+    log
+    update_state
+  end
+
+  private
+  attr_reader :pulp_id, :params
+
+  def repo
+    @repo ||= case type
+              when 'sync'
+                Content::Repository.where(:pulp_id => pulp_id).first
+              when 'promote'
+                Content::RepositoryClone.where(:pulp_id => pulp_id).first
+              end
+  end
+
+  def log
+    logger.info "Repository #{name} #{type} #{status}"
+  end
+
+  def parse_type
+    # converts repo.sync.start to ['sync','start']
+    params['event_type'].gsub(/^repo\./, '').split('.')
+  end
+
+  def update_state
+    #nothing to do if we didnt finish a task
+    return unless status == 'finish'
+
+    case type
+    when 'sync'
+      repo.update_attribute(:last_sync, finished_at) if success?
+    when 'promote'
+      repo.update_attribute(:last_published, finished_at) if success?
+
+    end
+  end
+
+  def success?
+    result == 'success'
+  end
+
+  def result
+    params['payload']['result']
+  end
+
+  def finished_at
+    Time.parse(params['payload']['completed'])
+  end
+
+end

data/app/services/content/pulp/repository.rb

@@ -0,0 +1,200 @@
+class Content::Pulp::Repository
+  PULP_SELECT_FIELDS = ['name', 'epoch', 'version', 'release', 'arch', 'checksumtype', 'checksum']
+
+  attr_reader :pulp_id,  :content_type, :relative_path, :name, :description
+  delegate :logger, :to => :Rails
+
+  class << self
+
+    def create(options = {})
+      new(options).create
+    end
+
+    def delete(pulp_id)
+      new(:pulp_id => pulp_id).delete
+    end
+
+    def sync(pulp_id)
+      new(:pulp_id => pulp_id).sync
+    end
+
+  end
+
+  def initialize options = {}
+    options.each do |k, v|
+      instance_variable_set("@#{k}", v) if respond_to?("#{k}".to_sym)
+    end
+
+    raise('must define pulp id') unless pulp_id
+
+    # initiate pulp connection
+    Content::Pulp::Configuration.new
+  end
+
+  def create_with_distributor
+    create_repository [pulp_distributor]
+  end
+
+  def create
+    create_repository
+  end
+
+  def display_name
+    details['display_name']
+  end
+
+  def checksum_type
+    details['checksum_type']
+  end
+
+  def description
+    @description || details['description']
+  end
+
+  def counters
+    details['content_unit_counts']
+  end
+
+  def feed
+    @feed || importer['config']['feed_url']
+  end
+
+  def last_sync
+    importer['last_sync']
+  end
+
+  def last_publish
+    distributor['last_publish']
+  end
+
+  def auto_publish
+    @auto_publish.nil? ? distributor['auto_publish'] : @auto_publish
+  end
+
+  def protected
+    @protected.nil? ? distributor['protected'] : @protected
+  end
+
+  def reload!
+    @details = nil
+  end
+
+  def sync_status
+    status = Runcible::Extensions::Repository.sync_status(pulp_id)
+    Content::Pulp::RepositorySyncStatus.new(status.first) unless status.empty?
+  end
+
+  def sync_history
+    history = Runcible::Extensions::Repository.sync_history(pulp_id)
+    (history || []).map do |sync|
+      Content::Pulp::RepositorySyncHistory.new(sync)
+    end
+  end
+
+  def delete
+    Runcible::Resources::Repository.delete(pulp_id)
+  rescue RestClient::ResourceNotFound => e
+    true #not found is not a failure for delete
+  end
+
+  def sync
+    Runcible::Resources::Repository.sync(pulp_id)
+  end
+
+  def publish
+    Runcible::Extensions::Repository.publish_all(pulp_id)
+  end
+
+  def cancel_running_sync!
+    return if sync_status.blank? || sync_status.not_synced?
+    Runcible::Resources::Task.cancel(sync_status.task_id)
+  rescue RestClient::ResourceNotFound
+    # task already done, nothing to do here
+  end
+
+  # once we keep a list pulp servers, this should be done in create/destroy
+  def create_event_notifier
+    url      = Rails.application.routes.url_helpers.
+                 events_api_repositories_url(:only_path => false, :host => Setting[:foreman_url])
+    type     = '*'
+    resource = Runcible::Resources::EventNotifier
+    notifs   = resource.list
+
+    #only create a notifier if one doesn't exist with the correct url
+    exists   = notifs.select { |n| n['event_types'] == [type] && n['notifier_config']['url'] == url }
+    resource.create(resource::NotifierTypes::REST_API, { :url => url }, [type]) if exists.empty?
+    true
+  end
+
+  private
+
+  def create_repository pulp_distributors = []
+    defaults
+    Runcible::Extensions::Repository.create_with_importer_and_distributors(pulp_id,
+                                                                           pulp_importer,
+                                                                           pulp_distributors,
+                                                                           { :display_name => relative_path || name,
+                                                                             :description  => description })
+  rescue RestClient::BadRequest => e
+    raise parse_error(e)
+  end
+
+  def pulp_importer
+    options = {
+      :feed_url => feed
+    }
+
+    case content_type
+      when Content::Repository::YUM_TYPE, Content::Repository::KICKSTART_TYPE
+        Runcible::Extensions::YumImporter.new(options)
+      when Content::Repository::FILE_TYPE
+        Runcible::Extensions::IsoImporter.new(options)
+      else
+        raise "Unexpected repo type %s" % content_type
+    end
+  end
+
+  def pulp_distributor
+    case content_type
+      when Content::Repository::YUM_TYPE, Content::Repository::KICKSTART_TYPE
+        Runcible::Extensions::YumDistributor.new(relative_path, protected, true,
+                                                 { :protected    => protected, :id => pulp_id,
+                                                   :auto_publish => auto_publish })
+      when Content::Repository::FILE_TYPE
+        dist              = Runcible::Extensions::IsoDistributor.new(true, true)
+        dist.auto_publish = true
+        dist
+      else
+        raise "Unexpected repo type %s" % content_type
+    end
+  end
+
+  def defaults
+    @protected = true if @protected.nil?
+  end
+
+  def importer
+    details['importers'].empty? ? {} : details['importers'].first
+  end
+
+  def distributor
+    details['distributors'].empty? ? {} : details['distributors'].first
+  end
+
+  def details
+    @details ||= Runcible::Resources::Repository.retrieve(pulp_id, { :details => true })
+  rescue RestClient::ResourceNotFound => e
+    logger.warn "Repo not found: #{parse_error(e)}"
+    {:state => 'not found'}
+  end
+
+  def state
+    return 'published'       if last_publish.present?
+    return sync_status.state if sync_status.present?
+    return details[:state]   if details[:state]
+  end
+
+  def parse_error exception
+    JSON.parse(exception.response)['error_message']
+  end
+end

data/app/services/content/pulp/repository_clone.rb

@@ -0,0 +1,24 @@
+class Content::Pulp::RepositoryClone < Content::Pulp::Repository
+  PULP_SELECT_FIELDS = %w(name epoch version release arch checksumtype checksum)
+
+  def copy_from(src_repo_id)
+    # In order to reduce the memory usage of pulp during the copy process,
+    # include the fields that will uniquely identify the rpm. If no fields
+    # are listed, pulp will retrieve every field it knows about for the rpm
+    # (e.g. changelog, filelist...etc).
+    Runcible::Extensions::Rpm.copy(src_repo_id, pulp_id, { :fields => PULP_SELECT_FIELDS })
+    Runcible::Extensions::Distribution.copy(src_repo_id, pulp_id)
+
+    # Since the rpms will be copied above, during the copy of errata and package groups,
+    # include the copy_children flag to request that pulp skip copying them again.
+    Runcible::Extensions::Errata.copy(src_repo_id, pulp_id, { :copy_children => false })
+    Runcible::Extensions::PackageGroup.copy(src_repo_id, pulp_id, { :copy_children => false })
+    Runcible::Extensions::YumRepoMetadataFile.copy(src_repo_id, pulp_id)
+  end
+
+  def defaults; end
+
+  def pulp_importer
+    Runcible::Extensions::YumImporter.new
+  end
+end

data/app/services/content/pulp/repository_sync_history.rb

@@ -0,0 +1,35 @@
+class Content::Pulp::RepositorySyncHistory
+  attr_reader :exception, :removed_count, :started, :completed, :summary,
+    :error_message, :added_count, :updated_count, :details, :result
+
+  def initialize(attrs)
+    attrs.each do |k, v|
+      instance_variable_set("@#{k}", v) if respond_to?("#{k}".to_sym)
+    end
+  end
+
+  def times
+    {
+      :comps    => summary[:time_total_sec],
+      :errata   => summary[:errata_time_total_sec],
+      :packages => summary[:packages][:time_total_sec]
+    }
+  end
+
+  def metrics
+    {
+      :updated => updated_count,
+      :removed => removed_count,
+      :added   => added_count,
+    }
+  end
+
+  def status
+    {
+      :result    => result,
+      :message   => error_message || summary['error'],
+      :completed => completed
+    }
+  end
+
+end