cgcsdk 1.0.6__py3-none-any.whl → 1.0.9__py3-none-any.whl

cgc/commands/jobs/jobs_cmd.py

@@ -0,0 +1,238 @@
+import click
+import json
+import sys
+
+from cgc.commands.jobs.job_utils import job_delete_payload, job_create_payload
+from cgc.commands.jobs.jobs_responses import (
+    job_delete_response,
+    job_list_response,
+    job_create_response,
+)
+from cgc.commands.compute.compute_models import GPUsList
+from cgc.utils.prepare_headers import get_api_url_and_prepare_headers
+from cgc.utils.response_utils import (
+    retrieve_and_validate_response_send_metric,
+)
+from cgc.utils.click_group import CustomGroup, CustomCommand
+from cgc.utils.requests_helper import call_api, EndpointTypes
+
+
+@click.group(name="job", cls=CustomGroup, hidden=False)
+def job_group():
+    """
+    Management of jobs.
+    """
+
+
+@job_group.command("delete", cls=CustomCommand)
+@click.argument("name", type=click.STRING)
+def job_delete(name: str):
+    """
+    Delete an job using backend endpoint.
+    \f
+    :param name: name of job to delete
+    :type name: str
+    """
+    api_url, headers = get_api_url_and_prepare_headers()
+    url = f"{api_url}/v1/api/job/delete"
+    metric = "job.delete"
+    __payload = job_delete_payload(name=name)
+    __res = call_api(
+        request=EndpointTypes.delete,
+        url=url,
+        headers=headers,
+        data=json.dumps(__payload).encode("utf-8"),
+    )
+    click.echo(
+        job_delete_response(retrieve_and_validate_response_send_metric(__res, metric))
+    )
+
+
+@job_group.command("list", cls=CustomCommand)
+def job_list():
+    """List all ports for a running resource"""
+    api_url, headers = get_api_url_and_prepare_headers()
+    url = f"{api_url}/v1/api/job/list"
+    metric = "job.list"
+    __res = call_api(
+        request=EndpointTypes.get,
+        url=url,
+        headers=headers,
+    )
+    click.echo(
+        job_list_response(retrieve_and_validate_response_send_metric(__res, metric))
+    )
+
+
+@job_group.command("create", cls=CustomCommand)
+@click.argument("startup_command", required=False)
+@click.option(
+    "-n", "--name", "name", type=click.STRING, required=True, help="Desired app name"
+)
+@click.option(
+    "-g",
+    "--gpu",
+    "gpu",
+    type=click.INT,
+    default=0,
+    help="How much GPU cards app will use",
+)
+@click.option(
+    "-gt",
+    "--gpu-type",
+    "gpu_type",
+    type=click.Choice(GPUsList.get_list(), case_sensitive=False),
+    default="A5000",
+    help="Graphic card used by the app",
+)
+@click.option(
+    "-c",
+    "--cpu",
+    "cpu",
+    type=click.INT,
+    default=1,
+    help="How much CPU cores app can use",
+)
+@click.option(
+    "-m",
+    "--memory",
+    "memory",
+    type=click.INT,
+    default=2,
+    help="How much Gi RAM app can use",
+)
+@click.option(
+    "-v",
+    "--volume",
+    "volumes",
+    multiple=True,
+    help="List of volume names to be mounted with default mount path",
+)
+@click.option(
+    "-fp",
+    "--full-path",
+    "volume_full_path",
+    type=click.STRING,
+    help="If set, full path will be used for volume mount. Valid for 1 volume.",
+)
+@click.option(
+    "-d",
+    "--resource-data",
+    "resource_data",
+    multiple=True,
+    help="List of optional arguments to be passed to the app, key=value format",
+)
+@click.option(
+    "--image",
+    "image_name",
+    type=click.STRING,
+    help="Image to be used by the app",
+)
+@click.option(
+    "--repository-secret",
+    "repository_secret",
+    type=click.STRING,
+    help="Use secret to pull image from private repository",
+)
+@click.option(
+    "-cm",
+    "--config-map",
+    "config_maps_data",
+    multiple=True,
+    help="List of optional arguments to be passed to the app, key=value format",
+)
+@click.option(
+    "--shm",
+    "shm_size",
+    type=click.IntRange(0, 1024, clamp=True),
+    default=0,
+    help="Size of shared memory in Gi",
+)
+@click.option(
+    "--ttl",
+    "ttl_seconds_after_finished",
+    type=click.INT,
+    default=None,
+    help="Time to live in seconds after app is finished",
+)
+def job_create(
+    gpu: int,
+    gpu_type: str,
+    cpu: int,
+    memory: int,
+    volumes: list[str],
+    volume_full_path: str,
+    resource_data: list[str],
+    config_maps_data: list[str],
+    name: str,
+    shm_size: int,
+    image_name: str,
+    startup_command: str,
+    repository_secret: str,
+    ttl_seconds_after_finished: int,
+):
+    """
+    Create job in user namespace.
+    \f
+    :param gpu: number of gpus to be used by app
+    :type gpu: int
+    :param cpu: number of cores to be used by app
+    :type cpu: int
+    :param memory: GB of memory to be used by app
+    :type memory: int
+    :param volumes: list of volumes to mount
+    :type volumes: list[str]
+    :param volume_full_path: if set, full path will be used for volume mount
+    :type volume_full_path: str
+    :param resource_data: list of optional arguments to be passed to the app
+    :type resource_data: list[str]
+    :param config_maps_data: list of optional arguments to be passed to the app
+    :type config_maps_data: list[str]
+    :param name: name of app
+    :type name: str
+    :param shm_size: size of shared memory
+    :type shm_size: int
+    :param image_name: name of image to be used by the app
+    :type image_name: str
+    :param startup_command: command to be executed on app startup; it is stdin input
+    :type startup_command: str
+    :param repository_secret: use secret to pull image from private repository
+    :type repository_secret: str
+    :param ttl_seconds_after_finished: time to live in seconds after app is finished
+    :type ttl_seconds_after_finished: int
+    """
+    api_url, headers = get_api_url_and_prepare_headers()
+    url = f"{api_url}/v1/api/job/create"
+    cleaned_data = ""
+    if not sys.stdin.isatty():
+        input_data = sys.stdin.read()
+        cleaned_data = input_data.replace("|", "")
+        startup_command = cleaned_data
+    elif startup_command:
+        cleaned_data = startup_command
+    metric = "job.create"
+    __payload = job_create_payload(
+        name=name,
+        cpu=cpu,
+        memory=memory,
+        gpu=gpu,
+        volumes=volumes,
+        volume_full_path=volume_full_path,
+        resource_data=resource_data,
+        config_maps_data=config_maps_data,
+        gpu_type=gpu_type,
+        shm_size=shm_size,
+        image_name=image_name,
+        startup_command=cleaned_data,
+        repository_secret=repository_secret,
+        ttl_seconds_after_finished=ttl_seconds_after_finished,
+    )
+    __res = call_api(
+        request=EndpointTypes.post,
+        url=url,
+        headers=headers,
+        data=json.dumps(__payload).encode("utf-8"),
+    )
+    click.echo(
+        job_create_response(retrieve_and_validate_response_send_metric(__res, metric))
+    )

