katello 1.5.0 → 2.2.2

data/app/models/katello/glue/pulp/repo.rb

@@ -1,5 +1,5 @@
 #
-# Copyright 2013 Red Hat, Inc.
+# Copyright 2014 Red Hat, Inc.
 #
 # This software is licensed to you under the GNU General Public
 # License as published by the Free Software Foundation; either version
@@ -11,841 +11,781 @@
 # http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
 
 module Katello
-module Glue::Pulp::Repo
-
-  # TODO: move into submodules
-  # rubocop:disable MethodLength
-  def self.included(base)
-    base.send :include, LazyAccessor
-    base.send :include, InstanceMethods
-
-    base.class_eval do
-
-      before_save :save_repo_orchestration
-      before_destroy :destroy_repo_orchestration
-
-      lazy_accessor :pulp_repo_facts,
-                    :initializer => (lambda do |s|
-                                       if pulp_id
-                                         Katello.pulp_server.extensions.repository.retrieve_with_details(pulp_id)
-                                       end
-                                     end)
-
-      lazy_accessor :checksum_type,
-                    :initializer => lambda { |s| self.lookup_checksum_type if pulp_id}
+  module Glue::Pulp::Repo
+    # TODO: move into submodules
+    # rubocop:disable MethodLength
+    def self.included(base)
+      base.send :include, LazyAccessor
+      base.send :include, InstanceMethods
+
+      base.class_eval do
+        lazy_accessor :pulp_repo_facts,
+                      :initializer => (lambda do |_s|
+                                         if pulp_id
+                                           begin
+                                             Katello.pulp_server.extensions.repository.retrieve_with_details(pulp_id)
+                                           rescue RestClient::ResourceNotFound
+                                             nil # not found = it was not orchestrated yet
+                                           end
+                                         end
+                                       end)
+
+        lazy_accessor :importers,
+                      :initializer => lambda { |_s| pulp_repo_facts["importers"] if pulp_id }
+
+        lazy_accessor :distributors,
+                      :initializer => lambda { |_s| pulp_repo_facts["distributors"] if pulp_id }
+
+        attr_accessor :feed_cert, :feed_key, :feed_ca
+
+        def self.ensure_sync_notification
+          resource =  Katello.pulp_server.resources.event_notifier
+          url = Katello.config.post_sync_url
+          type = Runcible::Resources::EventNotifier::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
 
-      lazy_accessor :importers,
-                    :initializer => lambda { |s| pulp_repo_facts["importers"] if pulp_id }
+          #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(Runcible::Resources::EventNotifier::NotifierTypes::REST_API, {:url => url}, [type]) if exists.empty?
+        end
 
-      lazy_accessor :distributors,
-                    :initializer => lambda { |s| pulp_repo_facts["distributors"] if pulp_id }
+        def self.delete_orphaned_content
+          Katello.pulp_server.resources.content.remove_orphans
+        end
+      end
+    end
 
-      attr_accessor :feed_cert, :feed_key, :feed_ca
+    module InstanceMethods
+      def last_sync
+        last = self.latest_dynflow_sync
+        last.nil? ? nil : last.to_s
+      end
 
-      def self.ensure_sync_notification
-        resource =  Katello.pulp_server.resources.event_notifier
-        url = Katello.config.post_sync_url
-        type = Runcible::Resources::EventNotifier::EventTypes::REPO_SYNC_COMPLETE
-        notifs = resource.list
+      def initialize(attrs = nil, options = {})
+        if attrs.nil?
+          super
+        else
+          #rename "type" to "cp_type" (activerecord and candlepin variable name conflict)
+          #if attrs.has_key?(type_key) && !(attrs.has_key?(:cp_type) || attrs.has_key?('cp_type'))
+          #  attrs[:cp_type] = attrs[type_key]
+          #end
 
-        #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'])
+          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
+          super(attrs_used_by_model, options)
         end
+      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(Runcible::Resources::EventNotifier::NotifierTypes::REST_API, {:url => url}, [type]) if exists.empty?
+      def uri
+        uri = URI.parse(Katello.config.pulp.url)
+        "https://#{uri.host}/pulp/repos/#{relative_path}"
       end
 
-      def self.delete_orphaned_content
-        Katello.pulp_server.resources.content.remove_orphans
+      def to_hash
+        pulp_repo_facts.merge(as_json).merge(:sync_state => sync_state)
       end
 
-    end
-  end
+      def pulp_checksum_type
+        find_distributor['config']['checksum_type'] if self.try(:yum?) && find_distributor
+      end
 
-  module InstanceMethods
-    def save_repo_orchestration
-      case orchestration_for
-      when :create
-        pre_queue.create(:name => "create pulp repo: #{self.name}", :priority => 2, :action => [self, :create_pulp_repo])
-      when :update
-        if self.feed_changed? && !self.product.provider.redhat_provider?
-          pre_queue.create(:name => "update pulp repo: #{self.name}", :priority => 2,
-                           :action => [self, :refresh_pulp_repo, nil, nil, nil])
+      def create_pulp_repo
+        #if we are in library, no need for an distributor, but need to sync
+        if self.environment && self.environment.library?
+          importer = generate_importer
+        else
+          #if not in library, no need for sync info, but we need a distributor
+          case self.content_type
+          when Repository::YUM_TYPE
+            importer = Runcible::Models::YumImporter.new
+          when Repository::PUPPET_TYPE
+            importer = Runcible::Models::PuppetImporter.new
+          end
         end
-      end
-    end
 
-    def last_sync
-      self.importers.first["last_sync"] if self.importers.first
-    end
+        distributors = generate_distributors
 
-    def initialize(attrs = nil, options = {})
-      if attrs.nil?
-        super
-      elsif
-        #rename "type" to "cp_type" (activerecord and candlepin variable name conflict)
-        #if attrs.has_key?(type_key) && !(attrs.has_key?(:cp_type) || attrs.has_key?('cp_type'))
-        #  attrs[:cp_type] = attrs[type_key]
-        #end
+        Katello.pulp_server.extensions.repository.create_with_importer_and_distributors(self.pulp_id,
+            importer,
+            distributors,
+            :display_name => self.name)
+      rescue RestClient::ServiceUnavailable => e
+        message = _("Pulp service unavailable during creating repository '%s', please try again later.") % self.name
+        raise PulpErrors::ServiceUnavailable.new(message, e)
+      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)
+      def generate_importer
+        case self.content_type
+        when Repository::YUM_TYPE
+          Runcible::Models::YumImporter.new(:ssl_ca_cert => self.feed_ca,
+                                            :ssl_client_cert => self.feed_cert,
+                                            :ssl_client_key => self.feed_key,
+                                            :feed => self.url)
+        when Repository::FILE_TYPE
+          Runcible::Models::IsoImporter.new(:ssl_ca_cert => self.feed_ca,
+                                            :ssl_client_cert => self.feed_cert,
+                                            :ssl_client_key => self.feed_key,
+                                            :feed => self.url)
+        when Repository::PUPPET_TYPE
+          options = {}
+          options[:feed] = self.url if self.respond_to?(:url)
+          Runcible::Models::PuppetImporter.new(options)
+        when Repository::DOCKER_TYPE
+          options = {}
+          options[:upstream_name] = self.docker_upstream_name
+          options[:feed] = self.url if self.respond_to?(:url)
+          Runcible::Models::DockerImporter.new(options)
+        else
+          fail _("Unexpected repo type %s") % self.content_type
         end
