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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: domino-cli
-Version: 2.2.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
@@ -184,6 +184,73 @@ info <app>
 ```
 Instructs Domino to query the application's info endpoint and returns the results.
 
+### Deployment definition management commands
+
+```
+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.2.0 → domino_cli-2.4.0}/README.md

@@ -166,6 +166,73 @@ info <app>
 ```
 Instructs Domino to query the application's info endpoint and returns the results.
 
+### Deployment definition management commands
+
+```
+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.2.0 → domino_cli-2.4.0}/domino_cli/__init__.py

@@ -2,19 +2,10 @@
 domino_cli.py :: Main entry point for Domino CLI application.
 """
 
-__version__ = "2.2.0"
-
-import os
+__version__ = "2.4.0"
 
 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.2.0 → domino_cli-2.4.0}/domino_cli/core/ApplicationContext.py

@@ -8,17 +8,28 @@ 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.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
@@ -90,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, [
@@ -111,9 +123,23 @@ class ApplicationContext:
         _command_stop_app = StopApplicationCommand(_domino_service)
         _command_restart_app = RestartApplicationCommand(_domino_service)
         _command_deploy_app = DeployApplicationCommand(_domino_service)
+        _command_import = ImportCommand(_domino_service)
         _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, [
@@ -124,8 +150,10 @@ class ApplicationContext:
             _command_restart_app,
             _command_start_app,
             _command_stop_app,
+            _command_import,
             _command_wizard,
-            _command_info
+            _command_info,
+            _command_secret
         ])
 
         _cli = CLI(_command_processor)

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

@@ -26,7 +26,14 @@ class DominoClient:
         :return: Response object
         """
         resolved_path = urllib.parse.urljoin(self._domino_base_url, domino_request.path)
-        json_body = domino_request.body
+        headers = {"Content-Type": "text/plain"} \
+            if domino_request.as_text \
+            else {"Content-Type": "application/json"}
         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)
+        if auth:
+            headers.update(auth)
+
+        return requests.request(domino_request.method.value, resolved_path, headers=headers,
+                                json=None if domino_request.as_text else domino_request.body,
+                                data=domino_request.body if domino_request.as_text else None)

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

@@ -1,4 +1,5 @@
-from domino_cli.core.cli.Logging import warning
+from domino_cli.core.cli.Logging import error
+from domino_cli.core.cli.RuntimeHelper import RuntimeHelper
 from domino_cli.core.command.AbstractCommand import AbstractCommand
 from domino_cli.core.domain.CommandDescriptor import CommandDescriptor
 from domino_cli.core.domain.DominoCommand import DominoCommand
@@ -26,7 +27,9 @@ class DeployApplicationCommand(AbstractCommand):
         :param command_descriptor: CommandDescriptor object containing the command arguments
         """
         if not len(command_descriptor.arguments) == 2:
-            warning("Application name and 'latest' keyword or explicit version is required")
+            error("Application name and 'latest' keyword or explicit version is required")
+            RuntimeHelper.exit_with_error_in_cicd_mode()
+
         else:
             application: str = command_descriptor.arguments[0]
             version: str = command_descriptor.arguments[1]

{domino_cli-2.2.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/ImportCommand.py

@@ -0,0 +1,29 @@
+from domino_cli.core.cli.Logging import error
+from domino_cli.core.cli.RuntimeHelper import RuntimeHelper
+from domino_cli.core.command.AbstractCommand import AbstractCommand
+from domino_cli.core.domain.CommandDescriptor import CommandDescriptor
+from domino_cli.core.service.DominoService import DominoService
+
+_COMMAND_NAME = "import"
+
+
+class ImportCommand(AbstractCommand):
+    """
+    Command implementation to import a deployment definition from static YAML configuration file.
+    """
+    def __init__(self, domino_service: DominoService):
+        super().__init__(_COMMAND_NAME)
+        self._domino_service = domino_service
+
+    def execute_command(self, command_descriptor: CommandDescriptor) -> None:
+
+        if len(command_descriptor.arguments) > 1:
+            error("Too many arguments, expected command usage is 'import optional/path/to/deployment.yml' (defaults to '.domino/deployment.yml' without argument)")
+            RuntimeHelper.exit_with_error_in_cicd_mode()
+            return
+
+        definition_path = command_descriptor.arguments[0] \
+            if len(command_descriptor.arguments) == 1 \
+            else None
+
+        self._domino_service.import_definition(definition_path)

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>"