cgcsdk 1.0.7__py3-none-any.whl → 1.0.10__py3-none-any.whl

cgc/commands/user/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/user/keys_responses.py

@@ -0,0 +1,44 @@
+import click
+from cgc.utils.message_utils import key_error_decorator_for_helpers
+from cgc.commands.user.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) -> str:
+    """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) -> str:
+    """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) -> str:
+    """Create a response for listing all SSH keys"""
+    list_of_json_data = get_user_ssh_keys(data["details"])
+    if not list_of_json_data:
+        return "No keys found."
+    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(_: dict) -> str:
+    """Create a response for updating an SSH key"""
+    return "Key updated."

cgc/commands/user/keys_utils.py

@@ -0,0 +1,79 @@
+from typing import Optional
+import click
+from cgc.commands.user.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/user/secret_cmd.py

@@ -0,0 +1,154 @@
+import json
+from typing import Optional, Set
+import click
+
+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
+from cgc.commands.user.secret_utils import create_secret_payload, update_secret_payload
+from cgc.commands.user.secret_responses import (
+    create_secret_response,
+    update_secret_response,
+    delete_secret_response,
+    list_secrets_response,
+)
+
+
+@click.group(name="secret", cls=CustomGroup)
+def secret_group():
+    """
+    Management of secrets.
+    """
+
+
+@secret_group.command("create", cls=CustomCommand)
+@click.argument("secret_name", type=click.STRING)
+@click.option(
+    "-r",
+    "--registry-list",
+    "registry_list",
+    multiple=True,
+    help="URL of the registry",
+    required=True,
+)
+@click.option(
+    "-u",
+    "--username",
+    "username",
+    type=click.STRING,
+    help="Username for the registry",
+    required=True,
+)
+@click.option(
+    "-p",
+    "--password",
+    "password",
+    type=click.STRING,
+    help="Password for the username",
+    required=True,
+)
+def create_secret(
+    secret_name: str, registry_list: Set[str], username: str, password: str
+):
+    """Create a new secret in the namespace"""
+    api_url, headers = get_api_url_and_prepare_headers()
+    url = f"{api_url}/v1/api/secret/create"
+    metric = "user.secret.create"
+    __payload = create_secret_payload(secret_name, registry_list, username, password)
+    __res = call_api(
+        request=EndpointTypes.post,
+        url=url,
+        headers=headers,
+        data=json.dumps(__payload).encode("utf-8"),
+    )
+    click.echo(
+        create_secret_response(
+            retrieve_and_validate_response_send_metric(__res, metric)
+        ),
+        color="green",
+    )
+
+
+@secret_group.command("update", cls=CustomCommand)
+@click.argument("secret_name", type=click.STRING)
+@click.option(
+    "-r",
+    "--registry-list",
+    "registry_list",
+    multiple=True,
+    help="URL of the registry",
+)
+@click.option(
+    "-u",
+    "--username",
+    "username",
+    type=click.STRING,
+    help="Username for the registry",
+)
+@click.option(
+    "-p",
+    "--password",
+    "password",
+    type=click.STRING,
+    help="Password for the username",
+)
+def update_secret(
+    secret_name: str,
+    registry_list: Optional[Set[str]] = None,
+    username: Optional[str] = None,
+    password: Optional[str] = None,
+):
+    """Update an existing secret in the namespace"""
+    api_url, headers = get_api_url_and_prepare_headers()
+    url = f"{api_url}/v1/api/secret/manage/{secret_name}"
+    metric = "user.secret.update"
+    __payload = update_secret_payload(registry_list, username, password)
+    __res = call_api(
+        request=EndpointTypes.put,
+        url=url,
+        headers=headers,
+        data=json.dumps(__payload).encode("utf-8"),
+    )
+    click.echo(
+        update_secret_response(
+            retrieve_and_validate_response_send_metric(__res, metric)
+        ),
+        color="green",
+    )
+
+
+@secret_group.command("delete", cls=CustomCommand)
+@click.argument("secret_name", type=click.STRING)
+def delete_secret(secret_name: str):
+    """Delete an secret"""
+    api_url, headers = get_api_url_and_prepare_headers()
+    url = f"{api_url}/v1/api/secret/manage/{secret_name}"
+    metric = "user.secret.delete"
+    __res = call_api(
+        request=EndpointTypes.delete,
+        url=url,
+        headers=headers,
+    )
+    click.echo(
+        delete_secret_response(
+            retrieve_and_validate_response_send_metric(__res, metric)
+        ),
+        color="green",
+    )
+
+
+@secret_group.command("list", cls=CustomCommand)
+def list_secrets():
+    """List all secrets in the namespace"""
+    api_url, headers = get_api_url_and_prepare_headers()
+    url = f"{api_url}/v1/api/secret/list"
+    metric = "user.secret.list"
+    __res = call_api(
+        request=EndpointTypes.get,
+        url=url,
+        headers=headers,
+    )
+    click.echo(
+        list_secrets_response(retrieve_and_validate_response_send_metric(__res, metric))
+    )

