domino-cli 2.0.0__py3-none-any.whl

domino_cli/__init__.py

@@ -0,0 +1,20 @@
+"""
+domino_cli.py :: Main entry point for Domino CLI application.
+"""
+
+__version__ = "2.0.0"
+
+import os
+
+from domino_cli.core.ApplicationContext import ApplicationContext
+
+
+def _set_work_dir() -> None:
+    script_path: str = os.path.realpath(__file__)
+    script_dir: str = os.path.dirname(script_path)
+    os.chdir(script_dir)
+
+
+def main() -> None:
+    _set_work_dir()
+    ApplicationContext.init_cli(__version__).run_loop()

domino_cli/__main__.py

@@ -0,0 +1,4 @@
+from domino_cli import main
+
+if __name__ == "__main__":
+    main()

domino_cli/core/ApplicationContext.py

@@ -0,0 +1,144 @@
+import os
+
+from domino_cli.core.cli.CLI import CLI
+from domino_cli.core.client.DominoClient import DominoClient
+from domino_cli.core.client.OAuthAuthorizationClient import OAuthAuthorizationClient
+from domino_cli.core.command.AuthCommand import AuthCommand
+from domino_cli.core.command.DeployApplicationCommand import DeployApplicationCommand
+from domino_cli.core.command.ExitCommand import ExitCommand
+from domino_cli.core.command.HelpCommand import HelpCommand
+from domino_cli.core.command.InfoCommand import InfoCommand
+from domino_cli.core.command.RestartApplicationCommand import RestartApplicationCommand
+from domino_cli.core.command.StartApplicationCommand import StartApplicationCommand
+from domino_cli.core.command.StopApplicationCommand import StopApplicationCommand
+from domino_cli.core.command.WizardCommand import WizardCommand
+from domino_cli.core.domain.AuthMode import AuthMode
+from domino_cli.core.domain.OAuthConfig import OAuthConfig
+from domino_cli.core.service.AuthenticationService import AuthenticationService
+from domino_cli.core.service.CommandProcessor import CommandProcessor
+from domino_cli.core.service.ConfigurationWizardService import ConfigurationWizardService
+from domino_cli.core.service.DominoService import DominoService
+from domino_cli.core.service.SessionContextHolder import SessionContextHolder
+from domino_cli.core.service.auth.DirectAuthHandler import DirectAuthHandler
+from domino_cli.core.service.auth.OAuthAuthHandler import OAuthAuthHandler
+from domino_cli.core.service.wizard.BinaryExecutableAgentConfigWizard import BinaryExecutableAgentConfigWizard
+from domino_cli.core.service.wizard.CoordinatorConfigWizard import CoordinatorConfigWizard
+from domino_cli.core.service.wizard.DeploymentConfigWizard import DeploymentConfigWizard
+from domino_cli.core.service.wizard.DockerAgentConfigWizard import DockerAgentConfigWizard
+from domino_cli.core.service.wizard.InstallerWizard import InstallerWizard
+from domino_cli.core.service.wizard.installer.BinaryExecutablePlatformComponentInstaller import \
+    BinaryExecutablePlatformComponentInstaller
+from domino_cli.core.service.wizard.installer.DockerPlatformComponentInstaller import DockerPlatformComponentInstaller
+from domino_cli.core.service.wizard.installer.DockerVersionResolver import DockerVersionResolver
+from domino_cli.core.service.wizard.installer.GitHubReleaseVersionResolver import GitHubReleaseVersionResolver
+from domino_cli.core.service.wizard.render.WizardResultConsoleRenderer import WizardResultConsoleRenderer
+from domino_cli.core.service.wizard.render.WizardResultFileRenderer import WizardResultFileRenderer
+from domino_cli.core.service.wizard.transformer.BinaryExecutableAgentConfigWizardResultTransformer import \
+    BinaryExecutableAgentConfigWizardResultTransformer
+from domino_cli.core.service.wizard.transformer.CoordinatorConfigWizardResultTransformer import \
+    CoordinatorConfigWizardResultTransformer
+from domino_cli.core.service.wizard.transformer.DeploymentConfigWizardResultTransformer import \
+    DeploymentConfigWizardResultTransformer
+from domino_cli.core.service.wizard.transformer.DockerAgentConfigWizardResultTransformer import \
+    DockerAgentConfigWizardResultTransformer
+
+
+class ApplicationContext:
+    """
+    Simple IoC container for Domino CLI.
+    """
+    @staticmethod
+    def init_cli(version: str) -> CLI:
+
+        print("Initializing Domino CLI...")
+
+        # configuration properties
+        _domino_base_url = ApplicationContext._assert_config_value("DOMINO_BASE_URL")
+        _default_auth_mode = AuthMode.by_value(os.getenv("DOMINO_DEFAULT_AUTH_MODE", AuthMode.DIRECT.value))
+        _oauth_config = OAuthConfig()
+
+        # wizards
+        _wizard_result_console_renderer = WizardResultConsoleRenderer()
+        _wizard_result_file_renderer = WizardResultFileRenderer()
+        _deployment_config_wizard_result_transformer = DeploymentConfigWizardResultTransformer()
+        _coordinator_config_wizard_result_transformer = CoordinatorConfigWizardResultTransformer()
+        _docker_agent_config_wizard_result_transformer = DockerAgentConfigWizardResultTransformer()
+        _bin_exec_agent_config_wizard_result_transformer = BinaryExecutableAgentConfigWizardResultTransformer()
+        _deployment_config_wizard = DeploymentConfigWizard(_deployment_config_wizard_result_transformer,
+                                                           _wizard_result_console_renderer,
+                                                           _wizard_result_file_renderer)
+        _coordinator_config_wizard = CoordinatorConfigWizard(_coordinator_config_wizard_result_transformer,
+                                                             _wizard_result_console_renderer,
+                                                             _wizard_result_file_renderer)
+        _docker_agent_config_wizard = DockerAgentConfigWizard(_docker_agent_config_wizard_result_transformer,
+                                                              _wizard_result_console_renderer,
+                                                              _wizard_result_file_renderer)
+        _bin_exec_agent_config_wizard = BinaryExecutableAgentConfigWizard(_bin_exec_agent_config_wizard_result_transformer,
+                                                                          _wizard_result_console_renderer,
+                                                                          _wizard_result_file_renderer)
+
+        # installer
+        _docker_version_resolver = DockerVersionResolver()
+        _github_release_version_resolver = GitHubReleaseVersionResolver()
+        _docker_platform_component_installer = DockerPlatformComponentInstaller(_docker_version_resolver)
+        _bin_exec_platform_component_installer = BinaryExecutablePlatformComponentInstaller(_github_release_version_resolver)
+        _installer_wizard = InstallerWizard(_docker_platform_component_installer, _bin_exec_platform_component_installer)
+
+        # common components
+        _session_context_holder = SessionContextHolder()
+        _domino_client = DominoClient(_domino_base_url, _session_context_holder)
+        _oauth_authorization_client = OAuthAuthorizationClient(_oauth_config)
+        _domino_service = DominoService(_domino_client)
+        _direct_auth_handler = DirectAuthHandler(_domino_client)
+        _oauth_auth_handler = OAuthAuthHandler(_oauth_config, _oauth_authorization_client)
+        _auth_service = AuthenticationService(_default_auth_mode, _session_context_holder, [
+            _direct_auth_handler,
+            _oauth_auth_handler
+        ])
+        _config_wizard_service = ConfigurationWizardService([
+            _deployment_config_wizard,
+            _coordinator_config_wizard,
+            _docker_agent_config_wizard,
+            _bin_exec_agent_config_wizard,
+            _installer_wizard
+        ])
+
+        # commands
+        _command_exit = ExitCommand()
+        _command_help = HelpCommand()
+        _command_start_app = StartApplicationCommand(_domino_service)
+        _command_stop_app = StopApplicationCommand(_domino_service)
+        _command_restart_app = RestartApplicationCommand(_domino_service)
+        _command_deploy_app = DeployApplicationCommand(_domino_service)
+        _command_auth = AuthCommand(_auth_service)
+        _command_wizard = WizardCommand(_config_wizard_service)
+        _command_info = InfoCommand(_domino_service)
+
+        # command processor
+        _command_processor = CommandProcessor(_command_help, [
+            _command_help,
+            _command_exit,
+            _command_auth,
+            _command_deploy_app,
+            _command_restart_app,
+            _command_start_app,
+            _command_stop_app,
+            _command_wizard,
+            _command_info
+        ])
+
+        _cli = CLI(_command_processor)
+
+        print(f"Domino CLI v{version} initialized.")
+        print("-" * 30)
+
+        return _cli
+
+    @staticmethod
+    def _assert_config_value(config_parameter: str) -> str:
+
+        config_value = os.getenv(config_parameter)
+        if config_value is None:
+            raise Exception("Configuration parameter {0} is not specified".format(config_parameter))
+
+        return config_value

