katello 4.14.1 → 4.15.0.rc2

data/app/lib/actions/katello/content_view/remove.rb

@@ -119,11 +119,13 @@ module Actions
           end
           all_cv_envs = combined_cv_envs(cv_envs, versions)
 
-          if all_cv_envs.flat_map(&:hosts).any? && system_cve(options).nil?
+          if all_cv_envs.flat_map(&:hosts).any? && !cve_exists?(options[:system_environment_id],
+                                                                options[:system_content_view_id])
             fail _("Unable to reassign systems. Please check system_content_view_id and system_environment_id.")
           end
 
-          if all_cv_envs.flat_map(&:activation_keys).any? && activation_key_cve(options).nil?
+          if all_cv_envs.flat_map(&:activation_keys).any? && !cve_exists?(options[:key_environment_id],
+                                                                          options[:key_content_view_id])
             fail _("Unable to reassign activation_keys. Please check activation_key_content_view_id and activation_key_environment_id.")
           end
         end
@@ -132,16 +134,10 @@ module Actions
           (cv_envs + versions.flat_map(&:content_view_environments)).uniq
         end
 
-        def system_cve(options)
-          ::Katello::ContentViewEnvironment.where(:environment_id => options[:system_environment_id],
-                                                  :content_view_id => options[:system_content_view_id]
-                                                 ).first
-        end
-
-        def activation_key_cve(options)
-          ::Katello::ContentViewEnvironment.where(:environment_id => options[:key_environment_id],
-                                                  :content_view_id => options[:key_content_view_id]
-                                                 ).first
+        def cve_exists?(environment_id, content_view_id)
+          ::Katello::ContentViewEnvironment.where(:environment_id => environment_id,
+                                                  :content_view_id => content_view_id
+                                                 ).exists?
         end
       end
     end

data/app/lib/actions/katello/content_view_version/import.rb

@@ -40,7 +40,7 @@ module Actions
                             importing: !metadata_map.syncable_format?,
                             syncable: metadata_map.syncable_format?,
                             major: metadata_map.content_view_version.major,
-                            minor: metadata_map.content_view_version.minor
+                            minor: metadata_map.content_view_version.minor,
                           })
               plan_self(content_view_id: import.content_view.id)
             end

data/app/lib/actions/katello/content_view_version/incremental_update.rb

@@ -8,7 +8,7 @@ module Actions
         HUMANIZED_TYPES = {
           ::Katello::Erratum::CONTENT_TYPE => "Errata",
           ::Katello::Rpm::CONTENT_TYPE => "Packages",
-          ::Katello::Deb::CONTENT_TYPE => "Deb Packages"
+          ::Katello::Deb::CONTENT_TYPE => "Deb Packages",
         }.freeze
 
         def humanized_name
@@ -217,7 +217,7 @@ module Actions
           content = { ::Katello::Erratum::CONTENT_TYPE => [],
                       ::Katello::Rpm::CONTENT_TYPE => [],
                       ::Katello::ModuleStream::CONTENT_TYPE => [],
-                      ::Katello::Deb::CONTENT_TYPE => []
+                      ::Katello::Deb::CONTENT_TYPE => [],
                     }
 
           base_repos = ::Katello::ContentViewVersion.find(input[:old_version]).repositories

data/app/lib/actions/katello/flatpak/scan_remote.rb

