cgcsdk 1.0.3__py3-none-any.whl → 1.0.5__py3-none-any.whl

cgc/commands/compute/compute_utills.py

@@ -1,3 +1,25 @@
+from ast import main
+import cgc.utils.consts.env_consts as env_consts
+
+def list_get_mounted_volumes_paths(volume_list: list) -> str:
+    """Formats and returns list of PVC volumes mounted to an app.
+
+    :param volume_list: list of all volumes mounted to an app
+    :type volume_list: list
+    :return: list of volume paths
+    :rtype: str
+    """
+    volume_name_list = []
+    for volume in volume_list:
+        volume_type = volume.get("type")
+        if volume_type == "PVC":
+            volume_mount_path = volume.get("mount_path")
+            volume_name_list.append(volume_mount_path)
+    volumes_mounted = (
+        ", ".join(volume_name_list) if len(volume_name_list) != 0 else None
+    )
+    return volumes_mounted
+
 def list_get_mounted_volumes(volume_list: list) -> str:
     """Formats and returns list of PVC volumes mounted to an app.
 
@@ -17,6 +39,29 @@ def list_get_mounted_volumes(volume_list: list) -> str:
     )
     return volumes_mounted
 
+def get_app_mounts(pod_list:list) -> list:
+    output_data = []
+    
+    for pod in pod_list:
+        try:
+            main_container_name = pod["labels"]["entity"]   
+            try:
+                main_container = [x for x in pod["containers"] if x["name"] == main_container_name][0]
+            except IndexError:
+                raise Exception("Parser was unable to find main container in server output in container list")
+            volumes_mounted = list_get_mounted_volumes(main_container["mounts"])
+            volumes_paths = list_get_mounted_volumes_paths(main_container["mounts"])
+            pod_data = {
+                "name": pod["labels"]["app-name"],
+                "type": pod["labels"]["entity"],
+                "status": pod["status"],
+                "volumes_mounted": volumes_mounted,
+                "volumes_paths": volumes_paths,
+            }
+            output_data.append(pod_data)
+        except KeyError:
+            pass
+    return output_data
 
 def get_app_list(pod_list: list, detailed: bool) -> list:
     """Formats and returns list of apps to print.
@@ -117,13 +162,23 @@ def compute_create_payload(
     cpu,
     memory,
     volumes: list,
+    volume_full_path: str,
     resource_data: list = [],
+    config_maps_data: list = [],
     gpu: int = 0,
     gpu_type: str = None,
+    shm_size: int = 0,
+    image_name: str = "",
+    startup_command: str = "",
+    repository_secret: str = "",
+    node_port_enabled: bool = False,
 ):
     """
     Create payload for app creation.
     """
