dockge-cli/dockge_cli/client/commandprovider/bindings.py

from urllib.parse import urlparse
from getpass import getpass

from ...models import Credentials
from ...service import storage
from ...service.communicate import DockgeConnection
from ..utils import stack_formatter, status_formatter, generic_formatter, get_credential_parser

class ExecutionCommands():
    """
    Helper class that provides all the static methods in an organized way
    This is an abstraction layer of the CLI, as those functions only do little preprocessing before calling the actural DockgeConnection
    """
    @staticmethod
    def __setup():
        con = DockgeConnection()
        con.connect_and_login()
        return con

    @staticmethod
    def host(extra_args):
        """
        host command binding
        """
        if len(extra_args) > 0:
            res = urlparse(extra_args[0])
            if all([res.scheme, res.netloc]):
                host = extra_args[0].rstrip("/").replace("https://", "").replace("wss://", "")
                storage.put("host", host)
            else:
                raise ValueError(f"Malformed URL {extra_args[0]}")
        print(storage.get("host"))

    @staticmethod
    def login(extra_args):
        """
        login command binding
        """
        if len(extra_args) > 0:
            credentials = get_credential_parser().parse_args(extra_args, namespace=Credentials)
            storage.put("username", credentials.username, encoded=True)
            storage.put("password", credentials.password, encoded=True)
            return
        storage.put("username", input("Username: "), encoded=True)
        storage.put("password", getpass("Password: "), encoded=True)

    @staticmethod
    def logout(_):
        """
        logout command binding
        """
        storage.remove("username")
        storage.remove("password")

    @staticmethod
    def exit(_):
        """
        exit command binding
        """
        storage.clear()

    @staticmethod
    def list(_):
        """
        list command binding
        """
        con = ExecutionCommands.__setup()
        stack_formatter(con.list_stacks())
        con.disconnect()

    @staticmethod
    def status(extra_args):
        """
        status command binding
        """
        if extra_args is None:
            raise ValueError
        con = ExecutionCommands.__setup()
        status_formatter(con.list_stack(extra_args[0]))
        con.disconnect()

    @staticmethod
    def restart(extra_args):
        """
        restart command binding
        """
        if extra_args is None:
            raise ValueError
        con = ExecutionCommands.__setup()
        generic_formatter(con.restart(extra_args[0]))
        con.disconnect()

    @staticmethod
    def update(extra_args):
        """
        update command binding
        """
        if extra_args is None:
            raise ValueError
        con = ExecutionCommands.__setup()
        generic_formatter(con.update(extra_args[0]))
        con.disconnect()

    @staticmethod
    def stop(extra_args):
        """
        stop command binding
        """
        if extra_args is None:
            raise ValueError
        con = ExecutionCommands.__setup()
        generic_formatter(con.stop(extra_args[0]))
        con.disconnect()

    @staticmethod
    def start(extra_args):
        """
        start command binding
        """
        if extra_args is None:
            raise ValueError
        con = ExecutionCommands.__setup()
        generic_formatter(con.start(extra_args[0]))
        con.disconnect()

    @staticmethod
    def down(extra_args):
        """
        down command binding
        """
        if extra_args is None:
            raise ValueError
        con = ExecutionCommands.__setup()
        generic_formatter(con.down(extra_args[0]))
        con.disconnect()

    @staticmethod
    def help():
        """
        exit command binding - This should never be invoked
        """
        print("WTF")