@@ -0,0 +1,62 @@
+require 'cgi'
+require 'uri'
+module Actions
+  module Katello
+    module Flatpak
+      class ScanRemote < Actions::EntryAction
+        def plan(remote, _args = {})
+          url = format_url(remote.url)
+          plan_self({:remote_id => remote.id, :url => url})
+        end
+
+        def run
+          remote = ::Katello::FlatpakRemote.find(input[:remote_id])
+          url = input[:url]
+          request_params = {
+            method: :get,
+            headers: { accept: :json },
+            url: url,
+          }
+          results = RestClient::Request.execute(request_params)
+          results = JSON.parse(results)
+          repositories = results['Results']
+          repositories.each do |repository|
+            remote_repository = remote.remote_repositories.find_or_initialize_by(name: repository['Name'])
+            remote_repository.label = remote.name + '-' + repository['Name']
+            remote_repository.flatpak_remote = remote
+            remote_repository.save!
+            repository['Images'].each do |image|
+              remote_repository_manifest = remote_repository.manifests.find_or_initialize_by(digest: image['Digest'])
+              remote_repository_manifest.flatpak_remote_repository_id = remote_repository.id
+              remote_repository_manifest.name = image['Labels']['name']
+              remote_repository_manifest.tags = image['Tags']
+              remote_repository_manifest.application = image['Labels']['org.flatpak.ref'].start_with?('app/')
+              remote_repository_manifest.flatpak_ref = image['Labels']['org.flatpak.ref']
+              remote_repository_manifest.runtime = extract_runtime_from_metadata(image['Labels']['org.flatpak.metadata'])
+              remote_repository_manifest.save!
+            end
+          end
+        end
+
+        private
+
+        def extract_runtime_from_metadata(metadata)
+          match = metadata.match(/^runtime=(.*)$/)
+          match ? "runtime/" + match[1] : nil
+        end
+
+        def format_url(url)
+          unless url.ends_with?('/index/static?')
+            url += '/index/static?'
+          end
+          params = [
+            ['tag', 'latest'],
+            ['label:org.flatpak.ref:exists', '1'],
+          ]
+          encoded_params = params.map { |k, v| "#{CGI.escape(k.to_s)}=#{CGI.escape(v.to_s)}" }
+          "#{url}#{encoded_params.sort.join('&')}"
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/katello/host/hypervisors.rb

@@ -29,7 +29,7 @@ module Actions
                 {
                   :name => hypervisor['name'],
                   :uuid => hypervisor['uuid'],
-                  :organization_label => hypervisor['owner']['key']
+                  :organization_label => hypervisor['owner']['key'],
                 }
               end
             end

data/app/lib/actions/katello/product/content_create.rb

@@ -4,51 +4,60 @@ module Actions
       class ContentCreate < Actions::Base
         middleware.use Actions::Middleware::RemoteAction
 
-        def plan(root)
+        def plan(repository)
+          root = repository.root
           sequence do
-            if root.content_id.nil?
+            if repository.content_id.nil? || repository.content_id == 'INITIAL_DUMMY_VALUE'
               content_create = plan_action(Candlepin::Product::ContentCreate,
-                                           owner:         root.product.organization.label,
+                                           repository_id: repository.id,
+                                           owner:         root.organization.label,
                                            name:          root.name,
                                            type:          root.content_type,
                                            arches:        root.format_arches,
                                            label:         root.custom_content_label,
-                                           os_versions:   root.os_versions&.join(','),
-                                           content_url:   root.custom_content_path)
+                                           content_url:   root.custom_content_path,
+                                           os_versions:   root.os_versions&.join(','))
               content_id = content_create.output[:response][:id]
               plan_action(Candlepin::Product::ContentAdd, owner: root.product.organization.label,
                                     product_id: root.product.cp_id,
                                     content_id: content_id)
 
             else
-              content_id = root.content_id
+              content_id = repository.content_id
             end
 
+            plan_self(root_repository_id: root.id, repository_id: repository.id, content_id: content_id)
+
             if root.gpg_key
               plan_action(Candlepin::Product::ContentUpdate,
-                          owner:       root.organization.label,
-                          content_id:  content_id,
-                          name:        root.name,
-                          type:        root.content_type,
-                          arches:      root.format_arches,
-                          label:       root.custom_content_label,
-                          content_url: root.custom_content_path,
-                          gpg_key_url: root.library_instance.yum_gpg_key_url)
+                          repository_id: repository.id,
+                          owner:         root.organization.label,
+                          name:          root.name,
+                          type:          root.content_type,
+                          arches:        root.format_arches,
+                          label:         root.custom_content_label,
+                          content_url:   root.custom_content_path,
+                          gpg_key_url:   root.library_instance.yum_gpg_key_url)
             end
-
-            plan_self(root_repository_id: root.id, content_id: content_id)
           end
         end
 
         def finalize
           root = ::Katello::RootRepository.find(input[:root_repository_id])
-          root.update(:content_id => input[:content_id])
+          content_url = root.custom_content_path
+          if root.deb_using_structured_apt?
+            repository = ::Katello::Repository.find(input[:repository_id])
+            content_url += repository.deb_content_url_options
+            repository.update(:content_id => input[:content_id])
+          else
+            root.update(:content_id => input[:content_id])
+          end
 