-        super(attrs_used_by_model, options)
       end
-    end
 
-    def uri
-      uri = URI.parse(Katello.config.pulp.url)
-      "https://#{uri.host}/pulp/repos/#{relative_path}"
-    end
-
-    def to_hash
-      pulp_repo_facts.merge(as_json).merge(:sync_state => sync_state)
-    end
+      def generate_distributors
+        case self.content_type
+        when Repository::YUM_TYPE
+          yum_dist_id = self.pulp_id
+          yum_dist_options = {:protected => true, :id => yum_dist_id, :auto_publish => true}
+          #check the instance variable, as we do not want to go to pulp
+          yum_dist_options['checksum_type'] = self.checksum_type
+          yum_dist = Runcible::Models::YumDistributor.new(self.relative_path, (self.unprotected || false), true,
+                                                          yum_dist_options)
+          clone_dist = Runcible::Models::YumCloneDistributor.new(:id => "#{self.pulp_id}_clone",
+                                                                 :destination_distributor_id => yum_dist_id)
+          [yum_dist, clone_dist, nodes_distributor]
+        when Repository::FILE_TYPE
+          dist = Runcible::Models::IsoDistributor.new(true, true)
+          dist.auto_publish = true
+          [dist]
+        when Repository::PUPPET_TYPE
+          repo_path =  File.join(Katello.config.puppet_repo_root,
+                                 Environment.construct_name(self.organization,
+                                                            self.environment,
+                                                            self.content_view),
+                                 'modules')
+          puppet_install_dist =
+              Runcible::Models::PuppetInstallDistributor.new(repo_path,
+                                                             :id => self.pulp_id, :auto_publish => true)
+          [puppet_install_dist, nodes_distributor]
+        when Repository::DOCKER_TYPE
+          options = { :protected => !self.unprotected,
+                      :id => self.pulp_id,
+                      :auto_publish => true }
+          docker_dist = Runcible::Models::DockerDistributor.new(options)
+          [docker_dist, nodes_distributor]
+        else
+          fail _("Unexpected repo type %s") % self.content_type
+        end
+      end
 
-    def lookup_checksum_type
-      find_distributor['config']['checksum_type'] if self.yum? && find_distributor
-    end
+      def nodes_distributor
+        Runcible::Models::NodesHttpDistributor.new(:id => "#{self.pulp_id}_nodes", :auto_publish => true)
+      end
 
-    def create_pulp_repo
-      #if we are in library, no need for an distributor, but need to sync
-      if self.environment.library?
-        importer = generate_importer
-      else
-        #if not in library, no need for sync info, but we need a distributor
+      def importer_type
         case self.content_type
         when Repository::YUM_TYPE
-          importer = Runcible::Models::YumImporter.new
+          Runcible::Models::YumImporter::ID
+        when Repository::FILE_TYPE
+          Runcible::Models::IsoImporter::ID
         when Repository::PUPPET_TYPE
-          importer = Runcible::Models::PuppetImporter.new
+          Runcible::Models::PuppetImporter::ID
+        when Repository::DOCKER_TYPE
+          Runcible::Models::DockerImporter::ID
+        else
+          fail _("Unexpected repo type %s") % self.content_type
         end
       end
 
-      distributors = generate_distributors
+      def refresh_pulp_repo(feed_ca, feed_cert, feed_key)
+        self.feed_ca = feed_ca
+        self.feed_cert = feed_cert
+        self.feed_key = feed_key
 
-      Katello.pulp_server.extensions.repository.create_with_importer_and_distributors(self.pulp_id,
-          importer,
-          distributors,
-          {:display_name => self.name})
-    rescue RestClient::ServiceUnavailable => e
-      message = _("Pulp service unavailable during creating repository '%s', please try again later.") % self.name
-      raise PulpErrors::ServiceUnavailable.new(message, e)
-    end
+        Katello.pulp_server.extensions.repository.update_importer(self.pulp_id, self.importers.first['id'], generate_importer.config)
 
-    def generate_importer
-      case self.content_type
-      when Repository::YUM_TYPE
-        Runcible::Models::YumImporter.new(:ssl_ca_cert => self.feed_ca,
-                                          :ssl_client_cert => self.feed_cert,
-                                          :ssl_client_key => self.feed_key,
-                                          :feed => self.feed)
-      when Repository::FILE_TYPE
-        Runcible::Models::IsoImporter.new(:ssl_ca_cert => self.feed_ca,
-                                          :ssl_client_cert => self.feed_cert,
-                                          :ssl_client_key => self.feed_key,
-                                          :feed => self.feed)
-      when Repository::PUPPET_TYPE
-        Runcible::Models::PuppetImporter.new(:feed => self.feed)
-      else
-        fail _("Unexpected repo type %s") % self.content_type
+        existing_distributors = self.distributors
+        generate_distributors.each do |distributor|
+          found = existing_distributors.select { |i| i['distributor_type_id'] == distributor.type_id }.first
+          if found
+            Katello.pulp_server.extensions.repository.update_distributor(self.pulp_id, found['id'], distributor.config)
+          else
+            Katello.pulp_server.extensions.repository.associate_distributor(self.pulp_id, distributor.type_id, distributor.config,
+                                                                   :distributor_id => distributor.id)
+          end
+        end
       end
-    end
 
-    def generate_distributors
-      case self.content_type
-      when Repository::YUM_TYPE
-        yum_dist_id = self.pulp_id
-        yum_dist_options = {:protected => true, :id => yum_dist_id, :auto_publish => true}
-        #check the instance variable, as we do not want to go to pulp
-        yum_dist_options['checksum_type'] = self.checksum_type if self.instance_variable_get('@checksum_type')
-        yum_dist = Runcible::Models::YumDistributor.new(self.relative_path, (self.unprotected || false), true,
-                                                        yum_dist_options)
-        clone_dist = Runcible::Models::YumCloneDistributor.new(:id => "#{self.pulp_id}_clone",
-                                                               :destination_distributor_id => yum_dist_id)
-        [yum_dist, clone_dist, nodes_distributor]
-      when Repository::FILE_TYPE
-        dist = Runcible::Models::IsoDistributor.new(true, true)
-        dist.auto_publish = true
-        [dist]
-      when Repository::PUPPET_TYPE
-        repo_path =  File.join(Katello.config.puppet_repo_root, self.puppet_environment_name, 'modules')
-        puppet_install_dist =
-            Runcible::Models::PuppetInstallDistributor.new(repo_path,
-                                                           {:id => self.pulp_id, :auto_publish => true})
-        [puppet_install_dist, nodes_distributor]
-      else
-        fail _("Unexpected repo type %s") % self.content_type
+      def populate_from(repos_map)
+        found = repos_map[self.pulp_id]
+        prepopulate(found) if found
+        !found.nil?
       end
