domino-cli 2.0.1__tar.gz → 2.2.0__tar.gz

{domino_cli-2.0.1 → domino_cli-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: domino-cli
-Version: 2.0.1
+Version: 2.2.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
@@ -33,18 +33,20 @@ also generate configuration files for each Domino Platform components, as well a
 
 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                                                                  |
+| 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_PREAUTHORIZED_TOKEN | No            | (For CI/CD mode) Passes an already generated access token - see further information in [CI/CD mode](#cicd-mode)) |
+| DOMINO_CLI_DEBUG_MODE          | No            | Optional debug switch. Currently its only effect is echoing the parsed command                                   |
+| DOMINO_CLI_DISABLE_COLORS      | No            | Optional switch to disable terminal colors.                                                                      |
+| 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
 
@@ -85,6 +87,29 @@ After this step, you can start Domino CLI:
 domino-cli
 ```
 
+### CI/CD mode
+
+Domino CLI now supports execution in so-called CI/CD mode, which is a simplified execution mode, primarily to be used on
+CI/CD environments, usually within a deployment script. There are a few things to note here:
+* To execute Domino CLI in CI/CD mode, pass the `--cicd` switch as the first command line parameter, then the command
+  you wish to execute, e.g. like this:
+   ```bash
+  domino-cli --cicd deploy your_app latest
+   ```
+* Interactive terminal is not available in CI/CD mode, you may only execute a single command at a time, then Domino CLI
+  immediately quits with `exit 0` status code, or `exit 1` in case of any error.
+* This also means, you can't open an authorized session. Instead, you may call the `auth --generate-token` command and 
+set the result (the generated access token) as the `DOMINO_CLI_PREAUTHORIZED_TOKEN` environment variable, e.g. as follows:
+   ```bash
+  export DOMINO_CLI_PREAUTHORIZED_TOKEN="$(domino-cli --cicd auth --generate-token)"
+  # the token in DOMINO_CLI_PREAUTHORIZED_TOKEN will be used by Domino CLI to authorize any further operations
+  domino-cli --cicd deploy your_app latest
+  domino-cli --cicd start your_app
+   ```
+* Please note, that without the interactive terminal, any operation that depends on user input, is not available,
+  including the configuration wizards, and manual authentication (you need to define the necessary parameters as
+  environment variables, as described above in the [Configuration section](#configuration))
+
 ## 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:

{domino_cli-2.0.1 → domino_cli-2.2.0}/README.md

@@ -15,18 +15,20 @@ also generate configuration files for each Domino Platform components, as well a
 
 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                                                                  |
+| 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_PREAUTHORIZED_TOKEN | No            | (For CI/CD mode) Passes an already generated access token - see further information in [CI/CD mode](#cicd-mode)) |
+| DOMINO_CLI_DEBUG_MODE          | No            | Optional debug switch. Currently its only effect is echoing the parsed command                                   |
+| DOMINO_CLI_DISABLE_COLORS      | No            | Optional switch to disable terminal colors.                                                                      |
+| 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
 
@@ -67,6 +69,29 @@ After this step, you can start Domino CLI:
 domino-cli
 ```
 
+### CI/CD mode
+
+Domino CLI now supports execution in so-called CI/CD mode, which is a simplified execution mode, primarily to be used on
+CI/CD environments, usually within a deployment script. There are a few things to note here:
+* To execute Domino CLI in CI/CD mode, pass the `--cicd` switch as the first command line parameter, then the command
+  you wish to execute, e.g. like this:
+   ```bash
+  domino-cli --cicd deploy your_app latest
+   ```
+* Interactive terminal is not available in CI/CD mode, you may only execute a single command at a time, then Domino CLI
+  immediately quits with `exit 0` status code, or `exit 1` in case of any error.
+* This also means, you can't open an authorized session. Instead, you may call the `auth --generate-token` command and 
+set the result (the generated access token) as the `DOMINO_CLI_PREAUTHORIZED_TOKEN` environment variable, e.g. as follows:
+   ```bash
+  export DOMINO_CLI_PREAUTHORIZED_TOKEN="$(domino-cli --cicd auth --generate-token)"
+  # the token in DOMINO_CLI_PREAUTHORIZED_TOKEN will be used by Domino CLI to authorize any further operations
+  domino-cli --cicd deploy your_app latest
+  domino-cli --cicd start your_app
+   ```
+* Please note, that without the interactive terminal, any operation that depends on user input, is not available,
+  including the configuration wizards, and manual authentication (you need to define the necessary parameters as
+  environment variables, as described above in the [Configuration section](#configuration))
+
 ## 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:

{domino_cli-2.0.1 → domino_cli-2.2.0}/domino_cli/__init__.py

@@ -2,7 +2,7 @@
 domino_cli.py :: Main entry point for Domino CLI application.
 """
 
-__version__ = "2.0.1"
+__version__ = "2.2.0"
 
 import os
 

{domino_cli-2.0.1 → domino_cli-2.2.0}/domino_cli/core/ApplicationContext.py

@@ -1,6 +1,7 @@
 import os
 
 from domino_cli.core.cli.CLI import CLI
+from domino_cli.core.cli.Logging import info
 from domino_cli.core.client.DominoClient import DominoClient
 from domino_cli.core.client.OAuthAuthorizationClient import OAuthAuthorizationClient
 from domino_cli.core.command.AuthCommand import AuthCommand
@@ -50,7 +51,7 @@ class ApplicationContext:
     @staticmethod
     def init_cli(version: str) -> CLI:
 
-        print("Initializing Domino CLI...")
+        info("Initializing Domino CLI...")
 
         # configuration properties
         _domino_base_url = ApplicationContext._assert_config_value("DOMINO_BASE_URL")
@@ -129,8 +130,8 @@ class ApplicationContext:
 
         _cli = CLI(_command_processor)
 
-        print(f"Domino CLI v{version} initialized.")
-        print("-" * 30)
+        info(f"Domino CLI v{version} initialized")
+        info("-" * 30)
 
         return _cli
 

domino_cli-2.2.0/domino_cli/core/cli/CLI.py

@@ -0,0 +1,31 @@
+from domino_cli.core.cli.Logging import TerminalColor, get_color
+from domino_cli.core.cli.RuntimeHelper import RuntimeHelper
+from domino_cli.core.domain.CommandDescriptor import CommandDescriptor
+from domino_cli.core.service.CommandProcessor import CommandProcessor
+
+_PROMPT = f"\n{get_color(TerminalColor.BLUE)}Domino CLI > {get_color(TerminalColor.NORMAL)}"
+
+
+class CLI:
+    """
+    Command line interface (CLI) executor.
+    """
+    def __init__(self, command_processor: CommandProcessor):
+        self._command_processor = command_processor
+
+    def run_loop(self) -> None:
+        """
+        Executes a single command (passed from the command line) in CI/CD mode, otherwise runs CLI command execution
+        loop until an exit command terminates it.
+        """
+        if RuntimeHelper.is_cicd_mode():
+            command = CommandDescriptor(RuntimeHelper.get_cicd_command_line())
+            self._command_processor.execute_command(command)
+            return
+
+        while True:
+            command = CommandDescriptor(RuntimeHelper.input_wrapper(lambda: input(_PROMPT)))
+            continue_loop = self._command_processor.execute_command(command)
+
+            if not continue_loop:
+                break

domino_cli-2.2.0/domino_cli/core/cli/Logging.py

@@ -0,0 +1,68 @@
+import os
+import string
+import sys
+from enum import Enum
+
+from domino_cli.core.cli.RuntimeHelper import RuntimeHelper
+
+
+class TerminalColor(Enum):
+    GREEN = "\033[92m"
+    YELLOW = "\033[93m"
+    RED = "\033[91m"
+    BLUE = "\033[94m"
+    NORMAL = "\033[0m"
+
+
+class LogLevel(Enum):
+    INFO = "info"
+    WARNING = "warn"
+    ERROR = "error"
+
+_terminal_color_mapping: dict[LogLevel, TerminalColor] = {
+    LogLevel.INFO: TerminalColor.GREEN,
+    LogLevel.WARNING: TerminalColor.YELLOW,
+    LogLevel.ERROR: TerminalColor.RED,
+}
+
+
+def info(message: string) -> None:
+    """
+    Logs the given message on info level. Ignores logging in CI/CD mode.
+
+    :param message: message to log
+    """
+    _log(LogLevel.INFO, message, False)
+
+def warning(message: string) -> None:
+    """
+    Logs the given message on warn level. Ignores logging in CI/CD mode.
+
+    :param message: message to log
+    """
+    _log(LogLevel.WARNING, message, False)
+
+def error(message: string) -> None:
+    """
+    Logs the given message on error level. Logs the given message even in CI/CD mode.
+
+    :param message: message to log
+    """
+    _log(LogLevel.ERROR, message, True)
+
+def get_color(color: TerminalColor) -> str:
+    """
+    Returns the terminal color code assigned to the given TerminalColor, if using terminal colors is enabled. Otherwise,
+    returns an empty string.
+
+    :param color: TerminalColor enum constant
+    :return: color code or empty string
+    """
+    return "" \
+        if os.getenv("DOMINO_CLI_DISABLE_COLORS") is not None or "unittest" in sys.modules \
+        else color.value
+
+def _log(log_level: LogLevel, message: string, force: bool = False) -> None:
+
+    if not RuntimeHelper.is_cicd_mode() or force:
+        print(f"[{get_color(_terminal_color_mapping[log_level])}{log_level.value:5}{get_color(TerminalColor.NORMAL)}] {message}")

domino_cli-2.2.0/domino_cli/core/cli/RuntimeHelper.py

@@ -0,0 +1,64 @@
+import sys
+
+
+class RuntimeHelper:
+    """
+    Runtime helper utilities.
+    """
+
+    _cicd_mode = len(sys.argv) > 1 and sys.argv[1] == "--cicd"
+
+    @classmethod
+    def is_cicd_mode(cls) -> bool:
+        """
+        Checks if the CLI was executed in CI/CD mode. CI/CD mode only allows executing a single command, defined
+        directly in the command line. The same commands and parameterization should be used as before, but in order to
+        run the CLI in CI/CD mode, the first parameter should be "--cicd". E.g. domino-cli --cicd deploy app 1.0.0.
+        For further information, see the relevant section of the documentation in README.md.
+
+        :return: true if CI/CD mode is enabled, false otherwise.
+        """
+        return cls._cicd_mode
+
+    @classmethod
+    def get_cicd_command_line(cls) -> str:
+        """
+        Returns the CI/CD command line, without the --cicd flag itself, only if the CLI is running in CI/CD mode.
+        Otherwise, it returns None.
+
+        :return: CI/CD command line without --cicd flag
+        """
+        return " ".join(sys.argv[2:]) \
+            if cls._cicd_mode \
+            else None
+
+    @classmethod
+    def input_wrapper(cls, input_call: lambda: str) -> str:
+        """
+        Checks if the CLI is running in CI/CD mode before executing an input call. If so, immediately quits, otherwise
+        executes the input call.
+
+        :param input_call: input call to be executed
+        :return: result of the input call
+        """
+        cls.unsupported_in_cicd_mode()
+
+        return input_call()
+
+    @classmethod
+    def exit_with_error_in_cicd_mode(cls) -> None:
+        """
+        Closes the CLI application with exit status 1 in CI/CD mode. Can be used to terminate the CLI on exception.
+        """
+        if cls._cicd_mode:
+            exit(1)
+
+    @classmethod
+    def unsupported_in_cicd_mode(cls) -> None:
+        """
+        Closes the CLI application with exit status 1 in CI/CD mode. Can be used to terminate the CLI when an
+        unsupported operation is executed in CI/CD mode.
+        """
+        if cls._cicd_mode:
+            print("[error] This operation is not supported in CI/CD mode")
+            exit(1)

{domino_cli-2.0.1 → domino_cli-2.2.0}/domino_cli/core/client/DominoClient.py

@@ -3,6 +3,7 @@ import urllib.parse
 import requests
 from requests import Response
 
+from domino_cli.core.cli.Logging import info
 from domino_cli.core.domain.DominoRequest import DominoRequest
 from domino_cli.core.service.SessionContextHolder import SessionContextHolder
 
@@ -15,7 +16,7 @@ class DominoClient:
         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))
+        info("Domino CLI is configured to communicate with Domino on {0}".format(domino_base_url))
 
     def send_command(self, domino_request: DominoRequest) -> Response:
         """

{domino_cli-2.0.1 → domino_cli-2.2.0}/domino_cli/core/command/AbstractLifecycleCommand.py

@@ -1,3 +1,4 @@
+from domino_cli.core.cli.Logging import warning
 from domino_cli.core.command.AbstractCommand import AbstractCommand
 from domino_cli.core.domain.CommandDescriptor import CommandDescriptor
 from domino_cli.core.domain.DominoCommand import DominoCommand
@@ -21,6 +22,6 @@ class AbstractLifecycleCommand(AbstractCommand):
         :param command_descriptor: CommandDescriptor object containing the command arguments
         """
         if not len(command_descriptor.arguments) == 1:
-            print("Application name required")
+            warning("Application name required")
         else:
             self._domino_service.execute_lifecycle_command(self._domino_command, command_descriptor.arguments[0])

{domino_cli-2.0.1 → domino_cli-2.2.0}/domino_cli/core/command/AuthCommand.py

@@ -1,3 +1,4 @@
+from domino_cli.core.cli.Logging import warning
 from domino_cli.core.command.AbstractCommand import AbstractCommand
 from domino_cli.core.domain.CommandDescriptor import CommandDescriptor
 from domino_cli.core.service.AuthenticationService import AuthenticationService
@@ -42,5 +43,5 @@ class AuthCommand(AbstractCommand):
 
     @staticmethod
     def _show_help():
-        print("Auth command requires operation flag of: --encrypt-password | --generate-token | --open-session "
+        warning("Auth command requires operation flag of: --encrypt-password | --generate-token | --open-session "
               "| --set-mode direct|oauth")

{domino_cli-2.0.1 → domino_cli-2.2.0}/domino_cli/core/command/DeployApplicationCommand.py

@@ -1,3 +1,4 @@
+from domino_cli.core.cli.Logging import warning
 from domino_cli.core.command.AbstractCommand import AbstractCommand
 from domino_cli.core.domain.CommandDescriptor import CommandDescriptor
 from domino_cli.core.domain.DominoCommand import DominoCommand
@@ -25,7 +26,7 @@ class DeployApplicationCommand(AbstractCommand):
         :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")
+            warning("Application name and 'latest' keyword or explicit version is required")
         else:
             application: str = command_descriptor.arguments[0]
             version: str = command_descriptor.arguments[1]

{domino_cli-2.0.1 → domino_cli-2.2.0}/domino_cli/core/command/ExitCommand.py

@@ -1,5 +1,6 @@
-from domino_cli.core.domain.CommandDescriptor import CommandDescriptor
+from domino_cli.core.cli.Logging import info
 from domino_cli.core.command.AbstractCommand import AbstractCommand
+from domino_cli.core.domain.CommandDescriptor import CommandDescriptor
 
 _COMMAND_NAME = "exit"
 
@@ -13,4 +14,4 @@ class ExitCommand(AbstractCommand):
         super().__init__(_COMMAND_NAME)
 
     def execute_command(self, command_descriptor: CommandDescriptor) -> None:
-        print("Bye!")
+        info("Bye!")

{domino_cli-2.0.1 → domino_cli-2.2.0}/domino_cli/core/command/HelpCommand.py

@@ -1,5 +1,6 @@
-from domino_cli.core.domain.CommandDescriptor import CommandDescriptor
+from domino_cli.core.cli.RuntimeHelper import RuntimeHelper
 from domino_cli.core.command.AbstractCommand import AbstractCommand
+from domino_cli.core.domain.CommandDescriptor import CommandDescriptor
 
 _COMMAND_NAME = "help"
 _HELP_CONTENT = """
@@ -30,3 +31,4 @@ class HelpCommand(AbstractCommand):
 
     def execute_command(self, command_descriptor: CommandDescriptor) -> None:
         [print(line, end="") for line in self._help_text]
+        RuntimeHelper.exit_with_error_in_cicd_mode()

{domino_cli-2.0.1 → domino_cli-2.2.0}/domino_cli/core/command/WizardCommand.py

@@ -1,3 +1,4 @@
+from domino_cli.core.cli.Logging import warning
 from domino_cli.core.command.AbstractCommand import AbstractCommand
 from domino_cli.core.domain.CommandDescriptor import CommandDescriptor
 from domino_cli.core.service.ConfigurationWizardService import ConfigurationWizardService
@@ -21,7 +22,7 @@ class WizardCommand(AbstractCommand):
         :param command_descriptor: CommandDescriptor object containing the command arguments
         """
         if not len(command_descriptor.arguments) == 1:
-            print("Wizard name required")
+            warning("Wizard name required")
             self._configuration_wizard_service.show_available_wizards()
         else:
             self._configuration_wizard_service.run_wizard(command_descriptor.arguments[0])

{domino_cli-2.0.1 → domino_cli-2.2.0}/domino_cli/core/domain/OAuthConfig.py

@@ -1,5 +1,7 @@
 import os
 
+from domino_cli.core.cli.Logging import warning
+
 _OAUTH_TOKEN_URL = "DOMINO_OAUTH_TOKEN_URL"
 _OAUTH_CLIENT_ID = "DOMINO_OAUTH_CLIENT_ID"
 _OAUTH_CLIENT_SECRET = "DOMINO_OAUTH_CLIENT_SECRET"
@@ -38,7 +40,7 @@ class OAuthConfig:
         present: bool = True
         if OAuthConfig._get_parameter(parameter) is None:
             present = False
-            print(f"Parameter {parameter} is missing")
+            warning(f"Parameter {parameter} is missing")
 
         return present
 

{domino_cli-2.0.1 → domino_cli-2.2.0}/domino_cli/core/service/AuthenticationService.py

@@ -1,5 +1,7 @@
 from typing import List, Dict
 
+from domino_cli.core.cli.Logging import info, error
+from domino_cli.core.cli.RuntimeHelper import RuntimeHelper
 from domino_cli.core.domain.AuthMode import AuthMode
 from domino_cli.core.domain.SessionContext import SessionContext
 from domino_cli.core.service.SessionContextHolder import SessionContextHolder
@@ -18,15 +20,16 @@ class AuthenticationService:
         self._session_context_holder: SessionContextHolder = session_context_holder
         self._auth_handler_dict: Dict[AuthMode, AbstractAuthHandler] = self._init_handler_map(auth_handlers)
 
-        print(f"Domino authentication mode is set to {self._auth_mode.name}. Use 'auth --set-mode' command to change")
+        info(f"Domino authentication mode is set to {self._auth_mode.name}. Use 'auth --set-mode' command to change")
 
     def encrypt_password(self) -> None:
         """
         Utility to encrypt a password with BCrypt for usage in Domino (as service user password).
         """
+        RuntimeHelper.unsupported_in_cicd_mode()
         encrypted_password: str = encrypt(AuthUtils.input_password())
 
-        print("Encrypted password: {0}".format(encrypted_password))
+        info("Encrypted password: {0}".format(encrypted_password))
 
     def generate_token(self) -> None:
         """
@@ -35,22 +38,29 @@ class AuthenticationService:
         try:
             session_context: SessionContext = self._request_token()
 
-            print("Generated auth token: {0}".format(session_context.authentication_token))
+            if RuntimeHelper.is_cicd_mode():
+                print(session_context.authentication_token)
+            else:
+                info("Generated auth token: {0}".format(session_context.authentication_token))
+
         except Exception as exc:
-            print("Failed to generate token - reason: {0}".format(str(exc)))
+            error("Failed to generate token - reason: {0}".format(str(exc)))
+            RuntimeHelper.exit_with_error_in_cicd_mode()
 
     def open_session(self) -> None:
         """
         Opens an authenticated session for Domino CLI.
         This step is required before executing any lifecycle command, otherwise Domino rejects every request.
         """
+        RuntimeHelper.unsupported_in_cicd_mode()
         try:
             session_context: SessionContext = self._request_token()
             self._session_context_holder.update(session_context)
 
-            print("Session is open")
+            info("Session is open")
         except Exception as exc:
-            print("Failed to open session - reason: {0}".format(str(exc)))
+            error("Failed to open session - reason: {0}".format(str(exc)))
+            RuntimeHelper.exit_with_error_in_cicd_mode()
 
     def set_mode(self, new_mode: str) -> None:
         """
@@ -59,10 +69,11 @@ class AuthenticationService:
 
         :param new_mode: authentication mode to change to
         """
+        RuntimeHelper.unsupported_in_cicd_mode()
         try:
             self._auth_mode = AuthMode.by_value(new_mode)
         except KeyError:
-            print(f"Failed to change authentication mode, invalid mode defined: {new_mode}")
+            error(f"Failed to change authentication mode, invalid mode defined: {new_mode}")
 
     def _request_token(self) -> SessionContext:
 

{domino_cli-2.0.1 → domino_cli-2.2.0}/domino_cli/core/service/CommandProcessor.py

@@ -1,6 +1,7 @@
 import os
 from typing import List
 
+from domino_cli.core.cli.Logging import info
 from domino_cli.core.command.AbstractCommand import AbstractCommand
 from domino_cli.core.command.ExitCommand import ExitCommand
 from domino_cli.core.domain.CommandDescriptor import CommandDescriptor
@@ -27,7 +28,7 @@ class CommandProcessor:
         """
 
         if _DEBUG_MODE:
-            print("Command to be executed: {0}".format(command_descriptor))
+            info("Command to be executed: {0}".format(command_descriptor))
 
         command_iterator = filter(lambda command: command.is_applicable(command_descriptor), self._registered_commands)
         selected_command = next(command_iterator, self._default_command)

{domino_cli-2.0.1 → domino_cli-2.2.0}/domino_cli/core/service/ConfigurationWizardService.py

@@ -1,5 +1,7 @@
 from typing import List, Dict
 
+from domino_cli.core.cli.Logging import warning, info
+from domino_cli.core.cli.RuntimeHelper import RuntimeHelper
 from domino_cli.core.service.wizard.AbstractWizard import AbstractWizard
 
 _WIZARD_HELP_TEXT_LINE = "{}\n[{:>15}]: {}"
@@ -17,7 +19,8 @@ class ConfigurationWizardService:
         """
         Prints the name and the description of the available wizards.
         """
-        print("Available wizards:{0}".format(self._available_wizards_help))
+        RuntimeHelper.unsupported_in_cicd_mode()
+        info("Available wizards:{0}".format(self._available_wizards_help))
 
     def run_wizard(self, wizard_name: str) -> None:
         """
@@ -25,8 +28,9 @@ class ConfigurationWizardService:
 
         :param wizard_name: name of the wizard to be executed
         """
+        RuntimeHelper.unsupported_in_cicd_mode()
         if wizard_name not in self._wizards.keys():
-            print("Unknown wizard '{0}'".format(wizard_name))
+            warning("Unknown wizard '{0}'".format(wizard_name))
             self.show_available_wizards()
         else:
             wizard: AbstractWizard = self._wizards.get(wizard_name)

{domino_cli-2.0.1 → domino_cli-2.2.0}/domino_cli/core/service/DominoService.py

@@ -1,5 +1,7 @@
 from requests import Response
 
+from domino_cli.core.cli.Logging import info, error
+from domino_cli.core.cli.RuntimeHelper import RuntimeHelper
 from domino_cli.core.client.DominoClient import DominoClient
 from domino_cli.core.domain.DominoCommand import DominoCommand
 from domino_cli.core.domain.DominoCommand import DominoRequestDescriptor
@@ -25,21 +27,23 @@ class DominoService:
         formatted_path = domino_request_descriptor.path_template.format(application, version)
         domino_request = DominoRequest(domino_request_descriptor.method, formatted_path, authenticated=True)
 
-        print("Sending {0} command for application {1} via Domino".format(domino_command.name, application))
+        info("Sending {0} command for application {1} via Domino".format(domino_command.name, application))
 
         try:
             response: Response = self._domino_client.send_command(domino_request)
 
             if DominoService._is_successful(response):
-                print("Command {0} successfully executed on application {1}".format(domino_command.name, application))
+                info("Command {0} successfully executed on application {1}".format(domino_command.name, application))
             else:
-                print("Failed to execute command {0} on application {1} - Domino responded with {2}"
+                error("Failed to execute command {0} on application {1} - Domino responded with {2}"
                       .format(domino_command.name, application, response.status_code))
+                RuntimeHelper.exit_with_error_in_cicd_mode()
 
             DominoService._render_response(response)
 
         except Exception as exc:
-            print("Failed to execute HTTP request {0} - reason {1}".format(domino_request, str(exc)))
+            error("Failed to execute HTTP request {0} - reason {1}".format(domino_request, str(exc)))
+            RuntimeHelper.exit_with_error_in_cicd_mode()
 
     @staticmethod
     def _is_successful(response: Response) -> bool:
@@ -48,6 +52,6 @@ class DominoService:
     @staticmethod
     def _render_response(response: Response):
         response_dict = response.json()
-        print(" --- Response details ---")
-        [print("{:>10}: {}".format(field, response_dict[field])) for field in response_dict]
+        info(" --- Response details ---")
+        [info("{:>20}: {}".format(field, response_dict[field])) for field in response_dict]
         print()