qubership-pipelines-common-library 0.2.5__py3-none-any.whl → 2.0.0__py3-none-any.whl

qubership_pipelines_common_library/v2/podman/podman_command.py

@@ -0,0 +1,311 @@
+import os, subprocess, time, uuid
+
+from pathlib import Path
+from qubership_pipelines_common_library.v1.execution.exec_command import ExecutionCommand
+from qubership_pipelines_common_library.v1.utils.utils_string import UtilsString
+
+
+class PodmanRunImage(ExecutionCommand):
+    """
+        Executes a container using "podman run" command.
+
+        This command supports running containers with configurable execution parameters,
+        environment variable management, file mounting, and output extraction.
+
+        Input Parameters Structure (this structure is expected inside "input_params.params" block):
+        ```
+        {
+            "image": "docker.io/library/hello-world:latest",  # REQUIRED: Container image to run
+            "command": "python -m pipelines_declarative_executor run --pipeline_dir=\"/WORK/EXEC_DIR\"",  # OPTIONAL: Command to execute in container
+            "execution_config": { # ALL OF THESE ARE OPTIONAL
+                "working_dir": "/some/dir/inside/container",  # Working directory inside container
+                "timeout": "600",  # Maximum execution time in seconds
+                "operations_timeout": "15",  # Timeout for operations like file copying
+                "remove_container": True,  # Whether to remove container after execution
+                "save_stdout_to_logs": True,  # Save container stdout to execution logs
+                "save_stdout_to_files": True,  # Save container stdout to output files
+                "save_stdout_to_params": False,  # Save container stdout to output parameters
+                "expected_return_codes": "0,125",  # Comma-separated list of acceptable exit codes
+                "additional_run_flags": "--cgroups=disabled",  # Optional string of flags that will be added to "podman run" command
+            },
+            "before_script": {
+                "mounts": {  # Filesystem mounts, "host_path: container_path"
+                    "output_files": "/WORK",
+                    "prepared_data": "/CONFIGS"
+                },
+                "env_vars": {
+                    "explicit": {  # Direct environment variable assignment
+                        "PIPELINES_DECLARATIVE_EXECUTOR_ENCRYPT_OUTPUT_SECURE_PARAMS": False
+                    },
+                    "env_files": [  # Environment files on host to load and pass into container
+                        "../CONFIGS/sample.env"
+                    ],
+                    "pass_via_file": {  # Sensitive vars passed via temp file
+                        "SOMETHING_VERY_SECURE": "PASSWORD"
+                    },
+                    "host_prefixes": [  # Host environment variable prefixes to pass through. Can use "*" to pass everything from host.
+                        "SOME_PREFIX_*"
+                    ]
+                }
+            },
+            "after_script": {
+                "copy_files_to_host": {  # Copy files from container to host after execution, "host_path: container_path"
+                    "output_files/report.json": "/WORK/EXEC_DIR/pipeline_state/pipeline_ui_view.json",
+                    "output_files/pipeline_state": "/WORK/EXEC_DIR/pipeline_state",
+                },
+                "extract_params_from_files": {  # OPTIONAL: Extract parameters from container files. Supports JSON, YAML, and ENV files
+                    "SOME_FILE_IN_CONTAINER": "SECTION_NAME_IN_PARAMS_WHERE_IT_WILL_BE_STORED",
+                }
+            }
+        }
+        ```
+
+        Output Parameters:
+            - params.execution_time: Total execution time in seconds
+            - params.return_code: Container exit code
+            - params.stdout: Container stdout (if save_stdout_to_params enabled)
+            - params.stderr: Container stderr (if save_stdout_to_params enabled)
+            - params.extracted_output.*: Extracted parameters from files (if extract_params_from_files configured)
+
+        Notes:
+            - The command automatically handles container lifecycle including start, execution, and cleanup
+            - All host-paths (including mount paths) are resolved relative to context directory.
+        """
+
+    def _validate(self):
+        names = [
+            "paths.input.params",
+            "paths.output.params",
+            "paths.output.files",
+            "params.image",
+        ]
+        if not self.context.validate(names):
+            return False
+
+        # Check if podman is available
+        try:
+            subprocess.run(["podman", "--version"], capture_output=True, check=True)
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            self.context.logger.error("Podman is not available on this system. Please install podman to use this command.")
+            return False
+
+        # Setup defaults & convert values
+        self.image = self.context.input_param_get("params.image")
+        self.command = self.context.input_param_get("params.command")
+
+        # execution_config
+        self.working_dir = self.context.input_param_get("params.execution_config.working_dir")
+        self.timeout = float(self.context.input_param_get("params.execution_config.timeout", 60))
+        self.operations_timeout = float(self.context.input_param_get("params.execution_config.operations_timeout", 15))
+        self.remove_container = UtilsString.convert_to_bool(self.context.input_param_get("params.execution_config.remove_container", True))
+        self.save_stdout_to_logs = UtilsString.convert_to_bool(self.context.input_param_get("params.execution_config.save_stdout_to_logs", True))
+        self.save_stdout_to_files = UtilsString.convert_to_bool(self.context.input_param_get("params.execution_config.save_stdout_to_files", True))
+        self.save_stdout_to_params = UtilsString.convert_to_bool(self.context.input_param_get("params.execution_config.save_stdout_to_params", False))
+        self.expected_return_codes = [int(num) for num in self.context.input_param_get("params.execution_config.expected_return_codes", "0").split(',')]
+        self.additional_run_flags = self.context.input_param_get("params.execution_config.additional_run_flags")
+
+        # before_script
+        self.mounts_config = self.context.input_param_get("params.before_script.mounts", {})
+        self.env_vars_config = self.context.input_param_get("params.before_script.env_vars", {})
+
+        # after_script
+        self.copy_files_config = self.context.input_param_get("params.after_script.copy_files_to_host", {})
+        self.extract_params_config = self.context.input_param_get("params.after_script.extract_params_from_files", {})
+
+        # Get base paths
+        self.context_dir_path = Path(os.path.dirname(self.context.context_path))
+        self.input_params_path = Path(self.context.input_param_get("paths.input.params"))
+        self.output_params_path = Path(self.context.input_param_get("paths.output.params"))
+        self.output_files_path = Path(self.context.input_param_get("paths.output.files"))
+        self.container_name = f"podman_{str(uuid.uuid4())}"
+        return True
+
+    def _run_sp_command(self, command, timeout=None):
+        return subprocess.run(command, capture_output=True, text=True,
+                              timeout=timeout if timeout else self.timeout,
+                              cwd=self.context_dir_path)
+
+    def _build_podman_command(self) -> list[str]:
+        cmd = ["podman", "run", "--name", self.container_name]
+
+        if self.additional_run_flags:
+            import shlex
+            cmd.extend(shlex.split(self.additional_run_flags))
+
+        if self.working_dir:
+            cmd.extend(["--workdir", self.working_dir])
+
+        if self.env_vars_config:
+            cmd.extend(self._build_command_env_var_args())
+
+        for host_path, container_path in self.mounts_config.items():
+            cmd.extend(["--mount", f"type=bind,source={host_path},target={container_path}"])
+
+        cmd.append(self.image)
+
+        if self.command:
+            import shlex
+            cmd.extend(shlex.split(self.command))
+
+        return cmd
+
+    def _build_command_env_var_args(self) -> list[str]:
+        args = []
+        for key, value in self.env_vars_config.get("explicit", {}).items():
+            args.extend(["--env", f"{key}={value}"])
+
+        for prefix in self.env_vars_config.get("host_prefixes", []):
+            args.extend(["--env", f"{prefix}"])
+
+        for env_file in self.env_vars_config.get("env_files", []):
+            args.extend(["--env-file", f"{env_file}"])
+
+        if self.env_vars_config.get("pass_via_file"):
+            env_file_path = self.context_dir_path.joinpath("temp").joinpath("temp.env")
+            env_file_path.parent.mkdir(parents=True, exist_ok=True)
+            with open(env_file_path, 'w') as f:
+                for key, value in self.env_vars_config["pass_via_file"].items():
+                    f.write(f"{key}={value}\n")
+            args.extend(["--env-file", str(env_file_path)])
+
+        return args
+
+    def _copy_files_from_container(self):
+        for host_path, container_path in self.copy_files_config.items():
+            full_host_path = self.context_dir_path.joinpath(host_path)
+            full_host_path.parent.mkdir(parents=True, exist_ok=True)
+
+            copy_command = ["podman", "cp", f"{self.container_name}:{container_path}", str(full_host_path)]
+            try:
+                copy_result = self._run_sp_command(copy_command, self.operations_timeout)
+                if copy_result.returncode != 0:
+                    self.context.logger.warning(f"Failed to copy {container_path} to {host_path}: {copy_result.stderr}")
+                else:
+                    self.context.logger.debug(f"Copied {container_path} to {host_path}")
+            except subprocess.TimeoutExpired:
+                self.context.logger.warning(f"Copy command timed out after {self.operations_timeout} seconds")
+
+    def _extract_params_from_container(self):
+        import tempfile
+        with tempfile.TemporaryDirectory() as temp_dir:
+            for container_file_path, output_key_base in self.extract_params_config.items():
+                try:
+                    temp_file_path = Path(temp_dir) / Path(container_file_path).name
+                    copy_command = ["podman", "cp", f"{self.container_name}:{container_file_path}", str(temp_file_path)]
+                    copy_result = self._run_sp_command(copy_command, self.operations_timeout)
+                    if copy_result.returncode != 0:
+                        self.context.logger.warning(f"Failed to copy file {container_file_path} for params-extraction: {copy_result.stderr}")
+                        continue
+                    if not temp_file_path.exists():
+                        self.context.logger.warning(f"File {container_file_path} for params-extraction not found after copy")
+                        continue
+                    if file_content := self._parse_custom_file_params(temp_file_path):
+                        base_key = output_key_base if output_key_base else container_file_path.replace('/','_').replace('.', '_')
+                        self.context.output_param_set(f"params.extracted_output.{base_key}", file_content)
+                except Exception as e:
+                    self.context.logger.warning(f"Failed to extract params from file {container_file_path}: {e}")
+
+    def _parse_custom_file_params(self, file_path: Path):
+        try:
+            try:
+                import json
+                with open(file_path, 'r', encoding='utf-8') as f:
+                    return json.load(f)
+            except:
+                pass
+
+            try:
+                import yaml
+                with open(file_path, 'r', encoding='utf-8') as f:
+                    return yaml.safe_load(f)
+            except:
+                pass
+
+            try:
+                key_values = {}
+                with open(file_path, 'r', encoding='utf-8') as f:
+                    for line in f:
+                        line = line.strip()
+                        if line and not line.startswith('#') and '=' in line:
+                            key, value = line.split('=', 1)
+                            key_values[key.strip()] = value.strip()
+                return key_values if key_values else None
+            except:
+                pass
+
+            with open(file_path, 'r', encoding='utf-8') as f:
+                return f.read().strip()
+
+        except Exception as e:
+            self.context.logger.warning(f"Failed to parse custom-params file {file_path}: {e}")
+            return None
+
+    def _write_stdout_files(self, stdout: str, stderr: str):
+        (self.output_files_path / "container_stdout.txt").write_text(stdout, encoding='utf-8')
+        (self.output_files_path / "container_stderr.txt").write_text(stderr, encoding='utf-8')
+
+    def _process_output(self, output: subprocess.CompletedProcess):
+        self.context.output_param_set("params.execution_time", f"{self.execution_time:0.3f}s")
+        self.context.output_param_set("params.return_code", output.returncode)
+
+        if output.stdout and isinstance(output.stdout, bytes):
+            output.stdout = output.stdout.decode('utf-8', errors='replace')
+        if output.stderr and isinstance(output.stderr, bytes):
+            output.stderr = output.stderr.decode('utf-8', errors='replace')
+
+        if self.save_stdout_to_logs:
+            if output.stdout:
+                self.context.logger.debug(f"Container stdout:\n{output.stdout}")
+            if output.stderr:
+                self.context.logger.debug(f"Container stderr:\n{output.stderr}")
+
+        if self.save_stdout_to_files:
+            self._write_stdout_files(output.stdout, output.stderr)
+
+        if self.save_stdout_to_params:
+            self.context.output_param_set("params.stdout", output.stdout)
+            self.context.output_param_set("params.stderr", output.stderr)
+
+        if self.extract_params_config:
+            self._extract_params_from_container()
+
+        if self.copy_files_config:
+            self._copy_files_from_container()
+
+        if output.returncode not in self.expected_return_codes:
+            raise PodmanException(output.stderr)
+
+    def _execute(self):
+        self.context.logger.info(f"Running podman image \"{self.image}\"...")
+        start = time.perf_counter()
+        try:
+            output = self._run_sp_command(self._build_podman_command())
+            self.execution_time = time.perf_counter() - start
+            self.context.logger.info(
+                f"Container finished with code: {output.returncode}"
+                f"\nExecution time: {self.execution_time:0.3f}s"
+            )
+            self._process_output(output)
+
+        except subprocess.TimeoutExpired:
+            self.context.logger.error(f"Container execution timed out after {self.timeout} seconds")
+            raise
+
+        except PodmanException:
+            self.context.logger.error(f"Container exited with unexpected exitcode")
+            raise
+
+        except Exception as e:
+            self.context.logger.error(f"Container execution failed: {e}")
+            raise
+
+        finally:
+            if self.remove_container:
+                remove_output = subprocess.run(["podman", "rm", "-f", self.container_name], capture_output=True)
+                if remove_output.returncode != 0:
+                    self.context.logger.warning(f"Failed to remove container {self.container_name}:\n{remove_output.stdout}\n{remove_output.stderr}")
+            self.context.output_params_save()
+
+
+class PodmanException(Exception):
+    pass

