domino-cli 2.3.0__tar.gz → 2.4.0__tar.gz

{domino_cli-2.3.0 → domino_cli-2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: domino-cli
-Version: 2.3.0
+Version: 2.4.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
@@ -192,6 +192,65 @@ import <optional/path/to/deployment-definition.yml>
 Imports a YAML formatted deployment definition. Without providing an absolute or relative path to your deployment 
 definition file, defaults to `.domino/deployment.yml`.
 
+### Secret management commands
+
+Domino Coordinator, starting with v2.3.0, can act as a simple secret manager. Domino CLI provides an integration for
+these operations. Please note, that most of the commands do not support CI/CD mode, except for the --retrieve commands.
+
+```
+secret --create <key> <context>
+```
+Creates a new secret. You'll need to provide the secret key and a context (basically a group) name for the secret as
+arguments, then you'll be prompted to enter the secret value, without echoing the value to the terminal.  
+Notes:
+ * Context is an arbitrary value, that lets you return multiple, corresponding secrets with a single request.
+ * Created secrets are by default "locked", meaning they can't be returned via the API (only accessible by Domino 
+Coordinator directly, for deployment definitions).
+
+```
+secret --metadata --all
+```
+Returns the metadata of all existing secrets, grouped by their context.
+
+```
+secret --metadata <key>
+```
+Returns the metadata of the given secret.
+
+```
+secret --retrieve --key <key>
+```
+Returns the value of the given secret, if retrievable. In CI/CD mode, the result is returned in `<key>=<value>` format,
+that can be put in a `.env` file directly. 
+
+```
+secret --retrieve --context <context>
+```
+Returns the value of all secrets under the given context, if each of them is retrievable. In CI/CD mode, the result is 
+returned in `<key>=<value>` format, that can be used in a `.env` file directly. E.g.:
+```
+$ domino-cli --cicd secret --retrieve --context config > .env
+$ cat .env
+datasource.host=jdbc:mysql://localhost:3306/test
+datasource.username=root
+...
+```
+
+```
+secret --lock <key>
+```
+Locks (disables retrieval of) the given secret.
+
+```
+secret --unlock <key>
+```
+Unlocks (enables retrieval of) the given secret.
+
+```
+secret --delete <key>
+```
+Deletes the given secret.
+
 ### Configuration wizards
 
 Domino CLI also provides configuration wizards which help to properly create Domino configuration files.

{domino_cli-2.3.0 → domino_cli-2.4.0}/README.md

@@ -174,6 +174,65 @@ import <optional/path/to/deployment-definition.yml>
 Imports a YAML formatted deployment definition. Without providing an absolute or relative path to your deployment 
 definition file, defaults to `.domino/deployment.yml`.
 
+### Secret management commands
+
+Domino Coordinator, starting with v2.3.0, can act as a simple secret manager. Domino CLI provides an integration for
+these operations. Please note, that most of the commands do not support CI/CD mode, except for the --retrieve commands.
+
+```
+secret --create <key> <context>
+```
+Creates a new secret. You'll need to provide the secret key and a context (basically a group) name for the secret as
+arguments, then you'll be prompted to enter the secret value, without echoing the value to the terminal.  
+Notes:
+ * Context is an arbitrary value, that lets you return multiple, corresponding secrets with a single request.
+ * Created secrets are by default "locked", meaning they can't be returned via the API (only accessible by Domino 
+Coordinator directly, for deployment definitions).
+
+```
+secret --metadata --all
+```
+Returns the metadata of all existing secrets, grouped by their context.
+
+```
+secret --metadata <key>
+```
+Returns the metadata of the given secret.
+
+```
+secret --retrieve --key <key>
+```
+Returns the value of the given secret, if retrievable. In CI/CD mode, the result is returned in `<key>=<value>` format,
+that can be put in a `.env` file directly. 
+
+```
+secret --retrieve --context <context>
+```
+Returns the value of all secrets under the given context, if each of them is retrievable. In CI/CD mode, the result is 
+returned in `<key>=<value>` format, that can be used in a `.env` file directly. E.g.:
+```
+$ domino-cli --cicd secret --retrieve --context config > .env
+$ cat .env
+datasource.host=jdbc:mysql://localhost:3306/test
+datasource.username=root
+...
+```
+
+```
+secret --lock <key>
+```
+Locks (disables retrieval of) the given secret.
+
+```
+secret --unlock <key>
+```
+Unlocks (enables retrieval of) the given secret.
+
+```
+secret --delete <key>
+```
+Deletes the given secret.
+
 ### Configuration wizards
 
 Domino CLI also provides configuration wizards which help to properly create Domino configuration files.