-    end
 
-    def puppet_environment_name
-      name = ["KT",
-              self.environment.organization.label,
-              self.environment.label,
-              self.content_view.label,
-              self.content_view.id.to_s].reject(&:blank?).join('_')
-      return name.gsub('-', '_')
-    end
+      def generate_applicability
+        task = Katello.pulp_server.extensions.repository.regenerate_applicability_by_ids([self.pulp_id])
+        PulpTaskStatus.using_pulp_task(task)
+      end
 
-    def nodes_distributor
-      Runcible::Models::NodesHttpDistributor.new(:id => "#{self.pulp_id}_nodes", :auto_publish => true)
-    end
+      def other_repos_with_same_product_and_content
+        Repository.where(:content_id => self.content_id).in_product(self.product).pluck(:pulp_id) - [self.pulp_id]
+      end
 
-    def importer_type
-      case self.content_type
-      when Repository::YUM_TYPE
-        Runcible::Models::YumImporter::ID
-      when Repository::FILE_TYPE
-        Runcible::Models::IsoImporter::ID
-      when Repository::PUPPET_TYPE
-        Runcible::Models::PuppetImporter::ID
-      else
-        fail _("Unexpected repo type %s") % self.content_type
+      def other_repos_with_same_content
+        Repository.where(:content_id => self.content_id).pluck(:pulp_id) - [self.pulp_id]
       end
-    end
 
-    def refresh_pulp_repo(feed_ca, feed_cert, feed_key)
-      self.feed_ca = feed_ca
-      self.feed_cert = feed_cert
-      self.feed_key = feed_key
+      def package_ids
+        Katello.pulp_server.extensions.repository.rpm_ids(self.pulp_id)
+      end
 
-      Katello.pulp_server.extensions.repository.update_importer(self.pulp_id, self.importers.first['id'], generate_importer.config)
+      def errata_ids
+        Katello.pulp_server.extensions.repository.errata_ids(self.pulp_id)
+      end
 
-      existing_distributors = self.distributors
-      generate_distributors.each do |distributor|
-        found = existing_distributors.select{ |i| i['distributor_type_id'] == distributor.type_id }.first
-        if found
-          Katello.pulp_server.extensions.repository.update_distributor(self.pulp_id, found['id'], distributor.config)
-        else
-          Katello.pulp_server.extensions.repository.associate_distributor(self.pulp_id, distributor.type_id, distributor.config,
-                                                                 {:distributor_id => distributor.id})
+      def distribution_ids
+        Katello.pulp_server.extensions.repository.distributions(self.pulp_id).collect do |distribution|
+          distribution['_id']
         end
       end
-    end
 
-    def promote(from_env, to_env)
-      if self.is_cloned_in?(to_env)
-        self.clone_contents(self.get_clone(to_env))
-      else
-        clone = self.create_clone(to_env)
-        clone_events = self.clone_contents(clone) #return clone task
-        # TODO: ensure that clone content is indexed
-        #clone.index_packages
-        #clone.index_errata
-        return clone_events
+      def package_group_count
+        content_unit_counts = 0
+        if self.pulp_repo_facts
+          content_unit_counts = self.pulp_repo_facts[:content_unit_counts][:package_group]
+        end
+        content_unit_counts
       end
-    end
 
-    def populate_from(repos_map)
-      found = repos_map[self.pulp_id]
-      prepopulate(found) if found
-      !found.nil?
-    end
-
-    def generate_applicability
-      task = Katello.pulp_server.extensions.repository.regenerate_applicability_by_ids([self.pulp_id])
-      PulpTaskStatus.using_pulp_task(task)
-    end
-
-    def destroy_repo
-      Katello.pulp_server.extensions.repository.delete(self.pulp_id)
-      true
-    end
-
-    def other_repos_with_same_product_and_content
-      Repository.where(:content_id => self.content_id).in_product(self.product).pluck(:pulp_id) - [self.pulp_id]
-    end
+      def puppet_module_count
+        content_unit_counts = 0
+        if self.pulp_repo_facts
+          content_unit_counts = self.pulp_repo_facts[:content_unit_counts][:puppet_module]
+        end
+        content_unit_counts
+      end
 
-    def other_repos_with_same_content
-      Repository.where(:content_id => self.content_id).pluck(:pulp_id) - [self.pulp_id]
-    end
+      # remove errata and groups from this repo
+      # that have no packages
+      def purge_empty_groups_errata
+        package_lists = package_lists_for_publish
+        rpm_names = package_lists[:names]
+        filenames = package_lists[:filenames]
 
-    def destroy_repo_orchestration
-      pre_queue.create(:name => "delete pulp repo : #{self.name}", :priority => 3, :action => [self, :destroy_repo])
-    end
+        # Remove all errata with no packages
+        errata_to_delete = errata.collect do |erratum|
+          erratum.errata_id if filenames.intersection(erratum.package_filenames).empty?
+        end
+        errata_to_delete.compact!
 
-    def package_ids
-      Katello.pulp_server.extensions.repository.rpm_ids(self.pulp_id)
-    end
+        #do the errata remove call
+        unless errata_to_delete.empty?
+          unassociate_by_filter(ContentViewErratumFilter::CONTENT_TYPE,
+                                 "id" => { "$in" => errata_to_delete })
+        end
 
-    # remove errata and groups from this repo
-    # that have no packages
-    def purge_empty_groups_errata
-      package_lists = package_lists_for_publish
-      rpm_names = package_lists[:names]
-      filenames = package_lists[:filenames]
+        # Remove all  package groups with no packages
+        package_groups_to_delete = package_groups.collect do |group|
+          group.package_group_id if rpm_names.intersection(group.package_names).empty?
+        end
+        package_groups_to_delete.compact!
 
-      # Remove all errata with no packages
-      errata_to_delete = errata.collect do |erratum|
-        erratum.errata_id if filenames.intersection(erratum.package_filenames).empty?
+        unless package_groups_to_delete.empty?
+          unassociate_by_filter(ContentViewPackageGroupFilter::CONTENT_TYPE,
+                                 "id" => { "$in" => package_groups_to_delete })
+        end
       end
-      errata_to_delete.compact!
 
-      #do the errata remove call
-      unless errata_to_delete.empty?
-        unassociate_by_filter(FilterRule::ERRATA, {"id" => {"$in" => errata_to_delete}})
-      end
+      def packages
+        #we fetch ids and then fetch packages by id, because repo packages
+        #  does not contain all the info we need (bz 854260)
+        tmp_packages = []
 
-      # Remove all  package groups with no packages
-      package_groups_to_delete = package_groups.collect do |group|
-        group.package_group_id if rpm_names.intersection(group.package_names).empty?
-      end
-      package_groups_to_delete.compact!
+        self.package_ids.each_slice(Katello.config.pulp.bulk_load_size) do |sub_list|
+          tmp_packages.concat(Katello.pulp_server.extensions.rpm.find_all_by_unit_ids(
+                                  sub_list, Katello::Package::PULP_INDEXED_FIELDS))
+        end
+        self.packages = tmp_packages
 
