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

qubership_pipelines_common_library/v2/artifacts_finder/providers/artifactory.py

@@ -0,0 +1,52 @@
+import logging
+import re
+
+from pathlib import Path
+from qubership_pipelines_common_library.v2.artifacts_finder.model.artifact import Artifact
+from qubership_pipelines_common_library.v2.artifacts_finder.model.artifact_provider import ArtifactProvider
+
+
+class ArtifactoryProvider(ArtifactProvider):
+
+    def __init__(self, registry_url: str, username: str = None, password: str = None, **kwargs):
+        """
+        Initializes this client to work with **JFrog Artifactory** maven repositories.
+        Requires `username` and its `password` or `token`.
+        """
+        super().__init__(**kwargs)
+        self.registry_url = registry_url
+        if password:
+            from requests.auth import HTTPBasicAuth
+            self._session.auth = HTTPBasicAuth(username, password)
+
+    def download_artifact(self, resource_url: str, local_path: str | Path, **kwargs) -> None:
+        return self.generic_download(resource_url=resource_url, local_path=local_path)
+
+    def search_artifacts(self, artifact: Artifact, **kwargs) -> list[str]:
+        timestamp_version_match = re.match(self.TIMESTAMP_VERSION_PATTERN, artifact.version)
+        if timestamp_version_match:
+            base_version = timestamp_version_match.group(1) + "SNAPSHOT"
+        else:
+            base_version = artifact.version
+
+        search_params = {
+            **({"g": artifact.group_id} if artifact.group_id else {}),
+            "a": artifact.artifact_id,
+            "v": base_version,
+            "specific": "true"
+        }
+        search_api_url = f"{self.registry_url}/api/search/gavc"
+        logging.debug(f"Search URL: {search_api_url}"f"\nSearch Parameters: {search_params}")
+
+        response = self._session.get(url=search_api_url,
+                                     params=search_params,
+                                     timeout=self.timeout)
+        if response.status_code != 200:
+            raise Exception(f"Could not find '{artifact.artifact_id}' - search request returned {response.status_code}!")
+
+        return [result["downloadUri"] for result in response.json()["results"]
+                if result["ext"] == artifact.extension
+                and (not timestamp_version_match or result["downloadUri"].endswith(f"{artifact.version}.{artifact.extension}"))]
+
+    def get_provider_name(self) -> str:
+        return "artifactory"

qubership_pipelines_common_library/v2/artifacts_finder/providers/aws_code_artifact.py

@@ -0,0 +1,79 @@
+import logging
+import boto3
+
+from pathlib import Path
+from botocore.config import Config
+from qubership_pipelines_common_library.v2.artifacts_finder.model.artifact import Artifact
+from qubership_pipelines_common_library.v2.artifacts_finder.model.artifact_provider import ArtifactProvider
+from qubership_pipelines_common_library.v2.artifacts_finder.model.credentials import Credentials
+
+
+class AwsCodeArtifactProvider(ArtifactProvider):
+
+    def __init__(self, credentials: Credentials, domain: str, repository: str, package_format: str = "generic", **kwargs):
+        """
+        Initializes this client to work with **AWS Code Artifact** for generic or maven artifacts.
+        Requires `Credentials` provided by `AwsCredentialsProvider`.
+        """
+        super().__init__(**kwargs)
+        self._credentials = credentials
+        self._domain = domain
+        self._repository = repository
+        self._format = package_format
+        self._aws_client = boto3.client(
+            service_name='codeartifact',
+            config=Config(region_name=credentials.region_name),
+            aws_access_key_id=credentials.access_key,
+            aws_secret_access_key=credentials.secret_key,
+            aws_session_token=credentials.session_token,
+        )
+
+    def download_artifact(self, resource_url: str, local_path: str | Path, **kwargs) -> None:
+        """ 'resource_url' is actually AWS-specific resource_id, expected to be "namespace/package/version/asset_name" """
+        asset_parts = resource_url.split("/")
+        response = self._aws_client.get_package_version_asset(
+            domain=self._domain, repository=self._repository,
+            format=self._format, namespace=asset_parts[0],
+            package=asset_parts[1], packageVersion=asset_parts[2],
+            asset=asset_parts[3]
+        )
+        with open(local_path, 'wb') as file:
+            file.write(response.get('asset').read())
+
+    def search_artifacts(self, artifact: Artifact, **kwargs) -> list[str]:
+        list_packages_response = self._aws_client.list_packages(
+            domain=self._domain, repository=self._repository,
+            format=self._format, packagePrefix=artifact.artifact_id
+        )
+        logging.debug(f"list_packages_response: {list_packages_response}")
+
+        namespaces = [package.get('namespace') for package in list_packages_response.get('packages')
+                      if package.get('package') == artifact.artifact_id]
+        logging.debug(f"namespaces: {namespaces}")
+
+        if not namespaces:
+            logging.warning(f"Found no packages with artifactId = {artifact.artifact_id}!")
+            return []
+        if len(namespaces) > 1:
+            logging.warning(f"Found multiple namespaces with same artifactId = {artifact.artifact_id}:\n{namespaces}")
+
+        results = []
+        for namespace in namespaces:
+            try:
+                assets_response = self._aws_client.list_package_version_assets(
+                    domain=self._domain, repository=self._repository,
+                    format=self._format, package=artifact.artifact_id,
+                    packageVersion=artifact.version, namespace=namespace
+                )
+                logging.debug(f"assets: {assets_response}")
+                for asset in assets_response.get('assets'):
+                    if asset.get('name').lower().endswith(artifact.extension.lower()):
+                        results.append(f"{assets_response.get('namespace')}/{assets_response.get('package')}/"
+                                       f"{assets_response.get('version')}/{asset.get('name')}")
+            except Exception:
+                logging.warning(f"Specific version ({artifact.version}) of package ({namespace}.{artifact.artifact_id}) not found!")
+        logging.info(f"AWS search results: {results}")
+        return results
+
+    def get_provider_name(self) -> str:
+        return "aws_code_artifact"