cgc/commands/user/secret_responses.py

@@ -0,0 +1,44 @@
+import click
+
+from cgc.commands.user import NoSecretsToList
+from cgc.commands.user.secret_utils import get_secret_list
+from cgc.telemetry.basic import 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 create_secret_response(data: dict) -> str:
+    """Create a response for creating a new secret in the namespace"""
+    return f'Secret {data.get("details", {}).get("secret_name")} successfully created.'
+
+
+@key_error_decorator_for_helpers
+def update_secret_response(data: dict) -> str:
+    """Create a response for updating a secret in the namespace"""
+    return f'Secret {data.get("details", {}).get("secret_name")} successfully updated.'
+
+
+@key_error_decorator_for_helpers
+def delete_secret_response(data: dict) -> str:
+    """Create a response for deleting a secret in the namespace"""
+    return f'Secret {data.get("details", {}).get("secret_name")} successfully deleted.'
+
+
+@key_error_decorator_for_helpers
+def list_secrets_response(data: dict) -> str:
+    """Create a response for listing all secrets in the namespace"""
+    secret_list = data.get("details", {}).get("secret_names", [])
+    setup_gauge(f"{get_namespace()}.secret.count", len(secret_list))
+
+    if not secret_list:
+        raise NoSecretsToList()
+
+    list_of_json_data = get_secret_list(secret_list)
+    table = fill_missing_values_in_a_response(list_of_json_data)
+
+    return tabulate_a_response(table)

cgc/commands/user/secret_utils.py

@@ -0,0 +1,60 @@
+from typing import Set
+
+
+def create_secret_payload(
+    secret_name: str, registry_list: Set[str], username: str, password: str
+) -> dict:
+    """Create a payload for creating a new secret"""
+    payload = {
+        "name": secret_name,
+        "registry_list": registry_list,
+        "username": username,
+        "password": password,
+    }
+    return payload
+
+
+def update_secret_payload(
+    registry_list: Set[str], username: str, password: str
+) -> dict:
+    """Create a payload for updating a secret"""
+    payload = {}
+    if registry_list:
+        payload["registry_list"] = registry_list
+    if username:
+        payload["username"] = username
+    if password:
+        payload["password"] = password
+    return payload
+
+
+def _get_secret_json_data(secret_list: list):
+    """Formats and returns list of secrets to print.
+
+    :param job_list: list of secrets
+    :type job_list: list
+    :return: formatted list of secrets
+    :rtype: list
+    """
+    output_data = []
+
+    for secret in secret_list:
+        try:
+
+            secret_data = {
+                "name": secret.get("secret"),
+                "secret_type": secret.get("secret_type"),
+                "registry_list": secret.get("registry_list", []),
+                "secret_admin": secret.get("secret_admin"),
+                "date_created": f'{secret.get("date_created")} UTC',
+                "whitelist": secret.get("whitelist", ["*"]),
+            }
+            output_data.append(secret_data)
+        except KeyError:
+            pass
+
+    return output_data
+
+
+def get_secret_list(secret_list: list):
+    return _get_secret_json_data(secret_list)

cgc/sdk/__init__.py

@@ -1,5 +1,3 @@
-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

cgc/sdk/job.py

@@ -119,7 +119,7 @@ def job_list():
     )
     # job_pod_list = _response.get("details", {}).get("job_pod_list", [])
     # job_list = _response.get("details", {}).get("job_list", [])
-    # return _job_utils.get_job_list(job_pod_list, job_list)
+    # return _job_utils.get_job_list(job_list)
 
 
 def job_delete(name: str):

cgc/sdk/resource.py

@@ -2,7 +2,7 @@ import json as _json
 import cgc.sdk.exceptions as _exceptions
 from cgc.utils.custom_exceptions import CUSTOM_EXCEPTIONS
 import cgc.utils.prepare_headers as _prepare_headers
-import cgc.commands.compute.compute_utills as _compute_utills
+import cgc.commands.compute.compute_utils as _compute_utils
 import cgc.utils.requests_helper as _requests_helper
 import cgc.utils.response_utils as _response_utils
 from enum import Enum as _Enum