cgc/commands/jobs/jobs_responses.py

@@ -0,0 +1,52 @@
+from cgc.commands.jobs import NoJobsToList
+from cgc.commands.jobs.job_utils import get_job_list
+from cgc.telemetry.basic import change_gauge, setup_gauge
+from cgc.utils.config_utils import get_namespace
+from cgc.utils.message_utils import key_error_decorator_for_helpers
+from cgc.utils.response_utils import (
+    fill_missing_values_in_a_response,
+    tabulate_a_response,
+)
+
+
+@key_error_decorator_for_helpers
+def job_delete_response(data: dict) -> str:
+    """Create response string for job delete command.
+
+    :param response: dict object from API response.
+    :type response: requests.Response
+    :return: Response string.
+    :rtype: str
+    """
+    name = data.get("details", {}).get("job_deleted", {}).get("name")
+    change_gauge(f"{get_namespace()}.job.count", -1)
+    return f"Job {name} and its service successfully deleted."
+
+
+@key_error_decorator_for_helpers
+def job_list_response(data: dict) -> list:
+    job_pod_list = data.get("details", {}).get("job_pod_list", [])
+    job_list = data.get("details", {}).get("job_list", [])
+    setup_gauge(f"{get_namespace()}.job.count", len(job_list))
+
+    if not job_list:
+        raise NoJobsToList()
+
+    list_of_json_data = get_job_list(job_list, job_pod_list)
+    table = fill_missing_values_in_a_response(list_of_json_data)
+
+    return tabulate_a_response(table)
+
+
+@key_error_decorator_for_helpers
+def job_create_response(data: dict) -> str:
+    """Create response string for job create command.
+
+    :param response: dict object from API response.
+    :type response: requests.Response
+    :return: Response string.
+    :rtype: str
+    """
+    name = data.get("details", {}).get("job_created", {}).get("name")
+    change_gauge(f"{get_namespace()}.job.count", 1)
+    return f"Job {name} created successfully."