qubership_pipelines_common_library/v2/artifacts_finder/providers/azure_artifacts.py

@@ -0,0 +1,98 @@
+import logging
+import re
+
+from pathlib import Path
+from requests.auth import HTTPBasicAuth
+from qubership_pipelines_common_library.v2.artifacts_finder.model.artifact import Artifact
+from qubership_pipelines_common_library.v2.artifacts_finder.model.artifact_provider import ArtifactProvider
+from qubership_pipelines_common_library.v2.artifacts_finder.model.credentials import Credentials
+
+
+class AzureArtifactsProvider(ArtifactProvider):
+
+    def __init__(self, credentials: Credentials, organization: str, project: str, feed: str, **kwargs):
+        """
+        Initializes this client to work with **Azure Artifacts** for generic artifacts.
+        Requires `Credentials` provided by `AzureCredentialsProvider`.
+        """
+        super().__init__(**kwargs)
+        self._credentials = credentials
+        self._session.auth = HTTPBasicAuth("", self._credentials.access_token)
+        self.organization = organization
+        self.project = project
+        self.feed = feed
+
+    def download_artifact(self, resource_url: str, local_path: str | Path, **kwargs) -> None:
+        return self.generic_download(resource_url=resource_url, local_path=local_path)
+
+    def search_artifacts(self, artifact: Artifact, **kwargs) -> list[str]:
+        acceptable_versions = [artifact.version]
+        if timestamp_version_match := re.match(self.TIMESTAMP_VERSION_PATTERN, artifact.version):
+            acceptable_versions.append(timestamp_version_match.group(1) + "SNAPSHOT")
+
+        # Try to find package with name ~ "artifact_id"
+        feeds_search_url = f"https://feeds.dev.azure.com/{self.organization}/{self.project}/_apis/packaging/feeds/{self.feed}/packages"
+        feed_search_params = {
+            "includeAllVersions": "true",
+            "packageNameQuery": artifact.artifact_id,
+            "protocolType": "maven",
+            "api-version": "7.1",
+        }
+        feeds_response = self._session.get(url=feeds_search_url, params=feed_search_params, timeout=self.timeout)
+        feeds_response_json = feeds_response.json()
+        if feeds_response.status_code != 200:
+            logging.error(f"Feeds search error ({feeds_response.status_code}) response: {feeds_response_json}")
+            raise Exception(f"Could not find '{artifact.artifact_id}' - search request returned {feeds_response.status_code}!")
+
+        logging.debug(f"Feeds search response: {feeds_response_json}")
+        if feeds_response_json.get("count") > 1:
+            logging.warning("Found more than 1 feeds. Use the first one.")
+        elif feeds_response_json.get("count") == 0:
+            logging.warning("No feeds were found.")
+            return []
+        feed = feeds_response_json.get("value")[0]
+        feed_links = feed.get("_links", {})
+
+        # Get feed versions
+        feed_versions_url = feed_links.get("versions", {}).get("href", "")
+        feed_versions_response = self._session.get(url=feed_versions_url, timeout=self.timeout)
+        feed_versions_response_json = feed_versions_response.json()
+        if feed_versions_response.status_code != 200:
+            logging.error(f"Feed versions error ({feed_versions_response.status_code}) response: {feed_versions_response_json}")
+            raise Exception(f"Could not find feed versions, search request returned {feed_versions_response.status_code}!")
+        logging.debug(f"Feed versions response: {feed_versions_response_json}")
+        feed_versions = feed_versions_response_json.get("value")
+
+        # Filter by acceptable versions
+        logging.debug(f"Filtering by acceptable versions: '{acceptable_versions}'")
+        feed_version = [f for f in feed_versions if (f.get('protocolMetadata').get('data').get('version') in acceptable_versions)]
+        if len(feed_version) == 0:
+            logging.warning("All feed versions filtered.")
+            return []
+        filtered_feed_version = feed_version[0]
+
+        # Search for target file
+        files = [f for f in filtered_feed_version.get("files") if f.get('name').startswith(f"{artifact.artifact_id}-{artifact.version}") and f.get('name').endswith(artifact.extension)]
+        logging.debug(f"Files found: {files}")
+        if len(files) == 0:
+            logging.warning("All files filtered.")
+            return []
+        target_file = files[0]
+
+        # Build download url
+        feed_id = feed_links.get("feed").get("href").split("/")[-1] # take id from link to feed
+        feed_version = filtered_feed_version.get("version")
+        group_id = filtered_feed_version.get('protocolMetadata').get('data').get("groupId")
+        artifact_id = filtered_feed_version.get('protocolMetadata').get('data').get("artifactId")
+        target_file_name = target_file.get("name")
+
+        download_url = (
+            f"https://pkgs.dev.azure.com/{self.organization}/{self.project}/_apis/packaging/feeds/{feed_id}/maven/"
+            f"{group_id}/{artifact_id}/{feed_version}/{target_file_name}/content"
+            f"?api-version=7.1-preview.1"
+        )
+        logging.info(f"Azure search resulting url: {download_url}")
+        return [download_url]
+
+    def get_provider_name(self) -> str:
+        return "azure_artifacts"