qubership_pipelines_common_library/v2/sops/sops_client.py

@@ -0,0 +1,116 @@
+import logging
+import os
+import shutil
+import subprocess
+import uuid
+import yaml
+
+from pathlib import Path
+
+
+class SopsClient:
+
+    def __init__(self, sops_artifact_configs_folder_path: Path):
+        self.sops_artifact_configs_folder_path = sops_artifact_configs_folder_path
+        self.sops_executable = Path(os.environ.get("SOPS_EXECUTABLE", "/usr/local/bin/sops"))
+        self.logger = logging.getLogger()
+
+    def encrypt_content_by_path(
+            self, age_public_key: str, source_file_path_to_encrypt: Path, target_file_path: Path = None):
+        """
+        Encrypts file and saves result into file by path
+        Args:
+            age_public_key: age public key
+            source_file_path_to_encrypt: file to encrypt
+            target_file_path: file to save result of encryption. If None then `source_file_path_to_encrypt` will be used
+        """
+        if not self.sops_executable.exists():
+            self.logger.error(f"Sops executable doesn't exist. Can't encrypt file {source_file_path_to_encrypt}")
+            return
+
+        sops_config_path = self._get_prepared_sops_config_path(age_public_key)
+        encrypted_file_path = target_file_path
+        if not encrypted_file_path:
+            encrypted_file_path = source_file_path_to_encrypt
+
+        args = (self.sops_executable, "--config", sops_config_path, "encrypt", source_file_path_to_encrypt)
+        sops_encrypt_result = subprocess.run(args, capture_output=True, text=True)
+        if sops_encrypt_result.stderr:
+            self.logger.error(f"Error during encryption of {source_file_path_to_encrypt}. "
+                              f"Saving empty content into {encrypted_file_path}"
+                              f"Error: {sops_encrypt_result.stderr}")
+
+            with open(encrypted_file_path, 'w') as encrypted_file:
+                encrypted_file.write("")
+            self._remove_sops_config(sops_config_path.parent)
+            return
+
+        with open(encrypted_file_path, 'w') as encrypted_file:
+            encrypted_file.write(sops_encrypt_result.stdout)
+        self.logger.debug(f"Content {source_file_path_to_encrypt} was encrypted by sops. "
+                          f"Result saved into {encrypted_file_path}")
+        self._remove_sops_config(sops_config_path.parent)
+
+    def get_decrypted_content_by_path(self, age_private_key: str, source_file_path_to_decrypt: Path) -> str:
+        """
+        Decrypts file by path
+        Args:
+            age_private_key: age private key
+            source_file_path_to_decrypt: file path to decrypt
+
+        Returns:
+            decrypted file content or empty string if error occurs
+        """
+        if not self.sops_executable.exists():
+            self.logger.error(f"Sops executable doesn't exist. Can't decrypt file {source_file_path_to_decrypt}")
+            return ""
+        if not age_private_key:
+            self.logger.warning("sops_private_key is not defined, skipping decryption")
+            return ""
+        environment_variables = os.environ.copy()
+        environment_variables["SOPS_AGE_KEY"] = age_private_key.strip()
+        args = (self.sops_executable, "-d", source_file_path_to_decrypt)
+        sops_decrypt_result = subprocess.run(args, env=environment_variables, capture_output=True, text=True)
+        if sops_decrypt_result.stderr:
+            self.logger.error(f"Error during {source_file_path_to_decrypt} decrypt. Error: {sops_decrypt_result.stderr}")
+            return ""
+        self.logger.debug(f"Content {source_file_path_to_decrypt} was decrypted by sops")
+        return sops_decrypt_result.stdout
+
+    def _get_prepared_sops_config_path(self, age_public_key) -> Path:
+        """
+        Generates `.sops.yaml` file `age-public-key`
+        Creates folder `uuid.uuid4()` under `self.sops_artifact_configs_folder_path` to make `.sops.yaml`
+        unique for exact encryption
+        Args:
+            age_public_key: age public key
+
+        Returns:
+            path to generated `.sops.yaml`
+        """
+        self.logger.debug(f"Preparing sops config for encryption")
+        sops_config_content = {
+            "creation_rules": [
+                {
+                    "age": age_public_key
+                }
+            ]
+        }
+        sops_config_path = self.sops_artifact_configs_folder_path.joinpath(str(uuid.uuid4()), ".sops.yaml")
+        sops_config_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(sops_config_path, mode="w") as file:
+            yaml.dump(sops_config_content, file)
+        return sops_config_path
+
+    def _remove_sops_config(self, sops_config_folder: Path):
+        """
+        Removes folder with generated sops config
+        Args:
+            sops_config_folder: path to folder with sops config
+
+        Returns:
+
+        """
+        self.logger.debug(f"Removing sops config")
+        if sops_config_folder.exists() and sops_config_folder.is_dir():
+            shutil.rmtree(sops_config_folder)

