chore: config generator tool

README.md

@@ -386,7 +386,15 @@ to specify the directory containing the [configuration file](#configyml).
 
 Several configuration files are used to control the behavior of the exporter.
 
-#### `config.yml`
+#### Guided configuration
+
+In order to simplify the configuration process, we provided a CLI application:
+The [ConfTool](./conftool/).
+
+Please follow the provided instructions in the [README](./conftool/README.md) for
+installation and usage.
+
+#### Manual configuration
 
 The main configuration for the exporter is the `config.yml` file. In fact, it
 does not need to be named `config.yml` although that is the default name if a
@@ -595,6 +603,17 @@ The `labels` parameter is a set of key/value pairs. The value of this parameter
 is a YAML mapping. Each key/value pair is added to all logs and events generated
 by the exporter.
 
+###### `service_schedule`
+
+| Description | Valid Values | Required | Default |
+| --- | --- | --- | --- |
+| Schedule configuration used by the built-in scheduler | YAML Mapping | N | N/a |
+
+Instance-specific service schedule configuration. When present it has precedence
+over the general `service_schedule` config.
+
+Check [`service_schedule`](#service_schedule) for format description.
+
 ##### Instance arguments
 
 The main configuration of an instance is specified in the `arguments` attribute

conftool/.gitignore

@@ -0,0 +1,2 @@
+*.yml
+*.yaml

conftool/README.md

@@ -0,0 +1,45 @@
+# ConfTool
+
+Configuration tool for the New Relic Salesforce Exporter.
+
+## Requirements
+
+Tested with Python versions 3.9 and 3.13.
+
+## Install
+
+From `conftool` folder:
+
+- Create a virtual environment ([venv](https://virtualenv.pypa.io/en/latest/installation.html) is required):
+
+    ```
+    python<version> -m venv my_env
+    ```
+
+- Activate the environment:
+
+    ```
+    source my_env/bin/activate
+    ```
+
+- Then install dependencies:
+
+    ```
+    pip install -r requirements.txt
+    ```
+
+## Usage
+
+From repo's root folder.
+
+1. To create new config file:
+
+    ```
+    python -m conftool path/to/config.yml
+    ```
+
+1. To validate an existing config file:
+
+    ```
+    python -m conftool path/to/config.yml --check
+    ```

conftool/__init__.py

@@ -0,0 +1 @@
+VERSION         = "0.1.0"

conftool/__main__.py

@@ -0,0 +1,111 @@
+from conftool.model.data_format import DataFormatModel
+from . import VERSION
+from .model.config import ConfigModel
+from .model.exception import ConfigException
+from .form import questionnaire
+from .form.format import print_warning, print_fail, print_ok
+from .form.text import t_warning_missing_auth, t_warning_missing_account_id, \
+                       t_warning_missing_license
+
+import argparse
+import os.path
+
+TITLE = f"New Relic Salesforce Exporter Config Tool {VERSION}"
+DESCRIPTION = f"{TITLE}. Create or check configuration files."
+
+def main():
+    parser = argparse.ArgumentParser(description=DESCRIPTION)
+    parser.add_argument('config_file', type=str, help='File path. Config YAML file to create or check.')
+    parser.add_argument('-c', '--check', action='store_true', help='Check configuration.')
+    args = parser.parse_args()
+
+    print(f"{TITLE}\n")
+
+    if args.check:
+        check_config(args.config_file)
+    else:
+        create_config(args.config_file)
+
+def create_config(config_file: str):
+    print("Creating new config file...\n")
+
+    if os.path.isfile(config_file):
+        print("Error: Config file already exists.")
+        exit(1)
+
+    try:
+        conf = questionnaire.run()
+    except KeyboardInterrupt:
+        print("\nAborted.")
+        exit(1)
+
+    conf_yml = conf.to_yaml()
+
+    print_config(conf_yml)
+
+    try:
+        with open(config_file, "w+") as file:
+            try:
+                file.write(conf_yml)
+                file.close()
+            except (IOError, OSError):
+                print("Error: Could not write to file.")
+                exit(1)
+    except (FileNotFoundError, PermissionError, OSError):
+        print("Error: Could not open file.")
+        exit(1)
+
+    print_ok("Done.")
+    print()
+
+def check_config(config_file: str):
+    print("Validating config file...\n")
+
+    if not os.path.isfile(config_file):
+        print("Error: Config file doesn't exist.")
+        exit(1)
+
+    try:
+        config_yaml_str = read_file(config_file)
+    except Exception as err:
+        print("Error opening file:", err)
+        exit(1)
+
+    try:
+        config_model = ConfigModel.from_yaml(config_yaml_str)
+    except ConfigException as err:
+        print_fail(str(err))
+        print()
+        exit(1)
+
+    for index,i in enumerate(config_model.instances):
+        if i.arguments.auth is None:
+            print(f"At instance #{index + 1}:")
+            print_warning(t_warning_missing_auth)
+            print()
+
+    if  config_model.newrelic.data_format == DataFormatModel.EVENTS and \
+        config_model.newrelic.account_id is None:
+        print_warning(t_warning_missing_account_id)
+
+    if config_model.newrelic.license_key is None:
+        print_warning(t_warning_missing_license)
+
+    # Serialize model into YAML
+    serialized_yaml = config_model.to_yaml()
+    print_config(serialized_yaml)
+
+    print_ok("Validation OK!")
+    print()
+
+def read_file(file_name: str) -> str:
+    with open(file_name) as file:
+        return file.read()
+
+def print_config(conf):
+    print('---- CONFIG FILE:\n')
+    print(conf)
+    print('----')
+    print()
+
+if __name__ == "__main__": main()

conftool/form/format.py

@@ -0,0 +1,30 @@
+class Color:
+    BG_RED = '\x1b[41m'
+    FG_BOLD_RED = '\x1b[1;31m'
+
+    FG_BOLD_WHITE = '\x1b[1;37m'
+
+    BG_BLUE = '\x1b[44m'
+
+    BG_YELLOW = '\x1b[43m'
+
+    FG_BOLD_BLACK = '\x1b[1;30m'
+
+    FG_BOLD_GREEN = '\x1b[1;32m'
+
+    RESET = '\x1b[0m'
+
+def print_title(msg: str):
+    print(Color.BG_RED + Color.FG_BOLD_WHITE + ' ' + msg + ' ' + Color.RESET + '\n')
+
+def print_statement(msg: str):
+    print(Color.BG_BLUE + Color.FG_BOLD_WHITE + msg + Color.RESET + "\n")
+
+def print_warning(msg: str):
+    print(Color.BG_YELLOW + Color.FG_BOLD_BLACK + "WARNING: " + msg + Color.RESET + "\n")
+
+def print_fail(msg: str):
+    print(Color.FG_BOLD_RED + "FAILED: " + msg + Color.RESET)
+
+def print_ok(msg: str):
+    print(Color.FG_BOLD_GREEN + msg + Color.RESET)

conftool/form/prompt.py

@@ -0,0 +1,146 @@
+from prompt_toolkit.validation import Validator, ValidationError
+from prompt_toolkit import prompt
+
+def prompt_list(message: str, options: list[str], required: bool) -> int:
+    for i,option in enumerate(options):
+        print(str(i+1) + ") " + str(option))
+    validator = ListNumberValidator(1, len(options), not required)
+    response = prompt(message + " ", validator=validator)
+    if response is None or response == "":
+        return None
+    else:
+        return int(response)
+
+def prompt_int(message: str, min: int, max: int, required: bool) -> int:
+    validator = NumberRangeValidator(min, max, not required)
+    response = prompt(message + " ", validator=validator)
+    if response is None or response == "":
+        return None
+    else:
+        return int(response)
+
+def prompt_bool(message: str, required: bool) -> int:
+    validator = BooleanValidator(not required)
+    response = prompt(message + " ", validator=validator)
+    if response is None or response == "":
+        return None
+    else:
+        return response == "y" or response == "Y"
+
+def prompt_str(message: str, checker, required: bool) -> int:
+    validator = StringValidator(checker, not required)
+    response = prompt(message + " ", validator=validator)
+    if response == "":
+        return None
+    else:
+        return response
+
+def prompt_any(message: str, required: bool) -> int:
+    validator = SkippableValidator(not required)
+    response = prompt(message + " ", validator=validator)
+    if response == "":
+        return None
+    else:
+        return response
+
+class SkippableValidator(Validator):
+    skippable: bool
+
+    def __init__(self, skippable: bool):
+        self.skippable = skippable
+        super().__init__()
+
+    def validate(self, document):
+        text = document.text
+        if not self.skippable and (text is None or text == ""):
+            raise ValidationError(
+                message=f"Input can't be empty",
+                cursor_position=0
+            )
+
+    def can_skip(self, text):
+        return self.skippable and (text is None or text == "")
+
+class ListNumberValidator(SkippableValidator):
+    min: int
+    max: int
+
+    def __init__(self, min: int, max: int, skippable: bool):
+        super().__init__(skippable)
+        self.min = min
+        self.max = max
+
+    def validate(self, document):
+        super().validate(document)
+        text = document.text
+        if self.can_skip(text):
+            return
+        if not self.digit_in_range(text):
+            raise ValidationError(
+                message="Input must be a number in the list",
+                cursor_position=0
+            )
+
+    def digit_in_range(self, text: str) -> bool:
+        if text.isdecimal():
+            n = int(text)
+            return n >= self.min and n <= self.max
+        else:
+            return False
+
+class NumberRangeValidator(SkippableValidator):
+    min: int
+    max: int
+
+    def __init__(self, min: int, max: int, skippable: bool):
+        super().__init__(skippable)
+        self.min = min
+        self.max = max
+
+    def validate(self, document):
+        super().validate(document)
+        text = document.text
+        if self.can_skip(text):
+            return
+        if not self.number_in_range(text):
+            raise ValidationError(
+                message=f"Input must be a number in the range [{self.min},{self.max}]",
+                cursor_position=0
+            )
+
+    def number_in_range(self, text: str) -> bool:
+        if text.isdecimal():
+            n = int(text)
+            return n >= self.min and n <= self.max
+        else:
+            return False
+
+class BooleanValidator(SkippableValidator):
+    def validate(self, document):
+        super().validate(document)
+        text = document.text
+        if self.can_skip(text):
+            return
+        if text not in {"y", "Y", "n", "N"}:
+            raise ValidationError(
+                message=f"Input must be a 'Y', 'y', 'N' or 'n'",
+                cursor_position=0
+            )
+
+class StringValidator(SkippableValidator):
+    checker: None
+
+    def __init__(self, checker, skippable: bool):
+        super().__init__(skippable)
+        self.checker = checker
+
+    def validate(self, document):
+        super().validate(document)
+        text = document.text
+        if self.can_skip(text):
+            return
+        if not self.checker(text):
+            raise ValidationError(
+                message=f"Wrong format",
+                cursor_position=0
+            )