qubership_pipelines_common_library/v2/artifacts_finder/providers/gcp_artifact_registry.py

@@ -0,0 +1,50 @@
+from pathlib import Path
+from google.cloud import artifactregistry_v1
+from qubership_pipelines_common_library.v2.artifacts_finder.model.artifact import Artifact
+from qubership_pipelines_common_library.v2.artifacts_finder.model.artifact_provider import ArtifactProvider
+from qubership_pipelines_common_library.v2.artifacts_finder.model.credentials import Credentials
+
+
+class GcpArtifactRegistryProvider(ArtifactProvider):
+
+    def __init__(self, credentials: Credentials, project: str, region_name: str, repository: str, **kwargs):
+        """
+        Initializes this client to work with **GCP Artifact Registry** for generic artifacts.
+        Requires `Credentials` provided by `GcpCredentialsProvider`.
+        """
+        super().__init__(**kwargs)
+        self._credentials = credentials
+        self._project = project
+        self._region_name = region_name
+        self._repository = repository
+        self._repo_resource_id = f"projects/{project}/locations/{region_name}/repositories/{repository}"
+
+        self._gcp_client = artifactregistry_v1.ArtifactRegistryClient(
+            credentials=self._credentials.google_credentials_object
+        )
+        self._authorized_session = self._credentials.authorized_session
+
+    def download_artifact(self, resource_url: str, local_path: str | Path, **kwargs) -> None:
+        response = self._authorized_session.get(url=resource_url, timeout=self.timeout)
+        response.raise_for_status()
+        with open(local_path, 'wb') as file:
+            file.write(response.content)
+
+    def search_artifacts(self, artifact: Artifact, **kwargs) -> list[str]:
+        # works with both "Maven" and "Generic" type repositories
+        name_filter = f"{self._repo_resource_id}/files/*{artifact.artifact_id}-{artifact.version}.{artifact.extension}"
+        list_files_request = artifactregistry_v1.ListFilesRequest(
+            parent=f"{self._repo_resource_id}",
+            filter=f'name="{name_filter}"',
+        )
+        files = self._gcp_client.list_files(request=list_files_request)
+        # logging.debug(f"[GCP search_artifacts] files: {files}")
+
+        urls = []
+        for file in files:
+            download_url = f"https://artifactregistry.googleapis.com/download/v1/{file.name}:download?alt=media"
+            urls.append(download_url)
+        return urls
+
+    def get_provider_name(self) -> str:
+        return "gcp_artifact_registry"