qubership_pipelines_common_library/v2/utils/crypto_utils.py

@@ -0,0 +1,48 @@
+class CryptoUtils:
+    EXCLUDE_KEYS = {"kind", "apiVersion"}
+
+    @staticmethod
+    def is_base64(s) -> bool:
+        try:
+            if isinstance(s, str):
+                s_bytes = s.encode('utf-8')
+            else:
+                s_bytes = s
+            import base64
+            return base64.b64encode(base64.b64decode(s_bytes)) == s_bytes
+        except Exception:
+            return False
+
+    @staticmethod
+    def get_base64_encrypted_str(s) -> str:
+        if isinstance(s, str):
+            s_bytes = s.encode('utf-8')
+        else:
+            s_bytes = s
+        import base64
+        return base64.b64encode(s_bytes).decode('utf-8')
+
+    @staticmethod
+    def mask_values(data, path=None):
+        if path is None:
+            path = []
+
+        if isinstance(data, dict):
+            return {
+                key: (CryptoUtils.mask_values(value, path + [key])
+                      if not (len(path) == 0 and key in CryptoUtils.EXCLUDE_KEYS)
+                      else value)
+                for key, value in data.items()
+            }
+        elif isinstance(data, list):
+            return [CryptoUtils.mask_values(item, path) for item in data]
+        else:
+            return "[MASKED]"
+
+    @staticmethod
+    def get_parameters_for_print(content: dict, need_mask: bool):
+        import yaml
+        if need_mask:
+            return yaml.dump(CryptoUtils.mask_values(content), default_flow_style=False)
+        else:
+            return yaml.dump(content, default_flow_style=False)

