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

qubership_pipelines_common_library/v1/execution/exec_command.py

@@ -15,9 +15,11 @@
 import logging
 import sys
 import traceback
+from abc import ABC, abstractmethod
 
 from qubership_pipelines_common_library.v1.execution.exec_context import ExecutionContext
 from qubership_pipelines_common_library.v1.utils.utils_context import create_execution_context
+from qubership_pipelines_common_library.v2.utils.crypto_utils import CryptoUtils
 
 
 class ExecutionCommand:
@@ -26,7 +28,9 @@ class ExecutionCommand:
     FAILURE_MSG = "Status: FAILURE"
 
     def __init__(self, context_path: str = None, input_params: dict = None, input_params_secure: dict = None,
-                 folder_path: str = None, parent_context_to_reuse: ExecutionContext = None):
+                 folder_path: str = None, parent_context_to_reuse: ExecutionContext = None,
+                 pre_execute_actions: list['ExecutionCommandExtension'] = None,
+                 post_execute_actions: list['ExecutionCommandExtension'] = None):
         """
         Extendable interface intended to simplify working with input/output params and passing them between commands in different Pipeline Executors
 
@@ -40,30 +44,56 @@ class ExecutionCommand:
             input_params_secure (dict): Secure parameters that will be merged into dynamically created params
             folder_path (str): Folder path where dynamically-created context will be stored. Optional, will create new temp folder if missing.
             parent_context_to_reuse (ExecutionContext): Optional, existing context to propagate input params from.
+            pre_execute_actions: Optional, list of actions, implementing ExecutionCommandExtension, to be executed before command
+            post_execute_actions: Optional, list of actions, implementing ExecutionCommandExtension, to be executed after command
         """
         if not context_path:
             context_path = create_execution_context(input_params=input_params, input_params_secure=input_params_secure,
                                                     folder_path=folder_path, parent_context_to_reuse=parent_context_to_reuse)
         self.context = ExecutionContext(context_path)
+        self._pre_execute_actions = []
+        if pre_execute_actions:
+            self._pre_execute_actions.extend(pre_execute_actions)
+        self._post_execute_actions = []
+        if post_execute_actions:
+            self._post_execute_actions.extend(post_execute_actions)
 
     def run(self):
         """Runs command following its lifecycle"""
         try:
+            self._log_input_params()
             if not self._validate():
                 logging.error(ExecutionCommand.FAILURE_MSG)
                 self._exit(False, ExecutionCommand.FAILURE_MSG)
+            self._pre_execute()
             self._execute()
+            self._post_execute()
             self._exit(True, ExecutionCommand.SUCCESS_MSG)
         except Exception as e:
             logging.error(traceback.format_exc())
             self._exit(False, ExecutionCommand.FAILURE_MSG)
 
+    def _log_input_params(self):
+        self.context.logger.info(
+            "Input context parameters:\n%s\n%s",
+            CryptoUtils.get_parameters_for_print(self.context.input_params_secure.content, True),
+            CryptoUtils.get_parameters_for_print(self.context.input_params.content, False)
+        )
+
     def _validate(self):
         return self.context.validate(["paths.input.params"])
 
+    def _pre_execute(self):
+        for action in self._pre_execute_actions:
+            action.with_command(self).execute()
+
     def _execute(self):
         logging.info("Status: SKIPPED")
 
+    def _post_execute(self):
+        for action in self._post_execute_actions:
+            action.with_command(self).execute()
+
     def _exit(self, success: bool, message: str):
         if success:
             self.context.logger.info(message)
@@ -71,3 +101,24 @@ class ExecutionCommand:
         else:
             self.context.logger.error(message)
             sys.exit(1)
+
+
+class ExecutionCommandExtension(ABC):
+    """
+    Base interface used in ExecutionCommand pre_execute and post_execute actions
+    Can be extended by users to perform custom extension logic before and after execution
+    """
+
+    def __init__(self):
+        self.context = None
+        self.command = None
+
+    def with_command(self, command: ExecutionCommand) -> 'ExecutionCommandExtension':
+        self.command = command
+        self.context = command.context
+        return self
+
+    @abstractmethod
+    def execute(self) -> None:
+        """Implements custom extension logic"""
+        pass