qubership_pipelines_common_library/v2/artifacts_finder/providers/nexus.py

@@ -0,0 +1,41 @@
+from pathlib import Path
+from qubership_pipelines_common_library.v2.artifacts_finder.model.artifact import Artifact
+from qubership_pipelines_common_library.v2.artifacts_finder.model.artifact_provider import ArtifactProvider
+
+
+class NexusProvider(ArtifactProvider):
+
+    def __init__(self, registry_url: str, username: str = None, password: str = None, **kwargs):
+        """
+        Initializes this client to work with **Sonatype Nexus Repository** for maven artifacts.
+        Requires `username` and its `password` or `token`.
+        """
+        super().__init__(**kwargs)
+        self.registry_url = registry_url
+        if password:
+            from requests.auth import HTTPBasicAuth
+            self._session.auth = HTTPBasicAuth(username, password)
+
+    def download_artifact(self, resource_url: str, local_path: str | Path, **kwargs) -> None:
+        return self.generic_download(resource_url=resource_url, local_path=local_path)
+
+    def search_artifacts(self, artifact: Artifact, **kwargs) -> list[str]:
+        search_params = {
+            "maven.extension": artifact.extension,
+            "maven.artifactId": artifact.artifact_id,
+            **({"maven.groupId": artifact.group_id} if artifact.group_id else {}),
+        }
+        if artifact.is_snapshot():
+            search_params["maven.baseVersion"] = artifact.version
+        else:
+            search_params["version"] = artifact.version
+
+        response = self._session.get(url=f"{self.registry_url}/service/rest/v1/search/assets",
+                                     params=search_params,
+                                     timeout=self.timeout)
+        if response.status_code != 200:
+            raise Exception(f"Could not find '{artifact.artifact_id}' - search request returned {response.status_code}!")
+        return [result["downloadUrl"] for result in response.json()["items"]]
+
+    def get_provider_name(self) -> str:
+        return "nexus"

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("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")
+        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("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()

qubership_pipelines_common_library/v2/github/safe_github_client.py

@@ -0,0 +1,24 @@
+from qubership_pipelines_common_library.v1.execution.exec_info import ExecutionInfo
+from qubership_pipelines_common_library.v2.github.github_client import GithubClient
+from qubership_pipelines_common_library.v2.utils.retry_decorator import RetryDecorator
+
+
+class SafeGithubClient(GithubClient):
+
+    def __init__(self, api_url: str, token: str):
+        super().__init__(api_url=api_url, token=token)
+
+    @classmethod
+    @RetryDecorator(condition_func=lambda result: result is not None)
+    def create_github_client(cls, api_url: str, token, retry_timeout_seconds: int = 180, retry_wait_seconds: int = 1):
+        return cls(api_url=api_url, token=token)
+
+    @RetryDecorator(
+        condition_func=lambda result: result is not None and result.get_status() not in [
+            ExecutionInfo.STATUS_NOT_STARTED, ExecutionInfo.STATUS_UNKNOWN]
+    )
+    def trigger_workflow(self, owner: str, repo_name: str, workflow_file_name: str, branch: str,
+                         pipeline_params, retry_timeout_seconds: int = 180, retry_wait_seconds: int = 1):
+        return super().trigger_workflow(owner=owner, repo_name=repo_name,
+                                        workflow_file_name=workflow_file_name,
+                                        branch=branch, pipeline_params=pipeline_params)