{domino_cli-2.3.0 → domino_cli-2.4.0}/domino_cli/__init__.py

@@ -2,7 +2,7 @@
 domino_cli.py :: Main entry point for Domino CLI application.
 """
 
-__version__ = "2.3.0"
+__version__ = "2.4.0"
 
 from domino_cli.core.ApplicationContext import ApplicationContext
 

{domino_cli-2.3.0 → domino_cli-2.4.0}/domino_cli/core/ApplicationContext.py

@@ -11,15 +11,25 @@ from domino_cli.core.command.HelpCommand import HelpCommand
 from domino_cli.core.command.ImportCommand import ImportCommand
 from domino_cli.core.command.InfoCommand import InfoCommand
 from domino_cli.core.command.RestartApplicationCommand import RestartApplicationCommand
+from domino_cli.core.command.SecretCommand import SecretCommand
 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.command.dsl.dsm.DSLCreate import CreateSecretCommandProcessor
+from domino_cli.core.command.dsl.dsm.DSLDelete import DeleteSecretCommandProcessor
+from domino_cli.core.command.dsl.dsm.DSLLocking import LockSecretCommandProcessor, UnlockSecretCommandProcessor
+from domino_cli.core.command.dsl.dsm.DSLMain import MainSecretCommandProcessor
+from domino_cli.core.command.dsl.dsm.DSLMetadata import MetadataCommandProcessor, MetadataAllCommandProcessor, \
+    MetadataKeyCommandProcessor
+from domino_cli.core.command.dsl.dsm.DSLRetrieval import RetrievalSecretCommandProcessor, \
+    RetrieveByKeySecretCommandProcessor, RetrieveByContextSecretCommandProcessor
 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.SecretService import SecretService
 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
@@ -91,6 +101,7 @@ class ApplicationContext:
         _domino_client = DominoClient(_domino_base_url, _session_context_holder)
         _oauth_authorization_client = OAuthAuthorizationClient(_oauth_config)
         _domino_service = DominoService(_domino_client)
+        _secret_service = SecretService(_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, [
@@ -116,6 +127,19 @@ class ApplicationContext:
         _command_auth = AuthCommand(_auth_service)
         _command_wizard = WizardCommand(_config_wizard_service)
         _command_info = InfoCommand(_domino_service)
+        _command_secret = SecretCommand([
+            MainSecretCommandProcessor(),
+            CreateSecretCommandProcessor(_secret_service),
+            MetadataCommandProcessor(),
+            MetadataAllCommandProcessor(_secret_service),
+            MetadataKeyCommandProcessor(_secret_service),
+            RetrievalSecretCommandProcessor(),
+            RetrieveByKeySecretCommandProcessor(_secret_service),
+            RetrieveByContextSecretCommandProcessor(_secret_service),
+            LockSecretCommandProcessor(_secret_service),
+            UnlockSecretCommandProcessor(_secret_service),
+            DeleteSecretCommandProcessor(_secret_service),
+        ])
 
         # command processor
         _command_processor = CommandProcessor(_command_help, [
@@ -128,7 +152,8 @@ class ApplicationContext:
             _command_stop_app,
             _command_import,
             _command_wizard,
-            _command_info
+            _command_info,
+            _command_secret
         ])
 
         _cli = CLI(_command_processor)

{domino_cli-2.3.0 → domino_cli-2.4.0}/domino_cli/core/command/HelpCommand.py

@@ -13,6 +13,15 @@ Known commands:
     --generate-token: authenticates with Domino and prints the generated token
     --open-session: authenticates with Domino and stores the token in the session context for further usage
     --set-mode <oauth|direct>: switches authentication mode (oauth or direct)
+ - secret <arguments>: secret management operations
+    --metadata --all: retrieves metadata of all existing secrets
+    --metadata <key>: retrieves metadata of the given secret
+    --retrieve --key <key>: retrieves the value of the given secret
+    --retrieve --context <context>: retrieves the value of all secrets under the given context
+    --create <key> <context>: create a new secret (you'll be prompted to enter the secret value as password)
+    --lock <key>: locks a secret (disables retrieval)
+    --unlock <key>: unlocks a secret (enables retrieval)
+    --delete <key>: deletes a secret 
  - start <app>: commands Domino to start the given app
  - stop <app>: commands Domino to stop the given app
  - restart <app>: commands Domino to restart the given app

domino_cli-2.4.0/domino_cli/core/command/SecretCommand.py

@@ -0,0 +1,41 @@
+from typing import List
+
+from domino_cli.core.cli.Logging import error
+from domino_cli.core.command.AbstractCommand import AbstractCommand
+from domino_cli.core.command.dsl.dsm.DSLMain import SecretCommandProcessor
+from domino_cli.core.domain.CommandDescriptor import CommandDescriptor
+
+_command_processing_max_iteration = 4
+
+_COMMAND_NAME = "secret"
+
+
+class SecretCommand(AbstractCommand):
+    """
+    Command implementation to execute a Domino Secret Manager request.
+    """
+    def __init__(self, processors: List[SecretCommandProcessor]):
+        super().__init__(_COMMAND_NAME)
+        self._processors = {processor.for_subcommand(): processor for processor in processors}
+
+    def execute_command(self, command_descriptor: CommandDescriptor) -> None:
+
+        command_arguments = command_descriptor.arguments.copy()
+        current_argument = "secret"
+        processed = False
+
+        for _ in range(_command_processing_max_iteration):
+
+            processor = self._processors.get(current_argument)
+            processed = processor.process(command_arguments)
+
+            if processed:
+                break
+
+            current_argument = processor.chain_to(command_arguments)
+
+            if current_argument is None:
+                break
+
+        if not processed:
+            error("Domino CLI was not able to process your secret management request")

domino_cli-2.4.0/domino_cli/core/command/dsl/dsm/DSLCreate.py

@@ -0,0 +1,37 @@
+from getpass import getpass
+from typing import List
+
+from domino_cli.core.cli.Logging import error
+from domino_cli.core.cli.RuntimeHelper import RuntimeHelper
+from domino_cli.core.command.dsl.dsm.DSLMain import SecretCommandProcessor
+from domino_cli.core.service.SecretService import SecretService
+
+
+class CreateSecretCommandProcessor(SecretCommandProcessor):
+    """
+    SecretCommandProcessor implementation to process the --create <key> <context> secret management command.
+    """
+    def __init__(self, secret_service: SecretService):
+        self._secret_service = secret_service
+
+    def process(self, arguments: List[str]) -> bool:
+
+        RuntimeHelper.unsupported_in_cicd_mode()
+
+        if not len(arguments) == 2:
+            error("Invalid arguments, expected usage: secret --create <key> <context> (then you'll be prompted to enter the secret value)")
+            return False
+
+        key = arguments.pop(0)
+        context = arguments.pop(0)
+        value = RuntimeHelper.input_wrapper(lambda: getpass('Enter secret value > '))
+
+        self._secret_service.create_secret(key, context, value)
+
+        return True
+
+    def chain_to(self, arguments: List[str]) -> str | None:
+        return None
+
+    def for_subcommand(self) -> str:
+        return "--create"

domino_cli-2.4.0/domino_cli/core/command/dsl/dsm/DSLDelete.py

@@ -0,0 +1,33 @@
+from typing import List
+
+from domino_cli.core.cli.Logging import error
+from domino_cli.core.cli.RuntimeHelper import RuntimeHelper
+from domino_cli.core.command.dsl.dsm.DSLMain import SecretCommandProcessor
+from domino_cli.core.service.SecretService import SecretService
+
+
+class DeleteSecretCommandProcessor(SecretCommandProcessor):
+    """
+    SecretCommandProcessor implementation to process the --delete <key> secret management command.
+    """
+    def __init__(self, secret_service: SecretService):
+        self._secret_service = secret_service
+
+    def process(self, arguments: List[str]) -> bool:
+
+        RuntimeHelper.unsupported_in_cicd_mode()
+
+        if not len(arguments) == 1:
+            error("Invalid arguments, expected usage: secret --delete <key>")
+            return False
+
+        key = arguments.pop(0)
+        self._secret_service.delete_secret(key)
+
+        return True
+
+    def chain_to(self, arguments: List[str]) -> str | None:
+        return None
+
+    def for_subcommand(self) -> str:
+        return "--delete"

domino_cli-2.4.0/domino_cli/core/command/dsl/dsm/DSLLocking.py

@@ -0,0 +1,59 @@
+from typing import List
+
+from domino_cli.core.cli.Logging import error
+from domino_cli.core.cli.RuntimeHelper import RuntimeHelper
+from domino_cli.core.command.dsl.dsm.DSLMain import SecretCommandProcessor
+from domino_cli.core.service.SecretService import SecretService
+
+
+class LockSecretCommandProcessor(SecretCommandProcessor):
+    """
+    SecretCommandProcessor implementation to process the --lock <key> secret management command.
+    """
+    def __init__(self, secret_service: SecretService):
+        self._secret_service = secret_service
+
+    def process(self, arguments: List[str]) -> bool:
+
+        RuntimeHelper.unsupported_in_cicd_mode()
+
+        if not len(arguments) == 1:
+            error("Invalid arguments, expected usage: secret --lock <key>")
+            return False
+
+        key = arguments.pop(0)
+        self._secret_service.lock_secret(key)
+
+        return True
+
+    def chain_to(self, arguments: List[str]) -> str | None:
+        return None
+
+    def for_subcommand(self) -> str:
+        return "--lock"
+
+class UnlockSecretCommandProcessor(SecretCommandProcessor):
+    """
+    SecretCommandProcessor implementation to process the --unlock <key> secret management command.
+    """
+    def __init__(self, secret_service: SecretService):
+        self._secret_service = secret_service
+
+    def process(self, arguments: List[str]) -> bool:
+
+        RuntimeHelper.unsupported_in_cicd_mode()
+
+        if not len(arguments) == 1:
+            error("Invalid arguments, expected usage: secret --unlock <key>")
+            return False
+
+        key = arguments.pop(0)
+        self._secret_service.unlock_secret(key)
+
+        return True
+
+    def chain_to(self, arguments: List[str]) -> str | None:
+        return None
+
+    def for_subcommand(self) -> str:
+        return "--unlock"

domino_cli-2.4.0/domino_cli/core/command/dsl/dsm/DSLMain.py

@@ -0,0 +1,68 @@
+from abc import ABCMeta, abstractmethod
+from typing import List
+
+from domino_cli.core.cli.Logging import error
+
+
+class SecretCommandProcessor(object, metaclass=ABCMeta):
+    """
+    DSL processor interface for secret management commands.
+    """
+    @abstractmethod
+    def process(self, arguments: List[str]) -> bool:
+        """
+        Final state of the command, executes the recognized management operation.
+
+        :param arguments: current command argument list
+        :return: boolean flag indicating if the command was processed
+        """
+        pass
+
+    @abstractmethod
+    def chain_to(self, arguments: List[str]) -> str | None:
+        """
+        Defines the further chaining logic. Returns none if further chaining is not possible either because of an error,
+        or if the chain reached a final state. May drop the first argument of the list.
+
+        :param arguments: current command argument list
+        :return: next processor name or None if further chaining is not possible
+        """
+        pass
+
+    @abstractmethod
+    def for_subcommand(self) -> str:
+        """
+        Indicates the processor name to be used in chaining.
+
+        :return: processor name
+        """
+        pass
+
+class MainSecretCommandProcessor(SecretCommandProcessor):
+    """
+    Main command processor, i.e. the entry point of secret management command processing. Entry argument token is
+    "secret", and may move on to any of the known commands (--create, --metadata, --retrieve, --lock, --unlock, --delete).
+    """
+
+    valid_subcommands = ["--create", "--metadata", "--retrieve", "--lock", "--unlock", "--delete"]
+
+    def process(self, arguments: List[str]) -> bool:
+        return False
+
+    def chain_to(self, arguments: List[str]) -> str | None:
+
+        if len(arguments) == 0:
+            error(f"Too few arguments, first argument must be either: {" | ".join(self.valid_subcommands)}")
+            return None
+
+        subcommand = arguments.pop(0)
+
+        if subcommand not in self.valid_subcommands:
+            error(f"Invalid subcommand, first argument must be either: {" | ".join(self.valid_subcommands)}")
+            return None
+
+        else:
+            return subcommand
+
+    def for_subcommand(self) -> str:
+        return "secret"

domino_cli-2.4.0/domino_cli/core/command/dsl/dsm/DSLMetadata.py

@@ -0,0 +1,78 @@
+from typing import List
+
+from domino_cli.core.cli.Logging import error
+from domino_cli.core.cli.RuntimeHelper import RuntimeHelper
+from domino_cli.core.command.dsl.dsm.DSLMain import SecretCommandProcessor
+from domino_cli.core.service.SecretService import SecretService
+
+
+class MetadataCommandProcessor(SecretCommandProcessor):
+    """
+    SecretCommandProcessor implementation to process the --metadata secret management command. Chains forward to --all
+    and <key> subcommands.
+    """
+
+    def process(self, arguments: List[str]) -> bool:
+
+        RuntimeHelper.unsupported_in_cicd_mode()
+
+        return False
+
+    def chain_to(self, arguments: List[str]) -> str | None:
+
+        if len(arguments) == 0:
+            error(f"Too few arguments, first argument must be either: --all | <key>")
+            return None
+
+        return "--metadata --all" \
+            if arguments[0] == "--all" \
+            else "--metadata <key>"
+
+    def for_subcommand(self) -> str:
+        return "--metadata"
+
+class MetadataAllCommandProcessor(SecretCommandProcessor):
+    """
+    SecretCommandProcessor implementation to process the --metadata --all secret management command.
+    """
+    def __init__(self, secret_service: SecretService):
+        self._secret_service = secret_service
+
+    def process(self, arguments: List[str]) -> bool:
+
+        RuntimeHelper.unsupported_in_cicd_mode()
+        self._secret_service.get_all_metadata()
+
+        return True
+
+    def chain_to(self, arguments: List[str]) -> str | None:
+        return None
+
+    def for_subcommand(self) -> str:
+        return "--metadata --all"
+
+class MetadataKeyCommandProcessor(SecretCommandProcessor):
+    """
+    SecretCommandProcessor implementation to process the --metadata <key> secret management command.
+    """
+    def __init__(self, secret_service: SecretService):
+        self._secret_service = secret_service
+
+    def process(self, arguments: List[str]) -> bool:
+
+        RuntimeHelper.unsupported_in_cicd_mode()
+
+        if not len(arguments) == 1:
+            error("Invalid arguments, expected usage: secret --metadata <key>")
+            return False
+
+        key = arguments.pop(0)
+        self._secret_service.get_metadata_by_key(key)
+
+        return True
+
+    def chain_to(self, arguments: List[str]) -> str | None:
+        return None
+
+    def for_subcommand(self) -> str:
+        return "--metadata <key>"

domino_cli-2.4.0/domino_cli/core/command/dsl/dsm/DSLRetrieval.py

@@ -0,0 +1,86 @@
+from typing import List
+
+from domino_cli.core.cli.Logging import error
+from domino_cli.core.command.dsl.dsm.DSLMain import SecretCommandProcessor
+from domino_cli.core.service.SecretService import SecretService
+
+
+class RetrievalSecretCommandProcessor(SecretCommandProcessor):
+    """
+    SecretCommandProcessor implementation to process the --retrieve secret management command. Chains forward to --key
+    or --context subcommands.
+    """
+
+    valid_subcommands = ["--key", "--context"]
+
+    def process(self, arguments: List[str]) -> bool:
+        return False
+
+    def chain_to(self, arguments: List[str]) -> str | None:
+
+        if len(arguments) < 1:
+            error(f"Too few arguments, must be either: --key <key> | --context <context>")
+            return None
+
+        if len(arguments) > 2:
+            error(f"Too many arguments, must be either: --key <key> | --context <context>")
+            return None
+
+        subcommand = arguments.pop(0)
+
+        if subcommand not in self.valid_subcommands:
+            error(f"Invalid subcommand, first argument must be either: {" | ".join(self.valid_subcommands)}")
+            return None
+
+        return f"--retrieve {subcommand}"
+
+    def for_subcommand(self) -> str:
+        return "--retrieve"
+
+class RetrieveByKeySecretCommandProcessor(SecretCommandProcessor):
+    """
+    SecretCommandProcessor implementation to process the --retrieve --key <key> secret management command.
+    """
+    def __init__(self, secret_service: SecretService):
+        self._secret_service = secret_service
+
+    def process(self, arguments: List[str]) -> bool:
+
+        if not len(arguments) == 1:
+            error("Invalid arguments, expected usage: secret --retrieve --key <key>")
+            return False
+
+        key = arguments.pop(0)
+        self._secret_service.retrieve_secret_by_key(key)
+
+        return True
+
+    def chain_to(self, arguments: List[str]) -> str | None:
+        return None
+
+    def for_subcommand(self) -> str:
+        return "--retrieve --key"
+
+class RetrieveByContextSecretCommandProcessor(SecretCommandProcessor):
+    """
+    SecretCommandProcessor implementation to process the --retrieve --context <context> secret management command.
+    """
+    def __init__(self, secret_service: SecretService):
+        self._secret_service = secret_service
+
+    def process(self, arguments: List[str]) -> bool:
+
+        if not len(arguments) == 1:
+            error("Invalid arguments, expected usage: secret --retrieve --context <context>")
+            return False
+
+        context = arguments.pop(0)
+        self._secret_service.retrieve_secrets_by_context(context)
+
+        return True
+
+    def chain_to(self, arguments: List[str]) -> str | None:
+        return None
+
+    def for_subcommand(self) -> str:
+        return "--retrieve --context"

{domino_cli-2.3.0 → domino_cli-2.4.0}/domino_cli/core/domain/DominoCommand.py

@@ -25,3 +25,12 @@ class DominoCommand(Enum):
     DEPLOY_VERSION = DominoRequestDescriptor(HTTPMethod.PUT, "/lifecycle/{0}/deploy/{1}")
     INFO = DominoRequestDescriptor(HTTPMethod.GET, "/lifecycle/{0}/info")
     IMPORT = DominoRequestDescriptor(HTTPMethod.POST, "/deployments/import")
+
+    RETRIEVE_ALL_METADATA = DominoRequestDescriptor(HTTPMethod.GET, "/secrets")
+    RETRIEVE_SECRET = DominoRequestDescriptor(HTTPMethod.GET, "/secrets/{0}")
+    RETRIEVE_SECRET_METADATA = DominoRequestDescriptor(HTTPMethod.GET, "/secrets/{0}/metadata")
+    RETRIEVE_SECRETS_BY_CONTEXT = DominoRequestDescriptor(HTTPMethod.GET, "/secrets/context/{0}")
+    CREATE_SECRET = DominoRequestDescriptor(HTTPMethod.POST, "/secrets")
+    LOCK_SECRET = DominoRequestDescriptor(HTTPMethod.DELETE, "/secrets/{0}/retrieval")
+    UNLOCK_SECRET = DominoRequestDescriptor(HTTPMethod.PUT, "/secrets/{0}/retrieval")
+    DELETE_SECRET = DominoRequestDescriptor(HTTPMethod.DELETE, "/secrets/{0}")

{domino_cli-2.3.0 → domino_cli-2.4.0}/domino_cli/core/domain/DominoRequest.py

@@ -14,3 +14,14 @@ class DominoRequest:
 
     def __repr__(self):
         return "[{0} {1}]".format(self.method.value, self.path)
+
+    def __eq__(self, other):
+
+        if other is None:
+            return False
+
+        return self.method == other.method \
+            and self.path == other.path \
+            and self.body == other.body \
+            and self.as_text == other.as_text \
+            and self.authenticated == other.authenticated