qubership_pipelines_common_library/v1/execution/exec_info.py

@@ -108,3 +108,7 @@ class ExecutionInfo:
     def with_params(self, params: dict):
         self.params = params
         return self
+
+    def __str__(self):
+        return (f"ExecutionInfo(id='{self.id}', url='{self.url}', status='{self.status}', "
+                f"time_start={self.time_start.isoformat()})")

qubership_pipelines_common_library/v1/github_client.py

@@ -51,11 +51,20 @@ class GithubClient:
 
     def __init__(self, token: str = None, api_url: str = None, **kwargs):
         """
+        This class is deprecated and will be removed in v3.0.0. Use class from v2 module instead.
         Arguments:
             token (str): Token used in auth request
             api_url (str): Optional Github Enterprise API URL, leave empty if using github.com
             **kwargs (Any): will be passed into Github API constructor
         """
+        if self.__class__ == GithubClient:
+            import warnings
+            warnings.warn(
+                "v1.github_client.GithubClient is deprecated since v2.0.0 and will be removed in v3.0.0. "
+                "Use v2.github.github_client.GithubClient instead.",
+                DeprecationWarning,
+                stacklevel=2
+            )
         self.gh = GhApi(token=token, gh_host=api_url, **kwargs)
         logging.info("Github Client configured")
 

qubership_pipelines_common_library/v1/gitlab_client.py

@@ -12,8 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import logging, gitlab
-from time import sleep
+import logging, gitlab, time
+from pathlib import Path
+
 from gitlab import GitlabGetError
 from qubership_pipelines_common_library.v1.execution.exec_info import ExecutionInfo
 
@@ -36,6 +37,7 @@ class GitlabClient:
 
     def __init__(self, host: str, username: str, password: str, email: str = None, **kwargs):
         """
+        This class is deprecated and will be removed in v3.0.0. Use class from v2 module instead.
         Arguments:
             host (str): Gitlab instance URL
             username (str): User used in auth request, might be empty string if no auth is required
@@ -43,6 +45,14 @@ class GitlabClient:
             email (str): Email used when committing changes using API
             **kwargs (Any): will be passed into Gitlab API constructor
         """
+        if self.__class__ == GitlabClient:
+            import warnings
+            warnings.warn(
+                "v1.gitlab_client.GitlabClient is deprecated since v2.0.0 and will be removed in v3.0.0. "
+                "Use v2.gitlab.gitlab_client.GitlabClient instead.",
+                DeprecationWarning,
+                stacklevel=2
+            )
         self.host = host.rstrip("/")
         self.username = username
         self.email = email
@@ -120,7 +130,7 @@ class GitlabClient:
         while counter < timeout:
             counter += 1
             logging.info("Waiting pipeline execution timeout 1 second")
-            sleep(1)
+            time.sleep(1)
             continue
         pipeline.cancel()
         return execution.stop(ExecutionInfo.STATUS_ABORTED)
@@ -136,14 +146,17 @@ class GitlabClient:
             logging.error("Can't get pipeline status")
         return execution
 
