qubership-pipelines-common-library 0.2.6__py3-none-any.whl → 2.0.1__py3-none-any.whl

qubership_pipelines_common_library/v2/gitlab/custom_extensions.py

@@ -0,0 +1,101 @@
+from pathlib import Path
+
+from qubership_pipelines_common_library.v1.execution.exec_command import ExecutionCommandExtension
+from qubership_pipelines_common_library.v1.execution.exec_info import ExecutionInfo
+from qubership_pipelines_common_library.v2.extensions.pipeline_data_importer import PipelineDataImporter
+
+
+class GitlabDOBPParamsPreExt(ExecutionCommandExtension):
+    """
+    Pre-execution extension, enriching 'pipeline_params' with values from environment variables
+    """
+    def execute(self):
+        self.context.logger.info("Adding DOBP-specific params to pipeline_params...")
+
+        # Add upstream-cancelled params:
+        import os
+        if project_url := os.getenv('PROJECT_URL'):
+            from urllib.parse import urlparse
+            parsed_project_url = urlparse(project_url)
+            self.command.pipeline_params.setdefault('DOBP_UPSTREAM_SERVER_URL', f"{parsed_project_url.scheme}://{parsed_project_url.netloc}")
+            self.command.pipeline_params.setdefault('DOBP_UPSTREAM_PROJECT_PATH', parsed_project_url.path.strip('/'))
+
+        if pipeline_id := os.getenv('PIPELINE_ID'):
+            self.command.pipeline_params.setdefault('DOBP_UPSTREAM_PIPELINE_ID', pipeline_id)
+
+        # Add retry params:
+        if retry_downstream_pipeline_id := os.getenv('DOBP_RETRY_DOWNSTREAM_PIPELINE_ID'):
+            self.command.pipeline_params.setdefault('DOBP_RETRY_PIPELINE_ID', retry_downstream_pipeline_id)
+
+
+class GitlabModulesOpsPipelineDataImporter(PipelineDataImporter):
+    """
+    GitLab Modules Ops implementation:
+        imports data from contracted GitLab Declarative Pipelines
+        extracts output files and params of targeted pipeline into 'output' folder of this command
+    """
+
+    IMPORTED_CONTEXT_FILE = 'pipeline/output/context.yaml'
+
+    def import_pipeline_data(self, execution: ExecutionInfo) -> None:
+        import os, zipfile
+        self.context.logger.info("GitlabModulesOpsPipelineDataImporter - importing pipeline data...")
+        project_id = execution.get_name()
+        pipeline_id = execution.get_id()
+
+        if job := self.command.gl_client.get_latest_job(project_id, pipeline_id):
+            self.context.logger.info(f"Latest job: {job.id}")
+            local_dirpath = self.context.path_temp
+            self.context.logger.debug(f"Contents of folder {local_dirpath}: {os.listdir(local_dirpath)}")
+            if artifacts_file := self.command.gl_client.download_job_artifacts(job.pipeline.get('project_id'), job.id, local_dirpath):
+                with zipfile.ZipFile(artifacts_file) as zf:
+                    self.context.logger.debug(f"Zip contents: ${zf.namelist()}")
+                    zf.extractall(local_dirpath)
+            self.context.logger.debug(f"Contents of folder {local_dirpath} (after zip.extractall): {os.listdir(local_dirpath)}")
+            self._import_downloaded_data(local_dirpath / self.IMPORTED_CONTEXT_FILE)
+        else:
+            self.context.logger.warning("No jobs found")
+
+        self.context.output_params.load(self.context.context.get("paths.output.params"))
+        self.context.output_params_secure.load(self.context.context.get("paths.output.params_secure"))
+
+    def _import_downloaded_data(self, src_context_filepath: Path):
+        import shutil
+        from qubership_pipelines_common_library.v1.utils.utils_file import UtilsFile
+        from qubership_pipelines_common_library.v1.utils.utils_dictionary import UtilsDictionary
+
+        if src_context_filepath.is_file():
+            self.context.logger.info(f"Importing from context file {src_context_filepath}")
+            src_context = UtilsFile.read_yaml(src_context_filepath)
+            src_base_dirpath = src_context_filepath.parent
+
+            def get_path_from_src_context(param, default_value=None):
+                if param_value := UtilsDictionary.get_by_path(src_context, param, default_value):
+                    return Path(src_base_dirpath, param_value)
+                return None
+
+            for src in ('paths.output.params', 'paths.output.params_secure',):
+                src_filepath = get_path_from_src_context(src)
+                if src_filepath and src_filepath.is_file():
+                    dst_file = self.context.context.get(src)
+                    self.context.logger.info(f"Copying file {src_filepath} -> {dst_file}")
+                    UtilsFile.create_parent_dirs(dst_file)
+                    shutil.copyfile(src_filepath, dst_file)
+
+            src_files_dirpath = get_path_from_src_context('paths.output.files')
+            if src_files_dirpath and src_files_dirpath.is_dir():
+                dst_files_dir = self.context.context.get('paths.output.files')
+                self.context.logger.info(f"Copying dir {src_files_dirpath} -> {dst_files_dir}")
+                shutil.copytree(src_files_dirpath, dst_files_dir, dirs_exist_ok=True)
+
+            src_logs_dirpath = get_path_from_src_context('paths.logs', 'logs')
+            for _ext in ('json', 'yaml',):
+                src_exec_report_filepath = src_logs_dirpath / f"execution_report.{_ext}"
+                if src_exec_report_filepath.is_file():
+                    dst_exec_report_filepath = self.context.path_logs / f"nested_pipeline_report.{_ext}"
+                    UtilsFile.create_parent_dirs(dst_exec_report_filepath)
+                    self.context.logger.info(f"Copying file {src_exec_report_filepath} -> {dst_exec_report_filepath}")
+                    shutil.copyfile(src_exec_report_filepath, dst_exec_report_filepath)
+
+        else:
+            self.context.logger.warning(f"Imported context file does not exist: {src_context_filepath}")