-          content = ::Katello::Content.where(organization_id: root.product.organization_id, cp_content_id: root.content_id).first_or_create do |new_content|
+          content = ::Katello::Content.where(organization_id: root.product.organization_id, cp_content_id: input[:content_id]).first_or_create do |new_content|
             new_content.name = root.name
             new_content.content_type = root.content_type
             new_content.label = root.custom_content_label
-            new_content.content_url = root.custom_content_path
+            new_content.content_url = content_url
             new_content.vendor = ::Katello::Provider::CUSTOM
           end
 

data/app/lib/actions/katello/product/content_destroy.rb

@@ -2,22 +2,23 @@ module Actions
   module Katello
     module Product
       class ContentDestroy < Actions::Base
-        def plan(root_repository)
+        def plan(repository)
+          root_repository = repository.root
           fail _("Cannot delete redhat product content") if root_repository.product.redhat?
           sequence do
             plan_action(Candlepin::Product::ContentRemove,
                         owner: root_repository.product.organization.label,
                         product_id: root_repository.product.cp_id,
-                        content_id: root_repository.content_id)
+                        content_id: repository.content_id)
 
-            katello_content_id = root_repository.content&.id
+            katello_content_id = repository.content&.id
             ::Katello::ProductContent.where(product_id: root_repository.product_id,
                                             content_id: katello_content_id).destroy_all
 
-            if root_repository.repositories.count <= 1
+            if root_repository.repositories.count <= 1 || repository.deb_using_structured_apt?
               plan_action(Candlepin::Product::ContentDestroy,
                           owner: root_repository.product.organization.label,
-                          content_id: root_repository.content_id)
+                          content_id: repository.content_id)
 
               ::Katello::Content.find_by_id(katello_content_id)&.destroy!
             end

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

@@ -65,7 +65,7 @@ module Actions
             if repo.root.repositories.where.not(id: repo.id).empty? &&
                 !repo.redhat? &&
                 !skip_environment_update
-              plan_action(::Actions::Katello::Product::ContentDestroy, repo.root)
+              plan_action(::Actions::Katello::Product::ContentDestroy, repo)
             end
           end
         end

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

@@ -25,6 +25,20 @@ module Actions
 
             index_options = {id: new_repository.id, force_index: true}
             index_options[:source_repository_id] = source_repositories.first.id if source_repositories.count == 1 && filters.empty? && rpm_filenames.nil?
+
+            if new_repository.deb_using_structured_apt? && generate_metadata
+              plan_action(Candlepin::Product::ContentUpdate,
+                          owner:           new_repository.organization.label,
+                          repository_id:   new_repository.id,
+                          name:            new_repository.root.name,
+                          type:            new_repository.root.content_type,
+                          arches:          new_repository.root.format_arches,
+                          label:           new_repository.root.custom_content_label,
+                          content_url:     new_repository.root.custom_content_path,
+                          gpg_key_url:     new_repository.yum_gpg_key_url,
+                          metadata_expire: new_repository.root.metadata_expire)
+            end
+
             plan_action(Katello::Repository::IndexContent, index_options)
           end
         end

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

@@ -2,41 +2,38 @@ module Actions
   module Katello
     module Repository
       class Create < Actions::EntryAction
-        # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def plan(repository, args = {})
           clone = args[:clone] || false
           force_repo_create = args[:force_repo_create] || false
           repository.save!
-          root = repository.root
 
           action_subject(repository)
 
-          org = repository.organization
           sequence do
             # Container push repositories will already be in pulp. The version_href is
             # directly updated after a push.
-            unless root.is_container_push && repository.in_default_view?
+            unless repository.root.is_container_push && repository.in_default_view?
               create_action = plan_action(Pulp3::Orchestration::Repository::Create,
                                           repository, SmartProxy.pulp_primary, force_repo_create)
               return if create_action.error
             end
 