domino_cli/core/cli/CLI.py

@@ -0,0 +1,23 @@
+from domino_cli.core.domain.CommandDescriptor import CommandDescriptor
+from domino_cli.core.service.CommandProcessor import CommandProcessor
+
+_PROMPT = "\nDomino CLI > "
+
+
+class CLI:
+    """
+    Command line interface (CLI) executor.
+    """
+    def __init__(self, command_processor: CommandProcessor):
+        self._command_processor = command_processor
+
+    def run_loop(self) -> None:
+        """
+        Runs CLI command execution loop until an exit command terminates it.
+        """
+        while True:
+            command = CommandDescriptor(input(_PROMPT))
+            continue_loop = self._command_processor.execute_command(command)
+
+            if not continue_loop:
+                break

domino_cli/core/client/DominoClient.py

@@ -0,0 +1,31 @@
+import urllib.parse
+
+import requests
+from requests import Response
+
+from domino_cli.core.domain.DominoRequest import DominoRequest
+from domino_cli.core.service.SessionContextHolder import SessionContextHolder
+
+
+class DominoClient:
+    """
+    HTTP client implementation for sending REST request to Domino.
+    """
+    def __init__(self, domino_base_url: str, session_context_holder: SessionContextHolder):
+        self._domino_base_url = domino_base_url
+        self._session_context_holder = session_context_holder
+
+        print("Domino CLI is configured to communicate with Domino on {0}".format(domino_base_url))
+
+    def send_command(self, domino_request: DominoRequest) -> Response:
+        """
+        Prepares and sends a REST request to Domino based on the given DominoRequest object.
+
+        :param domino_request: DominoRequest object specifying request parameters
+        :return: Response object
+        """
+        resolved_path = urllib.parse.urljoin(self._domino_base_url, domino_request.path)
+        json_body = domino_request.body
+        auth = self._session_context_holder.get_bearer_auth() if domino_request.authenticated else None
+
+        return requests.request(domino_request.method.value, resolved_path, json=json_body, headers=auth)

