qubership-pipelines-common-library 0.1.10__py3-none-any.whl → 0.2.0__py3-none-any.whl

qubership_pipelines_common_library/v1/execution/exec_command.py

@@ -27,12 +27,27 @@ class ExecutionCommand:
 
     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):
+        """
+        Extendable interface intended to simplify working with input/output params and passing them between commands in different Pipeline Executors
+
+        Implementations are expected to override **`_validate`** and **`_execute`** methods
+
+        If **`context_path`** is not provided - context will be created dynamically using other provided params
+
+        Arguments:
+            context_path (str): Path to context-describing yaml, that should contain references to input/output param file locations
+            input_params (dict): Non-secure parameters that will be merged into dynamically created params
+            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.
+        """
         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)
 
     def run(self):
+        """Runs command following its lifecycle"""
         try:
             if not self._validate():
                 logging.error(ExecutionCommand.FAILURE_MSG)

qubership_pipelines_common_library/v1/execution/exec_context.py

@@ -23,6 +23,12 @@ from qubership_pipelines_common_library.v1.execution.exec_logger import Executio
 class ExecutionContext:
 
     def __init__(self, context_path: str):
+        """
+        Interface that provides references and shortcuts to navigating provided input params, storing any output params, and logging messages.
+
+        Arguments:
+            context_path (str): Path to context-describing yaml, that should contain references to input/output param file locations
+        """
         full_path = os.path.abspath(context_path)
         self.context_path = full_path
         self.context = ExecutionContextFile(full_path)
@@ -47,6 +53,7 @@ class ExecutionContext:
         self.__input_params_load()
 
     def output_params_save(self):
+        """Stores output_param files to disk"""
         if self.context.get("paths.output.params"):
             logging.info(f"Writing insecure param file '{self.context.get('paths.output.params')}'")
             self.output_params.save(self.context.get("paths.output.params"))
@@ -55,6 +62,7 @@ class ExecutionContext:
             self.output_params_secure.save(self.context.get("paths.output.params_secure"))
 
     def input_param_get(self, path, def_value=None):
+        """Gets parameter from provided params files by its param path, supporting dot-separated nested keys (e.g. 'parent_obj.child_obj.param_name')"""
         value = self.input_params.get(path, def_value)
         if value == def_value:
             value = self.input_params_secure.get(path, def_value)
@@ -63,12 +71,15 @@ class ExecutionContext:
         return value
 
     def output_param_set(self, path, value):
+        """Sets param by path in non-secure output params"""
         return self.output_params.set(path, value)
 
     def output_param_secure_set(self, path, value):
+        """Sets param by path in secure output params"""
         return self.output_params_secure.set(path, value)
 
     def validate(self, names, silent=False):
+        """Validates that all provided param `names` are present among provided param files"""
         valid = True
         for key in names:
             if not self.__validate_param(key):

qubership_pipelines_common_library/v1/execution/exec_context_file.py

@@ -35,6 +35,11 @@ class ExecutionContextFile:
     SUPPORTED_API_VERSIONS = [API_VERSION_V1]
 
     def __init__(self, path=None):