cgc/commands/keys/__init__.py

@@ -0,0 +1,5 @@
+from cgc.commands.exceptions import ResponseException
+
+
+class KeysCommandException(ResponseException):
+    pass

cgc/commands/keys/keys_cmd.py

@@ -0,0 +1,176 @@
+import json
+import click
+from typing import Optional
+from cgc.commands.keys.keys_responses import (
+    create_ssh_key_response,
+    delete_ssh_key_response,
+    list_ssh_keys_response,
+    update_ssh_key_response,
+)
+from cgc.commands.keys.keys_utils import create_ssh_key_payload, update_ssh_key_payload
+from cgc.commands.keys.keys_models import SSHKeyTypes
+from cgc.utils.prepare_headers import get_api_url_and_prepare_headers
+from cgc.utils.response_utils import retrieve_and_validate_response_send_metric
+from cgc.utils.click_group import CustomGroup, CustomCommand
+from cgc.utils.requests_helper import call_api, EndpointTypes
+
+
+@click.group(name="keys", cls=CustomGroup)
+def keys_group():
+    """
+    Management of keys.
+    """
+
+
+@keys_group.group(name="ssh", cls=CustomGroup)
+def ssh_keys_group():
+    """
+    Management of ssh keys.
+    """
+
+
+@ssh_keys_group.command("create", cls=CustomCommand)
+@click.option(
+    "-pk",
+    "--pub-key",
+    "public_key",
+    type=click.STRING,
+    required=False,
+    help="Whole Public key string",
+)
+@click.option(
+    "-kt",
+    "--key-type",
+    "key_type",
+    type=click.Choice(SSHKeyTypes.get_list(), case_sensitive=False),
+    required=False,
+    # default="ssh-rsa",
+    help="Type of the key",
+)
+@click.option(
+    "-k",
+    "--key",
+    "key",
+    type=click.STRING,
+    required=False,
+    help="Public key",
+)
+@click.option(
+    "-c",
+    "--comment",
+    "comment",
+    type=click.STRING,
+    required=False,
+    default="",
+    help="Comment for the key",
+)
+def create_ssh_key(
+    public_key: Optional[str] = None,
+    key_type: Optional[str] = None,
+    key: Optional[str] = None,
+    comment: str = "",
+):
+    """Create a new SSH key"""
+    api_url, headers = get_api_url_and_prepare_headers()
+    url = f"{api_url}/v1/api/keys/ssh/create"
+    metric = "keys.create"
+    __payload = create_ssh_key_payload(public_key, key_type, key, comment)
+    __res = call_api(
+        request=EndpointTypes.post,
+        url=url,
+        headers=headers,
+        data=json.dumps(__payload).encode("utf-8"),
+    )
+    click.echo(
+        create_ssh_key_response(
+            retrieve_and_validate_response_send_metric(__res, metric)
+        )
+    )
+
+
+@ssh_keys_group.command("update", cls=CustomCommand)
+@click.argument("key_id", type=click.STRING)
+@click.option(
+    "-kt",
+    "--key-type",
+    "key_type",
+    type=click.Choice(SSHKeyTypes.get_list(), case_sensitive=False),
+    # default="ssh-rsa",
+    required=False,
+    help="Type of the key",
+)
+@click.option(
+    "-k",
+    "--key",
+    "key",
+    type=click.STRING,
+    required=False,
+    help="Public key",
+)
+@click.option(
+    "-c",
+    "--comment",
+    "comment",
+    type=click.STRING,
+    required=False,
+    help="Comment for the key",
+)
+def update_ssh_key(
+    key_id: str,
+    key_type: Optional[str] = None,
+    key: Optional[str] = None,
+    comment: Optional[str] = None,
+):
+    """Update an existing SSH key"""
+    api_url, headers = get_api_url_and_prepare_headers()
+    url = f"{api_url}/v1/api/keys/ssh/update/{key_id}"
+    metric = "keys.update"
+    __payload = update_ssh_key_payload(key_type, key, comment)
+    __res = call_api(
+        request=EndpointTypes.post,
+        url=url,
+        headers=headers,
+        data=json.dumps(__payload).encode("utf-8"),
+    )
+    click.echo(
+        update_ssh_key_response(
+            retrieve_and_validate_response_send_metric(__res, metric)
+        )
+    )
+
+
+@ssh_keys_group.command("delete", cls=CustomCommand)
+@click.argument("key_id", type=click.STRING)
+def delete_ssh_key(key_id: str):
+    """Delete an SSH key"""
+    api_url, headers = get_api_url_and_prepare_headers()
+    url = f"{api_url}/v1/api/keys/ssh/delete/{key_id}"
+    metric = "keys.delete"
+    __res = call_api(
+        request=EndpointTypes.delete,
+        url=url,
+        headers=headers,
+    )
+    click.echo(
+        delete_ssh_key_response(
+            retrieve_and_validate_response_send_metric(__res, metric)
+        )
+    )
+
+
+@ssh_keys_group.command("list", cls=CustomCommand)
+def list_ssh_keys():
+    """List all SSH keys"""
+    api_url, headers = get_api_url_and_prepare_headers()
+    url = f"{api_url}/v1/api/keys/ssh/list"
+    metric = "keys.list"
+    __res = call_api(
+        request=EndpointTypes.get,
+        url=url,
+        headers=headers,
+    )
+    click.echo(
+        list_ssh_keys_response(
+            retrieve_and_validate_response_send_metric(__res, metric)
+        )
+    )