domino_cli/core/client/OAuthAuthorizationClient.py

@@ -0,0 +1,54 @@
+import base64
+
+import requests
+from requests import Response
+
+from domino_cli.core.domain.HTTPMethod import HTTPMethod
+from domino_cli.core.domain.OAuthConfig import OAuthConfig
+
+_ENCODING = "UTF-8"
+
+
+class OAuthAuthorizationClient:
+    """
+    HTTP client implementation for sending requests to the configured OAuth Authorization Server.
+    """
+    def __init__(self, oauth_config: OAuthConfig):
+        self._oauth_config = oauth_config
+
+    def request_authorization(self) -> Response:
+        """
+        Requests an access token from the configured OAuth Authorization Server.
+        Request is sent as Client Credentials Grant Flow token request, including the client ID and the scope,
+        as well as the basic authorization header.
+
+        :return: the response object
+        """
+        return requests.request(str(HTTPMethod.POST.value),
+                                self._prepare_token_url(),
+                                data=self._prepare_token_request_form(),
+                                headers=self._prepare_token_request_headers())
+
+    def _prepare_token_url(self) -> str:
+
+        return self._oauth_config.token_url \
+            if self._oauth_config.audience is None \
+            else f"{self._oauth_config.token_url}?audience={self._oauth_config.audience}"
+
+    def _prepare_token_request_form(self) -> dict[str, str]:
+
+        return {
+            "grant_type": "client_credentials",
+            "client_id": self._oauth_config.client_id,
+            "scope": self._oauth_config.scope
+        }
+
+    def _prepare_token_request_headers(self) -> dict[str, str]:
+
+        credentials: str = f"{self._oauth_config.client_id}:{self._oauth_config.client_secret}"
+        base64_encoded_credentials: str = base64.b64encode(bytes(credentials, _ENCODING)).decode(_ENCODING)
+        auth_header_value: str = f"Basic {base64_encoded_credentials}"
+
+        return {
+            "Authorization": auth_header_value
+        }

