[api] support release of single multibuild build containers

src/api/app/controllers/source_controller.rb

@@ -354,7 +354,11 @@ def package_command
     end
     unless PACKAGE_CREATING_COMMANDS.include?(@command) && !Project.exists_by_name(@target_project_name)
       valid_project_name! params[:project]
-      valid_package_name! params[:package]
+      if @command == 'release' # wipe and rebuild should become supported as well
+        valid_multibuild_package_name!(params[:package])
+      else
+        valid_package_name!(params[:package])
+      end
       # even when we can create the package, an existing instance must be checked if permissions are right
       @project = Project.get_by_name @target_project_name
       # rubocop:disable Metrics/LineLength
@@ -1443,13 +1447,17 @@ def reparse_backend_package(spackage, sproject)
 
   # POST /source/<project>/<package>?cmd=release
   def package_command_release
-    pkg = Package.get_by_project_and_name params[:project], params[:package], use_source: true, follow_project_links: false
+    pkg = Package.get_by_project_and_name params[:project], params[:package], use_source: true, follow_project_links: false, follow_multibuild: true
+    multibuild_container = nil
+    if params[:package].include?(":") && !params[:package].starts_with?('_product:')
+      multibuild_container = params[:package].gsub(/^.*:/, '')
+    end
 
     # specified target
     if params[:target_project]
       # we do not create it ourself
       Project.get_by_name(params[:target_project])
-      _package_command_release_manual_target(pkg)
+      _package_command_release_manual_target(pkg, multibuild_container)
     else
       spkg = Package.get_by_project_and_name(params[:project], params[:package])
       verify_repos_match!(spkg.project)
@@ -1459,15 +1467,15 @@ def package_command_release
         next if params[:repository] && params[:repository] != repo.name
         repo.release_targets.each do |releasetarget|
           # find md5sum and release source and binaries
-          release_package(pkg, releasetarget.target_repository, pkg.name, repo, nil, params[:setrelease], true)
+          release_package(pkg, releasetarget.target_repository, pkg.name, repo, multibuild_container, nil, params[:setrelease], true)
         end
       end
     end
 
     render_ok
   end
 
-  def _package_command_release_manual_target(pkg)
+  def _package_command_release_manual_target(pkg, multibuild_container)
     verify_can_modify_target!
 
     if params[:target_repository].blank? || params[:repository].blank?
@@ -1480,7 +1488,7 @@ def _package_command_release_manual_target(pkg)
     raise UnknownRepository, "Repository does not exist #{params[:repository]}" unless repo.count > 0
     repo = repo.first
 
-    release_package(pkg, targetrepo, pkg.name, repo, nil, params[:setrelease], true)
+    release_package(pkg, targetrepo, pkg.name, repo, multibuild_container, nil, params[:setrelease], true)
   end
   private :_package_command_release_manual_target
 

src/api/app/helpers/maintenance_helper.rb

@@ -41,7 +41,8 @@ def _release_package(source_package, target_project, target_package_name, action
   end
 
   def release_package(source_package, target, target_package_name,
-                      filter_source_repository = nil, action = nil, setrelease = nil, manual = nil)
+                      filter_source_repository = nil, multibuild_container = nil, action = nil,
+                      setrelease = nil, manual = nil)
     if target.kind_of? Repository
       target_project = target.project
     else