qubership_pipelines_common_library/v2/gitlab/gitlab_client.py

@@ -0,0 +1,36 @@
+import os, logging
+
+from qubership_pipelines_common_library.v1.execution.exec_info import ExecutionInfo
+from qubership_pipelines_common_library.v1.gitlab_client import GitlabClient as GitlabClientV1
+
+
+class GitlabClient(GitlabClientV1):
+
+    def trigger_pipeline(self, project_id: str, ref: str, trigger_token: str = None, variables: dict = None, use_ci_job_token: bool = False):
+        """"""
+        if variables is None:
+            variables = {}
+        if use_ci_job_token:
+            trigger_token = os.getenv('CI_JOB_TOKEN')
+        trigger_data = {k: self._cast_to_string(v) for k, v in variables.items()}
+        project = self.gl.projects.get(project_id, lazy=True)
+        pipeline = project.trigger_pipeline(ref, trigger_token, trigger_data)
+        logging.info(f"Pipeline successfully started (via TRIGGER) at {pipeline.web_url}")
+        return ExecutionInfo().with_name(project_id).with_id(pipeline.get_id()) \
+            .with_url(pipeline.web_url).with_params(trigger_data) \
+            .start()
+
+    def create_pipeline(self, project_id: str, ref: str, variables: dict):
+        """"""
+        if variables is None:
+            variables = {}
+        create_data = {
+            'ref': ref,
+            'variables': [{'key': k, 'value': self._cast_to_string(v)} for k, v in variables.items()],
+        }
+        project = self.gl.projects.get(project_id, lazy=True)
+        pipeline = project.pipelines.create(create_data)
+        logging.info(f"Pipeline successfully started (via CREATE) at {pipeline.web_url}")
+        return ExecutionInfo().with_name(project_id).with_id(pipeline.get_id()) \
+            .with_url(pipeline.web_url).with_params(create_data) \
+            .start()

qubership_pipelines_common_library/v2/gitlab/gitlab_pipeline_data_importer.py