domino_cli/core/command/AbstractCommand.py

@@ -0,0 +1,31 @@
+from abc import abstractmethod
+from abc import ABCMeta
+
+from domino_cli.core.domain.CommandDescriptor import CommandDescriptor
+
+
+class AbstractCommand(object, metaclass=ABCMeta):
+    """
+    Command interface.
+    Implementations should contain the associated logic for each supported command.
+    """
+    def __init__(self, command_name: str):
+        self._command_name = command_name
+
+    def is_applicable(self, command_descriptor: CommandDescriptor) -> bool:
+        """
+        Checks if the currently selected command implementation supports the requested command.
+
+        :param command_descriptor: CommandDescriptor object containing the requested command with its arguments
+        :return: boolean, true if the implementation is applicable, false otherwise
+        """
+        return command_descriptor.command == self._command_name
+
+    @abstractmethod
+    def execute_command(self, command_descriptor: CommandDescriptor) -> None:
+        """
+        Executes implemented command logic.
+
+        :param command_descriptor: CommandDescriptor object containing the requested command with its arguments
+        """
+        pass

domino_cli/core/command/AbstractLifecycleCommand.py

@@ -0,0 +1,26 @@
+from domino_cli.core.command.AbstractCommand import AbstractCommand
+from domino_cli.core.domain.CommandDescriptor import CommandDescriptor
+from domino_cli.core.domain.DominoCommand import DominoCommand
+from domino_cli.core.service.DominoService import DominoService
+
+
+class AbstractLifecycleCommand(AbstractCommand):
+    """
+    Abstract base class for simple lifecycle commands (with only the name of the application as parameter).
+    """
+    def __init__(self, command_name: str, domino_service: DominoService, domino_command: DominoCommand):
+        super().__init__(command_name)
+        self._domino_service = domino_service
+        self._domino_command = domino_command
+
+    def execute_command(self, command_descriptor: CommandDescriptor) -> None:
+        """
+        Executes a simple lifecycle command (currently supported commands are start, stop, restart).
+        Argument array should only contain the name of the application.
+
+        :param command_descriptor: CommandDescriptor object containing the command arguments
+        """
+        if not len(command_descriptor.arguments) == 1:
+            print("Application name required")
+        else:
+            self._domino_service.execute_lifecycle_command(self._domino_command, command_descriptor.arguments[0])

domino_cli/core/command/AuthCommand.py