-            # when creating a clone, the following actions are handled by the
-            # publish/promote process
-            unless clone
-              view_env = org.default_content_view.content_view_environment(org.library)
-              if repository.product.redhat?
-                plan_action(Actions::Candlepin::Environment::AddContentToEnvironment, :view_env_cp_id => view_env.cp_id, :content_id => repository.content_id)
-              else
-                unless root.content
-                  content_create = plan_action(Katello::Product::ContentCreate, root)
-                  plan_action(Actions::Candlepin::Environment::AddContentToEnvironment, :view_env_cp_id => view_env.cp_id, :content_id => content_create.input[:content_id])
-                end
-              end
+            content_id = false
+            if !clone && repository.product.redhat?
+              content_id = repository.content_id
+            elsif create_content?(repository, clone)
+              content_create = plan_action(Katello::Product::ContentCreate, repository)
+              content_id = content_create.input[:content_id]
+            end
+
+            if !clone && content_id
+              view_env = repository.organization.default_content_view.content_view_environment(repository.organization.library)
+              plan_action(Actions::Candlepin::Environment::AddContentToEnvironment, :view_env_cp_id => view_env.cp_id, :content_id => content_id)
             end
 
             # Container push repos do not need metadata generation or ACS (they do not sync)
-            unless root.is_container_push && repository.in_default_view?
+            unless repository.root.is_container_push && repository.in_default_view?
               concurrence do
                 plan_self(:repository_id => repository.id, :clone => clone)
                 if !clone && repository.url.present? && !repository.url.start_with?('uln')
@@ -65,6 +62,16 @@ module Actions
         def humanized_name
           _("Create")
         end
+
+        def create_content?(repository, clone)
+          if repository.deb_using_structured_apt?
+            return true
+          elsif clone || repository.content
+            return false
+          else
+            return true
+          end
+        end
       end
     end
   end

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

@@ -0,0 +1,44 @@
+module Actions
+  module Katello
+    module Repository
+      class CreateContainerPushRoot < Actions::EntryAction
+        def plan(root, relative_path = nil)
+          repository = ::Katello::Repository.new(:environment => root.organization.library, :content_view_version => root.organization.library.default_content_view_version, :root => root)
+          #Container push may concurrently call root add several times before the db can update.
+          # If the root already exists, we can skip the creation of the root and repository.
+          # We acquire a lock on the product to ensure that the root is not created multiple times by different workers.
+
+          root.product.with_lock do
+            begin
+              root.save!
+            rescue ActiveRecord::RecordInvalid => e
+              if root.is_container_push && e.message.include?("Name has already been taken for this product")
+                Rails.logger.debug("Skipping root repository creation as container push root repository already exists: #{root.container_push_name}")
+                return
+              end
+              raise e
+            end
+            repository.container_repository_name = relative_path if root.docker? && root.is_container_push
+            repository.relative_path = relative_path || repository.custom_repo_path
+            begin
+              repository.save!
+            rescue ActiveRecord::RecordInvalid => e
+              if root.is_container_push && e.message.include?("Container Repository Name") && e.message.include?("conflicts with an existing repository")
+                Rails.logger.debug("Skipping repository creation as container push repository already exists: #{root.container_push_name}")
+                return
+              end
+              raise e
+            end
+          end
+
+          action_subject(repository)
+          plan_action(::Actions::Katello::Repository::Create, repository)
+        end
+
+        def humanized_name
+          _("Create Container Push Repository Root")
+        end
+      end
+    end
+  end
+end

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

@@ -2,23 +2,13 @@ module Actions
   module Katello
     module Repository
       class CreateRoot < Actions::EntryAction
-        def plan(root, relative_path = nil)
-          begin
-            root.save!
-          rescue ActiveRecord::RecordInvalid => e
-            if root.is_container_push && e.message.include?("Container Repository Name") && e.message.include?("conflicts with an existing repository")
-              logger.warn("Skipping repository creation as container push repository already exists: #{root.container_push_name}")
-              return
-            end
-            raise e
-          end
+        def plan(root)
+          root.save!
           repository = ::Katello::Repository.new(:environment => root.organization.library,
-                                      :content_view_version => root.organization.library.default_content_view_version,
-                                      :root => root)
-          repository.container_repository_name = relative_path if root.docker? && root.is_container_push
-          repository.relative_path = relative_path || repository.custom_repo_path
+                                                 :content_view_version => root.organization.library.default_content_view_version,
+                                                 :root => root)
+          repository.relative_path = repository.custom_repo_path
           repository.save!
-
           action_subject(repository)
           plan_action(::Actions::Katello::Repository::Create, repository)
         end

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