@@ -0,0 +1,26 @@
+import zipfile
+from pathlib import Path
+
+from qubership_pipelines_common_library.v1.execution.exec_info import ExecutionInfo
+from qubership_pipelines_common_library.v2.extensions.pipeline_data_importer import PipelineDataImporter
+
+
+class DefaultGitlabPipelineDataImporter(PipelineDataImporter):
+    """
+    Default GitLab implementation:
+        downloads all available workflow run artifacts,
+        extracts them into context-defined 'paths.output.files' path
+    """
+    def import_pipeline_data(self, execution: ExecutionInfo) -> None:
+        self.context.logger.info("DefaultGitlabPipelineDataImporter - importing pipeline data...")
+        project_id = execution.get_name()
+        pipeline_id = execution.get_id()
+        if job := self.command.gl_client.get_latest_job(project_id, pipeline_id):
+            if artifacts_file := self.command.gl_client.download_job_artifacts(job.pipeline.get('project_id'), job.id, self.context.path_temp):
+                output_path = Path(self.context.input_param_get("paths.output.files"))
+                output_path.mkdir(parents=True, exist_ok=True)
+                with zipfile.ZipFile(artifacts_file) as zf:
+                    self.context.logger.debug(f"Zip contents: ${zf.namelist()}")
+                    zf.extractall(output_path)
+        else:
+            self.context.logger.warning(f"Job not found! project_id: {project_id}, pipeline_id: {pipeline_id}")

qubership_pipelines_common_library/v2/gitlab/gitlab_run_pipeline_command.py