@@ -0,0 +1,46 @@
+from domino_cli.core.command.AbstractCommand import AbstractCommand
+from domino_cli.core.domain.CommandDescriptor import CommandDescriptor
+from domino_cli.core.service.AuthenticationService import AuthenticationService
+
+_COMMAND_NAME = "auth"
+
+
+class AuthCommand(AbstractCommand):
+    """
+    Command implementation for authentication related operations.
+    """
+    def __init__(self, authentication_service: AuthenticationService):
+        super().__init__(_COMMAND_NAME)
+        self._authentication_service = authentication_service
+
+    def execute_command(self, command_descriptor: CommandDescriptor) -> None:
+        """
+        Routes authentication command processing to the proper handler.
+
+        :param command_descriptor: CommandDescriptor object containing the command arguments
+        """
+        if not 0 < len(command_descriptor.arguments) < 3:
+            AuthCommand._show_help()
+        else:
+            additional_parameter: str = command_descriptor.arguments[1] \
+                if len(command_descriptor.arguments) == 2 \
+                else None
+            self._route_auth_request(command_descriptor.arguments[0], additional_parameter)
+
+    def _route_auth_request(self, operation_flag: str, additional_parameter: str):
+
+        if operation_flag == "--encrypt-password":
+            self._authentication_service.encrypt_password()
+        elif operation_flag == "--generate-token":
+            self._authentication_service.generate_token()
+        elif operation_flag == "--open-session":
+            self._authentication_service.open_session()
+        elif operation_flag == "--set-mode":
+            self._authentication_service.set_mode(additional_parameter)
+        else:
+            AuthCommand._show_help()
+
+    @staticmethod
+    def _show_help():
+        print("Auth command requires operation flag of: --encrypt-password | --generate-token | --open-session "
+              "| --set-mode direct|oauth")

domino_cli/core/command/DeployApplicationCommand.py

@@ -0,0 +1,36 @@
+from domino_cli.core.command.AbstractCommand import AbstractCommand
+from domino_cli.core.domain.CommandDescriptor import CommandDescriptor
+from domino_cli.core.domain.DominoCommand import DominoCommand
+from domino_cli.core.service.DominoService import DominoService
+
+_LATEST_KEYWORD = "latest"
+_COMMAND_NAME = "deploy"
+
+
+class DeployApplicationCommand(AbstractCommand):
+    """
+    Lifecycle command implementation being able to send a deploy command for the given application.
+    """
+    def __init__(self, domino_service: DominoService):
+        super().__init__(_COMMAND_NAME)
+        self._domino_service = domino_service
+
+    def execute_command(self, command_descriptor: CommandDescriptor) -> None:
+        """
+        Sends a deployment command for the given application.
+        Argument array must contain two parameters:
+         - application name
+         - "latest" keyword or an explicit version of the application to be deployed
+
+        :param command_descriptor: CommandDescriptor object containing the command arguments
+        """
+        if not len(command_descriptor.arguments) == 2:
+            print("Application name and 'latest' keyword or explicit version is required")
+        else:
+            application: str = command_descriptor.arguments[0]
+            version: str = command_descriptor.arguments[1]
+            command: DominoCommand = DominoCommand.DEPLOY_LATEST \
+                if version == _LATEST_KEYWORD \
+                else DominoCommand.DEPLOY_VERSION
+
+            self._domino_service.execute_lifecycle_command(command, application, version)

domino_cli/core/command/ExitCommand.py

@@ -0,0 +1,16 @@
+from domino_cli.core.domain.CommandDescriptor import CommandDescriptor
+from domino_cli.core.command.AbstractCommand import AbstractCommand
+
+_COMMAND_NAME = "exit"
+
+
+class ExitCommand(AbstractCommand):
+    """
+    Exit command implementation.
+    Interrupts CLI execution loop.
+    """
+    def __init__(self):
+        super().__init__(_COMMAND_NAME)
+
+    def execute_command(self, command_descriptor: CommandDescriptor) -> None:
+        print("Bye!")

domino_cli/core/command/HelpCommand.py