@@ -59,9 +60,9 @@ def release_package(source_package, target, target_package_name,
 
     # copy binaries
     if target.kind_of? Repository
-      u_ids = copy_binaries_to_repository(filter_source_repository, source_package, target, target_package_name, setrelease)
+      u_ids = copy_binaries_to_repository(filter_source_repository, source_package, target, target_package_name, multibuild_container, setrelease)
     else
-      u_ids = copy_binaries(filter_source_repository, source_package, target_package_name, target_project, setrelease)
+      u_ids = copy_binaries(filter_source_repository, source_package, target_package_name, target_project, multibuild_container, setrelease)
     end
 
     # create or update main package linking to incident package
@@ -169,14 +170,16 @@ def release_package_copy_sources(action, source_package, target_package_name, ta
     action.set_acceptinfo(result["acceptinfo"]) if action
   end
 
-  def copy_binaries(filter_source_repository, source_package, target_package_name, target_project, setrelease)
+  def copy_binaries(filter_source_repository, source_package, target_package_name, target_project,
+                    multibuild_container, setrelease)
     update_ids = []
     source_package.project.repositories.each do |source_repo|
       next if filter_source_repository && filter_source_repository != source_repo
       source_repo.release_targets.each do |releasetarget|
         # FIXME: filter given release and/or target repos here
         if releasetarget.target_repository.project == target_project
-          u_id = copy_binaries_to_repository(source_repo, source_package, releasetarget.target_repository, target_package_name, setrelease)
+          u_id = copy_binaries_to_repository(source_repo, source_package, releasetarget.target_repository,
+                                             target_package_name, multibuild_container, setrelease)
           update_ids << u_id if u_id
         end
         # remove maintenance release trigger in source
@@ -190,27 +193,35 @@ def copy_binaries(filter_source_repository, source_package, target_package_name,
     update_ids
   end
 
-  def copy_binaries_to_repository(source_repository, source_package, target_repo, target_package_name, setrelease)
+  def copy_binaries_to_repository(source_repository, source_package, target_repo, target_package_name,
+                                  multibuild_container, setrelease)
     u_id = get_updateinfo_id(source_package, target_repo)
+    source_package_name = source_package.name
+    unless multibuild_container.blank?
+      source_package_name << ":" << multibuild_container
+      target_package_name = target_package_name.gsub(/:.*/, '') << ":" << multibuild_container
+    end
     source_repository.architectures.each do |arch|
       # get updateinfo id in case the source package comes from a maintenance project
-      copy_single_binary(arch, target_repo, source_package, source_repository, target_package_name, u_id, setrelease)
+      copy_single_binary(arch, target_repo, source_package.project.name, source_package_name,
+                         source_repository, target_package_name, u_id, setrelease)
     end
     u_id
   end
 
-  def copy_single_binary(arch, target_repository, source_package, source_repo, target_package_name, update_info_id, setrelease)
+  def copy_single_binary(arch, target_repository, source_project_name, source_package_name, source_repo,
+                         target_package_name, update_info_id, setrelease)
     cp_params = {
       cmd:         "copy",
-      oproject:    source_package.project.name,
-      opackage:    source_package.name,
+      oproject:    source_project_name,
+      opackage:    source_package_name,
       orepository: source_repo.name,
       user:        User.current.login,
-      multibuild:  "1",
       resign:      "1"
     }
     cp_params[:setupdateinfoid] = update_info_id if update_info_id
     cp_params[:setrelease] = setrelease if setrelease
+    cp_params[:multibuild] = "1" unless source_package_name.include? ':'
     # rubocop:disable Metrics/LineLength
     cp_path = "/build/#{CGI.escape(target_repository.project.name)}/#{URI.escape(target_repository.name)}/#{URI.escape(arch.name)}/#{URI.escape(target_package_name)}"
     # rubocop:enable Metrics/LineLength

src/api/app/helpers/validation_helper.rb

@@ -19,10 +19,18 @@ def valid_package_name?(name)
     Package.valid_name? name
   end
 
+  def valid_multibuild_package_name?(name)
+    Package.valid_multibuild_name?(name)
+  end
+
   def valid_package_name!(package_name)
     raise InvalidPackageNameError, "invalid package name '#{package_name}'" unless valid_package_name? package_name
   end
 
+  def valid_multibuild_package_name!(package_name)
+    raise InvalidPackageNameError, "invalid package name '#{package_name}'" unless valid_multibuild_package_name? package_name
+  end
+
   # load last package meta file and just check if sourceaccess flag was used at all, no per user checking atm
   def validate_read_access_of_deleted_package(project, name)
     prj = Project.get_by_name project

src/api/app/models/bs_request_action_maintenance_release.rb

@@ -39,7 +39,7 @@ def execute_accept(opts)
     # have a unique time stamp for release
     opts[:acceptTimeStamp] ||= Time.now
 
-    opts[:updateinfoIDs] = release_package(pkg, Project.get_by_name(target_project), target_package, nil, self)
+    opts[:updateinfoIDs] = release_package(pkg, Project.get_by_name(target_project), target_package, nil, nil, self)
     opts[:projectCommit] ||= {}
     opts[:projectCommit][target_project] = source_project
 

src/api/app/models/package.rb

@@ -1085,13 +1085,18 @@ def developed_packages
     packages
   end
 
-  def self.valid_name?(name)
+  def self.valid_multibuild_name?(name)
+    valid_name?(name, true)
+  end
+
+  def self.valid_name?(name, allow_multibuild = false)
     return false unless name.kind_of? String
     # this length check is duplicated but useful for other uses for this function
     return false if name.length > 200
     return false if name == "0"
     return true if %w(_product _pattern _project _patchinfo).include?(name)
     # _patchinfo: is obsolete, just for backward compatibility
+    return name =~ /\A([a-zA-Z0-9]|(_product:|_patchinfo:)\w)[-+:\w\.]*\z/ ? true : false if allow_multibuild
     name =~ /\A([a-zA-Z0-9]|(_product:|_patchinfo:)\w)[-+\w\.]*\z/ ? true : false
   end
 

src/api/app/models/project.rb

@@ -1239,7 +1239,7 @@ def do_project_release( params )
           next if params[:targetreposiory] && params[:targetreposiory] != releasetarget.target_repository.name
           # release source and binaries
           # permission checking happens inside this function
-          release_package(pkg, releasetarget.target_repository, pkg.name, repo, nil, params[:setrelease], true)
+          release_package(pkg, releasetarget.target_repository, pkg.name, repo, nil, nil, params[:setrelease], true)
         end
       end
     end