-    def wait_pipeline_execution(self, execution: ExecutionInfo, timeout_seconds: float = 10.0,
+    def wait_pipeline_execution(self, execution: ExecutionInfo, timeout_seconds: float = 180.0,
                                 break_status_list: list = None, wait_seconds: float = 1.0):
         """"""
         if break_status_list is None:
             break_status_list = self.BREAK_STATUS_LIST
-        timeout = 0
+        count_seconds = 0
+        last_log_time = time.perf_counter()
+        estimated_max_attempts = timeout_seconds // wait_seconds
+        retries = 0
         execution.with_status(execution.get_status())
-        while timeout < timeout_seconds:
+        while count_seconds < timeout_seconds:
             try:
                 project = self.gl.projects.get(execution.get_name(), lazy=True)
                 pipeline = project.pipelines.get(execution.get_id())
@@ -154,10 +167,13 @@ class GitlabClient:
                     break
             except:
                 pass
-            timeout += wait_seconds
-            logging.info(f"Waiting pipeline execution timeout {wait_seconds} seconds")
-            sleep(wait_seconds)
-            continue
+            now = time.perf_counter()
+            retries += 1
+            if now - last_log_time >= 10.0:
+                logging.info(f"Made [{retries} of {estimated_max_attempts}] retries. Waiting pipeline execution {count_seconds} of {timeout_seconds}")
+                last_log_time = now
+            count_seconds += wait_seconds
+            time.sleep(wait_seconds)
         return execution
 
     @staticmethod
@@ -170,6 +186,65 @@ class GitlabClient:
                 return {"repo": url[:pos1], "branch": url[pos1 + len(part):pos2], "path": url[pos2 + 1:]}
         return None
 
+    def get_default_branch(self, project_id: str) -> str:
+        return self.gl.projects.get(project_id).default_branch
+
+    def get_latest_pipeline_id(self, project_id: str, ref: str) -> int | str:
+        project = self.gl.projects.get(project_id, lazy=True)
+        return project.pipelines.latest(ref=ref).get_id()
+
+    def get_latest_job(self, project_id: str, pipeline_id: str):
+        project = self.gl.projects.get(project_id, lazy=True)
+        pipeline = project.pipelines.get(pipeline_id, lazy=True)
+
+        jobs = pipeline.jobs.list(get_all=True)
+        logging.debug(f"All jobs from the pipeline: {jobs}")
+
+        # get jobs from downstream pipelines
+        bridges = pipeline.bridges.list(get_all=True)
+        logging.debug(f"Bridges: {bridges}")
+        for bridge in bridges:
+            downstream_pipeline_data = bridge.downstream_pipeline
+            downstream_project = self.gl.projects.get(downstream_pipeline_data.get('project_id'), lazy=True)
+            logging.debug(f"Getting jobs from a downstream pipeline: {downstream_pipeline_data.get('id')}...")
+            downstream_pipeline = downstream_project.pipelines.get(downstream_pipeline_data.get('id'))
+            jobs.extend(downstream_pipeline.jobs.list(get_all=True))
+
+        # get jobs from child pipelines
+        child_pipelines = project.pipelines.list(ref=f"downstream/{pipeline_id}", source="pipeline", all=True)
+        logging.debug(f"Child pipelines: {child_pipelines}")
+        for child_pipeline in child_pipelines:
+            logging.debug(f"Getting jobs from a child pipeline: {child_pipeline.id}...")
+            child_jobs = child_pipeline.jobs.list(get_all=True)
+            jobs.extend(child_jobs)
+
+        logging.debug(f"All jobs (+ jobs from downstream pipelines): {jobs}")
+        jobs = [j for j in jobs if j.started_at]
+        jobs = sorted(jobs, key=lambda j: j.started_at, reverse=True)
+        return jobs[0] if jobs else None
+
+    def download_job_artifacts(self, project_id, job_id, local_dir):
+        project = self.gl.projects.get(project_id, lazy=True)
+        job = project.jobs.get(job_id, lazy=True)
+        local_file = Path(local_dir, f"{job_id}.zip")
+        with local_file.open('wb') as f:
+            try:
+                job.artifacts(streamed=True, action=f.write)
+            except gitlab.GitlabGetError as e:
+                if e.response_code == 404:
+                    logging.warning(f"No artifacts for job {job_id}")
+                    return None
+                else: raise
+        logging.info(f"Artifacts downloaded to {local_file}")
+        return local_file
+
+    @staticmethod
+    def _cast_to_string(value) -> str:
+        if isinstance(value, str): return value
+        if value is None: return ''
+        if isinstance(value, bool): return 'true' if value else 'false'
+        return str(value)
+
     def _map_status(self, git_status: str, default_status: str):
         result = default_status
         if git_status in (GitlabClient.STATUS_CREATED, GitlabClient.STATUS_WAITING,
@@ -186,3 +261,88 @@ class GitlabClient:
         elif git_status == GitlabClient.STATUS_MANUAL:
             result = ExecutionInfo.STATUS_MANUAL
         return result
+
+    # Related static methods, with direct REST access
+    @staticmethod
+    def is_gitlab_project_exist(gitlab_url, gitlab_project, gitlab_token):
+        """"""
+        import requests
+        headers = {"PRIVATE-TOKEN": gitlab_token}
+        request = f"{gitlab_url}/api/v4/projects/{requests.utils.quote(gitlab_project, safe='')}"
+        logging.debug(f"Sending '{request}' request...")
+        response = requests.get(request, headers=headers)
+        if response.status_code == 200:
+            return True
+        else:
+            logging.error(f"Error {response.status_code}: {response.text}")
+        return False
+
+    @staticmethod
+    def search_group_id(gitlab_url, gitlab_project, gitlab_token):
+        """"""
+        import requests
+        headers = {"PRIVATE-TOKEN": gitlab_token}
+        request = f"{gitlab_url}/api/v4/groups?search={gitlab_project}"
+        logging.debug(f"Sending '{request}' request...")
+        response = requests.get(request, headers=headers)
+        if response.status_code == 200:
+            groups = response.json()
+            for group in groups:
+                if group.get("full_path") == gitlab_project:
+                    return group["id"]
+        else:
+            logging.error(f"Error {response.status_code}: {response.text}")
+
+    @staticmethod
+    def create_internal_gitlab_project(gitlab_url, gitlab_token, group_id, repo_name, repo_branch, visibility="internal"):
+        """"""
+        import requests
+        headers = {"PRIVATE-TOKEN": gitlab_token, "Content-Type": "application/json"}
+        data = {
+            "name": repo_name,
+            "namespace_id": group_id,
+            "visibility": visibility,
+            "default_branch": repo_branch
+        }
+        request = f"{gitlab_url}/api/v4/projects"
+        logging.debug(f"Sending '{request}' request...")
+        response = requests.post(request, headers=headers, json=data)
+        if response.status_code == 201:
+            response_json = response.json()
+            logging.info(f"Gitlab project was created. Url: '{response_json['web_url']}'")
+            GitlabClient.make_first_commit_to_gitlab_project(
+                gitlab_url=gitlab_url,
+                gitlab_token=gitlab_token,
+                project_id=response_json['id'],
+                repo_branch=repo_branch
+            )
+        else:
+            logging.error(f"Error {response.status_code}: {response.text}")
+
+    @staticmethod
+    def make_first_commit_to_gitlab_project(gitlab_url, gitlab_token, project_id, repo_branch):
+        """"""
+        import requests
+        logging.debug(f"Making first commit...")
+        headers = {"PRIVATE-TOKEN": gitlab_token, "Content-Type": "application/json"}
+        commit_payload = {
+            "branch": repo_branch,
+            "commit_message": "Initial commit",
+            "actions": [
+                {
+                    "action": "create",
+                    "file_path": "README.md",
+                    "content": "# This is an automatically created project"
+                }
+            ]
+        }
+
+        response = requests.post(
+            f"{gitlab_url}/api/v4/projects/{project_id}/repository/commits",
+            headers=headers,
+            json=commit_payload
+        )
+        if response.status_code == 201:
+            logging.info(f"Commit successfull")
+        else:
+            logging.error(f"Error {response.status_code}: {response.text}")

qubership_pipelines_common_library/v1/utils/utils_cli.py

@@ -15,6 +15,8 @@ def utils_cli(func):
     @click.option('--context_path', required=True, default=DEFAULT_CONTEXT_FILE_PATH, type=str, help="Path to context")
     @click.option("--input_params", "-p", multiple=True, callback=_input_params_to_dict,
                   help="Params to use instead of context as key-values. Nested keys are supported with double-underscores or dots as separators, e.g. -p params__group__key=value")
+    @click.option("--input_params_secure", "-s", multiple=True, callback=_input_params_to_dict,
+                  help="Params to use instead of context as key-values. Nested keys are supported with double-underscores or dots as separators, e.g. -p params__group__key=value")
     @click.pass_context
     def wrapper(ctx, *args, log_level, **kwargs):
         ExecutionLogger.EXECUTION_LOG_LEVEL = getattr(logging, log_level.upper(), logging.INFO)
@@ -38,7 +40,7 @@ def _configure_global_logger(global_logger: logging.Logger, log_level: str, form
 
 
 def _transform_kwargs(kwargs):
-    if kwargs.get("input_params"):
+    if kwargs.get("input_params") or kwargs.get("input_params_secure"):
         kwargs.pop("context_path")
 
 

qubership_pipelines_common_library/v1/utils/utils_file.py

@@ -66,3 +66,20 @@ class UtilsFile:
             func(path)
         else:
             raise
+
+    @staticmethod
+    def create_parent_dirs(filepath):
+        if directory := os.path.dirname(filepath):
+            os.makedirs(directory, exist_ok=True)
+
+    @staticmethod
+    def create_exec_dir(execution_folder_path: str | Path, exists_ok: bool = False) -> Path:
+        import shutil
+        exec_dir = Path(execution_folder_path)
+        if exec_dir.exists() and not exists_ok:
+            if exec_dir.is_dir():
+                shutil.rmtree(exec_dir)
+            else:
+                raise FileExistsError(f"Path '{execution_folder_path}' exists and is a file, not a directory.")
+        exec_dir.mkdir(parents=True, exist_ok=exists_ok)
+        return exec_dir

qubership_pipelines_common_library/v2/extensions/pipeline_data_importer.py

@@ -0,0 +1,24 @@
+from abc import ABC, abstractmethod
+
+from qubership_pipelines_common_library.v1.execution.exec_command import ExecutionCommand
+from qubership_pipelines_common_library.v1.execution.exec_info import ExecutionInfo
+
+
+class PipelineDataImporter(ABC):
+    """
+    Base interface used by "GitHub/GitLab Run Workflow" commands
+    Can be extended by users to perform custom artifacts transformations at the end of workflow
+    """
+
+    def __init__(self):
+        self.context = None
+        self.command = None
+
+    def with_command(self, command: ExecutionCommand):
+        self.command = command
+        self.context = command.context
+
+    @abstractmethod
+    def import_pipeline_data(self, execution: ExecutionInfo) -> None:
+        """Implements custom data import logic"""
+        pass

qubership_pipelines_common_library/v2/github/github_client.py

@@ -0,0 +1,5 @@
+from qubership_pipelines_common_library.v1.github_client import GithubClient as GithubClientV1
+
+
+class GithubClient(GithubClientV1):
+    pass

qubership_pipelines_common_library/v2/github/github_pipeline_data_importer.py

@@ -0,0 +1,21 @@
+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 DefaultGithubPipelineDataImporter(PipelineDataImporter):
+    """
+    Default GitHub 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("DefaultGithubPipelineDataImporter - importing pipeline data...")
+        self.command.github_client.download_workflow_run_artifacts(execution, self.context.path_temp)
+        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)

qubership_pipelines_common_library/v2/github/github_run_pipeline_command.py

@@ -0,0 +1,175 @@
+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.github.github_pipeline_data_importer import DefaultGithubPipelineDataImporter
+from qubership_pipelines_common_library.v2.github.safe_github_client import SafeGithubClient
+
+
+class GithubRunPipeline(ExecutionCommand):
+    """
+    Executes a GitHub Actions workflow pipeline and optionally imports artifacts.
+
+    This command triggers a GitHub workflow run, monitors its execution, and provides
+    options for importing workflow artifacts and custom data processing through extensible
+    importers.
+
+    Input Parameters Structure (this structure is expected inside "input_params.params" block):
+    ```
+    {
+        "pipeline_owner": "Netcracker",                          # REQUIRED: Repository owner/organization
+        "pipeline_repo_name": "qubership-test-pipelines",        # REQUIRED: Repository name
+        "pipeline_workflow_file_name": "test.yaml",              # REQUIRED: Workflow filename (e.g., main.yaml, ci-cd.yml)
+        "pipeline_branch": "main",                               # OPTIONAL: Branch to run workflow from (default: repo's default branch)
+        "pipeline_params": {                                     # OPTIONAL: Input parameters to pass to the workflow
+            "KEY1": "VALUE1",
+            "KEY2": "VALUE2"
+        },
+        "import_artifacts": false,                               # OPTIONAL: Whether to import workflow artifacts (default: false)
+        "use_existing_pipeline": 123456789,                      # OPTIONAL: Use existing workflow run ID instead of starting new one (debug feature)
+        "timeout_seconds": 1800,                                 # OPTIONAL: Maximum wait time for workflow 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 GitHub client initialization and workflow 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.github" block):
+    ```
+    {
+        "url": "https://github.com",                             # OPTIONAL: GitHub UI URL for self-hosted instances (default: https://github.com)
+        "api_url": "https://api.github.com",                     # OPTIONAL: GitHub API URL for self-hosted instances (default: https://api.github.com)
+        "password": "<github_token>"                             # REQUIRED: GitHub access token with workflow permissions
+    }
+    ```
+
+    Output Parameters:
+        - params.build.url: URL to view the workflow run in GitHub
+        - params.build.id: ID of the executed workflow run
+        - params.build.status: Final status of the workflow 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 workflow run
+
+    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 GitHub Enterprise, configure both "systems.github.url" and "systems.github.api_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
+
+    def __init__(self, *args, pipeline_data_importer: PipelineDataImporter = None, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.pipeline_data_importer = pipeline_data_importer or DefaultGithubPipelineDataImporter()
+        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.github.password",
+            "params.pipeline_owner",
+            "params.pipeline_repo_name",
+            "params.pipeline_workflow_file_name",
+        ]
+        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.pipeline_owner = self.context.input_param_get("params.pipeline_owner")
+        self.pipeline_repo_name = self.context.input_param_get("params.pipeline_repo_name")
+        self.pipeline_workflow_file_name = self.context.input_param_get("params.pipeline_workflow_file_name")
+        self.pipeline_branch = self.context.input_param_get("params.pipeline_branch")
+        self.pipeline_params = self.context.input_param_get("params.pipeline_params", {})
+        if not self.pipeline_params:
+            self.context.logger.info(f"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(f"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")
+        self.ui_url = self.context.input_param_get("systems.github.ui_url", "https://github.com")
+        return True
+
+    def _execute(self):
+        self.context.logger.info("GithubRunPipeline - triggering GitHub workflow run and fetching results...")
+
+        self.github_client = SafeGithubClient.create_github_client(
+            api_url=self.context.input_param_get("systems.github.api_url"),
+            token=self.context.input_param_get("systems.github.password"),
+            retry_timeout_seconds=self.retry_timeout_seconds,
+            retry_wait_seconds=self.retry_wait_seconds
+        )
+
+        if self.use_existing_pipeline: # work with existing workflow run
+            pipeline_id = self.use_existing_pipeline
+            self.context.logger.info(f"Using existing pipeline {pipeline_id}")
+            execution = (ExecutionInfo()
+                         .with_url(f"{self.ui_url}/{self.pipeline_owner}/{self.pipeline_repo_name}/")
+                         .with_name(self.pipeline_workflow_file_name).with_id(int(pipeline_id))
+                         .with_status(ExecutionInfo.STATUS_UNKNOWN))
+            execution.start()
+        else:
+            branch = self.pipeline_branch
+            if not branch:
+                branch = self.github_client.get_repo_default_branch(self.pipeline_owner, self.pipeline_repo_name)
+            execution = self.github_client.trigger_workflow(owner=self.pipeline_owner, repo_name=self.pipeline_repo_name,
+                                                            workflow_file_name=self.pipeline_workflow_file_name,
+                                                            branch=branch, pipeline_params=self.pipeline_params,
+                                                            retry_timeout_seconds=self.retry_timeout_seconds,
+                                                            retry_wait_seconds=self.retry_wait_seconds
+                                                            )
+            self.context.logger.info(f"Triggered pipeline {execution.get_id()}, status: {execution.get_status()}, url: {execution.get_url()}")
+
+        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
+
+        execution = self.github_client.wait_workflow_run_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(f"Writing GitHub workflow 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()