@@ -243,7 +243,7 @@ def compute_create_custom(
     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(
+    __payload = _compute_utils.compute_create_payload(
         name=name,
         entity="custom",
         cpu=cpu,
@@ -291,7 +291,7 @@ def resource_update_port(
     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(
+    __payload = _compute_utils.port_modification_payload(
         port_name=port_name,
         port_number=new_port,
         ingress=ingress,
@@ -325,7 +325,7 @@ def resource_add_port(name: str, port_name: str, new_port: int, ingress: bool =
     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(
+    __payload = _compute_utils.port_modification_payload(
         port_name=port_name,
         port_number=new_port,
         ingress=ingress,
@@ -360,7 +360,7 @@ def resource_delete_port(
     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(
+    __payload = _compute_utils.port_delete_payload(
         port_name=port_name,
         app_name=name,
     )
@@ -411,7 +411,7 @@ def resource_delete(name: str):
     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)
+    __payload = _compute_utils.compute_delete_payload(name=name)
     __res = _requests_helper.call_api(
         request=_requests_helper.EndpointTypes.delete,
         url=url,

cgc/tests/responses_tests.py

@@ -27,7 +27,7 @@ from cgc.utils.response_utils import (
     tabulate_a_response,
     fill_missing_values_in_a_response,
 )
-from cgc.commands.compute.compute_utills import get_app_list
+from cgc.commands.compute.compute_utils import get_app_list
 
 
 class TestVolumeResponses(unittest.TestCase):

cgc/utils/__init__.py

@@ -20,6 +20,14 @@ def require_confirm_loop(message: str):
             exit(0)
 
 
+def require_answer_loop(message: str, default: str):
+    while True:
+        answer = input(f"{message}: [{default}]").lower()
+        if answer == "":
+            return default
+        return answer
+
+
 def quick_sort(collection: list) -> list:
     """A pure Python implementation of quick sort algorithm
 

cgc/utils/config_utils.py

@@ -5,7 +5,7 @@ import click
 
 from cgc.commands.auth import NoNamespaceInConfig, NoConfigFileFound
 from cgc.utils.message_utils import prepare_error_message
-from cgc.utils.consts.env_consts import get_config_file_name
+from cgc.utils.consts.env_consts import CGC_API_URL, CGC_SECRET, get_config_file_name
 
 
 def get_config_path():
@@ -78,6 +78,10 @@ def read_from_cfg(key: str, filename=None):
     except KeyError:
         if key == "namespace":
             raise NoNamespaceInConfig()
+        elif key == "cgc_secret":
+            return CGC_SECRET
+        elif key == "cgc_api_url":
+            return CGC_API_URL
         print("Config file is corrupted. Please contact support at support@comtegra.pl")
         sys.exit()
 

cgc/utils/consts/env_consts.py

@@ -33,7 +33,7 @@ else:
     raise Exception("not defined API_SECURE_CONNECTION. set yes/no")
 
 API_PORT = os.getenv("API_PORT")
-API_URL = f"{__prefix}://{API_HOST}:{API_PORT}"
+CGC_API_URL = f"{__prefix}://{API_HOST}:{API_PORT}"
 TMP_DIR = os.getenv("TMP_DIR")
 RELEASE = int(os.getenv("RELEASE"))
 MAJOR_VERSION = int(os.getenv("MAJOR_VERSION"))

cgc/utils/custom_exceptions.py

@@ -4,6 +4,7 @@
 CUSTOM_EXCEPTIONS = {
     500: {
         "UNDEFINED": "undefined exception",
+        "USER_KEY_CREATE_ERROR": "Error while creating key",
     },
     413: {
         "PVC_CREATE_STORAGE_LIMIT_EXCEEDED": "This request exceeds your storage limits",
@@ -17,6 +18,7 @@ CUSTOM_EXCEPTIONS = {
         "RESOURCE_PORTS_ALREADY_EXISTS": "Port with this name already exists.",
         "RESOURCE_TEMPLATE_NAME_ALREADY_EXISTS": "Resource with this name already exists.",
         "JOB_CREATE_ALREADY_EXISTS": "Job with this name already exists.",
+        "USER_KEY_ALREADY_EXISTS": "Key with these data already exists.",
     },
     404: {
         "PVC_CREATE_NO_SC": "Selected disk type and access mode unavailable",
@@ -33,6 +35,7 @@ CUSTOM_EXCEPTIONS = {
         "COMPUTE_RESOURCE_QUOTA_NOT_FOUND": "You do not have enforced limits on your namespace.",
         "JOB_NOT_FOUND": "Job with this name not found.",
         "RESOURCE_NOT_FOUND": "Resource with this name not found.",
+        "USER_KEY_NOT_FOUND": "Key with this id not found.",
     },
     400: {
         "WRONG_DATE_FORMAT": "Wrong date format.",

cgc/utils/message_utils.py

@@ -58,7 +58,7 @@ def key_error_decorator_for_helpers(func):
             if "debug" in kwargs:
                 raise err
             return prepare_error_message(UNKNOWN_ERROR)
-        except ResponseException as err:
+        except (ResponseException, click.ClickException) as err:
             return prepare_warning_message(err)
 
     return wrapper

cgc/utils/prepare_headers.py

@@ -1,5 +1,4 @@
 from cgc.utils.config_utils import read_from_cfg
-from cgc.utils.consts.env_consts import API_URL, CGC_SECRET
 from cgc.commands.auth import auth_utils
 from cgc.utils.message_utils import key_error_decorator_for_helpers
 
@@ -13,41 +12,51 @@ def load_user_api_keys():
     return read_from_cfg("api_key"), read_from_cfg("api_secret")
 
 
+def load_user_cgc_secret():
+    return read_from_cfg("cgc_secret")
+
+
+def load_user_api_url():
+    return read_from_cfg("cgc_api_url")
+
+
 @key_error_decorator_for_helpers
 def get_api_url_and_prepare_headers():
-    """Loads API_URL and user api keys into single function. Mend to be used as single point of truth for all endpoints except register - due to different Content-Type header
+    """Loads CGC_API_URL and user api keys into single function. Mend to be used as single point of truth for all endpoints except register - due to different Content-Type header
 
-    :return: API_URL and headers
+    :return: CGC_API_URL and headers
     :rtype: string and dict
     """
     api_key, api_secret = load_user_api_keys()
     headers = {
-        "Content-Type": "application/json; charset=UTF-8",
         "accept": "application/json",
+        "Content-Type": "application/json; charset=UTF-8",
+        "comtegra-cgc": load_user_cgc_secret(),
         "api-key": api_key,
         "api-secret": api_secret,
-        "comtegra-cgc": CGC_SECRET,
     }
-    return API_URL, headers
+    return load_user_api_url(), headers
 
 
-def get_url_and_prepare_headers_register(user_id: str, access_key: str):
+def get_url_and_prepare_headers_register(
+    user_id: str, access_key: str, url: str = None, secret: str = None
+):
     """Creates and returns url and headers for register request.
 
     :return: url, headers
     :rtype: string and dict
     """
-    url = f"{API_URL}/v1/api/user/register?user_id={user_id}&access_key={access_key}"
+    url = f"{load_user_api_url() if url is None else url}/v1/api/user/register?user_id={user_id}&access_key={access_key}"
     headers = {
         "accept": "application/json",
-        "comtegra-cgc": CGC_SECRET,
         "Content-Type": "octet-stream",
+        "comtegra-cgc": load_user_cgc_secret() if secret is None else secret,
     }
     return url, headers
 
 
 def get_url_and_headers_jwt_token():
-    url = f"{API_URL}/v1/api/user/create/token"
+    url = f"{load_user_api_url()}/v1/api/user/create/token"
     headers = {
         "accept": "application/json",
         "Content-Type": "application/x-www-form-urlencoded",
@@ -64,8 +73,8 @@ def prepare_headers_api_key(user_id: str = None, password: str = None):
     """
     headers = {
         "accept": "application/json",
-        "comtegra-cgc": CGC_SECRET,
         "Authorization": f"Bearer {auth_utils.get_jwt(user_id, password)}",
+        "comtegra-cgc": load_user_cgc_secret(),
     }
     return headers
 
@@ -76,10 +85,10 @@ def get_api_url_and_prepare_headers_version_control():
     :return: url and headers in a for of dictionary
     :rtype: string, dict
     """
-    url = f"{API_URL}/v1/api/info/version"
+    url = f"{load_user_api_url()}/v1/api/info/version"
     headers = {
         "accept": "application/json",
-        "comtegra-cgc": CGC_SECRET,
         "Content-Type": "application/json",
+        "comtegra-cgc": load_user_cgc_secret(),
     }
     return url, headers

cgc/utils/requests_helper.py

@@ -1,7 +1,6 @@
 import requests
 import urllib3
 import urllib3.exceptions
-import ssl
 import click
 import sys
 
@@ -24,10 +23,11 @@ class EndpointTypes(Enum):
     get = requests.get
     post = requests.post
     delete = requests.delete
+    put = requests.put
 
 
 def _process_endpoint_kwargs(**kwargs):
-    if not "timeout" in kwargs.keys():
+    if "timeout" not in kwargs.keys():
         kwargs["timeout"] = 30
     return kwargs