@@ -90,9 +90,9 @@ module Actions
         end
 
         def handle_custom_content(repository, remove_from_content_view_versions)
-          #if this is the last instance of a custom repo, destroy the content
-          if remove_from_content_view_versions || repository.root.repositories.where.not(id: repository.id).empty?
-            plan_action(::Actions::Katello::Product::ContentDestroy, repository.root)
+          #if this is the last instance of a custom repo or a deb repo using structured APT, destroy the content
+          if remove_from_content_view_versions || repository.root.repositories.where.not(id: repository.id).empty? || repository.deb_using_structured_apt?
+            plan_action(::Actions::Katello::Product::ContentDestroy, repository)
           end
         end
 

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

@@ -39,7 +39,7 @@ module Actions
                                                                                                 {
                                                                                                   upstream_username: input[:upstream_username],
                                                                                                   upstream_password: password,
-                                                                                                  search: input[:search]
+                                                                                                  search: input[:search],
                                                                                                 }
                                                                                               )
 

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

@@ -15,6 +15,19 @@ module Actions
           generate_metadata = options.fetch(:generate_metadata, true)
           plan_action(Katello::Repository::MetadataGenerate, repository, :dependency => import_upload_task, :force_publication => true) if generate_metadata
 
+          if repository.deb_using_structured_apt? && generate_metadata
+            plan_action(::Actions::Candlepin::Product::ContentUpdate,
+                        owner:           repository.organization.label,
+                        repository_id:   repository.id,
+                        name:            repository.root.name,
+                        type:            repository.root.content_type,
+                        arches:          repository.root.format_arches,
+                        label:           repository.root.custom_content_label,
+                        content_url:     repository.root.custom_content_path,
+                        gpg_key_url:     repository.yum_gpg_key_url,
+                        metadata_expire: repository.root.metadata_expire)
+          end
+
           recent_range = 5.minutes.ago.utc.iso8601
           plan_action(Katello::Repository::FilteredIndexContent,
                       id: repository.id,

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

@@ -32,7 +32,7 @@ module Actions
                   unit_type_id: unit_type_id,
                   unit_key: unit_key.with_indifferent_access,
                   upload_id: upload_id,
-                  unit_metadata: unit_metadata
+                  unit_metadata: unit_metadata,
                 }
 
                 import_upload_args.merge!(options)

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

@@ -46,6 +46,7 @@ module Actions
                                         pulp_sync_options)
               output = sync_action.output
 
+              update_deb_content(repo)
               plan_action(Katello::Repository::IndexContent, :id => repo.id, :force_index => skip_metadata_check)
               plan_action(Katello::Foreman::ContentUpdate, repo.environment, repo.content_view, repo)
               plan_action(Katello::Repository::FetchPxeFiles, :id => repo.id)
@@ -94,6 +95,21 @@ module Actions
           Helpers::Presenter::Delegated.new(self, found)
         end
 
+        def update_deb_content(repo)
+          return unless repo.deb_using_structured_apt?
+
+          plan_action(::Actions::Candlepin::Product::ContentUpdate,
+                      owner:           repo.organization.label,
+                      repository_id:   repo.id,
+                      name:            repo.root.name,
+                      type:            repo.root.content_type,
+                      arches:          repo.root.format_arches,
+                      label:           repo.root.custom_content_label,
+                      content_url:     repo.root.custom_content_path,
+                      gpg_key_url:     repo.yum_gpg_key_url,
+                      metadata_expire: repo.root.metadata_expire)
+        end
+
         def rescue_strategy
           Dynflow::Action::Rescue::Skip
         end

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

@@ -4,7 +4,6 @@ module Actions
   module Katello
     module Repository
       class Update < Actions::EntryAction
-        # rubocop:disable Metrics/MethodLength
         def plan(root, repo_params)
           repository = root.library_instance
           action_subject root.library_instance
@@ -20,27 +19,19 @@ module Actions
           root.update!(repo_params)
 
           if update_content?(repository)