-      unless package_groups_to_delete.empty?
-        unassociate_by_filter(FilterRule::PACKAGE_GROUP, {"id" => {"$in" => package_groups_to_delete}})
+        @repo_packages
       end
-    end
 
-    def packages
-      #we fetch ids and then fetch packages by id, because repo packages
-      #  does not contain all the info we need (bz 854260)
-      tmp_packages = []
-      package_fields = %w(name version release arch suffix epoch
-                          download_url checksum checksumtype license group
-                          children vendor filename relativepath description
-                          size buildhost _id _content_type_id _href
-                          _storage_path _type _last_updated)
-
-      self.package_ids.each_slice(Katello.config.pulp.bulk_load_size) do |sub_list|
-        tmp_packages.concat(Katello.pulp_server.extensions.rpm.find_all_by_unit_ids(sub_list, package_fields))
+      def packages=(attrs)
+        @repo_packages = attrs.collect do |package|
+          Katello::Package.new(package)
+        end
+        @repo_packages
       end
-      self.packages = tmp_packages
 
-      @repo_packages
-    end
+      def index_db_errata(force = false)
+        if self.content_view.default? || force
+          errata_json.each do |erratum_json|
+            erratum = Erratum.find_or_create_by_uuid(:uuid => erratum_json['_id'])
+            erratum.update_from_json(erratum_json)
+          end
+        end
 
-    def packages=(attrs)
-      @repo_packages = attrs.collect do |package|
-        Katello::Package.new(package)
+        Katello::Erratum.sync_repository_associations(self, errata_ids)
       end
-      @repo_packages
-    end
 
-    def errata
-      if @repo_errata.nil?
+      def errata_json
+        tmp_errata = []
         #we fetch ids and then fetch errata by id, because repo errata
         #  do not contain all the info we need (bz 854260)
-        e_ids = Katello.pulp_server.extensions.repository.errata_ids(self.pulp_id)
-        tmp_errata = []
-        e_ids.each_slice(Katello.config.pulp.bulk_load_size) do |sub_list|
+        self.errata_ids.each_slice(Katello.config.pulp.bulk_load_size) do |sub_list|
           tmp_errata.concat(Katello.pulp_server.extensions.errata.find_all_by_unit_ids(sub_list))
         end
-        self.errata = tmp_errata
+        tmp_errata
       end
-      @repo_errata
-    end
 
-    def errata=(attrs)
-      @repo_errata = attrs.collect do |erratum|
-        Katello::Errata.new(erratum)
-      end
-      @repo_errata
-    end
+      def index_db_docker_images
+        docker_tags.destroy_all
 
-    def distributions
-      if @repo_distributions.nil?
-        self.distributions = Katello.pulp_server.extensions.repository.distributions(self.pulp_id)
-      end
-      @repo_distributions
-    end
+        docker_images_json.each do |image_json|
+          image = DockerImage.find_or_create_by_uuid(image_json[:_id])
+          image.update_from_json(image_json)
+          create_docker_tags(image, image_json[:tags])
+        end
 
-    def distributions=(attrs)
-      @repo_distributions = attrs.collect do |dist|
-        Katello::Distribution.new(dist)
+        DockerImage.sync_repository_associations(self, docker_image_ids)
       end
-      @repo_distributions
-    end
 
-    def package_groups
-      if @repo_package_groups.nil?
-        groups = Katello.pulp_server.extensions.repository.package_groups(self.pulp_id)
-        self.package_groups = groups
-      end
-      @repo_package_groups
-    end
+      def docker_images_json
+        docker_images = []
 
-    def package_groups=(attrs)
-      @repo_package_groups = attrs.collect do |group|
-        Katello::PackageGroup.new(group)
-      end
-      @repo_package_groups
-    end
+        # retrieve the docker image tags
+        repo_attrs = Katello.pulp_server.extensions.repository.retrieve_with_details(pulp_id)
+        tags = repo_attrs.try(:[], :scratchpad).try(:[], :tags) || []
 
-    def package_groups_search(search_args = {})
-      groups = package_groups
-      unless search_args.empty?
-        groups.delete_if do |group|
-          group_attrs = group.as_json
-          search_args.any?{ |attr, value| group_attrs[attr] != value }
+        docker_image_ids.each_slice(Katello.config.pulp.bulk_load_size) do |sub_list|
+          docker_images.concat(Katello.pulp_server.extensions.docker_image.find_all_by_unit_ids(sub_list))
         end
+        # add the docker tags in
+        docker_images.each do |attrs|
+          attrs[:tags] = tags.select { |tag| tag[:image_id] == attrs[:image_id] }.map { |tag| tag[:tag] }
+        end
+
+        docker_images
       end
-      groups
-    end
 
-    def package_group_categories(search_args = {})
-      categories = Katello.pulp_server.extensions.repository.package_categories(self.pulp_id)
-      unless search_args.empty?
-        categories.delete_if do |category_attrs|
-          search_args.any?{ |attr, value| category_attrs[attr] != value }
+      def create_docker_tags(image, tags)
+        return if tags.empty?
+
+        tags.each do |tag|
+          DockerTag.find_or_create_by_repository_id_and_docker_image_id_and_name!(id, image.id, tag)
         end
       end
-      categories
-    end
 
-    def puppet_modules
-      if @repo_puppet_modules.nil?
-        # we fetch ids and then fetch modules by id, because repo puppet modules
-        #  do not contain all the info we need
-        ids = Katello.pulp_server.extensions.repository.puppet_module_ids(self.pulp_id)
-        tmp_modules = []
-        ids.each_slice(Katello.config.pulp.bulk_load_size) do |sub_list|
-          tmp_modules.concat(Katello.pulp_server.extensions.puppet_module.find_all_by_unit_ids(sub_list))
+      def distributions
+        if @repo_distributions.nil?
+          # we fetch ids and then fetch distributions by id, because repo distributions do not contain
+          # all the info needed, e.g. repoids
+          tmp_distributions = []
+          self.distribution_ids.each_slice(Katello.config.pulp.bulk_load_size) do |sub_list|
+            tmp_distributions.concat(Katello.pulp_server.extensions.distribution.find_all_by_unit_ids(sub_list))
+          end
+          self.distributions = tmp_distributions
         end
-        self.puppet_modules = tmp_modules
+        @repo_distributions
       end
-      @repo_puppet_modules
-    end
 
-    def puppet_modules=(attrs)
-      @repo_puppet_modules = attrs.collect do |puppet_module|
-        Katello::PuppetModule.new(puppet_module)
+      def distributions=(attrs)
+        @repo_distributions = attrs.collect do |dist|
+          Katello::Distribution.new(dist)
+        end
+        @repo_distributions
       end
-      @repo_puppet_modules
-    end
 
-    def has_distribution?(id)
-      self.distributions.each do |distro|
-        return true if distro.id == id
+      def bootable_distribution
+        return unless self.unprotected
+        self.distributions.find { |distribution| distribution.bootable? }
       end
-      return false
-    end
 