@@ -0,0 +1,18 @@
+from domino_cli.core.domain.CommandDescriptor import CommandDescriptor
+from domino_cli.core.command.AbstractCommand import AbstractCommand
+
+_COMMAND_NAME = "help"
+_HELP_FILE = "./domino_cli/resource/help.txt"
+
+
+class HelpCommand(AbstractCommand):
+    """
+    Prints help contents, containing information about the supported commands.
+    """
+    def __init__(self):
+        super().__init__(_COMMAND_NAME)
+        with open(_HELP_FILE, "r") as help_contents:
+            self._help_text = help_contents.readlines()
+
+    def execute_command(self, command_descriptor: CommandDescriptor) -> None:
+        [print(line, end="") for line in self._help_text]

domino_cli/core/command/InfoCommand.py

@@ -0,0 +1,14 @@
+from domino_cli.core.command.AbstractLifecycleCommand import AbstractLifecycleCommand
+from domino_cli.core.domain.DominoCommand import DominoCommand
+from domino_cli.core.service.DominoService import DominoService
+
+_COMMAND_NAME = "info"
+
+
+class InfoCommand(AbstractLifecycleCommand):
+    """
+    Lifecycle command implementation being able to send an info request command for the given application.
+    """
+    def __init__(self, domino_service: DominoService):
+        super().__init__(_COMMAND_NAME, domino_service, DominoCommand.INFO)
+        self._domino_service = domino_service

domino_cli/core/command/RestartApplicationCommand.py

@@ -0,0 +1,14 @@
+from domino_cli.core.command.AbstractLifecycleCommand import AbstractLifecycleCommand
+from domino_cli.core.domain.DominoCommand import DominoCommand
+from domino_cli.core.service.DominoService import DominoService
+
+_COMMAND_NAME = "restart"
+
+
+class RestartApplicationCommand(AbstractLifecycleCommand):
+    """
+    Lifecycle command implementation being able to send a restart command for the given application.
+    """
+    def __init__(self, domino_service: DominoService):
+        super().__init__(_COMMAND_NAME, domino_service, DominoCommand.RESTART)
+        self._domino_service = domino_service

domino_cli/core/command/StartApplicationCommand.py

@@ -0,0 +1,14 @@
+from domino_cli.core.command.AbstractLifecycleCommand import AbstractLifecycleCommand
+from domino_cli.core.domain.DominoCommand import DominoCommand
+from domino_cli.core.service.DominoService import DominoService
+
+_COMMAND_NAME = "start"
+
+
+class StartApplicationCommand(AbstractLifecycleCommand):
+    """
+    Lifecycle command implementation being able to send a start command for the given application.
+    """
+    def __init__(self, domino_service: DominoService):
+        super().__init__(_COMMAND_NAME, domino_service, DominoCommand.START)
+        self._domino_service = domino_service

domino_cli/core/command/StopApplicationCommand.py

@@ -0,0 +1,14 @@
+from domino_cli.core.command.AbstractLifecycleCommand import AbstractLifecycleCommand
+from domino_cli.core.domain.DominoCommand import DominoCommand
+from domino_cli.core.service.DominoService import DominoService
+
+_COMMAND_NAME = "stop"
+
+
+class StopApplicationCommand(AbstractLifecycleCommand):
+    """
+    Lifecycle command implementation being able to send a stop command for the given application.
+    """
+    def __init__(self, domino_service: DominoService):
+        super().__init__(_COMMAND_NAME, domino_service, DominoCommand.STOP)
+        self._domino_service = domino_service

domino_cli/core/command/WizardCommand.py