+    shm_payload = {}
+    if shm_size is not None and shm_size != 0:
+        shm_payload = {"shared_memory": shm_size}
 
     payload = {
         "resource_data": {
@@ -133,16 +188,31 @@ def compute_create_payload(
             "gpu": gpu,
             "memory": memory,
             "gpu_type": gpu_type,
+            "full_mount_path": volume_full_path,
+            **shm_payload,
         }
     }
     try:
         if len(volumes) != 0:
-            payload["resource_data"]["pv_volume"] = volumes
+            if not volume_full_path:
+                payload["resource_data"]["pv_volume"] = volumes
+            elif volume_full_path and len(volumes) != 1:
+                raise Exception(
+                    "Volume full path can only be used with a single volume"
+                )
+            else:
+                payload["resource_data"]["pv_volume"] = volumes
     except TypeError:
         pass
     try:
+        resource_data_dict = {"resource_data": {}}
+        if node_port_enabled:
+            if not env_consts.ON_PREMISES:
+                raise Exception(
+                    "NodePort is supported in on-premises environments only."
+                )
+            resource_data_dict["resource_data"]["node_port_enabled"] = True
         if len(resource_data) != 0:
-            resource_data_dict = {"resource_data": {}}
             for resource in resource_data:
                 try:
                     key, value = resource.split("=")
@@ -151,9 +221,36 @@ def compute_create_payload(
                     raise Exception(
                         "Invalid resource data format. Use key=value format"
                     )
+        if image_name:
+            resource_data_dict["resource_data"]["custom_image"] = image_name
+        if startup_command:
+            resource_data_dict["resource_data"]["custom_command"] = startup_command
+        if repository_secret:
+            resource_data_dict["resource_data"][
+                "image_pull_secret_name"
+            ] = repository_secret
+        if resource_data_dict["resource_data"] != {}:
             payload["template_specific_data"] = resource_data_dict
     except TypeError:
         pass
+    try:
+        if len(config_maps_data) != 0:
+            config_maps_data_dict = {}
+            for config_map in config_maps_data:
+                try:
+                    key, value = config_map.split(
+                        "="
+                    )  # where key is name of config map and value is data
+                    config_maps_data_dict[key] = (
+                        value  # value is dict, ex.: {"key": "value"}
+                    )
+                except ValueError:
+                    raise Exception(
+                        "Invalid config map data format. Use key=value format"
+                    )
+            payload["config_maps_data"] = config_maps_data_dict
+    except TypeError:
+        pass
     return payload
 
 

cgc/commands/resource/resource_cmd.py

@@ -1,7 +1,7 @@
 import click
 import json
 
-from cgc.commands.compute.compute_models import EntityList, DatabasesList
+from cgc.commands.compute.compute_models import ComputesList, DatabasesList
 from cgc.commands.compute.compute_responses import (
     template_list_response,
     template_get_start_path_response,
@@ -22,7 +22,7 @@ from cgc.utils.click_group import CustomGroup, CustomCommand
 from cgc.utils.requests_helper import call_api, EndpointTypes
 
 
-@click.group(name="resource", cls=CustomGroup, hidden=True)
+@click.group(name="resource", cls=CustomGroup, hidden=False)
 def resource_group():
     """
     Management of templates.
@@ -45,7 +45,7 @@ def template_list():
 
 @resource_group.command("get_start_path", cls=CustomCommand)
 @click.argument(
-    "template", type=click.Choice([*EntityList.get_list(), *DatabasesList.get_list()])
+    "template", type=click.Choice([*ComputesList.get_list(), *DatabasesList.get_list()])
 )
 def template_get_start_path(template: str):
     """Displays start path of specified template"""

cgc/sdk/__init__.py

@@ -1,3 +1,6 @@
 from cgc.sdk.mongodb import get_mongo_access as mongo_client
 from cgc.sdk.redis import get_redis_access as redis_client
 from cgc.sdk.postgresql import get_postgresql_access as postgresql_client
+
+import cgc.sdk.resource as resource
+import cgc.sdk.exceptions as exceptions

cgc/sdk/exceptions.py

@@ -0,0 +1,7 @@
+from cgc.commands.exceptions import ResponseException
+
+
+class SDKException(ResponseException):
+    def __init__(self, code: int, *args, **kwargs):
+        self.code = code
+        super().__init__(*args, **kwargs)

cgc/sdk/resource.py

@@ -0,0 +1,425 @@
+import json as _json
+import re
+import cgc.sdk.exceptions as _exceptions
+import cgc.utils.prepare_headers as _prepare_headers
+import cgc.commands.compute.compute_utills as _compute_utills
+import cgc.utils.requests_helper as _requests_helper
+import cgc.utils.response_utils as _response_utils
+from enum import Enum as _Enum
+from cgc.commands.compute.compute_models import GPUsList
+
+
+def start_function_loop(function, infinite: bool = True, *args, **kwargs):
+    """
+    Starts a function in a loop until it gets response code 200.
+
+    Args:
+        function: The function to be executed.
+        infinite: A boolean indicating whether the loop should be infinite (default: True).
+        *args: Positional arguments to be passed to the function.
+        **kwargs: Keyword arguments to be passed to the function.
+
+    Raises:
+        _SDKException: If the app fails to start within 10 iterations (when infinite is False).
+
+    Returns:
+        None
+    """
+    from time import sleep
+
+    counter = 0
+    try:
+        response = function(*args, **kwargs)
+        if type(response) is bool:
+            while not response:
+                counter += 1
+                if not infinite and counter > 10:
+                    raise _exceptions.SDKException(-1, response)
+                sleep(5)
+                response = function(*args, **kwargs)
+        elif type(response) is dict:
+            while response["code"] != 200:
+                counter += 1
+                if not infinite and counter > 10:
+                    raise _exceptions.SDKException(-1, response)
+                sleep(5)
+                response = function(*args, **kwargs)
+        else:
+            raise _exceptions.SDKException(-1, response)
+    except _exceptions.SDKException as e:
+        import logging
+
+        if e.code == 409:
+            logging.warning(e)
+        else:
+            raise e
+    else:
+        return response
+
+
+def stop_function_loop(function, infinite: bool = True, *args, **kwargs):
+    """
+    Stop function loop, proceed on response code 200.
+
+    Args:
+        function: The function to be stopped.
+        infinite (bool): Flag indicating whether the loop should run infinitely or not.
+        *args: Variable length argument list to be passed to the function.
+        **kwargs: Arbitrary keyword arguments to be passed to the function.
+
+    Raises:
+        _SDKException: If the app fails to stop within 10 attempts (when infinite is False).
+
+    Returns:
+        None
+    """
+    from time import sleep
+
+    counter = 0
+    response = function(*args, **kwargs)
+    if type(response) is bool:
+        while not response:
+            counter += 1
+            if not infinite and counter > 10:
+                raise _exceptions.SDKException(-1, response)
+            sleep(5)
+            response = function(*args, **kwargs)
+    elif type(response) is dict:
+        while response["code"] != 200:
+            counter += 1
+            if not infinite and counter > 10:
+                raise _exceptions.SDKException(-1, response)
+            sleep(5)
+            response = function(*args, **kwargs)
+    else:
+        raise _exceptions.SDKException(-1, response)
+    return response
+
+
+def compute_list():
+    """
+    List all compute apps for user namespace.
+    """
+    api_url, headers = _prepare_headers.get_api_url_and_prepare_headers()
+    url = f"{api_url}/v1/api/resource/list?resource_type=compute"
+    metric = "compute.list"
+    __res = _requests_helper.call_api(
+        request=_requests_helper.EndpointTypes.get,
+        url=url,
+        headers=headers,
+    )
+    return _response_utils.retrieve_and_validate_response_send_metric_for_sdk(
+        __res, metric
+    )
+
+
+class ResourceTypes(_Enum):
+    compute = "compute"
+    db = "db"
+
+
+def _resource_status_ready(name: str, response: dict):
+    """
+    Check if a resource is ready.
+
+    Args:
+        name: The name of the resource.
+        response: The response from the API call.
+
+    Returns:
+        The response from the API call.
+    """
+    for pod in response["details"]["pods_list"]:
+        try:
+            if pod["labels"]["app-name"] == name:
+                return pod["status"] == "Running"
+        except KeyError:
+            return False
+    return False
+
+
+def resource_ready(
+    name: str, resource_type: ResourceTypes = ResourceTypes.compute
+) -> bool:
+    """
+    Check if a resource is ready.
+
+    Args:
+        name: The name of the resource.
+        resource_type: The type of resource to check (default: ResourceTypes.compute).
+
+    Returns:
+        bool: A boolean indicating whether the resource is ready.
+    """
+    api_url, headers = _prepare_headers.get_api_url_and_prepare_headers()
+    url = f"{api_url}/v1/api/resource/list?resource_type={resource_type.value}"
+    metric = "resource.list"
+    __res = _requests_helper.call_api(
+        request=_requests_helper.EndpointTypes.get,
+        url=url,
+        headers=headers,
+    )
+    validated_response = (
+        _response_utils.retrieve_and_validate_response_send_metric_for_sdk(
+            __res, metric
+        )
+    )
+    return _resource_status_ready(name, validated_response)
+
+
+def db_list():
+    """
+    List all db apps for user namespace.
+    """
+    api_url, headers = _prepare_headers.get_api_url_and_prepare_headers()
+    url = f"{api_url}/v1/api/resource/list?resource_type=db"
+    metric = "compute.list"
+    __res = _requests_helper.call_api(
+        request=_requests_helper.EndpointTypes.get,
+        url=url,
+        headers=headers,
+    )
+    return _response_utils.retrieve_and_validate_response_send_metric_for_sdk(
+        __res, metric
+    )
+
+
+def compute_create_custom(
+    name: str,
+    image_name: str,
+    cpu: int = 1,
+    memory: int = 2,
+    shm_size: int = 0,
+    gpu: int = 0,
+    gpu_type: str = "A5000",
+    volumes: list = [],
+    volume_full_path: str = "",
+    startup_command: str = "",
+    repository_secret: str = "",
+    resource_data: list = [],
+    config_maps_data: list = [],
+    node_port_enabled: bool = False,
+):
+    """
+    Create a custom compute resource.
+
+    :param name: The name of the compute resource.
+    :type name: str
+    :param image_name: The name of the image to use for the compute resource.
+    :type image_name: str,
+    :param cpu: The number of CPUs for the compute resource, defaults to 1.
+    :type cpu: int, optional
+    :param memory: The amount of memory (in GB) for the compute resource, defaults to 2.
+    :type memory: int, optional
+    :param shm_size: The size of the shared memory (in GB) for the compute resource, defaults to 0.
+    :type shm_size: int, optional
+    :param gpu: The number of GPUs for the compute resource, defaults to 0.
+    :type gpu: int, optional
+    :param gpu_type: The type of GPU for the compute resource, defaults to "A5000".
+    :type gpu_type: str, optional
+    :param volumes: The list of volumes to attach to the compute resource, defaults to [].
+    :type volumes: list, optional
+    :param volume_full_path: The full path of the volume, defaults to "".
+    :type volume_full_path: str, optional
+    :param startup_command: The startup command for the compute resource, defaults to "".
+    :type startup_command: str, optional
+    :param repository_secret: The secret for accessing the repository, defaults to "".
+    :type repository_secret: str, optional
+    :param resource_data: The additional resource data, defaults to [].
+    :type resource_data: list, optional
+    :param config_maps_data: The additional config maps data, defaults to [].
+    :type config_maps_data: list, optional
+    :param node_port_enabled: A flag indicating whether the node port is enabled, defaults to False.
+    :type node_port_enabled: bool, optional
+    :raises _SDKException: If the image name is not provided.
+    :raises _SDKException: If an invalid GPU type is specified.
+    :return: The response from the API call.
+    :rtype: _type_
+    """
+    if not image_name:
+        raise _exceptions.SDKException(-2, "Image name is required")
+    api_url, headers = _prepare_headers.get_api_url_and_prepare_headers()
+    url = f"{api_url}/v1/api/resource/create"
+    metric = "compute.create"
+    gpu_type = gpu_type.upper()
+    if gpu_type not in GPUsList.get_list():
+        raise _exceptions.SDKException(-3, f"Invalid GPU type: {gpu_type}")
+    __payload = _compute_utills.compute_create_payload(
+        name=name,
+        entity="custom",
+        cpu=cpu,
+        memory=memory,
+        gpu=gpu,
+        gpu_type=gpu_type,
+        volumes=volumes,
+        volume_full_path=volume_full_path,
+        resource_data=resource_data,
+        config_maps_data=config_maps_data,
+        shm_size=shm_size,
+        image_name=image_name,
+        startup_command=startup_command,
+        repository_secret=repository_secret,
+        node_port_enabled=node_port_enabled,
+    )
+
+    __res = _requests_helper.call_api(
+        request=_requests_helper.EndpointTypes.post,
+        url=url,
+        headers=headers,
+        data=_json.dumps(__payload),
+    )
+
+    return _response_utils.retrieve_and_validate_response_send_metric_for_sdk(
+        __res, metric
+    )
+
+
+def resource_update_port(
+    name: str, port_name: str, new_port: int, ingress: bool = True
+):
+    """
+    Update a port for an app using backend endpoint.
+
+    :param name: name of app to edit
+    :type name: str
+    :param port_name: name of port to edit
+    :type port_name: str
+    :param new_port: new port number
+    :type new_port: int
+    :return: response from the API call
+    :rtype: dict
+    """
+    api_url, headers = _prepare_headers.get_api_url_and_prepare_headers()
+    url = f"{api_url}/v1/api/resource/ports?port_modification_mode=UPDATE"
+    metric = "resource.ports.update"
+    __payload = _compute_utills.port_modification_payload(
+        port_name=port_name,
+        port_number=new_port,
+        ingress=ingress,
+        app_name=name,
+    )
+    __res = _requests_helper.call_api(
+        request=_requests_helper.EndpointTypes.post,
+        url=url,
+        headers=headers,
+        data=_json.dumps(__payload),
+    )
+
+    return _response_utils.retrieve_and_validate_response_send_metric_for_sdk(
+        __res, metric
+    )
+
+
+def resource_add_port(name: str, port_name: str, new_port: int, ingress: bool = True):
+    """
+    Add a port for an app using backend endpoint.
+
+    :param name: name of app to edit
+    :type name: str
+    :param port_name: name of port to add
+    :type port_name: str
+    :param new_port: new port number
+    :type new_port: int
+    :return: response from the API call
+    :rtype: dict
+    """
+    api_url, headers = _prepare_headers.get_api_url_and_prepare_headers()
+    url = f"{api_url}/v1/api/resource/ports?port_modification_mode=ADD"
+    metric = "resource.ports.add"
+    __payload = _compute_utills.port_modification_payload(
+        port_name=port_name,
+        port_number=new_port,
+        ingress=ingress,
+        app_name=name,
+    )
+    __res = _requests_helper.call_api(
+        request=_requests_helper.EndpointTypes.post,
+        url=url,
+        headers=headers,
+        data=_json.dumps(__payload),
+    )
+
+    return _response_utils.retrieve_and_validate_response_send_metric_for_sdk(
+        __res, metric
+    )
+
+
+def resource_delete_port(
+    name: str,
+    port_name: str,
+):
+    """
+    Add a port for an app using backend endpoint.
+
+    :param name: name of app to edit
+    :type name: str
+    :param port_name: name of port to delete
+    :type port_name: str
+    :return: response from the API call
+    :rtype: dict
+    """
+    api_url, headers = _prepare_headers.get_api_url_and_prepare_headers()
+    url = f"{api_url}/v1/api/resource/ports?port_modification_mode=DELETE"
+    metric = "resource.ports.delete"
+    __payload = _compute_utills.port_delete_payload(
+        port_name=port_name,
+        app_name=name,
+    )
+    __res = _requests_helper.call_api(
+        request=_requests_helper.EndpointTypes.post,
+        url=url,
+        headers=headers,
+        data=_json.dumps(__payload),
+    )
+
+    return _response_utils.retrieve_and_validate_response_send_metric_for_sdk(
+        __res, metric
+    )
+
+
+def resource_list_ports(name: str):
+    """
+    List ports for an app using backend endpoint.
+
+    :param name: name of app to list ports for
+    :type name: str
+    :return: response from the API call
+    :rtype: dict
+    """
+    api_url, headers = _prepare_headers.get_api_url_and_prepare_headers()
+    url = f"{api_url}/v1/api/resource/ports?resource_name={name}"
+    metric = "resource.ports.list"
+    __res = _requests_helper.call_api(
+        request=_requests_helper.EndpointTypes.get,
+        url=url,
+        headers=headers,
+    )
+
+    return _response_utils.retrieve_and_validate_response_send_metric_for_sdk(
+        __res, metric
+    )
+
+
+def resource_delete(name: str):
+    """
+    Delete an app using backend endpoint.
+
+    :param name: name of app to delete
+    :type name: str
+    :return: response from the API call
+    :rtype: dict
+    """
+    api_url, headers = _prepare_headers.get_api_url_and_prepare_headers()
+    url = f"{api_url}/v1/api/resource/delete"
+    metric = "resource.delete"
+    __payload = _compute_utills.compute_delete_payload(name=name)
+    __res = _requests_helper.call_api(
+        request=_requests_helper.EndpointTypes.delete,
+        url=url,
+        headers=headers,
+        data=_json.dumps(__payload),
+    )
+
+    return _response_utils.retrieve_and_validate_response_send_metric_for_sdk(
+        __res, metric
+    )

cgc/utils/consts/env_consts.py

@@ -38,6 +38,7 @@ TMP_DIR = os.getenv("TMP_DIR")
 RELEASE = int(os.getenv("RELEASE"))
 MAJOR_VERSION = int(os.getenv("MAJOR_VERSION"))
 MINOR_VERSION = int(os.getenv("MINOR_VERSION"))
+ON_PREMISES = True if os.getenv("ON_PREMISES") == "1" else False
 
 
 def get_config_file_name():

cgc/utils/custom_exceptions.py

@@ -14,7 +14,7 @@ CUSTOM_EXCEPTIONS = {
     409: {
         "PVC_NAME_ALREADY_EXISTS": "Volume with this name already exists.",
         "PVC_DELETE_EXCEPTION": "Can't delete mounted volume, try with force",
-        "COMPUTE_TEMPLATE_NAME_ALREADY_EXISTS": "Template with this name already exists.",
+        "RESOURCE_TEMPLATE_NAME_ALREADY_EXISTS": "Template with this name already exists.",
     },
     404: {
         "PVC_CREATE_NO_SC": "Selected disk type and access mode unavailable",