-    def set_sync_schedule(date_and_time)
-      if date_and_time
-        Katello.pulp_server.extensions.repository.create_or_update_schedule(self.pulp_id, importer_type, date_and_time)
-      else
-        Katello.pulp_server.extensions.repository.remove_schedules(self.pulp_id, importer_type)
+      def package_groups
+        if @repo_package_groups.nil?
+          groups = Katello.pulp_server.extensions.repository.package_groups(self.pulp_id)
+          self.package_groups = groups
+        end
+        @repo_package_groups
       end
-    end
-
-    def has_package?(id)
-      self.package_ids.include?(id)
-    end
 
-    def find_packages_by_name(name)
-      Katello.pulp_server.extensions.repository.rpms_by_nvre self.pulp_id, name
-    end
-
-    def find_packages_by_nvre(name, version, release, epoch)
-      Katello.pulp_server.extensions.repository.rpms_by_nvre self.pulp_id, name, version, release, epoch
-    end
-
-    def find_latest_packages_by_name(name)
-      packages = Katello.pulp_server.extensions.repository.rpms_by_nvre(self.pulp_id, name)
-      Util::Package.find_latest_packages(packages)
-    end
+      def package_groups=(attrs)
+        @repo_package_groups = attrs.collect do |group|
+          Katello::PackageGroup.new(group)
+        end
+        @repo_package_groups
+      end
 
-    def has_erratum?(errata_id)
-      self.errata.each do |err|
-        return true if err.errata_id == errata_id
+      def package_groups_search(search_args = {})
+        groups = package_groups
+        unless search_args.empty?
+          groups.delete_if do |group|
+            group_attrs = group.as_json
+            search_args.any? { |attr, value| group_attrs[attr] != value }
+          end
+        end
+        groups
       end
-      return false
-    end
 
-    def sync(options = {})
-      sync_options = {}
-      sync_options[:max_speed] ||= Katello.config.pulp.sync_KBlimit if Katello.config.pulp.sync_KBlimit # set bandwidth limit
-      sync_options[:num_threads] ||= Katello.config.pulp.sync_threads if Katello.config.pulp.sync_threads # set threads per sync
-      pulp_tasks = Katello.pulp_server.extensions.repository.sync(self.pulp_id, {:override_config => sync_options})
-      pulp_task = pulp_tasks.select{ |i| i['tags'].include?("pulp:action:sync") }.first.with_indifferent_access
+      def package_group_categories(search_args = {})
+        categories = Katello.pulp_server.extensions.repository.package_categories(self.pulp_id)
+        unless search_args.empty?
+          categories.delete_if do |category_attrs|
+            search_args.any? { |attr, value| category_attrs[attr] != value }
+          end
+        end
+        categories
+      end
 
-      task = PulpSyncStatus.using_pulp_task(pulp_task) do |t|
-        t.organization = self.environment.organization
-        t.parameters ||= {}
-        t.parameters[:options] = options
+      def puppet_module_ids
+        Katello.pulp_server.extensions.repository.puppet_module_ids(self.pulp_id)
       end
-      task.save!
-      return [task]
-    end
 
-    def handle_sync_complete_task(pulp_task_id, notifier_service = Notify)
-      pulp_task =  Katello.pulp_server.resources.task.poll(pulp_task_id)
+      def puppet_modules
+        if @repo_puppet_modules.nil?
+          # we fetch ids and then fetch modules by id, because repo puppet modules
+          #  do not contain all the info we need
+          ids = puppet_module_ids
+          tmp_modules = []
+          ids.each_slice(Katello.config.pulp.bulk_load_size) do |sub_list|
+            tmp_modules.concat(Katello.pulp_server.extensions.puppet_module.find_all_by_unit_ids(sub_list))
+          end
+          self.puppet_modules = tmp_modules
+        end
+        @repo_puppet_modules
+      end
 
-      if pulp_task.nil?
-        Rails.logger.error("Sync_complete called for #{pulp_task_id}, but no task found.")
-        return
+      def puppet_modules=(attrs)
+        @repo_puppet_modules = attrs.collect do |puppet_module|
+          Katello::PuppetModule.new(puppet_module)
+        end
+        @repo_puppet_modules
       end
 
-      task = PulpTaskStatus.using_pulp_task(pulp_task)
-      task.user ||= User.current
-      task.organization ||= self.environment.organization
-      task.save!
+      def docker_image_ids
+        Katello.pulp_server.extensions.repository.docker_image_ids(self.pulp_id)
+      end
 
-      notify = task.parameters.try(:[], :options).try(:[], :notify)
-      user = task.user
-      if task.state == TaskStatus::Status::FINISHED.to_s && task.progress.error_details[:messages].blank?
-        if user && notify
-          notifier_service.success _("Repository '%s' finished syncing successfully.") % [self.name],
-                         :user => user, :organization => self.organization
-        end
-      else
-        details = []
+      def docker_image_count
+        self.docker_images.count
+      end
 
-        if task.progress.error_details.present?
-          details = task.progress.error_details[:details].map do |error|
-            error[:error_message].to_s
-          end
-        else
-          details = task.result[:errors].flatten.map(&:chomp)
+      def docker_image_tag_hash
+        docker_tags.map do |tag|
+          {:tag => tag.name, :image_id => tag.docker_image.image_id}
         end
+      end
 
-        details = details.join("\n")
-
-        Rails.logger.error("*** Sync error: " +  details)
-        if user && notify
-          notifier_service.error _("There were errors syncing repository '%s'. See notices page for more details.") % self.name,
-                       :details => details, :user => user, :organization => self.organization
+      def distribution?(id)
+        self.distributions.each do |distro|
+          return true if distro.id == id
         end
+        return false
       end
-    end
 
-    def clone_contents_by_filter(to_repo, content_type, filter_clauses, override_config = {})
-      content_classes = {
-          Package::CONTENT_TYPE => :rpm,
-          PackageGroup::CONTENT_TYPE => :package_group,
-          Errata::CONTENT_TYPE => :errata,
-          PuppetModule::CONTENT_TYPE => :puppet_module
-      }
-      fail "Invalid content type #{content_type} sent. It needs to be one of #{content_classes.keys}"\
-                                                                     unless content_classes[content_type]
-      criteria = {}
-      if content_type == Runcible::Extensions::Rpm.content_type
-        criteria[:fields] = Package::PULP_SELECT_FIELDS
-      end
-
-      if filter_clauses && !filter_clauses.empty?
-        if content_type == Runcible::Extensions::PuppetModule.content_type
-          criteria[:filters] = {:association => filter_clauses}
+      def sync_schedule(date_and_time)
+        if date_and_time
+          Katello.pulp_server.extensions.repository.create_or_update_schedule(self.pulp_id, importer_type, date_and_time)
         else
-          criteria[:filters] = {:unit => filter_clauses}
+          Katello.pulp_server.extensions.repository.remove_schedules(self.pulp_id, importer_type)
         end
       end
-      criteria[:override_config] = override_config unless override_config.empty?
-      Katello.pulp_server.extensions.send(content_classes[content_type]).copy(self.pulp_id, to_repo.pulp_id, criteria)
-    end
-
-    def clone_contents(to_repo)
-      events = []
 