@@ -0,0 +1,27 @@
+from domino_cli.core.command.AbstractCommand import AbstractCommand
+from domino_cli.core.domain.CommandDescriptor import CommandDescriptor
+from domino_cli.core.service.ConfigurationWizardService import ConfigurationWizardService
+
+_COMMAND_NAME = "wizard"
+
+
+class WizardCommand(AbstractCommand):
+    """
+    Command implementation for wizard related operations.
+    """
+    def __init__(self, configuration_wizard_service: ConfigurationWizardService):
+        super().__init__(_COMMAND_NAME)
+        self._configuration_wizard_service: ConfigurationWizardService = configuration_wizard_service
+
+    def execute_command(self, command_descriptor: CommandDescriptor) -> None:
+        """
+        Instructs ConfigurationWizardService to start execution of the specified wizard.
+        Shows available wizards in case of missing wizard name parameter.
+
+        :param command_descriptor: CommandDescriptor object containing the command arguments
+        """
+        if not len(command_descriptor.arguments) == 1:
+            print("Wizard name required")
+            self._configuration_wizard_service.show_available_wizards()
+        else:
+            self._configuration_wizard_service.run_wizard(command_descriptor.arguments[0])

domino_cli/core/domain/AuthMode.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from enum import Enum
+
+
+class AuthMode(Enum):
+    """
+    Supported modes for authenticating with Domino.
+    """
+    DIRECT = "direct"
+    OAUTH = "oauth"
+
+    @staticmethod
+    def by_value(auth_mode: str) -> AuthMode:
+        """
+        Parses auth mode.
+        Converts the given auth mode parameter to uppercase, before trying to convert it by name.
+
+        :param auth_mode: auth mode value
+        :return: parsed AuthMode
+        :raise KeyError in case the given auth mode is unsupported
+        """
+        return AuthMode[auth_mode.upper()]

domino_cli/core/domain/AuthRequest.py

@@ -0,0 +1,18 @@
+class AuthRequest:
+    """
+    Authentication request data domain class.
+    """
+    def __init__(self, username: str, password: str):
+        self.username = username
+        self.password = password
+
+    def get_as_dict(self) -> dict:
+        """
+        Returns the contents as dict (JSON-serializable).
+
+        :return: contents as dict
+        """
+        return {
+            "username": self.username,
+            "password": self.password
+        }

domino_cli/core/domain/CommandDescriptor.py

@@ -0,0 +1,17 @@
+class CommandDescriptor:
+    """
+    Tokenized wrapper of a parsed command.
+    Every command must consist of the command itself and an unlimited number of arguments, separated by spaces.
+    """
+    def __init__(self, raw_input: str):
+
+        command_tokens = str(raw_input).split(" ")
+        self.command = str(command_tokens[0]).lower()
+
+        if len(command_tokens) > 1:
+            self.arguments = command_tokens[1:len(command_tokens)]
+        else:
+            self.arguments = []
+
+    def __repr__(self):
+        return "cmd={0};args={1}".format(self.command, self.arguments)

domino_cli/core/domain/DominoCommand.py

@@ -0,0 +1,26 @@
+from enum import Enum
+
+from domino_cli.core.domain.HTTPMethod import HTTPMethod
+
+
+class DominoRequestDescriptor:
+    """
+    Command descriptor for Domino commands, specifying the expected HTTP method and a request path template.
+    """
+    def __init__(self, method: HTTPMethod, path_template: str):
+        self.method = method
+        self.path_template = path_template
+
+
+class DominoCommand(Enum):
+    """
+    Enum of possible Domino commands.
+    Each enum value must specify its own DominoRequestDescriptor instance.
+    """
+
+    START = DominoRequestDescriptor(HTTPMethod.PUT, "/lifecycle/{0}/start")
+    STOP = DominoRequestDescriptor(HTTPMethod.DELETE, "/lifecycle/{0}/stop")
+    RESTART = DominoRequestDescriptor(HTTPMethod.PUT, "/lifecycle/{0}/restart")
+    DEPLOY_LATEST = DominoRequestDescriptor(HTTPMethod.PUT, "/lifecycle/{0}/deploy")
+    DEPLOY_VERSION = DominoRequestDescriptor(HTTPMethod.PUT, "/lifecycle/{0}/deploy/{1}")
+    INFO = DominoRequestDescriptor(HTTPMethod.GET, "/lifecycle/{0}/info")