+        """
+        Interface to work with **`params`** and **`context`** files, used in **`ExecutionContext`**.
+
+        Provides methods to init default content for different types of descriptors (e.g. **`init_context_descriptor`**, **`init_params`**)
+        """
         self.content = {
             "kind": "",
             "apiVersion": ""
@@ -44,12 +49,14 @@ class ExecutionContextFile:
             self.load(path)
 
     def init_empty(self):
+        """"""
         self.content = {
             "kind": "",
             "apiVersion": ""
         }
 
     def init_context_descriptor(self, context_folder_path: str = None):
+        """"""
         if context_folder_path is None:
             context_folder_path = ""
         ctx_path = Path(context_folder_path)
@@ -87,6 +94,7 @@ class ExecutionContextFile:
         return self
 
     def init_params(self):
+        """"""
         self.content = {
             "kind": ExecutionContextFile.KIND_PARAMS_INSECURE,
             "apiVersion": ExecutionContextFile.API_VERSION_V1,
@@ -103,6 +111,7 @@ class ExecutionContextFile:
         return self
 
     def init_params_secure(self):
+        """"""
         self.content = {
             "kind": ExecutionContextFile.KIND_PARAMS_SECURE,
             "apiVersion": ExecutionContextFile.API_VERSION_V1,
@@ -119,6 +128,7 @@ class ExecutionContextFile:
         return self
 
     def load(self, path):
+        """Loads and validates file as one of supported types of descriptors"""
         full_path = os.path.abspath(path)
         try:
             self.content = UtilsFile.read_yaml(full_path)
@@ -135,17 +145,21 @@ class ExecutionContextFile:
             self.init_empty()
 
     def save(self, path):
+        """Writes current file content from memory to disk"""
         # TODO: support encryption with SOPS
         UtilsFile.write_yaml(path, self.content)
 
     def get(self, path, def_value=None):
+        """Gets parameter from current file content by its param path, supporting dot-separated nested keys (e.g. 'parent_obj.child_obj.param_name')"""
         return UtilsDictionary.get_by_path(self.content, path, def_value)
 
     def set(self, path, value):
+        """Sets parameter in current file content"""
         UtilsDictionary.set_by_path(self.content, path, value)
         return self
 
     def set_multiple(self, dict):
+        """Sets multiple parameters in current file content"""
         for key in dict:
             UtilsDictionary.set_by_path(self.content, key, dict[key])
         return self

qubership_pipelines_common_library/v1/execution/exec_info.py

@@ -31,6 +31,9 @@ class ExecutionInfo:
     STATUSES_COMPLETE = [STATUS_SUCCESS, STATUS_UNSTABLE, STATUS_FAILED, STATUS_ABORTED]
 
     def __init__(self):
+        """
+        Describes trackable running processes (e.g. triggered GitHub workflow)
+        """
         self.url = ""  # url to pipeline execution
         self.id = ""  # unique id of the execution
         self.status = ExecutionInfo.STATUS_UNKNOWN  # current status of the pipeline
@@ -40,11 +43,13 @@ class ExecutionInfo:
         self.params = {}  # optional params used to run the pipe
 
     def start(self):
+        """Records start time for described process and transitions its status to **`IN_PROGRESS`**"""
         self.time_start = datetime.now()
         self.status = ExecutionInfo.STATUS_IN_PROGRESS
         return self
 
     def stop(self, status: str = None):
+        """Records finish time for described process, and optionally transitions its status to passed value"""
         if status:
             self.with_status(status)
         self.time_stop = datetime.now()
@@ -66,9 +71,11 @@ class ExecutionInfo:
         return self.time_stop
 
     def get_duration(self):
+        """Returns duration of this process after it's finished"""
         return self.time_stop - self.time_start
-    
+
     def get_duration_str(self):
+        """Returns formatted duration of this process as `hh:mm:ss` string after it's finished """
         seconds = int(self.get_duration().total_seconds())
         parts = [seconds / 3600, (seconds % 3600) / 60, seconds % 60]
         strings = list(map(lambda x: str(int(x)).zfill(2), parts))

qubership_pipelines_common_library/v1/execution/exec_logger.py

@@ -23,6 +23,13 @@ class ExecutionLogger:
     DEFAULT_FORMAT = u'[%(asctime)s] [%(levelname)-5s] [class=%(filename)s:%(lineno)-3s] %(message)s'
 
     def __init__(self, path_logs):
+        """
+        Default logger used by **`ExecutionCommands`**, implicitly initialized when using Context.
+
+        Reference to it is available from instance of **`ExecutionContext`**.
+
+        Provides common logging methods of different log levels - e.g. **`debug`**, **`info`**, **`error`**
+        """
         # todo: Currently all commands (if more than one are invoked in one go) will reuse same logger
         #  Also, file handlers are never removed
         self.path_logs = path_logs

qubership_pipelines_common_library/v1/maven_client.py

@@ -0,0 +1,286 @@
+import json
+import os
+import pathlib
+import re
+import requests
+import logging
+
+from xml.etree import ElementTree
+from requests.auth import HTTPBasicAuth
+
+
+class Artifact:
+    def __init__(self, artifact_id, version, extension='jar'):
+        self.artifact_id = artifact_id
+        self.version = version
+        self.extension = "jar" if not extension else extension
+
+    def is_snapshot(self):
+        return self.version and self.version.endswith("SNAPSHOT")
+
+    @staticmethod
+    def from_string(artifact_str: str):
+        parts = artifact_str.split(":")
+        if len(parts) == 3:
+            group, artifact, version = parts[0], parts[1], parts[-1]
+            return Artifact(artifact, version)
+
+
+class MavenArtifactSearcher:
+    """
+    Allows searching for specific maven artifacts in different repositories without knowing full coordinates
+    (e.g. knowing only `artifact_id` and `version`, but not its `group_id`)
+
+    Supports different Maven repository providers: Artifactory, Nexus, AWS, GCP
+
+    Start by initializing this client with one of implementations:
+    ``maven_client = MavenArtifactSearcher(registry_url).with_artifactory(artifactory_user, artifactory_token)``
+
+    Then find your artifacts using
+    ``maven_client.find_artifact_urls('art_id', '1.0.0')``
+
+    Additionally, perform filtering of returned results, and then download necessary artifacts with
+    ``maven_client.download_artifact(one_of_the_returned_urls, './my_artifact.jar')``
+    """
+
+    TIMESTAMP_VERSION_PATTERN = "^(.*-)?([0-9]{8}\\.[0-9]{6}-[0-9]+)$"
+
+    def __init__(self, registry_url: str, params: dict = None, **kwargs):
+        self.is_init = False
+        self._search_func = None
+        self._download_func = None
+        self.registry_url = registry_url.rstrip("/")
+        self.params = params if params else {}
+        self._session = requests.Session()
+        self._session.verify = self.params.get('verify', True)
+        self.timeout = self.params.get('timeout', None)
+
+    def find_artifact_urls(self, artifact_id: str = None, version: str = None, extension: str = "jar",
+                           artifact: Artifact = None) -> list[str]:
+        """
+        Finds and returns list of URLs (or resource IDs, for specific providers) to target artifacts.
+        Client should be initialized with one of providers first.
+        Doesn't require `group_id` to find artifacts.
+        Works with either `artifact_id`/`version` or `Artifact` class as input parameters.
+        """
+        self._check_init()
+        if not artifact:
+            artifact = Artifact(artifact_id=artifact_id, version=version, extension=extension)
+        if not artifact.artifact_id or not artifact.version:
+            raise Exception(f"Artifact 'artifact_id' and 'version' must be specified!")
+        logging.debug(f"Searching for '{artifact.artifact_id}' in {self.registry_url}...")
+        return self._search_func(artifact=artifact)
+
+    def download_artifact(self, url: str, local_path: str):
+        """
+        Downloads maven artifact from `url` to a `local_path` location
+        (you need to provide full path, including filename, since we can't determine it from resource urls for some providers).
+        `url` should be one of values returned by `find_artifact_urls`.
+        Client should be initialized with one of providers first.
+        """
+        self._check_init()
+        self._create_dir(local_path)
+        logging.debug(f"Downloading artifact from '{url}' to '{local_path}'...")
+        return self._download_func(url=url, local_path=local_path)
+
+    def _check_init(self):
+        if not self.is_init:
+            raise Exception("Init client with one of registry implementations first, e.g. '.with_artifactory'!")
+
+    def _create_dir(self, local_path: str):
+        directory = os.path.dirname(local_path)
+        if directory:
+            pathlib.Path(directory).mkdir(parents=True, exist_ok=True)
+
+    def _generic_download(self, url: str, local_path: str):
+        response = self._session.get(url=url, timeout=self.timeout)
+        response.raise_for_status()
+        with open(local_path, 'wb') as file:
+            file.write(response.content)
+
+    def with_artifactory(self, username: str = None, password: str = None):
+        """
+        Initializes this client to work with **JFrog Artifactory** maven repositories.
+        Requires `username` and its `password` or `token`.
+        """
+        if password:
+            self._session.auth = HTTPBasicAuth(username, password)
+        self._search_func = self._artifactory_search
+        self._download_func = self._generic_download
+        self.is_init = True
+        return self
+
+    def _artifactory_search(self, artifact: Artifact = None) -> list[str]:
+        # 1.0, 1.1              - release
+        # 1.0-SNAPSHOT          - snapshot head
+        # 1.0-123456-2025125-1  - specific snapshot
+        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
+        response = self._session.get(url=f"{self.registry_url}/api/search/gavc",
+                                     params={"a": artifact.artifact_id, "v": base_version, "specific": "true"},
+                                     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 with_nexus(self, username: str = None, password: str = None):
+        """
+        Initializes this client to work with **Sonatype Nexus Repository** for maven artifacts.
+        Requires `username` and its `password` or `token`.
+        """
+        if password:
+            self._session.auth = HTTPBasicAuth(username, password)
+        self._search_func = self._nexus_search
+        self._download_func = self._generic_download
+        self.is_init = True
+        return self
+
+    def _nexus_search(self, artifact: Artifact = None) -> list[str]:
+        search_params = {
+            "maven.artifactId": artifact.artifact_id,
+            "maven.extension": artifact.extension
+        }
+        if artifact.version.endswith("-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 with_aws_code_artifact(self, access_key: str, secret_key: str, domain: str, region_name: str, repository: str):
+        """
+        Initializes this client to work with **AWS Code Artifact** repository.
+        Requires `access_key` and `secret_key` of a service account.
+        Also requires `domain`, `region_name` and `repository` of used AWS instance.
+        """
+        import boto3
+        from botocore.config import Config
+        self._aws_client = boto3.client(service_name='codeartifact',
+                                        config=Config(region_name=region_name),
+                                        aws_access_key_id=access_key,
+                                        aws_secret_access_key=secret_key,
+                                        )
+        self._domain = domain
+        self._repository = repository
+        self._search_func = self._aws_search
+        self._download_func = self._aws_download
+        self.is_init = True
+        return self
+
+    def _aws_search(self, artifact: Artifact = None) -> list[str]:
+        list_packages_response = self._aws_client.list_packages(domain=self._domain, repository=self._repository,
+                                                 format="maven", packagePrefix=artifact.artifact_id)
+        # namespace == group_id
+        namespaces = [package.get('namespace') for package in list_packages_response.get('packages')
+                      if package.get('package') == artifact.artifact_id]
+        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:
+                resp = self._aws_client.list_package_version_assets(domain=self._domain, repository=self._repository,
+                                                                       format="maven", package=artifact.artifact_id,
+                                                                       packageVersion=artifact.version,
+                                                                       namespace=namespace)
+                for asset in resp.get('assets'):
+                    if asset.get('name').lower().endswith(artifact.extension.lower()):
+                        results.append(f"{resp.get('namespace')}/{resp.get('package')}/{resp.get('version')}/{asset.get('name')}")
+            except Exception:
+                logging.warning(f"Specific version ({artifact.version}) of package ({namespace}.{artifact.artifact_id}) not found!")
+        return results
+
+    def _aws_download(self, url: str, local_path: str):
+        """`url` is actually AWS-specific `resource_id`, expected to be `namespace/package/version/asset_name`"""
+        asset_parts = url.split("/")
+        response = self._aws_client.get_package_version_asset(domain=self._domain, repository=self._repository,
+                                                             format="maven", 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 with_gcp_artifact_registry(self, credential_params: dict, project: str, region_name: str, repository: str):
+        """
+        Initializes this client to work with **Google Cloud Artifact Registry** repository.
+        Supports different types of authorization in `credential_params` dict:
+            - `service_account_key` key -> requires content of key-file (generate key-file for your service account first)
+            - `oidc_token_path` and `audience` key -> path to text file ("/path/to/token/file.txt") with your OIDC token and your required audience.
+        Audience should be "//iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/PROVIDER_ID"
+
+        Also requires `project`, `region_name` and `repository` of used GCP instance.
+        """
+        from google.cloud import artifactregistry_v1
+        from google.auth.transport.requests import AuthorizedSession
+        self._gcp_scopes = ['https://www.googleapis.com/auth/cloud-platform']
+        creds = self._gcp_get_credentials(credential_params)
+        self._gcp_client = artifactregistry_v1.ArtifactRegistryClient(credentials=creds)
+        self._session = AuthorizedSession(credentials=creds)
+
+        self._gcp_download_url = f"https://{region_name}-maven.pkg.dev/{project}/{repository}"
+        self._repo_resource_id = f"projects/{project}/locations/{region_name}/repositories/{repository}"
+        self._search_func = self._gcp_search
+        self._download_func = self._generic_download
+        self.is_init = True
+        return self
+
+    def _gcp_get_credentials(self, credential_params: dict):
+        if service_account_key := credential_params.get("service_account_key"):
+            from google.oauth2 import service_account
+            return service_account.Credentials.from_service_account_info(
+                info=json.loads(service_account_key),
+                scopes=self._gcp_scopes,
+            )
+        if credential_params.get("oidc_token_path") and credential_params.get("audience"):
+            from google.auth import identity_pool
+            return identity_pool.Credentials(
+                audience=credential_params.get("audience"),
+                subject_token_type="urn:ietf:params:oauth:token-type:jwt",
+                credential_source={"file": credential_params.get("oidc_token_path")},
+                scopes=self._gcp_scopes,
+            )
+        raise Exception("No valid authentication params found in credential_params!")
+
+    def _gcp_search(self, artifact: Artifact = None) -> list[str]:
+        timestamp_version_match = re.match(self.TIMESTAMP_VERSION_PATTERN, artifact.version)
+        is_snapshot = artifact.version.endswith("-SNAPSHOT")
+        if timestamp_version_match:
+            base_version = timestamp_version_match.group(1) + "SNAPSHOT"
+        else:
+            base_version = artifact.version
+
+        response_pager = self._gcp_client.list_maven_artifacts(parent=self._repo_resource_id)
+        for gav in response_pager:
+            if gav.artifact_id == artifact.artifact_id and gav.version == base_version:
+                artifact_folder_url = "{gcp_download_url}/{group_path}/{artifact_id}/{version}".format(
+                    gcp_download_url=self._gcp_download_url,
+                    group_path=gav.group_id.replace('.', '/'),
+                    artifact_id=gav.artifact_id,
+                    version=gav.version
+                )
+                if is_snapshot:
+                    latest_snapshot_version = self._find_latest_snapshot_version(artifact_folder_url, artifact.version)
+                    return [f"{artifact_folder_url}/{gav.artifact_id}-{latest_snapshot_version}.{artifact.extension}"]
+                else:
+                    return [f"{artifact_folder_url}/{gav.artifact_id}-{artifact.version}.{artifact.extension}"]
+        return []
+
+    def _find_latest_snapshot_version(self, artifact_folder_url: str, snapshot_version: str) -> str:
+        response = self._session.get(url=f"{artifact_folder_url}/maven-metadata.xml", timeout=self.timeout)
+        response.raise_for_status()
+        xml = ElementTree.fromstring(response.content)
+        timestamp = xml.findall("./versioning/snapshot/timestamp")[0].text
+        build_number = xml.findall("./versioning/snapshot/buildNumber")[0].text
+        return snapshot_version.replace("SNAPSHOT", timestamp + "-" + build_number)

qubership_pipelines_common_library/v1/utils/utils_aws.py

@@ -0,0 +1,16 @@
+class AWSCodeArtifactHelper:
+    @staticmethod
+    def get_authorization_token(access_key: str, secret_key: str, domain: str, region_name: str):
+        """
+        Fetches 12-hour temporary authorization token (using long-term credentials).
+        This token is necessary for accessing CodeArtifact using standard maven interface
+        """
+        import boto3
+        from botocore.config import Config
+        client = boto3.client(service_name='codeartifact',
+                              config=Config(region_name=region_name),
+                              aws_access_key_id=access_key,
+                              aws_secret_access_key=secret_key,
+                              )
+        response = client.get_authorization_token(domain=domain)
+        return response.get('authorizationToken')

qubership_pipelines_common_library/v1/utils/utils_context.py

@@ -40,7 +40,10 @@ def init_context(context_path):
 
 def create_execution_context(input_params: dict = None, input_params_secure: dict = None, folder_path: str = None,
                              parent_context_to_reuse: ExecutionContext = None):
-    """params:
+    """
+    Dynamically creates **`ExecutionContext`** using provided params.
+
+    Arguments:
         input_params: dict (will be merged into created input params)
         input_params_secure: dict (will be merged into created secure input params)
         folder_path: str (optional, will generate new temp)

{qubership_pipelines_common_library-0.1.10.dist-info → qubership_pipelines_common_library-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: qubership-pipelines-common-library
-Version: 0.1.10
+Version: 0.2.0
 Summary: Qubership Pipelines common library
 License: Apache-2.0
 Author: Igor Lebedev
@@ -12,8 +12,10 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: GitPython (>=3.1.43,<4.0.0)
+Requires-Dist: boto3 (>=1.39.4,<2.0.0)
 Requires-Dist: click (>=8.1.7,<9.0.0)
 Requires-Dist: ghapi (>=1.0.6,<2.0.0)
+Requires-Dist: google-cloud-artifact-registry (>=1.16.1,<2.0.0)
 Requires-Dist: http-exceptions (>=0.2.10,<0.3.0)
 Requires-Dist: kubernetes (>=29.0.0,<30.0.0)
 Requires-Dist: minio (>=7.2.12,<8.0.0)

{qubership_pipelines_common_library-0.1.10.dist-info → qubership_pipelines_common_library-0.2.0.dist-info}/RECORD

@@ -2,29 +2,31 @@ qubership_pipelines_common_library/__init__.py,sha256=91r6ljRCMIXiH1mE5cME45Ostb
 qubership_pipelines_common_library/v1/__init__.py,sha256=QczIlSYNOtXMuMWSznhV_BkXMM5KLn1wOogtlT2kcy0,598
 qubership_pipelines_common_library/v1/artifactory_client.py,sha256=Gwf21BXUYNpKT_Y_wMyM07WlpDNTIBSUkSIsJlWfURg,4105
 qubership_pipelines_common_library/v1/execution/__init__.py,sha256=QczIlSYNOtXMuMWSznhV_BkXMM5KLn1wOogtlT2kcy0,598
-qubership_pipelines_common_library/v1/execution/exec_command.py,sha256=8Abzavo6d8G6rNLy-WgHTj8zEB7Z_bQUERLLVjVW2rQ,2259
-qubership_pipelines_common_library/v1/execution/exec_context.py,sha256=guTw5iHhK1k-fnphglG9FYEiwtl1Qz3I2KtePAIkGrQ,5321
-qubership_pipelines_common_library/v1/execution/exec_context_file.py,sha256=mPiU0MGLi6CmGP4UQeDQl3t7UnOVCIrxiLdJSK-QzxI,6661
-qubership_pipelines_common_library/v1/execution/exec_info.py,sha256=3ESB3C5Aa-BvBOLDc5oVlD1W6sKwS7mjkPjCCQB4UUo,3623
-qubership_pipelines_common_library/v1/execution/exec_logger.py,sha256=Dsyydt6rrwdeIZe3zhk1VB5Xc4lWVb19wAwoTxGD4H4,2791
+qubership_pipelines_common_library/v1/execution/exec_command.py,sha256=q499vODvHg4oP5Bd6xCAjrAMjTKtMZLGE5njth7vuY0,3317
+qubership_pipelines_common_library/v1/execution/exec_context.py,sha256=R9Kmb4t3QRXCJTMhC3qcPtxtyvCrIV037Ix9P_VD5YI,6055
+qubership_pipelines_common_library/v1/execution/exec_context_file.py,sha256=kbuL9mA21qhaueVe6SWvI3OM49Ekrm8v1lj1FFspBq4,7397
+qubership_pipelines_common_library/v1/execution/exec_info.py,sha256=RsHaSdzAnOzR5XRlpU2F0IYkEAcaWBEONDlkgUPpFWs,4102
+qubership_pipelines_common_library/v1/execution/exec_logger.py,sha256=rtSCLo3mqtwIc2S_tBs0uizehdthBGfygB1Vpwa-sRA,3102
 qubership_pipelines_common_library/v1/git_client.py,sha256=uop4dREW0HoaAbGHSzp3P4vk1Hk-VrPK5RhAP3Hj51o,6100
 qubership_pipelines_common_library/v1/github_client.py,sha256=cyAbPau94XfpVVvgRVk7sVgPWtp4Q-Bx-6HHgjQG3Xc,14607
 qubership_pipelines_common_library/v1/gitlab_client.py,sha256=I8o0qBm55oO99-sDHatYaFQEniGzE3gyielocOJNDtI,8633
 qubership_pipelines_common_library/v1/jenkins_client.py,sha256=VsD4KQNmLTeFvyVnY0m1xPv3s5bb-sNbgO6SwTJ2FfY,8597
 qubership_pipelines_common_library/v1/kube_client.py,sha256=rbdc0Q2r6AhJ49FKr-15_1r9Uit4_6U68rWwGYDjdWc,12715
 qubership_pipelines_common_library/v1/log_client.py,sha256=DTJ8aI_37l570RyolDC2cHaOkkccZWi7cFE6qYUuQeo,1514
+qubership_pipelines_common_library/v1/maven_client.py,sha256=DbyPp6lh17op04GGeq2jIbk-SyVzCCHRcr2ox-eUv54,15054
 qubership_pipelines_common_library/v1/minio_client.py,sha256=4KlkCJvtgGKQOujChxRtKrpoZVukooMLfj5D8C9CKC4,4343
 qubership_pipelines_common_library/v1/utils/__init__.py,sha256=QczIlSYNOtXMuMWSznhV_BkXMM5KLn1wOogtlT2kcy0,598
 qubership_pipelines_common_library/v1/utils/rest.py,sha256=MaCS6L6Khs_HaWoi3WNj9Go33d9zEVErLP5T8iVRyHA,3068
 qubership_pipelines_common_library/v1/utils/utils.py,sha256=5PhXyFC1Zfuz0KDrWC9QgacTLVVk8zu0-6wxYS0bmzE,1865
+qubership_pipelines_common_library/v1/utils/utils_aws.py,sha256=BPPnHBzPPXPqFijtAiw16sTPu1tFZjS95GkSMX_HdjA,808
 qubership_pipelines_common_library/v1/utils/utils_cli.py,sha256=0bBoeaZQ35zXaK6KO0EZvaQXKiH5kx3PcmAwyj80mzQ,2886
-qubership_pipelines_common_library/v1/utils/utils_context.py,sha256=L2PVBYJAmqIryIcV0MGwfZ1_lk-3eah5GPzmyARfTkU,3688
+qubership_pipelines_common_library/v1/utils/utils_context.py,sha256=IlMFXGxS8zJw33Gu3SbOUcj88wquIkobBlWkdFbR7MA,3767
 qubership_pipelines_common_library/v1/utils/utils_dictionary.py,sha256=6wGAoBmLzPGGqdtkoqU9RtMBYuOO-UkZsZDh7GzubjA,1365
 qubership_pipelines_common_library/v1/utils/utils_file.py,sha256=6tCGosFjtycGJq0LtR53MiAyR8-VAxiT0-1quJ6FhcE,2233
 qubership_pipelines_common_library/v1/utils/utils_json.py,sha256=QczIlSYNOtXMuMWSznhV_BkXMM5KLn1wOogtlT2kcy0,598
 qubership_pipelines_common_library/v1/utils/utils_string.py,sha256=Phx5ZXPRjhjg9AaSPx6WLX9zQvwJH1txslfnG3jJ43w,993
 qubership_pipelines_common_library/v1/webex_client.py,sha256=3Ij4EGRX6bCq23dmj24E0TZ29Fq-7vd5Ejlqo0hbFvU,2860
-qubership_pipelines_common_library-0.1.10.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-qubership_pipelines_common_library-0.1.10.dist-info/METADATA,sha256=_THOYMzEHt1yo8HpwMYsWg_RpaPj7BVaxmiFsqcZeRs,2408
-qubership_pipelines_common_library-0.1.10.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-qubership_pipelines_common_library-0.1.10.dist-info/RECORD,,
+qubership_pipelines_common_library-0.2.0.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+qubership_pipelines_common_library-0.2.0.dist-info/METADATA,sha256=UsznhtBrgJu66xboqQxFwKScb8b5SHdMcaYvGUpmO1E,2510
+qubership_pipelines_common_library-0.2.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+qubership_pipelines_common_library-0.2.0.dist-info/RECORD,,