-            content = root.content
-
             plan_action(::Actions::Candlepin::Product::ContentUpdate,
-                        :owner => repository.organization.label,
-                        :content_id => root.content_id,
-                        :name => root.name,
-                        :content_url => root.custom_content_path,
-                        :gpg_key_url => repository.yum_gpg_key_url,
-                        :label => content.label,
-                        :type => root.content_type,
-                        :arches => root.format_arches,
-                        :os_versions => root.os_versions&.join(','),
-                        :metadata_expire => root.metadata_expire
-                      )
-
-            content.update!(name: root.name,
-                                       content_url: root.custom_content_path,
-                                       content_type: repository.content_type,
-                                       label: content.label,
-                                       gpg_url: repository.yum_gpg_key_url)
+                        owner:           repository.organization.label,
+                        repository_id:   repository.id,
+                        name:            root.name,
+                        type:            root.content_type,
+                        arches:          root.format_arches,
+                        label:           repository.content.label,
+                        content_url:     root.custom_content_path,
+                        gpg_key_url:     repository.yum_gpg_key_url,
+                        os_versions:     root.os_versions&.join(','),
+                        metadata_expire: root.metadata_expire)
           end
+
           if root.pulp_update_needed?
             sequence do
               plan_action(::Actions::Pulp3::Orchestration::Repository::Update,

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

@@ -87,7 +87,7 @@ module Actions
           {
             :checksum => Digest::SHA256.hexdigest(File.read(file[:path])),
             :name => file[:filename],
-            :size => File.size(file[:path])
+            :size => File.size(file[:path]),
           }
         end
       end

data/app/lib/actions/katello/repository_set/enable_repository.rb

@@ -30,7 +30,7 @@ module Actions
           output[:repository] = {
             :name => repo.name,
             :id => repo.id,
-            :content_type => repo.content_type
+            :content_type => repo.content_type,
           }
         end
       end

data/app/lib/actions/katello/repository_set/scan_cdn.rb

@@ -50,7 +50,7 @@ module Actions
             name: mapper.content.name,
             enabled: !repo.nil?,
             promoted: (!repo.nil? && repo.promoted?),
-            repository_id: repo.try(:id)
+            repository_id: repo.try(:id),
           }
         end
 

data/app/lib/actions/katello/upstream_subscriptions/bind_entitlement.rb

@@ -20,7 +20,7 @@ module Actions
         def pool
           {
             pool: input[:pool],
-            quantity: input[:quantity]
+            quantity: input[:quantity],
           }
         end
       end

data/app/lib/actions/pulp3/capsule_content/sync.rb

@@ -14,7 +14,7 @@ module Actions
         def invoke_external_task
           repo = ::Katello::Repository.find(input[:repository_id])
           sync_options = {}
-          sync_options[:optimize] = false if sync_options[:skip_metadata_check]
+          sync_options[:optimize] = !input[:options].fetch(:skip_metadata_check, false)
           output[:pulp_tasks] = repo.backend_service(smart_proxy).with_mirror_adapter.sync(sync_options)
         end
 

data/app/lib/actions/pulp3/orchestration/content_view_version/export_library.rb

@@ -9,7 +9,7 @@ module Actions
               chunk_size: nil,
               from_history: nil,
               fail_on_missing_content: false,
-              format: ::Katello::Pulp3::ContentViewVersion::Export::IMPORTABLE
+              format: ::Katello::Pulp3::ContentViewVersion::Export::IMPORTABLE,
             }.merge(opts)
             action_subject(organization)
             validate_repositories_immediate!(organization) if options[:fail_on_missing_content]

data/app/lib/actions/pulp3/orchestration/repository/create.rb

@@ -6,7 +6,12 @@ module Actions
           def plan(repository, smart_proxy, force = false)
             sequence do
               create_action = plan_action(Actions::Pulp3::Repository::Create, repository, smart_proxy, force)
-              plan_action(Actions::Pulp3::Repository::SaveVersion, repository, repository_details: create_action.output[:response])
+              if repository.deb? && repository.library_instance?
+                response = plan_action(Pulp3::Repository::Initialize, repository, smart_proxy)
+                plan_action(Actions::Pulp3::Repository::SaveVersion, repository, tasks: response.output[:pulp_tasks])
+              else
+                plan_action(Actions::Pulp3::Repository::SaveVersion, repository, repository_details: create_action.output[:response])
+              end
 
               if repository.content_view.default? || !smart_proxy.pulp_primary?
                 plan_action(Actions::Pulp3::Repository::CreateRemote, repository, smart_proxy)