@@ -0,0 +1,195 @@
+from qubership_pipelines_common_library.v1.execution.exec_command import ExecutionCommand
+from qubership_pipelines_common_library.v1.execution.exec_info import ExecutionInfo
+from qubership_pipelines_common_library.v1.utils.utils_string import UtilsString
+from qubership_pipelines_common_library.v2.extensions.pipeline_data_importer import PipelineDataImporter
+from qubership_pipelines_common_library.v2.gitlab.gitlab_pipeline_data_importer import DefaultGitlabPipelineDataImporter
+from qubership_pipelines_common_library.v2.gitlab.safe_gitlab_client import SafeGitlabClient
+
+
+class GitlabRunPipeline(ExecutionCommand):
+    """
+    Runs GitLab Pipeline via Trigger or Create API and optionally imports artifacts.
+
+    This command runs GitLab Pipeline, monitors its execution, and provides
+    options for importing resulting artifacts and custom data processing through extensible
+    importers.
+
+    Input Parameters Structure (this structure is expected inside "input_params.params" block):
+    ```
+    {
+        "pipeline_path": "path/to/gitlab_project",               # REQUIRED: Full pipeline path (e.g. "group/subgroup/repo")
+        "pipeline_branch": "main",                               # OPTIONAL: Branch to run pipeline from (default: repo's default branch)
+        "trigger_type": "CREATE_PIPELINE",                       # OPTIONAL: Which API will be used to trigger the pipeline (CREATE_PIPELINE or TRIGGER_PIPELINE)
+        "pipeline_params": {                                     # OPTIONAL: Input parameters to pass to the pipeline
+            "KEY1": "VALUE1",
+            "KEY2": "VALUE2"
+        },
+        "import_artifacts": false,                               # OPTIONAL: Whether to import pipeline artifacts (default: false)
+        "use_existing_pipeline": 123456789,                      # OPTIONAL: Use existing pipeline ID (or use 'latest' here) instead of starting new one (debug feature)
+        "timeout_seconds": 1800,                                 # OPTIONAL: Maximum wait time for pipeline completion in seconds (default: 1800, 0 for async execution)
+        "wait_seconds": 1,                                       # OPTIONAL: Wait interval between status checks in seconds (default: 1)
+        "retry_timeout_seconds": 180,                            # OPTIONAL: Timeout for GitLab client initialization and pipeline start retries in seconds (default: 180)
+        "retry_wait_seconds": 1,                                 # OPTIONAL: Wait interval between retries in seconds (default: 1)
+        "success_statuses": "SUCCESS,UNSTABLE"                   # OPTIONAL: Comma-separated list of acceptable completion statuses (default: SUCCESS)
+    }
+    ```
+
+    Systems Configuration (expected in "systems.gitlab" block):
+    ```
+    {
+        "url": "https://github.com",                             # OPTIONAL: GitLab URL for self-hosted instances (default: https://gitlab.com)
+        "password": "<gitlab_token>"                             # REQUIRED: GitLab access token with CI/CD permissions
+        "trigger_token": "<gitlab_trigger_token>"                # OPTIONAL: Special token issued for triggering pipeline. If not provided - will try to use CI_JOB_TOKEN
+    }
+    ```
+
+    Output Parameters:
+        - params.build.url: URL to view the pipeline run in GitLab
+        - params.build.id: ID of the executed pipeline
+        - params.build.status: Final status of the pipeline execution
+        - params.build.date: Workflow start time in ISO format
+        - params.build.duration: Total execution duration in human-readable format
+        - params.build.name: Name of the pipeline execution
+
+    Extension Points:
+        - Custom pipeline data importers can be implemented by extending PipelineDataImporter interface
+        - PipelineDataImporter is passed into constructor of command via "pipeline_data_importer" arg
+
+    Notes:
+        - Setting timeout_seconds to 0 enables asynchronous execution (workflow starts but command doesn't wait for completion)
+        - For self-hosted GitLab instances, configure "systems.github.url"
+        - Custom data importers receive the command context and can implement advanced processing logic
+    """
+
+    # default timeout values
+    WAIT_TIMEOUT = 1800
+    WAIT_SECONDS = 1
+    RETRY_TIMEOUT_SECONDS = 180
+    RETRY_WAIT_SECONDS = 1
+
+    TRIGGER_TYPE_TRIGGER_PIPELINE = 'TRIGGER_PIPELINE'
+    TRIGGER_TYPE_CREATE_PIPELINE = 'CREATE_PIPELINE'
+    TRIGGER_TYPES = (TRIGGER_TYPE_TRIGGER_PIPELINE, TRIGGER_TYPE_CREATE_PIPELINE,)
+
+    def __init__(self, *args, pipeline_data_importer: PipelineDataImporter = None, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.pipeline_data_importer = pipeline_data_importer or DefaultGitlabPipelineDataImporter()
+        if pipeline_data_importer and not isinstance(pipeline_data_importer, PipelineDataImporter):
+            raise TypeError(f"Class {type(pipeline_data_importer)} must inherit from PipelineDataImporter")
+
+    def _validate(self):
+        names = [
+            "paths.input.params",
+            "paths.output.params",
+            "paths.output.files",
+            "systems.gitlab.password",
+            "params.pipeline_path",
+        ]
+        if not self.context.validate(names):
+            return False
+
+        self.timeout_seconds = max(0, int(self.context.input_param_get("params.timeout_seconds", self.WAIT_TIMEOUT)))
+        self.wait_seconds = max(1, int(self.context.input_param_get("params.wait_seconds", self.WAIT_SECONDS)))
+
+        self.retry_timeout_seconds = int(self.context.input_param_get("params.retry_timeout_seconds", self.RETRY_TIMEOUT_SECONDS))
+        self.retry_wait_seconds = int(self.context.input_param_get("params.retry_wait_seconds", self.RETRY_WAIT_SECONDS))
+
+        if self.timeout_seconds == 0:
+            self.context.logger.info(f"Timeout is set to: {self.timeout_seconds}. This means that the pipeline will be started asynchronously")
+
+        self.gitlab_url = self.context.input_param_get("systems.gitlab.url", "https://gitlab.com")
+        self.pipeline_path = self.context.input_param_get("params.pipeline_path").strip("/")
+        self.pipeline_branch = self.context.input_param_get("params.pipeline_branch")
+
+        self.trigger_type = self.context.input_param_get("params.trigger_type", self.TRIGGER_TYPE_CREATE_PIPELINE)
+        if self.trigger_type not in self.TRIGGER_TYPES:
+            self.context.logger.error(f"Unsupported trigger_type: {self.trigger_type}")
+            return False
+        if self.trigger_type == self.TRIGGER_TYPE_TRIGGER_PIPELINE:
+            self.trigger_token = self.context.input_param_get("systems.gitlab.trigger_token")
+
+        self.pipeline_params = self.context.input_param_get("params.pipeline_params", {})
+        if not self.pipeline_params:
+            self.context.logger.info("Pipeline parameters were not specified. This means that pipeline will be started with its default values")
+        if not isinstance(self.pipeline_params, dict):
+            self.context.logger.error("Pipeline parameters were not loaded correctly. Probably mistake in the params definition")
+            return False
+        self.import_artifacts = UtilsString.convert_to_bool(self.context.input_param_get("params.import_artifacts", False))
+        self.success_statuses = [x.strip() for x in self.context.input_param_get("params.success_statuses", ExecutionInfo.STATUS_SUCCESS).split(",")]
+        self.use_existing_pipeline = self.context.input_param_get("params.use_existing_pipeline")
+        return True
+
+    def _execute(self):
+        self.context.logger.info("Running gitlab-run-pipeline...")
+
+        self.gl_client = SafeGitlabClient.create_gitlab_client(
+            host=self.gitlab_url,
+            username="",
+            password=self.context.input_param_get("systems.gitlab.password"),
+            retry_timeout_seconds=self.retry_timeout_seconds,
+            retry_wait_seconds=self.retry_wait_seconds
+        )
+        self.context.logger.info("Successfully initialized GitLab client")
+
+        if not self.pipeline_branch:
+            self.pipeline_branch = self.gl_client.get_default_branch(project_id=self.pipeline_path)
+
+        if self.use_existing_pipeline: # work with existing pipeline run
+            if self.use_existing_pipeline == 'latest':
+                pipeline_id = self.gl_client.get_latest_pipeline_id(project_id=self.pipeline_path, ref=self.pipeline_branch)
+            else:
+                pipeline_id = self.use_existing_pipeline
+            self.context.logger.info(f"Using existing pipeline: {pipeline_id}")
+            execution = ExecutionInfo().with_name(self.pipeline_path).with_id(pipeline_id).with_status(ExecutionInfo.STATUS_UNKNOWN)
+            execution.start()
+        else:
+            if self.trigger_type == self.TRIGGER_TYPE_CREATE_PIPELINE:
+                execution = self.gl_client.create_pipeline(
+                    project_id=self.pipeline_path,
+                    ref=self.pipeline_branch,
+                    variables=self.pipeline_params,
+                    retry_timeout_seconds=self.retry_timeout_seconds,
+                    retry_wait_seconds=self.retry_wait_seconds
+                )
+            elif self.trigger_type == self.TRIGGER_TYPE_TRIGGER_PIPELINE:
+                 execution = self.gl_client.trigger_pipeline(
+                     project_id=self.pipeline_path,
+                     ref=self.pipeline_branch,
+                     trigger_token=self.trigger_token,
+                     variables=self.pipeline_params,
+                     use_ci_job_token=(self.trigger_token is None),
+                     retry_timeout_seconds=self.retry_timeout_seconds,
+                     retry_wait_seconds=self.retry_wait_seconds
+                 )
+
+        if execution.get_status() != ExecutionInfo.STATUS_IN_PROGRESS:
+            self._exit(False, f"Pipeline was not started. Status {execution.get_status()}")
+        elif self.timeout_seconds < 1:
+            self.context.logger.info("Pipeline was started in asynchronous mode. Pipeline status and artifacts will not be processed")
+            return
+
+        self.context.logger.info(f"Pipeline successfully started. Waiting {self.timeout_seconds} seconds for execution to complete")
+        execution = self.gl_client.wait_pipeline_execution(execution=execution, timeout_seconds=self.timeout_seconds,
+                                                           wait_seconds=self.wait_seconds)
+        self.context.logger.info(f"Pipeline status: {execution.get_status()}")
+
+        if self.import_artifacts and self.pipeline_data_importer and execution.get_status() in ExecutionInfo.STATUSES_COMPLETE:
+            try:
+                self.pipeline_data_importer.with_command(self)
+                self.pipeline_data_importer.import_pipeline_data(execution)
+            except Exception as e:
+                self.context.logger.error(f"Exception during pipeline_data_importer execution: {e}")
+
+        self._save_execution_info(execution)
+        if execution.get_status() not in self.success_statuses:
+            self._exit(False, f"Status: {execution.get_status()}")
+
+    def _save_execution_info(self, execution: ExecutionInfo):
+        self.context.logger.info("Writing GitLab pipeline execution status")
+        self.context.output_param_set("params.build.url", execution.get_url())
+        self.context.output_param_set("params.build.id", execution.get_id())
+        self.context.output_param_set("params.build.status", execution.get_status())
+        self.context.output_param_set("params.build.date", execution.get_time_start().isoformat())
+        self.context.output_param_set("params.build.duration", execution.get_duration_str())
+        self.context.output_param_set("params.build.name", execution.get_name())
+        self.context.output_params_save()

qubership_pipelines_common_library/v2/gitlab/safe_gitlab_client.py

@@ -0,0 +1,32 @@
+from qubership_pipelines_common_library.v1.execution.exec_info import ExecutionInfo
+from qubership_pipelines_common_library.v2.gitlab.gitlab_client import GitlabClient
+from qubership_pipelines_common_library.v2.utils.retry_decorator import RetryDecorator
+
+
+class SafeGitlabClient(GitlabClient):
+
+    def __init__(self, host: str, username: str, password: str):
+        super().__init__(host=host, username=username, password=password)
+
+    @classmethod
+    @RetryDecorator(condition_func=lambda result: result is not None)
+    def create_gitlab_client(cls, host: str, username: str, password: str,
+                             retry_timeout_seconds: int = 180, retry_wait_seconds: int = 1):
+        return cls(host, username, password)
+
+    @RetryDecorator(
+        condition_func=lambda result: result is not None and result.get_status() not in [
+            ExecutionInfo.STATUS_NOT_STARTED, ExecutionInfo.STATUS_UNKNOWN]
+    )
+    def trigger_pipeline(self, project_id: str, ref: str, trigger_token: str = None, variables: dict = None,
+                         use_ci_job_token: bool = False, retry_timeout_seconds: int = 180, retry_wait_seconds: int = 1):
+        return super().trigger_pipeline(project_id=project_id, ref=ref, trigger_token=trigger_token,
+                                        variables=variables, use_ci_job_token=use_ci_job_token)
+
+    @RetryDecorator(
+        condition_func=lambda result: result is not None and result.get_status() not in [
+            ExecutionInfo.STATUS_NOT_STARTED, ExecutionInfo.STATUS_UNKNOWN]
+    )
+    def create_pipeline(self, project_id: str, ref: str, variables: dict = None,
+                         retry_timeout_seconds: int = 180, retry_wait_seconds: int = 1):
+        return super().create_pipeline(project_id=project_id, ref=ref, variables=variables)

qubership_pipelines_common_library/v2/jenkins/custom_extensions.py

@@ -0,0 +1,63 @@
+from pathlib import Path
+
+from qubership_pipelines_common_library.v1.execution.exec_command import ExecutionCommandExtension
+from qubership_pipelines_common_library.v1.execution.exec_info import ExecutionInfo
+from qubership_pipelines_common_library.v2.extensions.pipeline_data_importer import PipelineDataImporter
+
+
+class JenkinsOutputParamsPipelineDataImporter(PipelineDataImporter):
+    """
+    Jenkins Output Params Importer:
+        imports data from contracted Declarative Pipelines
+        extracts output files and params of targeted pipeline into 'output' folder of this command
+    """
+    def import_pipeline_data(self, execution: ExecutionInfo) -> None:
+        self.context.logger.info("Processing jenkins job artifacts")
+        artifact_paths = self.command.jenkins_client.get_pipeline_execution_artifacts(execution)
+        if artifact_paths and len(artifact_paths):
+            for artifact_path in artifact_paths:
+                if artifact_path == "output/params.yaml":
+                    self.context.logger.info(f"Artifact with name '{artifact_path}' will be processed as output params")
+                    file_path = self.context.input_param_get("paths.output.params")
+                    self.command.jenkins_client.save_pipeline_execution_artifact_to_file(execution, artifact_path, file_path)
+                    self.context.output_params.load(file_path)
+                elif artifact_path == "output/params_secure.yaml":
+                    self.context.logger.info(f"Artifact with name '{artifact_path}' will be processed as output secure params")
+                    file_path = self.context.input_param_get("paths.output.params_secure")
+                    self.command.jenkins_client.save_pipeline_execution_artifact_to_file(execution, artifact_path, file_path)
+                    self.context.output_params_secure.load(file_path)
+                else:
+                    self.context.logger.info(f"Artifact with name '{artifact_path}' will be saved as output file")
+                    file_path = Path(self.context.input_param_get("paths.output.files")).joinpath(artifact_path)
+                    self.command.jenkins_client.save_pipeline_execution_artifact_to_file(execution, artifact_path, file_path)
+        else:
+            self.context.logger.info("No artifacts found in the job")
+
+
+class JenkinsSaveInjectedEnvVars(ExecutionCommandExtension):
+    """
+    Post-execution extension, saving injected environment variables from the build
+    """
+
+    INJECTED_ENV_VARS_URL = "injectedEnvVars/api/json"
+
+    def execute(self):
+        import os, requests
+        from requests.auth import HTTPBasicAuth
+
+        self.context.logger.info("Trying to get and save injected vars from build")
+        build_url = self.command.execution_info.get_url()
+        if build_url:
+            injected_api_url = build_url + self.INJECTED_ENV_VARS_URL
+            response = requests.get(injected_api_url,
+                                    auth=HTTPBasicAuth(self.context.input_param_get("systems.jenkins.username"),
+                                                       self.context.input_param_get("systems.jenkins.password")),
+                                    verify=True if os.getenv('PYTHONHTTPSVERIFY', '1') == '0' else False)
+
+            if response.status_code == 200:
+                self.context.output_param_set("params.build.injected_vars", response.json().get("envMap", {}))
+                self.context.output_params_save()
+            else:
+                self.context.logger.warning(f"Can't get injected variables for url {injected_api_url} with response code {response.status_code}")
+        else:
+            self.context.logger.warning("Can't get build url for injectedEnvVars")

qubership_pipelines_common_library/v2/jenkins/jenkins_client.py

@@ -0,0 +1,5 @@
+from qubership_pipelines_common_library.v1.jenkins_client import JenkinsClient as JenkinsClientV1
+
+
+class JenkinsClient(JenkinsClientV1):
+    pass

qubership_pipelines_common_library/v2/jenkins/jenkins_pipeline_data_importer.py

@@ -0,0 +1,31 @@
+import zipfile
+from pathlib import Path
+
+from qubership_pipelines_common_library.v1.execution.exec_info import ExecutionInfo
+from qubership_pipelines_common_library.v2.extensions.pipeline_data_importer import PipelineDataImporter
+from qubership_pipelines_common_library.v2.jenkins.jenkins_client import JenkinsClient
+
+
+class DefaultJenkinsPipelineDataImporter(PipelineDataImporter):
+    """
+    Default Jenkins implementation:
+        downloads all available workflow run artifacts as one archive,
+        extracts them into context-defined 'paths.output.files' path
+    """
+    def import_pipeline_data(self, execution: ExecutionInfo) -> None:
+        self.context.logger.info("DefaultJenkinsPipelineDataImporter - importing pipeline data...")
+        artifact_paths = self.command.jenkins_client.get_pipeline_execution_artifacts(execution)
+        if artifact_paths:
+            self.context.logger.info(f"Job produced {len(artifact_paths)} artifact(s)")
+            self.command.jenkins_client.save_pipeline_execution_artifact_to_file(
+                execution,
+                JenkinsClient.BUILD_ARTIFACTS_ZIP_PATH,
+                self.context.path_temp / "archive.zip")
+        else:
+            self.context.logger.info("No artifacts found, skipping pipeline import.")
+
+        output_path = Path(self.context.input_param_get("paths.output.files"))
+        output_path.mkdir(parents=True, exist_ok=True)
+        for file_path in Path(self.context.path_temp).iterdir():
+            with zipfile.ZipFile(file_path) as zf:
+                zf.extractall(output_path)