cgc/commands/keys/keys_models.py

@@ -0,0 +1,16 @@
+from cgc.commands.cgc_models import CGCEntityList
+
+
+class SSHKeyTypes(CGCEntityList):
+    """List of supported SSH key types
+
+    :param Enum: name of SSH key type
+    :type Enum: str
+    """
+
+    RSA = "ssh-rsa"
+    DSS = "ssh-dss"
+    ECDSA_P256 = "ecdsa-sha2-nistp256"
+    ECDSA_P384 = "ecdsa-sha2-nistp384"
+    ECDSA_P521 = "ecdsa-sha2-nistp521"
+    ED25519 = "ssh-ed25519"

cgc/commands/keys/keys_responses.py

@@ -0,0 +1,47 @@
+import click
+from cgc.utils.message_utils import key_error_decorator_for_helpers
+from cgc.commands.keys.keys_utils import get_user_ssh_keys
+from cgc.utils.response_utils import (
+    fill_missing_values_in_a_response,
+    tabulate_a_response,
+)
+
+
+@key_error_decorator_for_helpers
+def create_ssh_key_response(data: dict) -> dict:
+    """Create a response for creating a new SSH key"""
+    try:
+        key_id = data["details"]["key_id"]
+    except KeyError:
+        raise click.ClickException("Key creation failed!")
+    return f"Key created with ID: {key_id}"
+
+
+@key_error_decorator_for_helpers
+def delete_ssh_key_response(data: dict) -> dict:
+    """Create a response for deleting an SSH key"""
+    try:
+        key_id = data["details"]["key_id"]
+    except KeyError:
+        raise click.ClickException("Key deletion failed!")
+    return f"Key with ID: {key_id} deleted."
+
+
+@key_error_decorator_for_helpers
+def list_ssh_keys_response(data: dict) -> dict:
+    """Create a response for listing all SSH keys"""
+    list_of_json_data = get_user_ssh_keys(data["details"])
+    table = fill_missing_values_in_a_response(list_of_json_data)
+
+    return tabulate_a_response(table)
+
+
+@key_error_decorator_for_helpers
+def update_ssh_key_response(data: dict) -> dict:
+    """Create a response for updating an SSH key"""
+    try:
+        key_id = data["details"]["key_id"]
+    except KeyError:
+        return "Key updated."
+    else:
+        return f"Key updated. New key ID: {key_id}."

