domino-cli 2.0.0__tar.gz

domino_cli-2.0.0/.gitignore

@@ -0,0 +1,7 @@
+.idea
+*.iml
+.coverage
+*.in
+dist/
+htmlcov/
+out/

domino_cli-2.0.0/PKG-INFO

@@ -0,0 +1,198 @@
+Metadata-Version: 2.3
+Name: domino-cli
+Version: 2.0.0
+Summary: Domino Platform CLI tool, providing utilities to install, configure and control your Domino Platform insfrastructure
+Project-URL: Maintainer's website, https://psprog.hu
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: Natural Language :: English
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3.8
+Requires-Dist: bcrypt==4.0.0
+Requires-Dist: pyyaml
+Requires-Dist: requests
+Description-Content-Type: text/markdown
+
+# Domino CLI
+
+Domino CLI is a command line interface tool written in Python for 
+[Domino Platform deployment orchestration system](https://github.com/petersmith-hun/domino-platform).
+Its purpose is to provide a convenient way of controlling the Domino Platform Coordinator via its REST interface. It can 
+also generate configuration files for each Domino Platform components, as well as install those.
+
+## Requirements
+
+* Domino CLI requires Python 3.x for execution (tested on Python 3.7, 3.8, 3.10 and 3.12).
+* Pip (Python package installer) is required for installation.
+* It is executable both on Windows and Linux systems.
+
+## Configuration
+
+The tool can be configured via the following environment variables:
+
+| Environment variable       | Mandatory?    | Description                                                                                   |
+|----------------------------|---------------|-----------------------------------------------------------------------------------------------|
+| DOMINO_BASE_URL            | Yes           | URL of Domino instance to be controlled, e.g. http://localhost:8080/domino                    |
+| DOMINO_CLI_USERNAME        | No            | Optional predefined username for accessing Domino                                             |
+| DOMINO_CLI_PASSWORD        | No            | Optional predefined password for accessing Domino                                             |
+| DOMINO_CLI_DEBUG_MODE      | No            | Optional debug switch. Currently its only effect is echoing the parsed command                |
+| DOMINO_DEFAULT_AUTH_MODE   | No            | Changes how Domino CLI acquires the access token for Domino. Defaults to direct mode (legacy) |
+| DOMINO_OAUTH_TOKEN_URL     | In OAuth mode | OAuth 2.0 compliant authorization server address, including the token request endpoint path   |
+| DOMINO_OAUTH_CLIENT_ID     | In OAuth mode | OAuth 2.0 Client ID of Domino CLI                                                             |
+| DOMINO_OAUTH_CLIENT_SECRET | In OAuth mode | OAuth 2.0 Client Secret of Domino CLI                                                         |
+| DOMINO_OAUTH_SCOPE         | In OAuth mode | OAuth 2.0 access token scope                                                                  |                                                                                         
+| DOMINO_OAUTH_AUDIENCE      | No            | OAuth 2.0 audience of Domino                                                                  |
+
+## Installation
+
+Domino CLI can be installed via `pip` and then it can be executed as a standalone CLI tool. In order to install,
+execute the following command in the terminal:
+
+* On Windows:
+    ```shell
+    py -m pip install domino-cli
+    # or
+    pip install domino-cli
+    ```
+* On Linux:
+    ```shell
+    python3 -m pip install domino-cli
+    ```
+
+## Execution
+
+Domino CLI can be executed from any terminal with Python. First the `DOMINO_BASE_URL` parameter must be defined.
+To do this, execute the following command in the terminal:
+
+* On Windows:
+    ```shell
+    set DOMINO_BASE_URL=<your_domino_instance_url>
+    ```
+* On Linux:
+    ```shell
+    export DOMINO_BASE_URL=<your_domino_instance_url>
+    ```
+
+Notes:
+* With the same approach you can set the other supported environment variables as well.
+* You may consider setting the environment variables permanently in the supported way of your platform. 
+
+After this step, you can start Domino CLI:
+```shell
+domino-cli
+```
+
+## Usage
+After successfully starting up Domino CLI you should see its prompt (`Domino CLI >`) along with some start-up messages.
+Now it's time to start playing around with the commands - the supported ones are the following:
+
+### Generic commands
+
+```
+help
+```
+Anytime you feel unsure how to use the tool, just type this command to have the in-application help text printed.
+This will also be printed in case you type an unsupported command or hit enter without typing any commands.
+
+```
+exit
+```
+This command doesn't really need any explanation, it makes the tool quit.
+
+```
+auth <--encrypt-password|--generate-token|--open-session|--set-mode <direct|oauth>>
+```
+Authentication command serves three different purposes based on the provided flag.
+* `--encrypt-password`: Provides a utility to hash the provided password with BCrypt.
+    The generated hash can be used in Domino's configuration as its management access account password.
+* `--generate-token`: Authenticates with Domino in order to generate a management access token.
+    The generated token can be used by external systems needing access to Domino.
+* `--open-session`: Authenticates with Domino in order to generate a management access token AND
+    stores it in the tool's security context. Opening a session is always needed to access lifecycle commands.
+    Opening a session is only needed once every time you start the tool, but the token is stored only in memory,
+    so you always need to open a session after starting the tool.
+* `--set-mode <direct|oauth>`: Changes the active authentication mode. Since CLI v1.3.0, it's possible to use an
+    external OAuth 2.0 Authorization Server to acquire access token for Domino. Please note, that both Domino and
+    Domino CLI must be registered clients on the specified authorization server; as well as Domino must be configured
+    to accept the token issued by the configured authorization server. The default auth mode is the legacy one,
+    called "direct". Please make sure to specify the required OAuth parameters before changing the auth mode to "oauth".
+    Also, this feature is only supported in Domino v1.5.0 and above.
+    
+Opening a session and generating a token require full authentication, therefore the tool asks for your configured 
+(on Domino side) management account username and password (only in direct auth mode). You can speed up the process by 
+predefining the credentials as environment variables (see [Configuration](#configuration) section). Please be warned 
+that by setting the password as an environment variable you cause a potential security vulnerability to your system. 
+Keeping this in mind please handle this option with caution!
+
+### Lifecycle-management commands
+
+The commands below work only in case the proper application registrations have already been made in Domino.
+The `app` parameter of the commands always refer to an application's registered identifier.
+
+```
+deploy <app> <latest|version>
+```
+Instructs Domino to deploy the specified version of the given application. The application and its selected version 
+must be already uploaded to the target server via Domino. Specify the keyword `latest` to let Domino decide which 
+version to be deployed, or provide an existing version number of the application.
+
+```
+start <app>
+```
+Instructs Domino to start the currently deployed version of the application.
+
+```
+stop <app>
+```
+Instructs Domino to stop the currently running instance of the application.
+
+```
+restart <app>
+```
+Instructs Domino to restart the currently running instance of the application.
+
+```
+info <app>
+```
+Instructs Domino to query the application's info endpoint and returns the results.
+
+### Configuration wizards
+
+Domino CLI also provides configuration wizards which help to properly create Domino configuration files.
+Currently one configuration wizard is supported by the tool, but the list of wizards will be extended soon.
+
+```
+wizard deployment
+```
+Starts wizard that helps to create a Domino application deployment configuration. Usage notes:
+* Fixed choice steps are indicated by displaying the choices with a number in square brackets at the beginning
+of the line. Type the desired number and hit enter to select your choice.
+* Some steps may expect multiple responses. Hit enter after each of your answers. To finalize the step hit enter
+on an empty line.
+* Resulted configuration can be either displayed on console or written to file. If you chose to show the result
+on console, simply copy the displayed config into your existing Domino deployment config file. If you want to 
+write the results to file, you need to define the file path when prompted. Having an already existing deployment
+configuration file will cause the tool to merge the newly created config with the existing file.
+
+```
+wizard coordinator
+```
+Starts wizard that helps to create a Domino Platform Coordinator configuration.
+```
+wizard docker-agent
+```
+Starts wizard that helps to create a Domino Platform Docker Agent configuration.
+```
+wizard bin-exec-agent
+```
+Starts wizard that helps to create a Domino Platform Binary Executable Agent configuration.
+```
+wizard installer
+```
+Starts wizard that helps to install the currently available Domino Platform components (Domino Coordinator, Domino 
+Docker Agent, and Domino Binary Executable Agent). The first two are installed as Docker containers, while the last
+one is installed as a Systemd service. Please note, that because of this, Domino Binary Executable Agent installer 
+supports Linux OS only (tested on Ubuntu).

domino_cli-2.0.0/README.md

@@ -0,0 +1,180 @@
+# Domino CLI
+
+Domino CLI is a command line interface tool written in Python for 
+[Domino Platform deployment orchestration system](https://github.com/petersmith-hun/domino-platform).
+Its purpose is to provide a convenient way of controlling the Domino Platform Coordinator via its REST interface. It can 
+also generate configuration files for each Domino Platform components, as well as install those.
+
+## Requirements
+
+* Domino CLI requires Python 3.x for execution (tested on Python 3.7, 3.8, 3.10 and 3.12).
+* Pip (Python package installer) is required for installation.
+* It is executable both on Windows and Linux systems.
+
+## Configuration
+
+The tool can be configured via the following environment variables:
+
+| Environment variable       | Mandatory?    | Description                                                                                   |
+|----------------------------|---------------|-----------------------------------------------------------------------------------------------|
+| DOMINO_BASE_URL            | Yes           | URL of Domino instance to be controlled, e.g. http://localhost:8080/domino                    |
+| DOMINO_CLI_USERNAME        | No            | Optional predefined username for accessing Domino                                             |
+| DOMINO_CLI_PASSWORD        | No            | Optional predefined password for accessing Domino                                             |
+| DOMINO_CLI_DEBUG_MODE      | No            | Optional debug switch. Currently its only effect is echoing the parsed command                |
+| DOMINO_DEFAULT_AUTH_MODE   | No            | Changes how Domino CLI acquires the access token for Domino. Defaults to direct mode (legacy) |
+| DOMINO_OAUTH_TOKEN_URL     | In OAuth mode | OAuth 2.0 compliant authorization server address, including the token request endpoint path   |
+| DOMINO_OAUTH_CLIENT_ID     | In OAuth mode | OAuth 2.0 Client ID of Domino CLI                                                             |
+| DOMINO_OAUTH_CLIENT_SECRET | In OAuth mode | OAuth 2.0 Client Secret of Domino CLI                                                         |
+| DOMINO_OAUTH_SCOPE         | In OAuth mode | OAuth 2.0 access token scope                                                                  |                                                                                         
+| DOMINO_OAUTH_AUDIENCE      | No            | OAuth 2.0 audience of Domino                                                                  |
+
+## Installation
+
+Domino CLI can be installed via `pip` and then it can be executed as a standalone CLI tool. In order to install,
+execute the following command in the terminal:
+
+* On Windows:
+    ```shell
+    py -m pip install domino-cli
+    # or
+    pip install domino-cli
+    ```
+* On Linux:
+    ```shell
+    python3 -m pip install domino-cli
+    ```
+
+## Execution
+
+Domino CLI can be executed from any terminal with Python. First the `DOMINO_BASE_URL` parameter must be defined.
+To do this, execute the following command in the terminal:
+
+* On Windows:
+    ```shell
+    set DOMINO_BASE_URL=<your_domino_instance_url>
+    ```
+* On Linux:
+    ```shell
+    export DOMINO_BASE_URL=<your_domino_instance_url>
+    ```
+
+Notes:
+* With the same approach you can set the other supported environment variables as well.
+* You may consider setting the environment variables permanently in the supported way of your platform. 
+
+After this step, you can start Domino CLI:
+```shell
+domino-cli
+```
+
+## Usage
+After successfully starting up Domino CLI you should see its prompt (`Domino CLI >`) along with some start-up messages.
+Now it's time to start playing around with the commands - the supported ones are the following:
+
+### Generic commands
+
+```
+help
+```
+Anytime you feel unsure how to use the tool, just type this command to have the in-application help text printed.
+This will also be printed in case you type an unsupported command or hit enter without typing any commands.
+
+```
+exit
+```
+This command doesn't really need any explanation, it makes the tool quit.
+
+```
+auth <--encrypt-password|--generate-token|--open-session|--set-mode <direct|oauth>>
+```
+Authentication command serves three different purposes based on the provided flag.
+* `--encrypt-password`: Provides a utility to hash the provided password with BCrypt.
+    The generated hash can be used in Domino's configuration as its management access account password.
+* `--generate-token`: Authenticates with Domino in order to generate a management access token.
+    The generated token can be used by external systems needing access to Domino.
+* `--open-session`: Authenticates with Domino in order to generate a management access token AND
+    stores it in the tool's security context. Opening a session is always needed to access lifecycle commands.
+    Opening a session is only needed once every time you start the tool, but the token is stored only in memory,
+    so you always need to open a session after starting the tool.
+* `--set-mode <direct|oauth>`: Changes the active authentication mode. Since CLI v1.3.0, it's possible to use an
+    external OAuth 2.0 Authorization Server to acquire access token for Domino. Please note, that both Domino and
+    Domino CLI must be registered clients on the specified authorization server; as well as Domino must be configured
+    to accept the token issued by the configured authorization server. The default auth mode is the legacy one,
+    called "direct". Please make sure to specify the required OAuth parameters before changing the auth mode to "oauth".
+    Also, this feature is only supported in Domino v1.5.0 and above.
+    
+Opening a session and generating a token require full authentication, therefore the tool asks for your configured 
+(on Domino side) management account username and password (only in direct auth mode). You can speed up the process by 
+predefining the credentials as environment variables (see [Configuration](#configuration) section). Please be warned 
+that by setting the password as an environment variable you cause a potential security vulnerability to your system. 
+Keeping this in mind please handle this option with caution!
+
+### Lifecycle-management commands
+
+The commands below work only in case the proper application registrations have already been made in Domino.
+The `app` parameter of the commands always refer to an application's registered identifier.
+
+```
+deploy <app> <latest|version>
+```
+Instructs Domino to deploy the specified version of the given application. The application and its selected version 
+must be already uploaded to the target server via Domino. Specify the keyword `latest` to let Domino decide which 
+version to be deployed, or provide an existing version number of the application.
+
+```
+start <app>
+```
+Instructs Domino to start the currently deployed version of the application.
+
+```
+stop <app>
+```
+Instructs Domino to stop the currently running instance of the application.
+
+```
+restart <app>
+```
+Instructs Domino to restart the currently running instance of the application.
+
+```
+info <app>
+```
+Instructs Domino to query the application's info endpoint and returns the results.
+
+### Configuration wizards
+
+Domino CLI also provides configuration wizards which help to properly create Domino configuration files.
+Currently one configuration wizard is supported by the tool, but the list of wizards will be extended soon.
+
+```
+wizard deployment
+```
+Starts wizard that helps to create a Domino application deployment configuration. Usage notes:
+* Fixed choice steps are indicated by displaying the choices with a number in square brackets at the beginning
+of the line. Type the desired number and hit enter to select your choice.
+* Some steps may expect multiple responses. Hit enter after each of your answers. To finalize the step hit enter
+on an empty line.
+* Resulted configuration can be either displayed on console or written to file. If you chose to show the result
+on console, simply copy the displayed config into your existing Domino deployment config file. If you want to 
+write the results to file, you need to define the file path when prompted. Having an already existing deployment
+configuration file will cause the tool to merge the newly created config with the existing file.
+
+```
+wizard coordinator
+```
+Starts wizard that helps to create a Domino Platform Coordinator configuration.
+```
+wizard docker-agent
+```
+Starts wizard that helps to create a Domino Platform Docker Agent configuration.
+```
+wizard bin-exec-agent
+```
+Starts wizard that helps to create a Domino Platform Binary Executable Agent configuration.
+```
+wizard installer
+```
+Starts wizard that helps to install the currently available Domino Platform components (Domino Coordinator, Domino 
+Docker Agent, and Domino Binary Executable Agent). The first two are installed as Docker containers, while the last
+one is installed as a Systemd service. Please note, that because of this, Domino Binary Executable Agent installer 
+supports Linux OS only (tested on Ubuntu).

domino_cli-2.0.0/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-2.0.0/domino_cli/__main__.py

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

domino_cli-2.0.0/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-2.0.0/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-2.0.0/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-2.0.0/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
+        }