+   failed_build:

+   resume_cancelled_build:

+     module: testmodule

+     branch: cancel-build-branch

+     Run the build with "rebuild_strategy=all".

+     assert sorted(failing_components) == sorted(build.component_names(state="FAILED", batch=batch))

+         build.component_names(state="COMPLETE", batch=batch)

+         + build.component_names(state="CANCELED", batch=batch)

+     assert sorted(build.component_names()) == sorted(repo.components + ["module-build-macros"])

+ # -*- coding: utf-8 -*-

+ # SPDX-License-Identifier: MIT

+ 

+ import utils

+ import time

+ 

+ 

+ def test_resume_cancelled_build(test_env, repo, koji):

+     """

+     Run the  build with "rebuild_strategy=all".

+     Wait until the module-build-macros build is submitted to Koji.

+     Cancel module build.

+     Resume the module with "rhpkg-stage module-build -w".

+ 

+     Check that:

+       * Check that the testmodule had actually been cancelled

+       * Check that the testmodule build succeeded

+ 

+     """

+     build = utils.Build(test_env["packaging_utility"], test_env["mbs_api"])

+     repo.bump()

+     build.run(

+         "--optional",

+         "rebuild_strategy=all",

+     )

+     build.wait_for_koji_task_id(package="module-build-macros", batch=1)

+     build.cancel()

+     # Behave like a human: restarting the build too quickly would lead to an error.

+     time.sleep(10)

+     build.run("--watch")

+ 

+     assert build.state_name == "ready"

+     assert build.was_cancelled()

+     assert sorted(build.component_names(state="COMPLETE")) == sorted(

+ import time

+ from sh import Command, git

+     def bump(self):

+         """Create a "bump" commit"""

+         args = [

+             "--allow-empty",

+             "-m",

+             "Bump"

+         ]

+         git("commit", *args)

+         git("push")

+ 

+     :attribute string _module_build_data: Verbose module build data cache for this build

+         self._module_build_data = None

+     def cancel(self):

+         """Cancel the module build

+ 

+         :return: Standard output of the "module-build-cancel <build id=""> command

+         :rtype: str

+         """

+         stdout = self._packaging_utility("module-build-cancel", self._build_id).stdout.decode(

+             "utf-8")

+         return stdout

+ 

+     def module_build_data(self):

+         """Verbose module build

+ 

+         :return: Dictionary of the verbose module build parameters

+         :rtype: dict

+         """

+         if self._build_id:

+             params = {

+                 "verbose": True,

+             }

+             r = requests.get(f"{self._mbs_api}module-builds/{self._build_id}", params=params)

+             r.raise_for_status()

+             self._module_build_data = r.json()

+         return self._module_build_data

+ 

+     @property

+     def components(self, state=None, batch=None, package=None):

+         """Components of this module build, optionally filtered based on properties

+         :param string package: name of the component (package)

+         :rtype: list of dict

+         if package is not None:

+             filtered = filter(lambda x: x["package"] == package, filtered)

+         return list(filtered)

+ 

+     def component_names(self, state=None, batch=None, package=None):

+         """Component names of this module build, optionally filtered based on properties

+ 

+         :param string state: Koji build state the components should be in

+         :param int batch: the number of the batch the components should be in

+         :param string: name of component (package):

+         :return: List of components packages

+         :rtype: list of strings

+         """

+         components = self.components(state, batch, package)

+         return [item["package"] for item in components]

+     def wait_for_koji_task_id(self, package, batch, timeout=60, sleep=10):

+         """Wait until the component is submitted to Koji (has a task_id)

+ 

+         :param string: name of component (package)

+         :param int batch: the number of the batch the components should be in

+         :param int timeout: time in seconds

+         :param int sleep: time in seconds

+         """

+         start = time.time()

+         while time.time() - start <= timeout:

+             # Clear cached data

+             self._component_data = None

+             components = self.components(package=package, batch=batch)

+             # Wait until the right component appears and has a task_id

+             if components and components[0]["task_id"]:

+                 return components[0]["task_id"]

+             time.sleep(sleep)

+ 

+         raise RuntimeError(

+             f'Koji task for "{package}" did not start in {timeout} seconds'

+         )

+ 

+ 

+     def was_cancelled(self):

+         """Checking in the status trace if module was canceled

+ 

+         :return: Whether exists required status

+         :rtype: bool

+         """

+         for item in self.module_build_data["state_trace"]:

+             if (

+                     item["reason"] is not None

+                     and "Canceled" in item["reason"]

+                     and item["state_name"] == "failed"

+             ):

+                 return True

+         return False

+ passenv = REQUESTS_CA_BUNDLE MBS_TEST_CONFIG MBS_TEST_WORKERS HOME