cgc/commands/keys/keys_utils.py

@@ -0,0 +1,79 @@
+from typing import Optional
+import click
+from cgc.commands.keys.keys_models import SSHKeyTypes
+
+
+def create_ssh_key_payload(
+    public_key: Optional[str] = None,
+    key_type: Optional[str] = None,
+    key: Optional[str] = None,
+    comment: str = "",
+) -> dict:
+    """Create a payload for creating a new SSH key"""
+    if public_key:
+        try:
+            key_parts = public_key.split(" ")
+            key_type = key_parts[0] if key_parts[0] in SSHKeyTypes.get_list() else ""
+            if not key_type:
+                raise click.ClickException("Invalid key type")
+            key = key_parts[1]
+            comment = key_parts[2] if len(key_parts) > 2 else comment
+        except IndexError:
+            raise click.ClickException("Invalid public key format")
+    if not key_type or not key:
+        raise click.ClickException("Invalid public key or key_type")
+    payload = {
+        "key_type": key_type,
+        "key": key,
+        "comment": comment,
+    }
+    return payload
+
+
+def update_ssh_key_payload(
+    key_type: Optional[str] = None,
+    key: Optional[str] = None,
+    comment: Optional[str] = None,
+) -> dict:
+    """Create a payload for creating a new SSH key"""
+    payload = {}
+    if key_type:
+        if not key:
+            raise click.ClickException("Invalid public key")
+        payload["key_type"] = key_type
+    if key:
+        if not key_type:
+            raise click.ClickException("Invalid key_type")
+        payload["key"] = key
+    if comment:
+        payload["comment"] = comment
+    return payload
+
+
+def get_user_ssh_keys(keys: list) -> list:
+    """
+    Format list of keys for user
+    :param keys: list of user keys
+    :type keys: list
+    :return: formatted list of keys
+    :rtype: list
+    """
+    output_data = []
+
+    for key in keys:
+        try:
+            key_data = {
+                "key_id": key["key_id"],
+                "key_type": key["key_type"],
+                "key": key["key"],
+                "comment": key["comment"],
+                "date_added": key["date_added"],
+                "date_updated": key["date_updated"],
+            }
+            # appending the rest of labels
+            key_data.update(key)
+            output_data.append(key_data)
+        except KeyError:
+            pass
+
+    return output_data

cgc/commands/resource/resource_cmd.py

@@ -1,7 +1,8 @@
 import click
 import json
 
-from cgc.commands.compute.compute_models import ComputesList, DatabasesList
+from cgc.commands.db.db_models import DatabasesList
+from cgc.commands.compute.compute_models import ComputesList
 from cgc.commands.compute.compute_responses import (
     template_list_response,
     template_get_start_path_response,

cgc/sdk/__init__.py

@@ -1,6 +1,5 @@
-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.job as job
 import cgc.sdk.exceptions as exceptions