-      if self.content_type == Repository::PUPPET_TYPE
-        events << Katello.pulp_server.extensions.puppet_module.copy(self.pulp_id, to_repo.pulp_id)
-      else
-        # 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).
-        events << Katello.pulp_server.extensions.rpm.copy(self.pulp_id, to_repo.pulp_id,
-                                                 { :fields => Package::PULP_SELECT_FIELDS })
-        events << clone_distribution(to_repo)
-
-        # 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.
-        events << Katello.pulp_server.extensions.errata.copy(self.pulp_id, to_repo.pulp_id, { :copy_children => false })
-        events << Katello.pulp_server.extensions.package_group.copy(self.pulp_id, to_repo.pulp_id, { :copy_children => false })
-        events << clone_file_metadata(to_repo)
-      end
-
-      events
-    end
-
-    def clone_file_metadata(to_repo)
-      Katello.pulp_server.extensions.yum_repo_metadata_file.copy(self.pulp_id, to_repo.pulp_id)
-    end
+      def package?(id)
+        self.package_ids.include?(id)
+      end
 
-    def clone_distribution(to_repo)
-      Katello.pulp_server.extensions.distribution.copy(self.pulp_id, to_repo.pulp_id)
-    end
+      def find_packages_by_name(name)
+        Katello.pulp_server.extensions.repository.rpms_by_nvre self.pulp_id, name
+      end
 
-    def unassociate_by_filter(content_type, filter_clauses)
+      def find_packages_by_nvre(name, version, release, epoch)
+        Katello.pulp_server.extensions.repository.rpms_by_nvre self.pulp_id, name, version, release, epoch
+      end
 
-      criteria = {:type_ids => [content_type], :filters => {:unit => filter_clauses}}
-      if content_type == Katello.pulp_server.extensions.rpm.content_type
-        criteria[:fields] = { :unit => Package::PULP_SELECT_FIELDS}
+      def find_latest_packages_by_name(name)
+        packages = Katello.pulp_server.extensions.repository.rpms_by_nvre(self.pulp_id, name)
+        Util::Package.find_latest_packages(packages)
       end
-      Katello.pulp_server.extensions.repository.unassociate_units(self.pulp_id, criteria)
-    end
 
-    def clear_contents
-      self.clear_content_indices if Katello.config.use_elasticsearch
-      tasks = content_types.collect { |type| type.unassociate_from_repo(self.pulp_id, {}) }.flatten(1)
+      def pulp_update_needed?
+        unless redhat?
+          allowed_changes = %w(url unprotected checksum_type docker_upstream_name)
+          allowed_changes << "name" if docker?
+          allowed_changes.any? { |key| previous_changes.key?(key) }
+        end
+      end
 
-      tasks << Katello.pulp_server.extensions.repository.unassociate_units(self.pulp_id,
-                 {:type_ids => ['rpm'], :filters => {}, :fields => { :unit => Package::PULP_SELECT_FIELDS}})
-      tasks
-    end
+      def sync(options = {})
+        sync_options = {}
+        sync_options[:max_speed] ||= Katello.config.pulp.sync_KBlimit if Katello.config.pulp.sync_KBlimit # set bandwidth limit
+        sync_options[:num_threads] ||= Katello.config.pulp.sync_threads if Katello.config.pulp.sync_threads # set threads per sync
+        pulp_tasks = Katello.pulp_server.extensions.repository.sync(self.pulp_id, :override_config => sync_options)
 
-    def content_types
-      [Katello.pulp_server.extensions.errata,
-       Katello.pulp_server.extensions.package_group,
-       Katello.pulp_server.extensions.distribution,
-       Katello.pulp_server.extensions.puppet_module
-      ]
-    end
+        task = PulpSyncStatus.using_pulp_task(pulp_tasks) do |t|
+          t.organization = organization
+          t.parameters ||= {}
+          t.parameters[:options] = options
+        end
+        task.save!
+        return [task]
+      end
+
+      def clone_contents_by_filter(to_repo, content_type, filter_clauses, override_config = {})
+        content_classes = {
+          Katello::Package::CONTENT_TYPE => :rpm,
+          Katello::PackageGroup::CONTENT_TYPE => :package_group,
+          Katello::Erratum::CONTENT_TYPE => :errata,
+          Katello::PuppetModule::CONTENT_TYPE => :puppet_module
+        }
+        fail "Invalid content type #{content_type} sent. It needs to be one of #{content_classes.keys}"\
+                                                                       unless content_classes[content_type]
+        criteria = {}
+        if content_type == Runcible::Extensions::Rpm.content_type
+          criteria[:fields] = Package::PULP_SELECT_FIELDS
+        end
 
-    def sync_start
-      status = self.sync_status
-      retval = nil
-      if status.nil? || status['progress']['start_time'].nil?
-        retval = nil
-      else
-        retval = status['progress']['start_time']
-        # retval = date.strftime("%H:%M:%S %Y-%m-%d")
+        if filter_clauses && !filter_clauses.empty?
+          if content_type == Runcible::Extensions::PuppetModule.content_type
+            criteria[:filters] = {:association => filter_clauses}
+          else
+            criteria[:filters] = {:unit => filter_clauses}
+          end
+        end
+        criteria[:override_config] = override_config unless override_config.empty?
+        Katello.pulp_server.extensions.send(content_classes[content_type]).copy(self.pulp_id, to_repo.pulp_id, criteria)
       end
-      retval
-    end
 
-    def add_packages(pkg_id_list)
-      previous = self.environmental_instances(self.content_view).in_environment(self.environment.prior).first
-      Katello.pulp_server.extensions.rpm.copy(previous.pulp_id, self.pulp_id, {:ids => pkg_id_list})
-    end
+      def clone_contents(to_repo)
+        events = []
 
-    def add_errata(errata_unit_id_list)
-      previous = self.environmental_instances(self.content_view).in_environment(self.environment.prior).first
-      Katello.pulp_server.extensions.errata.copy(previous.pulp_id, self.pulp_id, {:ids => errata_unit_id_list})
-    end
+        if self.content_type == Repository::PUPPET_TYPE
+          events << Katello.pulp_server.extensions.puppet_module.copy(self.pulp_id, to_repo.pulp_id)
+        else
+          # 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).
+          events << Katello.pulp_server.extensions.rpm.copy(self.pulp_id, to_repo.pulp_id,
+                                                    :fields => Package::PULP_SELECT_FIELDS)
+          events << clone_distribution(to_repo)
+
+          # 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.
+          events << Katello.pulp_server.extensions.errata.copy(self.pulp_id, to_repo.pulp_id,  :copy_children => false)
+          events << Katello.pulp_server.extensions.package_group.copy(self.pulp_id, to_repo.pulp_id,  :copy_children => false)
+          events << clone_file_metadata(to_repo)
+        end
 
-    def add_distribution(distribution_id)
-      previous = self.environmental_instances(self.content_view).in_environment(self.environment.prior).first
-      Katello.pulp_server.extensions.distribution.copy(previous.pulp_id, self.pulp_id, {:ids => [distribution_id]})
-    end
+        events
+      end
 
