oak-cli 0.2.5__tar.gz

oak_cli-0.2.5/PKG-INFO

@@ -0,0 +1,98 @@
+Metadata-Version: 2.1
+Name: oak_cli
+Version: 0.2.5
+Summary: 
+Author: Alexander Malyuk
+Author-email: malyuk.alexander1999@gmail.com
+Requires-Python: >=3.10,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: argcomplete (>=3.2.3,<4.0.0)
+Description-Content-Type: text/markdown
+
+# Oakestra CLI
+
+> NM: Rename system commands to Oakestra
+
+**oakestra-cli** is a very basic command line tool for controlling the EdgeIO framework.
+
+## Installation
+
+Use the package manager [pip](https://pip.pypa.io/en/stable/) and the .whl file in the dist directory to install
+edgeiocli.
+
+```bash
+pip install edgeiocli-0.1.0-py3-none-any.whl
+```
+
+## Build
+
+Use the package [poetry](https://python-poetry.org/) to build the tool and create a new .whl file.
+
+Updates the dependency's: 
+```bash
+poetry update
+```
+
+Installs the package:
+```bash
+poetry install
+```
+
+Creates the .whl file:
+```bash
+poetry build
+```
+
+## Usage
+
+```bash
+edgeiocli COMMAND [ARGS] [OPTIONS] 
+
+# Try 'edgeiocli --help' for help.
+```
+
+## Available Commands
+
+- `login [USERNAME]` logs the user into the system and creates access token
+- `logout` logs out the user and deletes the token
+- `change-password` changes the password of the user
+- `application [COMMAND]`
+    - `create` creates a new application
+    - `delete [APPLICATION_ID]` deletes a application
+    - `list-jobs [APPLICATION_ID]` displays all jobs in the application
+    - `list` displays all applications of the user
+- `service [COMMAND]`
+    - `delete [SERVICE_ID]` deletes the job
+    - `create [PATH]` creates a new service
+    - `deploy [SERVICE_ID]` tries to deploy a service
+- `user  [COMMAND]`
+    - `create --role [Admin | Application_Provider | Infrastructure_Provider]` creates a new user
+    - `delete [USERNAME] deletes the user`
+    - `list` displays all user of the system
+    - `set-roles [USERNAME] --role [Admin | Application_Provider | Infrastructure_Provider]`
+
+## Deployment
+The given json file should contain only a microservice configuration, as in the example, all the application and user information will be added automatically.  
+
+```
+{
+      ...
+      "microservice_name": "service",
+      "microservice_namespace": "dev",
+      "virtualization": "docker",
+      "memory": 100,
+      ...
+}
+
+```
+
+## Contributing
+
+This is the first version of **oakestra-cli** and does not yet offer all features, also there
+might be some bugs, if you find one please report it or fix it. 
+
+To add a new command create a function in the main.py file and add the `@app.command()` annotation to the function. If you want to create sub commands, create the command in the corresponding file. 
+

oak_cli-0.2.5/README.md

@@ -0,0 +1,83 @@
+# Oakestra CLI
+
+> NM: Rename system commands to Oakestra
+
+**oakestra-cli** is a very basic command line tool for controlling the EdgeIO framework.
+
+## Installation
+
+Use the package manager [pip](https://pip.pypa.io/en/stable/) and the .whl file in the dist directory to install
+edgeiocli.
+
+```bash
+pip install edgeiocli-0.1.0-py3-none-any.whl
+```
+
+## Build
+
+Use the package [poetry](https://python-poetry.org/) to build the tool and create a new .whl file.
+
+Updates the dependency's: 
+```bash
+poetry update
+```
+
+Installs the package:
+```bash
+poetry install
+```
+
+Creates the .whl file:
+```bash
+poetry build
+```
+
+## Usage
+
+```bash
+edgeiocli COMMAND [ARGS] [OPTIONS] 
+
+# Try 'edgeiocli --help' for help.
+```
+
+## Available Commands
+
+- `login [USERNAME]` logs the user into the system and creates access token
+- `logout` logs out the user and deletes the token
+- `change-password` changes the password of the user
+- `application [COMMAND]`
+    - `create` creates a new application
+    - `delete [APPLICATION_ID]` deletes a application
+    - `list-jobs [APPLICATION_ID]` displays all jobs in the application
+    - `list` displays all applications of the user
+- `service [COMMAND]`
+    - `delete [SERVICE_ID]` deletes the job
+    - `create [PATH]` creates a new service
+    - `deploy [SERVICE_ID]` tries to deploy a service
+- `user  [COMMAND]`
+    - `create --role [Admin | Application_Provider | Infrastructure_Provider]` creates a new user
+    - `delete [USERNAME] deletes the user`
+    - `list` displays all user of the system
+    - `set-roles [USERNAME] --role [Admin | Application_Provider | Infrastructure_Provider]`
+
+## Deployment
+The given json file should contain only a microservice configuration, as in the example, all the application and user information will be added automatically.  
+
+```
+{
+      ...
+      "microservice_name": "service",
+      "microservice_namespace": "dev",
+      "virtualization": "docker",
+      "memory": 100,
+      ...
+}
+
+```
+
+## Contributing
+
+This is the first version of **oakestra-cli** and does not yet offer all features, also there
+might be some bugs, if you find one please report it or fix it. 
+
+To add a new command create a function in the main.py file and add the `@app.command()` annotation to the function. If you want to create sub commands, create the command in the corresponding file. 

oak_cli-0.2.5/oak_cli/args_parser/apps/create.py

@@ -0,0 +1,40 @@
+import argparse
+from typing import Any
+
+from oak_cli.commands.apps.main import send_sla
+from oak_cli.commands.services.deployment import deploy_new_instance
+from oak_cli.utils.SLAs.common import KnownSLA
+from oak_cli.utils.types import Subparsers
+
+
+def _aux_create_application(args: Any) -> None:
+    apps = send_sla(args.sla)
+    if args.deploy:
+        for app in apps:
+            for service_id in app["microservices"]:
+                deploy_new_instance(service_id)
+
+
+def prepare_applications_create_argparser(applications_subparsers: Subparsers) -> None:
+    HELP_TEXT = "creates a new application"
+    applications_create_parser = applications_subparsers.add_parser(
+        "create",
+        aliases=["c"],
+        help=HELP_TEXT,
+        description=HELP_TEXT,
+        formatter_class=argparse.RawTextHelpFormatter,
+    )
+    applications_create_parser.add_argument(
+        "-d",
+        "--deploy",
+        action="store_true",
+        help="deploy all services of the provided application(s)",
+    )
+    applications_create_parser.add_argument(
+        "sla",
+        help="creates an application based on a KnowsSLA (if is has its own enum)",
+        type=KnownSLA,
+        choices=KnownSLA,
+        default=KnownSLA.DEFAULT,
+    )
+    applications_create_parser.set_defaults(func=_aux_create_application)

oak_cli-0.2.5/oak_cli/args_parser/apps/delete.py

@@ -0,0 +1,36 @@
+import argparse
+from typing import Any
+
+from oak_cli.commands.apps.main import delete_all_applications, delete_application
+from oak_cli.utils.types import Subparsers
+
+_APP_ID_HELP_TEXT = """
+if a (single) application ID is provided only that one app will be deleted
+if 'all' is provided every application gets deleted"""
+
+_DELETION_HELP_TEXT = "deletes one or all applications" + _APP_ID_HELP_TEXT
+
+
+def prepare_applications_deletion_argparser(
+    applications_subparsers: Subparsers,
+) -> None:
+    def aux_delete_appliacations(args: Any):
+        if args.all:
+            delete_all_applications()
+        else:
+            delete_application(args.app_id)
+
+    applications_deletion_parser = applications_subparsers.add_parser(
+        "delete",
+        aliases=["d"],
+        help=_DELETION_HELP_TEXT,
+        description=_DELETION_HELP_TEXT,
+        formatter_class=argparse.RawTextHelpFormatter,
+    )
+    applications_deletion_parser.add_argument(
+        "-a", "--all", action="store_true", help="delete all applications"
+    )
+    applications_deletion_parser.add_argument(
+        "app_id", nargs="?", type=str, help=_APP_ID_HELP_TEXT
+    )
+    applications_deletion_parser.set_defaults(func=aux_delete_appliacations)

oak_cli-0.2.5/oak_cli/args_parser/apps/main.py

@@ -0,0 +1,29 @@
+import argparse
+from typing import Any
+
+from oak_cli.args_parser.apps.create import prepare_applications_create_argparser
+from oak_cli.args_parser.apps.delete import prepare_applications_deletion_argparser
+from oak_cli.args_parser.apps.status import prepare_applications_display_argparser
+from oak_cli.utils.types import Subparsers
+
+
+def prepare_applications_argparsers(subparsers: Subparsers) -> None:
+    applications_parser = subparsers.add_parser(
+        "applications",
+        aliases=["a"],
+        help="command for application(s) related activities",
+        formatter_class=argparse.RawTextHelpFormatter,
+    )
+
+    def applications_parser_print_help(_: Any) -> None:
+        applications_parser.print_help()
+
+    applications_parser.set_defaults(func=applications_parser_print_help)
+
+    applications_subparsers = applications_parser.add_subparsers(
+        dest="applications commands",
+    )
+
+    prepare_applications_create_argparser(applications_subparsers)
+    prepare_applications_display_argparser(applications_subparsers)
+    prepare_applications_deletion_argparser(applications_subparsers)

oak_cli-0.2.5/oak_cli/args_parser/apps/status.py

@@ -0,0 +1,18 @@
+import argparse
+
+from oak_cli.commands.apps.status import display_current_applications
+from oak_cli.utils.types import Subparsers
+
+
+def prepare_applications_display_argparser(applications_subparsers: Subparsers) -> None:
+    HELP_TEXT = "displays the currently available/active applications"
+    applications_status_parser = applications_subparsers.add_parser(
+        "status",
+        aliases=["s"],
+        help=HELP_TEXT,
+        description=HELP_TEXT,
+        formatter_class=argparse.RawTextHelpFormatter,
+    )
+    applications_status_parser.set_defaults(
+        func=lambda _: display_current_applications()
+    )

oak_cli-0.2.5/oak_cli/args_parser/main.py

@@ -0,0 +1,25 @@
+# PYTHON_ARGCOMPLETE_OK
+
+import argparse
+
+import argcomplete
+
+from oak_cli.args_parser.apps.main import prepare_applications_argparsers
+from oak_cli.args_parser.services.main import prepare_services_argparsers
+
+
+def parse_arguments_and_execute() -> None:
+    parser = argparse.ArgumentParser()
+
+    # 'dest' & 'required' are needed to ensure correct behavior if no arguments are passed.
+    subparsers = parser.add_subparsers(
+        dest="command",
+        required=True,
+    )
+
+    prepare_applications_argparsers(subparsers)
+    prepare_services_argparsers(subparsers)
+
+    argcomplete.autocomplete(parser)
+    args = parser.parse_args()
+    args.func(args)

oak_cli-0.2.5/oak_cli/args_parser/services/deployment.py

@@ -0,0 +1,53 @@
+import argparse
+from typing import Any
+
+from oak_cli.commands.services.deployment import (
+    deploy_new_instance,
+    undeploy_all_instances_of_service,
+    undeploy_instance,
+)
+from oak_cli.utils.types import Subparsers
+
+
+def prepare_services_deployment_argparser(services_subparsers: Subparsers) -> None:
+    HELP_TEXT = "deploys a service instance"
+    services_deployment_parser = services_subparsers.add_parser(
+        "deploy",
+        aliases=["d"],
+        help=HELP_TEXT,
+        description=HELP_TEXT,
+        formatter_class=argparse.RawTextHelpFormatter,
+    )
+    services_deployment_parser.add_argument("service_id", type=str)
+    services_deployment_parser.set_defaults(
+        func=lambda args: deploy_new_instance(args.service_id)
+    )
+
+
+def prepare_services_undeployment_argparser(services_subparsers: Subparsers) -> None:
+    def _aux_undeploy(args: Any) -> None:
+        if args.all:
+            undeploy_all_instances_of_service(args.service_id)
+        elif args.instancenumber:
+            undeploy_instance(args.service_id, args.instancenumber)
+        else:
+            undeploy_instance(args.service_id)
+
+    HELP_TEXT = "undeploys service instances"
+    services_undeployment_parser = services_subparsers.add_parser(
+        "undeploy",
+        aliases=["u"],
+        help=HELP_TEXT,
+        description=HELP_TEXT,
+        formatter_class=argparse.RawTextHelpFormatter,
+    )
+    services_undeployment_parser.add_argument("service_id", type=str)
+    services_undeployment_parser.add_argument(
+        "--instancenumber",
+        "-i",
+        type=str,
+    )
+    services_undeployment_parser.add_argument(
+        "-a", "--all", action="store_true", help="undeploy all instances of the service"
+    )
+    services_undeployment_parser.set_defaults(func=_aux_undeploy)

oak_cli-0.2.5/oak_cli/args_parser/services/main.py

@@ -0,0 +1,31 @@
+import argparse
+from typing import Any
+
+from oak_cli.args_parser.services.deployment import (
+    prepare_services_deployment_argparser,
+    prepare_services_undeployment_argparser,
+)
+from oak_cli.args_parser.services.status import prepare_services_display_argparser
+from oak_cli.utils.types import Subparsers
+
+
+def prepare_services_argparsers(subparsers: Subparsers) -> None:
+    services_parser = subparsers.add_parser(
+        "services",
+        aliases=["s"],
+        help="command for service(s) related activities",
+        formatter_class=argparse.RawTextHelpFormatter,
+    )
+
+    def services_parser_print_help(_: Any) -> None:
+        services_parser.print_help()
+
+    services_parser.set_defaults(func=services_parser_print_help)
+
+    services_subparsers = services_parser.add_subparsers(
+        dest="services commands",
+    )
+
+    prepare_services_display_argparser(services_subparsers)
+    prepare_services_deployment_argparser(services_subparsers)
+    prepare_services_undeployment_argparser(services_subparsers)

oak_cli-0.2.5/oak_cli/args_parser/services/status.py

@@ -0,0 +1,49 @@
+import argparse
+from typing import Any
+
+from oak_cli.commands.services.get import get_single_service
+from oak_cli.commands.services.status import (
+    display_all_current_services,
+    display_single_service,
+)
+from oak_cli.utils.types import Subparsers
+
+
+def _aux_display_current_services(args: Any) -> None:
+    if not args.serviceid:
+        display_all_current_services(verbose=args.verbose, app_id=args.appid)
+    elif args.serviceid:
+        service = get_single_service(args.serviceid)
+        display_single_service(service, verbose=args.verbose)
+
+
+def prepare_services_display_argparser(services_subparsers: Subparsers) -> None:
+    HELP_TEXT = "displays the currently available/active service(s)"
+    services_status_parser = services_subparsers.add_parser(
+        "status",
+        aliases=["s"],
+        help=HELP_TEXT,
+        description=HELP_TEXT,
+        formatter_class=argparse.RawTextHelpFormatter,
+    )
+    services_status_parser.add_argument(
+        "-a",
+        "--all",
+        help="displays all services",
+        action="store_true",
+    )
+    services_status_parser.add_argument(
+        "-v",
+        "--verbose",
+        action="store_true",
+    )
+    services_status_parser.add_argument(
+        "--appid",
+        type=str,
+    )
+    services_status_parser.add_argument(
+        "--serviceid",
+        "-i",
+        type=str,
+    )
+    services_status_parser.set_defaults(func=_aux_display_current_services)

oak_cli-0.2.5/oak_cli/commands/apps/main.py

@@ -0,0 +1,60 @@
+import enum
+import json
+from typing import List
+
+from oak_cli.utils.api.common import SYSTEM_MANAGER_URL, HttpMethod
+from oak_cli.utils.api.main import handle_request
+from oak_cli.utils.SLAs.common import get_SLAs_path
+from oak_cli.utils.types import Application, ApplicationId
+
+
+def get_application(app_id: ApplicationId) -> Application:
+    app = handle_request(
+        base_url=SYSTEM_MANAGER_URL,
+        http_method=HttpMethod.GET,
+        api_endpoint=f"/api/application/{app_id}",
+        what_should_happen=f"Get application '{app_id}'",
+    )
+    return app
+
+
+def get_applications() -> List[Application]:
+    apps = handle_request(
+        base_url=SYSTEM_MANAGER_URL,
+        http_method=HttpMethod.GET,
+        api_endpoint="/api/applications",
+        what_should_happen="Get all applications",
+    )
+    return apps
+
+
+def send_sla(sla_enum: enum) -> List[Application]:
+    sla_file_name = f"{sla_enum}.SLA.json"
+    SLA = ""
+    with open(get_SLAs_path() / sla_file_name, "r") as f:
+        SLA = json.load(f)
+
+    apps = handle_request(
+        base_url=SYSTEM_MANAGER_URL,
+        http_method=HttpMethod.POST,
+        data=SLA,
+        api_endpoint="/api/application",
+        what_should_happen=f"Create new application based on '{sla_enum}'",
+        show_msg_on_success=True,
+    )
+    return apps
+
+
+def delete_application(app_id: ApplicationId) -> None:
+    handle_request(
+        base_url=SYSTEM_MANAGER_URL,
+        http_method=HttpMethod.DELETE,
+        api_endpoint=f"/api/application/{app_id}",
+        what_should_happen=f"Delete application '{app_id}'",
+        show_msg_on_success=True,
+    )
+
+
+def delete_all_applications() -> None:
+    for app in get_applications():
+        delete_application(app["applicationID"])

oak_cli-0.2.5/oak_cli/commands/apps/status.py

@@ -0,0 +1,21 @@
+from oak_cli.commands.apps.main import get_applications
+from oak_cli.utils.logging import logger
+
+
+def display_current_applications() -> None:
+    current_applications = get_applications()
+
+    def log_aux(key: str, value: str) -> None:
+        logger.debug(f"   {key}: '{value}'")
+
+    logger.info(f"Current apps: '{len(current_applications)}'")
+    for i, application in enumerate(current_applications):
+        logger.info(f" App '{i}':")
+        log_aux("id", application["applicationID"])
+        log_aux("name", application["application_name"])
+        log_aux("ns", application["application_namespace"])
+        log_aux("desc", application["application_desc"])
+        log_aux(
+            "microservices",
+            f"{len(application['microservices'])}: {application['microservices']}",
+        )

oak_cli-0.2.5/oak_cli/commands/services/deployment.py

@@ -0,0 +1,30 @@
+from oak_cli.commands.services.get import get_single_service
+from oak_cli.utils.api.common import SYSTEM_MANAGER_URL, HttpMethod
+from oak_cli.utils.api.main import handle_request
+from oak_cli.utils.types import Id, ServiceId
+
+
+def deploy_new_instance(service_id: ServiceId) -> None:
+    handle_request(
+        base_url=SYSTEM_MANAGER_URL,
+        http_method=HttpMethod.POST,
+        api_endpoint=f"/api/service/{service_id}/instance",
+        what_should_happen=f"Deploy a new instance for the service '{service_id}'",
+        show_msg_on_success=True,
+    )
+
+
+def undeploy_instance(service_id: ServiceId, instance_id: Id = None) -> None:
+    handle_request(
+        base_url=SYSTEM_MANAGER_URL,
+        http_method=HttpMethod.DELETE,
+        api_endpoint=f"/api/service/{service_id}/instance/{instance_id or 0}",
+        what_should_happen=f"Undeploy instance '{instance_id or 0}' for the service '{service_id}'",
+        show_msg_on_success=True,
+    )
+
+
+def undeploy_all_instances_of_service(service_id: ServiceId) -> None:
+    service = get_single_service(service_id)
+    for instance in service["instance_list"]:
+        undeploy_instance(service_id, instance["instance_number"])

oak_cli-0.2.5/oak_cli/commands/services/get.py

@@ -0,0 +1,29 @@
+from typing import List
+
+from oak_cli.utils.api.common import SYSTEM_MANAGER_URL, HttpMethod
+from oak_cli.utils.api.main import handle_request
+from oak_cli.utils.types import Service, ServiceId
+
+
+def get_single_service(service_id: ServiceId) -> Service:
+    service = handle_request(
+        base_url=SYSTEM_MANAGER_URL,
+        http_method=HttpMethod.GET,
+        api_endpoint=f"/api/service/{service_id}",
+        what_should_happen=f"Get single service '{service_id}'",
+    )
+    return service
+
+
+def get_all_services(app_id: ServiceId = None) -> List[Service]:
+    what_should_happen = "Get all services"
+    if app_id:
+        what_should_happen += f" of app '{app_id}'"
+
+    services = handle_request(
+        base_url=SYSTEM_MANAGER_URL,
+        http_method=HttpMethod.GET,
+        api_endpoint=f"/api/services/{app_id or ''}",
+        what_should_happen=what_should_happen,
+    )
+    return services

oak_cli-0.2.5/oak_cli/commands/services/status.py

@@ -0,0 +1,75 @@
+from oak_cli.commands.services.get import get_all_services
+from oak_cli.utils.logging import logger
+from oak_cli.utils.types import ApplicationId, Service
+
+
+def _log_aux_service(key: str, value: str, service: Service) -> None:
+    value = service.get(value, None)
+    if value is not None:
+        _log_aux(key, value)
+
+
+def _log_aux(key: str, value: str) -> None:
+    logger.debug(f"   {key}: '{value}'")
+
+
+def verbose_log_aux(section_name: str) -> None:
+    logger.info(f"   - {section_name} -")
+
+
+def display_single_service(service: Service, verbose: bool = False) -> None:
+    verbose_log_aux("microservice")
+    _log_aux_service("id", "microserviceID", service)
+    _log_aux_service(
+        "microservice name" if verbose else "name", "microservice_name", service
+    )
+    _log_aux_service(
+        "microservice ns" if verbose else "ns", "microservice_namespace", service
+    )
+    _log_aux("parent app", f"{service['app_name']}: {service['applicationID']}")
+
+    if verbose:
+        verbose_log_aux("service")
+        _log_aux_service("service name", "service_name", service)
+
+    verbose_log_aux("resources")
+    _log_aux_service("memory", "memory", service)
+    _log_aux_service("vcpus", "vcpus", service)
+    if verbose:
+        _log_aux_service("storage", "storage", service)
+        _log_aux_service("vgpus", "vgpus", service)
+
+    verbose_log_aux("container")
+    _log_aux_service("image", "image", service)
+    if verbose:
+        _log_aux_service("code", "code", service)
+
+    verbose_log_aux("networking")
+    _log_aux_service("port", "port", service)
+    if verbose:
+        _log_aux_service("bandwidth in", "bandwidth_in", service)
+        _log_aux_service("bandwidth out", "bandwidth_out", service)
+
+    verbose_log_aux("instances")
+    instances = service["instance_list"]
+    num_instances = len(instances)
+    _log_aux("instances", num_instances)
+    if verbose and num_instances > 0:
+        for i, instance in enumerate(instances):
+            logger.info(f"   Instance '{i}':")
+            _log_aux("  instance_number", instance["instance_number"])
+            _log_aux("  status", instance["status"])
+            _log_aux("  publicip", instance["publicip"])
+            _log_aux("  cpu", instance["cpu"])
+
+
+def display_all_current_services(
+    verbose: bool = False,
+    app_id: ApplicationId = None,
+) -> None:
+    all_current_services = get_all_services(app_id)
+
+    logger.info(f"All current services: '{len(all_current_services)}'")
+    for i, service in enumerate(all_current_services):
+        logger.warning(f" Service '{i}':")
+        display_single_service(service, verbose)

oak_cli-0.2.5/oak_cli/main.py

@@ -0,0 +1,14 @@
+#!/usr/bin/env python3
+# PYTHON_ARGCOMPLETE_OK
+
+from oak_cli.args_parser.main import parse_arguments_and_execute
+from oak_cli.utils.argcomplete import handle_argcomplete
+
+
+def main():
+    handle_argcomplete()
+    parse_arguments_and_execute()
+
+
+if __name__ == "__main__":
+    main()

oak_cli-0.2.5/oak_cli/utils/SLAs/blank_app_without_services.SLA.json

@@ -0,0 +1,13 @@
+{
+    "sla_version": "v2.0",
+    "customerID": "Admin",
+    "applications": [
+        {
+            "applicationID": "",
+            "application_name": "blank",
+            "application_namespace": "blank",
+            "application_desc": "Blank app without any microservices",
+            "microservices": []
+        }
+    ]
+}

oak_cli-0.2.5/oak_cli/utils/SLAs/common.py

@@ -0,0 +1,13 @@
+import pathlib
+
+from oak_cli.utils.common import get_oak_cli_path
+from oak_cli.utils.types import CustomEnum
+
+
+def get_SLAs_path() -> pathlib.Path:
+    return get_oak_cli_path() / "utils" / "SLAs"
+
+
+class KnownSLA(CustomEnum):
+    DEFAULT = "default_app_with_services"
+    BLANK = "blank_app_without_services"

oak_cli-0.2.5/oak_cli/utils/SLAs/default_app_with_services.SLA.json

@@ -0,0 +1,57 @@
+{
+    "sla_version": "v2.0",
+    "customerID": "Admin",
+    "applications": [
+        {
+            "applicationID": "",
+            "application_name": "clientsrvr",
+            "application_namespace": "test",
+            "application_desc": "Simple demo with curl client and Nginx server",
+            "microservices": [
+                {
+                    "microserviceID": "",
+                    "microservice_name": "curl",
+                    "microservice_namespace": "test",
+                    "virtualization": "container",
+                    "cmd": [
+                        "sh",
+                        "-c",
+                        "tail -f /dev/null"
+                    ],
+                    "memory": 100,
+                    "vcpus": 1,
+                    "vgpus": 0,
+                    "vtpus": 0,
+                    "bandwidth_in": 0,
+                    "bandwidth_out": 0,
+                    "storage": 0,
+                    "code": "docker.io/curlimages/curl:7.82.0",
+                    "state": "",
+                    "port": "9080",
+                    "added_files": []
+                },
+                {
+                    "microserviceID": "",
+                    "microservice_name": "nginx",
+                    "microservice_namespace": "test",
+                    "virtualization": "container",
+                    "cmd": [],
+                    "memory": 100,
+                    "vcpus": 1,
+                    "vgpus": 0,
+                    "vtpus": 0,
+                    "bandwidth_in": 0,
+                    "bandwidth_out": 0,
+                    "storage": 0,
+                    "code": "docker.io/library/nginx:latest",
+                    "state": "",
+                    "port": "6080:60/tcp",
+                    "addresses": {
+                        "rr_ip": "10.30.30.30"
+                    },
+                    "added_files": []
+                }
+            ]
+        }
+    ]
+}

oak_cli-0.2.5/oak_cli/utils/api/common.py

@@ -0,0 +1,31 @@
+import os
+
+import requests
+
+from oak_cli.utils.types import CustomEnum
+
+GITHUB_PREFIX = "https://github.com/"
+SYSTEM_MANAGER_URL = f"http://{os.environ.get('SYSTEM_MANAGER_URL')}:10000"
+
+
+class HttpMethod(CustomEnum):
+    GET = "get"
+    POST = "post"
+    PUT = "put"
+    PATCH = "patch"
+    DELETE = "delete"
+
+    def call(cls, **kwargs) -> requests.Response:
+        method_map = {
+            cls.GET: requests.get,
+            cls.POST: requests.post,
+            cls.PUT: requests.put,
+            cls.PATCH: requests.patch,
+            cls.DELETE: requests.delete,
+        }
+        method = method_map.get(cls)
+
+        if method:
+            return method(**kwargs)
+        else:
+            raise ValueError(f"Unsupported HTTP method: {cls.value}")

oak_cli-0.2.5/oak_cli/utils/api/login.py

@@ -0,0 +1,33 @@
+from http import HTTPStatus
+
+import oak_cli.utils.api as oak_api
+
+_login_token = ""
+
+
+class LoginFailed(Exception):
+    pass
+
+
+def _login_and_set_token() -> str:
+    data = {"username": "Admin", "password": "Admin"}
+    headers = {"accept": "application/json", "Content-Type": "application/json"}
+
+    json_data = oak_api.main.handle_request(
+        base_url=oak_api.common.SYSTEM_MANAGER_URL,
+        http_method=oak_api.common.HttpMethod.POST,
+        api_endpoint="/api/auth/login",
+        headers=headers,
+        data=data,
+        what_should_happen="Login",
+    )
+
+    global _login_token
+    _login_token = json_data["token"]
+    return _login_token
+
+
+def get_login_token() -> str:
+    if _login_token == "":
+        return _login_and_set_token()
+    return _login_token

oak_cli-0.2.5/oak_cli/utils/api/main.py

@@ -0,0 +1,108 @@
+import json
+import sys
+from http import HTTPStatus
+from typing import NamedTuple, Optional, Tuple, Union
+
+import requests
+
+from oak_cli.utils.api.common import HttpMethod
+from oak_cli.utils.api.login import get_login_token
+from oak_cli.utils.logging import logger
+
+
+class ApiQueryComponents(NamedTuple):
+    url: str
+    headers: dict
+    data: dict = None
+
+
+def _prepare_api_query_components(
+    base_url: str,
+    api_endpoint: str = None,
+    custom_headers: dict = None,
+    data: dict = None,
+    query_params: str = None,
+) -> ApiQueryComponents:
+    url = base_url
+    if api_endpoint is not None:
+        url = f"{base_url}{api_endpoint}"
+    if query_params is not None:
+        url += f"?{query_params}"
+    headers = custom_headers or {"Authorization": f"Bearer {get_login_token()}"}
+    if data and not custom_headers:
+        headers["Content-Type"] = "application/json"
+    return ApiQueryComponents(url, headers, data)
+
+
+def _create_failure_msg(
+    what_should_happen: str,
+    http_method: HttpMethod,
+    url: str,
+    response_status: HTTPStatus = None,
+) -> str:
+    return (
+        " ".join(
+            (
+                what_should_happen,
+                "request failed with",
+                str(response_status),
+                f"for '{http_method}' '{url}",
+            )
+        ),
+    )
+
+
+def handle_request(
+    base_url: str,
+    what_should_happen: str,
+    http_method: HttpMethod = HttpMethod.GET,
+    api_endpoint: str = None,
+    headers: dict = None,
+    data: dict = None,
+    show_msg_on_success: bool = False,
+    special_msg_on_fail: str = None,
+    query_params: str = None,
+    terminate_when_failed: bool = True,
+) -> Union[HTTPStatus, Tuple[HTTPStatus, Optional[dict]]]:
+
+    url, headers, data = _prepare_api_query_components(
+        base_url, api_endpoint, headers, data, query_params
+    )
+    args = {
+        "url": url,
+        "verify": False,
+        **({"headers": headers} if headers else {}),
+        **({"json": data} if data else {}),
+    }
+
+    try:
+        response = http_method.call(**args)
+        response_status = HTTPStatus(response.status_code)
+
+        if response_status == HTTPStatus.OK:
+            if show_msg_on_success:
+                logger.info(f"Success: {what_should_happen}")
+            response = response.json()
+            if isinstance(response, str):
+                response = json.loads(response)
+            if terminate_when_failed:
+                return response
+            return response_status, response
+        else:
+            logger.error(f"FAILED: {special_msg_on_fail or what_should_happen}!")
+            logger.error(
+                _create_failure_msg(
+                    what_should_happen, http_method, url, response_status
+                )
+            )
+            logger.error(f"response: '{response}'")
+            if terminate_when_failed:
+                sys.exit(1)
+            return response_status, None
+
+    except requests.exceptions.RequestException as e:
+        logger.error(_create_failure_msg(what_should_happen, http_method, url))
+        logger.error(e)
+        if terminate_when_failed:
+            sys.exit(1)
+        return HTTPStatus.INTERNAL_SERVER_ERROR, None

oak_cli-0.2.5/oak_cli/utils/argcomplete.py

@@ -0,0 +1,16 @@
+import shlex
+import subprocess
+
+
+def handle_argcomplete() -> None:
+    # Note: Ideally this would only occur once in a dedicated postinstall script
+    # (similar to debian packages).
+    # However, python packages do not seem to allow postinstall scripts.
+    # The argcomplete command also is not too customizable to check if it is already installed,
+    # because it might behave differently depending on the OS.
+    with open("/dev/null", "w") as devnull:
+        subprocess.run(
+            shlex.split("activate-global-python-argcomplete -y --user"),
+            stdout=devnull,
+            stderr=devnull,
+        )

oak_cli-0.2.5/oak_cli/utils/common.py

@@ -0,0 +1,6 @@
+import pathlib
+
+
+def get_oak_cli_path() -> pathlib.Path:
+    current_file = pathlib.Path(__file__).resolve()
+    return current_file.parent.parent

oak_cli-0.2.5/oak_cli/utils/logging.py

@@ -0,0 +1,47 @@
+# Reference:
+# https://alexandra-zaharia.github.io/posts/make-your-own-custom-color-formatter-with-python-logging/
+
+import logging
+
+
+class CustomFormatter(logging.Formatter):
+    """Logging colored formatter, adapted from https://stackoverflow.com/a/56944256/3638629"""
+
+    grey = "\x1b[38;21m"
+    yellow = "\x1b[38;5;226m"
+    red = "\x1b[38;5;196m"
+    bold_red = "\x1b[31;1m"
+    blue = "\x1b[38;5;33m"
+    light_blue = "\x1b[38;5;45m"
+    reset = "\x1b[0m"
+
+    def __init__(self, fmt):
+        super().__init__()
+        self.fmt = fmt
+        self.FORMATS = {
+            logging.DEBUG: self.grey + self.fmt + self.reset,
+            logging.INFO: self.light_blue + self.fmt + self.reset,
+            logging.WARNING: self.yellow + self.fmt + self.reset,
+            logging.ERROR: self.red + self.fmt + self.reset,
+            logging.CRITICAL: self.bold_red + self.fmt + self.reset,
+        }
+
+    def format(self, record):
+        log_fmt = self.FORMATS.get(record.levelno)
+        formatter = logging.Formatter(log_fmt)
+        return formatter.format(record)
+
+
+_LOGGER_NAME = "logger"
+
+_FORMAT = "%(message)s"
+
+logger = logging.getLogger(_LOGGER_NAME)
+logger.setLevel(logging.DEBUG)
+
+_formatter = CustomFormatter(_FORMAT)
+
+_stream_handler = logging.StreamHandler()
+_stream_handler.setFormatter(_formatter)
+
+logger.addHandler(_stream_handler)

oak_cli-0.2.5/oak_cli/utils/types.py

@@ -0,0 +1,22 @@
+import argparse
+import enum
+
+
+class CustomEnum(enum.Enum):
+    def __str__(self) -> str:
+        return self.value
+
+
+Id = str
+ServiceId = Id
+ApplicationId = Id
+
+Service = dict
+Application = dict
+
+SLA = dict
+DbObject = dict
+
+
+# Custom type for nicer type hints
+Subparsers = argparse._SubParsersAction

oak_cli-0.2.5/pyproject.toml

@@ -0,0 +1,17 @@
+[tool.poetry]
+name = "oak_cli"
+version = "0.2.5"
+description = ""
+authors = ["Alexander Malyuk <malyuk.alexander1999@gmail.com>"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.10"
+argcomplete = "^3.2.3"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry.scripts]
+oak = "oak_cli.main:main"