qubership_pipelines_common_library/v2/utils/extension_utils.py

@@ -0,0 +1,22 @@
+import importlib
+from typing import Type, Any, Optional
+
+
+class ExtensionLoader:
+    """Utility methods to create instance of a class by its classpath and validate its expected base class"""
+
+    @staticmethod
+    def load_class(class_path: str) -> Type[Any]:
+        try:
+            module_path, class_name = class_path.rsplit('.', 1)
+            module = importlib.import_module(module_path)
+            return getattr(module, class_name)
+        except (ImportError, AttributeError, ValueError) as e:
+            raise ImportError(f"Failed to load class {class_path}: {e}")
+
+    @staticmethod
+    def create_instance(class_path: str, expected_base_class: Optional[Type] = None, **kwargs) -> Any:
+        klass = ExtensionLoader.load_class(class_path)
+        if expected_base_class and not issubclass(klass, expected_base_class):
+            raise TypeError(f"Class {class_path} must inherit from {expected_base_class.__name__}")
+        return klass(**kwargs)

qubership_pipelines_common_library/v2/utils/retry_decorator.py

@@ -0,0 +1,93 @@
+import logging
+import sys
+import time
+from functools import wraps
+from typing import Callable
+
+
+class RetryDecorator:
+
+    def __init__(self, condition_func, retry_timeout_seconds: int = 180, retry_wait_seconds: int = 1):
+        self.condition_func = condition_func
+        self.retry_timeout_seconds = retry_timeout_seconds
+        self.retry_wait_seconds = retry_wait_seconds
+        self.logger = logging.getLogger()
+
+    def __call__(self, func: Callable) -> Callable:
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            self._update_retry_timeout_seconds_from_kwargs(kwargs, func)
+            self._update_retry_wait_seconds_from_kwargs(kwargs, func)
+
+            count_seconds = 0
+            retries = 0
+            last_log_time = time.perf_counter()
+            last_result = None
+            estimated_max_attempts = self.retry_timeout_seconds // self.retry_wait_seconds
+
+            
+            while count_seconds < self.retry_timeout_seconds and not self.condition_func(last_result):
+                try:
+                    last_result = func(*args, **kwargs)
+                    if self.condition_func(last_result):
+                        self.logger.debug(f"Function {func.__name__} successfully executed after {retries} attempts in {count_seconds}s")
+                        return last_result
+                    retries += 1
+
+                    now = time.perf_counter()
+                    if now - last_log_time >= 10:
+                        self._sleep_with_warning_log(
+                            f"Made [{retries} of {estimated_max_attempts}] retries with {self.retry_wait_seconds} seconds between attempts. Trying to execute func: {self.condition_func.__name__}. {count_seconds} of {self.retry_timeout_seconds} seconds left")
+                        last_log_time = now
+                    else:
+                        time.sleep(self.retry_wait_seconds)
+                    
+                except Exception as e:
+                    retries += 1
+                    now = time.perf_counter()
+                    if now - last_log_time >= 10:
+                        self._process_exception_during_func_execution(e, count_seconds, func.__name__, retries, estimated_max_attempts)
+                        last_log_time = now
+                    else:
+                        time.sleep(self.retry_wait_seconds)
+                
+                finally:
+                    count_seconds += self.retry_wait_seconds
+
+            if self.condition_func(last_result):
+                self.logger.debug(f"Function {func.__name__} successfully executed after {retries} attempts in {count_seconds}s")
+                return last_result
+            
+            self._exit_with_error_message(func.__name__)
+        return wrapper
+
+    def _sleep_with_warning_log(self, message):
+        self.logger.warning(message)
+        time.sleep(self.retry_wait_seconds)
+
+    def _update_retry_timeout_seconds_from_kwargs(self, kwargs, func):
+        kwargs_retry_timeout_seconds = kwargs.get('retry_timeout_seconds')
+        if kwargs_retry_timeout_seconds:
+            self.retry_timeout_seconds = kwargs_retry_timeout_seconds
+        else:
+            self.logger.debug(
+                f"`retry_timeout_seconds` is not found in func {func.__name__} arguments. Using default value = {self.retry_timeout_seconds}")
+
+    def _update_retry_wait_seconds_from_kwargs(self, kwargs, func):
+        kwargs_retry_wait_seconds = kwargs.get('retry_wait_seconds')
+        if kwargs_retry_wait_seconds:
+            self.retry_wait_seconds = kwargs_retry_wait_seconds
+        else:
+            self.logger.debug(
+                f"`retry_wait_seconds` is not found in func {func.__name__} arguments. Using default value = {self.retry_wait_seconds}")
+    
+    def _process_exception_during_func_execution(self, exception, count_seconds, func_name, retries, estimated_max_attempts):
+        if count_seconds < self.retry_timeout_seconds:
+            self._sleep_with_warning_log(
+                f"Made [{retries} of {estimated_max_attempts}] retries. Exception happened during function {func_name} execution,  waiting {count_seconds} of {self.retry_timeout_seconds}. Exception: {exception}")
+        else:
+            self._exit_with_error_message(func_name)
+
+    def _exit_with_error_message(self, func_name):
+        self.logger.error(f"Can't execute function {func_name} in {self.retry_timeout_seconds} seconds")
+        sys.exit(1)