-    def delete_packages(package_id_list)
-      Katello.pulp_server.extensions.rpm.unassociate_unit_ids_from_repo(self.pulp_id, package_id_list)
-    end
+      def clone_file_metadata(to_repo)
+        Katello.pulp_server.extensions.yum_repo_metadata_file.copy(self.pulp_id, to_repo.pulp_id)
+      end
 
-    def delete_errata(errata_id_list)
-      Katello.pulp_server.extensions.errata.unassociate_unit_ids_from_repo(self.pulp_id, errata_id_list)
-    end
+      def clone_distribution(to_repo)
+        Katello.pulp_server.extensions.distribution.copy(self.pulp_id, to_repo.pulp_id)
+      end
 
-    def delete_distribution(distribution_id)
-      Katello.pulp_server.extensions.distribution.unassociate_unit_ids_from_repo(self.pulp_id, [distribution_id])
-    end
+      def unassociate_by_filter(content_type, filter_clauses)
+        criteria = {:type_ids => [content_type], :filters => {:unit => filter_clauses}}
+        if content_type == Katello.pulp_server.extensions.rpm.content_type
+          criteria[:fields] = { :unit => Package::PULP_SELECT_FIELDS}
+        end
+        Katello.pulp_server.extensions.repository.unassociate_units(self.pulp_id, criteria)
+      end
 
-    def cancel_sync
-      Rails.logger.info "Cancelling synchronization of repository #{self.pulp_id}"
-      history = self.sync_status
-      return if history.nil? || !history.pending?
-      Katello.pulp_server.resources.task.cancel(history.uuid)
-    end
+      def clear_contents
+        self.clear_content_indices if Katello.config.use_elasticsearch
+        tasks = content_types.collect { |type| type.unassociate_from_repo(self.pulp_id, {}) }.flatten(1)
 
-    def sync_finish
-      status = self.sync_status
-      retval = nil
-      if status.nil? || status['progress']['finish_time'].nil?
-        retval = nil
-      else
-        retval = status['progress']['finish_time']
+        tasks << Katello.pulp_server.extensions.repository.unassociate_units(self.pulp_id,
+                   :type_ids => ['rpm'], :filters => {}, :fields => { :unit => Package::PULP_SELECT_FIELDS})
+        tasks
       end
-      retval
-    end
-
-    def sync_status
-      self._get_most_recent_sync_status if @sync_status.nil?
-    end
 
-    def sync_state
-      status = sync_status
-      return PulpSyncStatus::Status::NOT_SYNCED if status.nil?
-      status.state
-    end
+      def content_types
+        [Katello.pulp_server.extensions.errata,
+         Katello.pulp_server.extensions.package_group,
+         Katello.pulp_server.extensions.distribution,
+         Katello.pulp_server.extensions.puppet_module
+        ]
+      end
 
-    def synced?
-      sync_history = self.sync_status
-      !sync_history.nil? && successful_sync?(sync_history)
-    end
+      def sync_start
+        status = self.sync_status
+        retval = nil
+        if status.nil? || status['progress']['start_time'].nil?
+          retval = nil
+        else
+          retval = status['progress']['start_time']
+          # retval = date.strftime("%H:%M:%S %Y-%m-%d")
+        end
+        retval
+      end
 
-    def successful_sync?(sync_history_item)
-      sync_history_item['state'] == PulpTaskStatus::Status::FINISHED.to_s
-    end
+      def cancel_sync
+        Rails.logger.info "Cancelling synchronization of repository #{self.pulp_id}"
+        history = self.sync_status
+        return if history.nil? || !history.pending?
+        Katello.pulp_server.resources.task.cancel(history.uuid)
+      end
 
-    def generate_metadata(force = false)
-      tasks = []
-      clone = self.content_view_version.repositories.where(:library_instance_id => self.library_instance_id).where("id != #{self.id}").first
-      if self.environment.library? || force || clone.nil?
-        tasks << self.publish_distributor
-      else
-        tasks << self.publish_clone_distributor(clone)
+      def sync_finish
+        status = self.sync_status
+        retval = nil
+        if status.nil? || status['progress']['finish_time'].nil?
+          retval = nil
+        else
+          retval = status['progress']['finish_time']
+        end
+        retval
       end
-      tasks << self.publish_node_distributor if self.find_node_distributor
-      tasks
-    end
 
-    def publish_distributor
-      dist = find_distributor
-      Katello.pulp_server.extensions.repository.publish(self.pulp_id, dist['id'])
-    end
+      def sync_status
+        self._get_most_recent_sync_status if @sync_status.nil?
+      end
 
-    def publish_node_distributor
-      dist = self.find_node_distributor
-      Katello.pulp_server.extensions.repository.publish(self.pulp_id, dist['id'])
-    end
+      def sync_state
+        status = sync_status
+        return PulpSyncStatus::Status::NOT_SYNCED if status.nil?
+        status.state
+      end
 
-    def publish_clone_distributor(source_repo)
-      dist = find_distributor(true)
-      source_dist = source_repo.find_distributor
+      def synced?
+        sync_history = self.sync_status
+        !sync_history.nil? && successful_sync?(sync_history)
+      end
 
-      fail "Could not find #{self.content_type} clone distributor for #{self.pulp_id}" if dist.nil?
-      fail "Could not find #{self.content_type} distributor for #{source_repo.pulp_id}" if source_dist.nil?
-      Katello.pulp_server.extensions.repository.publish(self.pulp_id, dist['id'],
-                               :override_config => {:source_repo_id => source_repo.pulp_id,
-                                                    :source_distributor_id => source_dist['id']})
-    end
+      def successful_sync?(sync_history_item)
+        sync_history_item['state'] == PulpTaskStatus::Status::FINISHED.to_s
+      end
 
-    def find_distributor(use_clone_distributor = false)
-      dist_type_id = if use_clone_distributor
-                       case self.content_type
-                       when Repository::YUM_TYPE
-                         Runcible::Models::YumCloneDistributor.type_id
-                       when Repository::PUPPET_TYPE
-                         Runcible::Models::PuppetInstallDistributor.type_id
+      def find_distributor(use_clone_distributor = false)
+        dist_type_id = if use_clone_distributor
+                         case self.content_type
+                         when Repository::YUM_TYPE
+                           Runcible::Models::YumCloneDistributor.type_id
+                         when Repository::PUPPET_TYPE
+                           Runcible::Models::PuppetInstallDistributor.type_id
+                         end
+                       else
+                         case self.content_type
+                         when Repository::YUM_TYPE
+                           Runcible::Models::YumDistributor.type_id
+                         when Repository::PUPPET_TYPE
+                           Runcible::Models::PuppetInstallDistributor.type_id
+                         end
                        end
-                     else
-                       case self.content_type
-                       when Repository::YUM_TYPE
-                         Runcible::Models::YumDistributor.type_id
-                       when Repository::PUPPET_TYPE
-                         Runcible::Models::PuppetInstallDistributor.type_id
-                       end
-                     end
 