{qubership_pipelines_common_library-0.2.5.dist-info → qubership_pipelines_common_library-2.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qubership-pipelines-common-library
-Version: 0.2.5
+Version: 2.0.0
 Summary: Qubership Pipelines common library
 License: Apache-2.0
 License-File: LICENSE

qubership_pipelines_common_library-2.0.0.dist-info/RECORD

@@ -0,0 +1,52 @@
+qubership_pipelines_common_library/__init__.py,sha256=91r6ljRCMIXiH1mE5cME45OstbTMJTicNEbTpGgJjQY,703
+qubership_pipelines_common_library/v1/__init__.py,sha256=QczIlSYNOtXMuMWSznhV_BkXMM5KLn1wOogtlT2kcy0,598
+qubership_pipelines_common_library/v1/artifactory_client.py,sha256=Gwf21BXUYNpKT_Y_wMyM07WlpDNTIBSUkSIsJlWfURg,4105
+qubership_pipelines_common_library/v1/execution/__init__.py,sha256=QczIlSYNOtXMuMWSznhV_BkXMM5KLn1wOogtlT2kcy0,598
+qubership_pipelines_common_library/v1/execution/exec_command.py,sha256=dezqVgaPG1rstl9U8MveqK-6ex-4waJ9Acfm0XBbBsA,5403
+qubership_pipelines_common_library/v1/execution/exec_context.py,sha256=R9Kmb4t3QRXCJTMhC3qcPtxtyvCrIV037Ix9P_VD5YI,6055
+qubership_pipelines_common_library/v1/execution/exec_context_file.py,sha256=kbuL9mA21qhaueVe6SWvI3OM49Ekrm8v1lj1FFspBq4,7397
+qubership_pipelines_common_library/v1/execution/exec_info.py,sha256=c1ksds6c-NcegSH9SPknzFxd1iw8xT8qS2_aZaVZ7F0,4280
+qubership_pipelines_common_library/v1/execution/exec_logger.py,sha256=rtSCLo3mqtwIc2S_tBs0uizehdthBGfygB1Vpwa-sRA,3102
+qubership_pipelines_common_library/v1/git_client.py,sha256=uop4dREW0HoaAbGHSzp3P4vk1Hk-VrPK5RhAP3Hj51o,6100
+qubership_pipelines_common_library/v1/github_client.py,sha256=okKc48tIB4G95gLYe6DgIyTYKK4joqrEQ-2-i0Yxywg,15058
+qubership_pipelines_common_library/v1/gitlab_client.py,sha256=ZhjaMT9JMfE5Mc0XSYvXHA_vE2imE7sXzbsse-4oBJ0,15736
+qubership_pipelines_common_library/v1/jenkins_client.py,sha256=VsD4KQNmLTeFvyVnY0m1xPv3s5bb-sNbgO6SwTJ2FfY,8597
+qubership_pipelines_common_library/v1/kube_client.py,sha256=rbdc0Q2r6AhJ49FKr-15_1r9Uit4_6U68rWwGYDjdWc,12715
+qubership_pipelines_common_library/v1/log_client.py,sha256=DTJ8aI_37l570RyolDC2cHaOkkccZWi7cFE6qYUuQeo,1514
+qubership_pipelines_common_library/v1/maven_client.py,sha256=DbyPp6lh17op04GGeq2jIbk-SyVzCCHRcr2ox-eUv54,15054
+qubership_pipelines_common_library/v1/minio_client.py,sha256=4KlkCJvtgGKQOujChxRtKrpoZVukooMLfj5D8C9CKC4,4343
+qubership_pipelines_common_library/v1/utils/__init__.py,sha256=QczIlSYNOtXMuMWSznhV_BkXMM5KLn1wOogtlT2kcy0,598
+qubership_pipelines_common_library/v1/utils/rest.py,sha256=MaCS6L6Khs_HaWoi3WNj9Go33d9zEVErLP5T8iVRyHA,3068
+qubership_pipelines_common_library/v1/utils/utils.py,sha256=5PhXyFC1Zfuz0KDrWC9QgacTLVVk8zu0-6wxYS0bmzE,1865
+qubership_pipelines_common_library/v1/utils/utils_aws.py,sha256=BPPnHBzPPXPqFijtAiw16sTPu1tFZjS95GkSMX_HdjA,808
+qubership_pipelines_common_library/v1/utils/utils_cli.py,sha256=3b4SbAKUearf2d_W6S8kuMNaB_Up1Qiblm8Nc5DHEqE,3199
+qubership_pipelines_common_library/v1/utils/utils_context.py,sha256=IlMFXGxS8zJw33Gu3SbOUcj88wquIkobBlWkdFbR7MA,3767
+qubership_pipelines_common_library/v1/utils/utils_dictionary.py,sha256=6wGAoBmLzPGGqdtkoqU9RtMBYuOO-UkZsZDh7GzubjA,1365
+qubership_pipelines_common_library/v1/utils/utils_file.py,sha256=E4RhpeCRhUt-EQ_6pUz-QEKkH8JidJWwYxZmrAvpHBk,2905
+qubership_pipelines_common_library/v1/utils/utils_json.py,sha256=QczIlSYNOtXMuMWSznhV_BkXMM5KLn1wOogtlT2kcy0,598
+qubership_pipelines_common_library/v1/utils/utils_string.py,sha256=Phx5ZXPRjhjg9AaSPx6WLX9zQvwJH1txslfnG3jJ43w,993
+qubership_pipelines_common_library/v1/webex_client.py,sha256=JU_0NgLu_p6zgaUi-ixgZeFMlJaTAvXwrU1oA607Bv0,2997
+qubership_pipelines_common_library/v2/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qubership_pipelines_common_library/v2/extensions/pipeline_data_importer.py,sha256=3I6hvqZy19kZsjhhqaluBFoaGBeDeF0DVOmXjYwibAA,784
+qubership_pipelines_common_library/v2/github/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qubership_pipelines_common_library/v2/github/github_client.py,sha256=8ZLFnJDXveoxS4-agiYTqv0sZFDT7FCvMRfIln51QnQ,142
+qubership_pipelines_common_library/v2/github/github_pipeline_data_importer.py,sha256=BXq549psTvErvUYOrx38QkpglgZg-TH10TfGk0PcQxE,1035
+qubership_pipelines_common_library/v2/github/github_run_pipeline_command.py,sha256=calEWrmFAbEk6XS_-RDghqR4KwnTMLA_eecgKyDDois,11245
+qubership_pipelines_common_library/v2/github/safe_github_client.py,sha256=tS6Huv5K_lkv4mKAY3Uw0PoG21kJkrXQ9e1NdGLvpws,1295
+qubership_pipelines_common_library/v2/gitlab/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qubership_pipelines_common_library/v2/gitlab/custom_extensions.py,sha256=cQX5H2VJJ7yqVAR9XsrXvDD6oiuHelAuu_QznU2s6UM,5628
+qubership_pipelines_common_library/v2/gitlab/gitlab_client.py,sha256=OdAZOZbLwpfxLqvqDMT3uGdNxD1SfRKAWyemIr7lVss,1707
+qubership_pipelines_common_library/v2/gitlab/gitlab_pipeline_data_importer.py,sha256=eWB92mGQl5L2XQpUnzpAPTVFm-p8k6H6LMF6T4VkR7o,1413
+qubership_pipelines_common_library/v2/gitlab/gitlab_run_pipeline_command.py,sha256=zMe1w4P1BlRcnCaKusA0Dv-muhYhP16Q5v5iH8z0hC0,11833
+qubership_pipelines_common_library/v2/gitlab/safe_gitlab_client.py,sha256=Ptlmgw5OCO0S24B-fAVxSdBO1yxx0LadVTLZXyhOwuI,1813
+qubership_pipelines_common_library/v2/podman/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qubership_pipelines_common_library/v2/podman/podman_command.md,sha256=D4eA8RsVmRq5o4NIxpMLV7QcRkBR_dCf3A5cVsh0w3M,6490
+qubership_pipelines_common_library/v2/podman/podman_command.py,sha256=kz5lGPzgih6PZNtHjr1fnzs0KYthY_WLgduBJAI2Kzo,15512
+qubership_pipelines_common_library/v2/sops/sops_client.py,sha256=CzeNTlMb3UPTmzT0Lgooqj34qyUrLTDLuUp8o2Leua4,4948
+qubership_pipelines_common_library/v2/utils/crypto_utils.py,sha256=zZ32IJY7WKzJEJNyZQVCPdWC4uujo6goR0MyzBAhn78,1504
+qubership_pipelines_common_library/v2/utils/extension_utils.py,sha256=-OyT6xrIg-PdHHy2Y712rbOAB6Q7WXTqGwP7oVne4k4,965
+qubership_pipelines_common_library/v2/utils/retry_decorator.py,sha256=Q0gXvOijOCF62z37qoRpYc3w0QPVkqk1Wg8PnW8musY,4455
+qubership_pipelines_common_library-2.0.0.dist-info/METADATA,sha256=Jb38VttMg0aGH1QEoEKH0V_zC_yLg7yZknlqI2lKNnw,3017
+qubership_pipelines_common_library-2.0.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+qubership_pipelines_common_library-2.0.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+qubership_pipelines_common_library-2.0.0.dist-info/RECORD,,