-      distributors.detect { |dist| dist["distributor_type_id"] == dist_type_id }
-    end
-
-    def find_node_distributor
-      self.distributors.detect{|i| i["distributor_type_id"] == Runcible::Models::NodesHttpDistributor.type_id}
-    end
-
-    def sort_sync_status(statuses)
-      statuses.sort! do |a, b|
-        if a['finish_time'].nil? && b['finish_time'].nil?
-          if a['start_time'].nil?
-            1
-          elsif b['start_time'].nil?
-            -1
-          else
-            a['start_time'] <=> b['start_time']
-          end
-        elsif a['finish_time'].nil?
-          if a['start_time'].nil?
-            1
-          else
-            -1
-          end
-        elsif b['finish_time'].nil?
-          if b['start_time'].nil?
-            -1
+        distributors.detect { |dist| dist["distributor_type_id"] == dist_type_id }
+      end
+
+      def find_node_distributor
+        self.distributors.detect { |i| i["distributor_type_id"] == Runcible::Models::NodesHttpDistributor.type_id }
+      end
+
+      def sort_sync_status(statuses)
+        statuses.sort! do |a, b|
+          if a['finish_time'].nil? && b['finish_time'].nil?
+            if a['start_time'].nil?
+              1
+            elsif b['start_time'].nil?
+              -1
+            else
+              a['start_time'] <=> b['start_time']
+            end
+          elsif a['finish_time'].nil?
+            if a['start_time'].nil?
+              1
+            else
+              -1
+            end
+          elsif b['finish_time'].nil?
+            if b['start_time'].nil?
+              -1
+            else
+              1
+            end
           else
-            1
+            b['finish_time'] <=> a['finish_time']
           end
-        else
-          b['finish_time'] <=> a['finish_time']
         end
+        return statuses
       end
-      return statuses
-    end
-
-    def upload_content(filepath)
-      case content_type
-      when "puppet"
-        unit_key, unit_metadata = Katello::PuppetModule.generate_unit_data(filepath)
-      else
-        fail _("Uploads not supported for content type '%s'.") % content_type
-      end
-
-      upload_id = Katello.pulp_server.resources.content.create_upload_request["upload_id"]
 
-      File.open(filepath, "rb") do |file|
-        offset = 0
-        while (chunk = file.read(Katello.config.pulp.upload_chunk_size))
-          Katello.pulp_server.resources.content.upload_bits(upload_id, offset, chunk)
-          offset += Katello.config.pulp.upload_chunk_size
+      def unit_type_id
+        case content_type
+        when Repository::YUM_TYPE
+          "rpm"
+        when Repository::PUPPET_TYPE
+          "puppet_module"
+        when Repository::DOCKER_TYPE
+          "docker_image"
         end
       end
 
-      Katello.pulp_server.resources.content.import_into_repo(self.pulp_id, unit_type_id,
-                                                             upload_id, unit_key,
-                                                             {:unit_metadata => unit_metadata}
-                                                            )
+      def unit_search(options = {})
+        Katello.pulp_server.extensions.repository.unit_search(self.pulp_id, options)
+      end
 
-      Katello.pulp_server.resources.content.delete_upload_request(upload_id)
-      self.trigger_contents_changed(:index_units => [unit_key], :wait => false, :reindex => false)
-    end
+      # A helper method used by purge_empty_groups_errata
+      # to obtain a list of package filenames and names
+      # so that it could mix/match empty package groups
+      # and errata and purge them.
+      def package_lists_for_publish
+        names = []
+        filenames = []
+        rpms = []
+        self.package_ids.each_slice(Katello.config.pulp.bulk_load_size) do |sub_list|
+          rpms.concat(Katello.pulp_server.extensions.rpm.find_all_by_unit_ids(
+                                  sub_list, %w(filename name)))
+        end
 
-    def unit_type_id
-      case content_type
-      when Repository::YUM_TYPE
-        "rpm"
-      when Repository::PUPPET_TYPE
-        "puppet_module"
+        rpms.each do |rpm|
+          filenames << rpm["filename"]
+          names << rpm["name"]
+        end
+        {:names => names.to_set,
+         :filenames => filenames.to_set}
       end
-    end
-
-    def unit_search(options = {})
-      Katello.pulp_server.extensions.repository.unit_search(self.pulp_id, options)
-    end
 
-    protected
+      protected
 
-    def _get_most_recent_sync_status
-      begin
-        history = Katello.pulp_server.extensions.repository.sync_status(pulp_id)
+      def _get_most_recent_sync_status
+        begin
+          history = Katello.pulp_server.extensions.repository.sync_status(pulp_id)
 
-        if history.nil? || history.empty?
+          if history.nil? || history.empty?
+            history = PulpSyncStatus.convert_history(Katello.pulp_server.extensions.repository.sync_history(pulp_id))
+          end
+        rescue
           history = PulpSyncStatus.convert_history(Katello.pulp_server.extensions.repository.sync_history(pulp_id))
         end
-      rescue
-          history = PulpSyncStatus.convert_history(Katello.pulp_server.extensions.repository.sync_history(pulp_id))
-      end
 
-      if history.nil? || history.empty?
-        return PulpSyncStatus.new(:state => PulpSyncStatus::Status::NOT_SYNCED)
-      else
-        history = sort_sync_status(history)
-        return PulpSyncStatus.pulp_task(history.first.with_indifferent_access)
+        if history.nil? || history.empty?
+          return PulpSyncStatus.new(:state => PulpSyncStatus::Status::NOT_SYNCED)
+        else
+          history = sort_sync_status(history)
+          return PulpSyncStatus.pulp_task(history.first.with_indifferent_access)
+        end
       end
     end
 
-    # A helper method used by purge_empty_groups_errata
-    # to obtain a list of package filenames and names
-    # so that it could mix/match empty package groups
-    # and errata and purge them.
-    def package_lists_for_publish
-      names = []
-      filenames = []
-
-      rpms = Katello.pulp_server.extensions.repository.unit_search(self.pulp_id,
-                                                                   :type_ids => ['rpm'],
-                                                                   :fields => {:unit => %w(filename name)})
-
-      rpms.each do |rpm|
-        filenames << rpm["metadata"]["filename"]
-        names << rpm["metadata"]["name"]
+    def full_path(smart_proxy = nil)
+      pulp_uri = URI.parse(smart_proxy ? smart_proxy.url : Katello.config.pulp.url)
+      scheme   = (self.unprotected ? 'http' : 'https')
+      if docker?
+        "#{pulp_uri.host.downcase}:5000/#{relative_path}"
+      else
+        "#{scheme}://#{pulp_uri.host.downcase}/pulp/repos/#{relative_path}"
       end
-      {:names => names.to_set,
-       :filenames => filenames.to_set}
     end
-
   end
-
-  def full_path
-    pulp_uri = URI.parse(Katello.config.pulp.url)
-    scheme   = (self.unprotected ? 'http' : 'https')
-    "#{scheme}://#{pulp_uri.host.downcase}/pulp/repos/#{relative_path}"
-  end
-end
 end