RED-4653: Reworked the configuration as a plain python object

pyinfra/config.py

@@ -1,55 +1,54 @@
-"""Implements a config object with dot-indexing syntax."""
-import os
-from itertools import chain
-from operator import truth
-
-from envyaml import EnvYAML
-from funcy import first, juxt, butlast, last
-
-from pyinfra.locations import CONFIG_FILE
+from os import environ
 
 
-def _get_item_and_maybe_make_dotindexable(container, item):
-    ret = container[item]
-    return DotIndexable(ret) if isinstance(ret, dict) else ret
+def read_from_environment(environment_variable_name, default_value):
+    return environ.get(environment_variable_name, default_value)
 
 
-class DotIndexable:
-    def __init__(self, x):
-        self.x = x
+class Config(object):
+    def __init__(self):
+        # Logging level for service logger
+        self.logging_level_root = read_from_environment("LOGGING_LEVEL_ROOT", "DEBUG")
 
-    def __getattr__(self, item):
-        return _get_item_and_maybe_make_dotindexable(self.x, item)
+        # RabbitMQ host address
+        self.rabbitmq_host = read_from_environment("RABBITMQ_HOST", "localhost")
 
-    def __repr__(self):
-        return self.x.__repr__()
+        # RabbitMQ host port
+        self.rabbitmq_port = read_from_environment("RABBITMQ_PORT", "5672")
 
-    def __getitem__(self, item):
-        return self.__getattr__(item)
+        # RabbitMQ username
+        self.rabbitmq_username = read_from_environment("RABBITMQ_USERNAME", "user")
 
+        # RabbitMQ password
+        self.rabbitmq_password = read_from_environment("RABBITMQ_PASSWORD", "bitnami")
 
-class Config:
-    def __init__(self, config_path):
-        self.__config = EnvYAML(config_path)
+        # Controls AMQP heartbeat timeout in seconds
+        self.rabbitmq_heartbeat = read_from_environment("RABBITMQ_HEARTBEAT", "7200")
 
-    def __getattr__(self, item):
-        if item in self.__config:
-            return _get_item_and_maybe_make_dotindexable(self.__config, item)
+        # Queue name for requests to the service
+        self.request_queue = read_from_environment("REQUEST_QUEUE", "request_queue")
 
-    def __getitem__(self, item):
-        return self.__getattr__(item)
+        # Queue name for responses by service
+        self.response_queue = read_from_environment("RESPONSE_QUEUE", "response_queue")
 
+        # Queue name for failed messages
+        self.dead_letter_queue = read_from_environment("DEAD_LETTER_QUEUE", "dead_letter_queue")
 
-CONFIG = Config(CONFIG_FILE)
+        # The type of storage to use {s3, azure}
+        self.storage_backend = read_from_environment("STORAGE_BACKEND", "s3")
 
+        # The bucket / container to pull files specified in queue requests from
+        self.storage_bucket = read_from_environment("STORAGE_BUCKET", "pyinfra-test-bucket")
 
-def parse_disjunction_string(disjunction_string):
-    def try_parse_env_var(disjunction_string):
-        try:
-            return os.environ[disjunction_string]
-        except KeyError:
-            return None
+        # Endpoint for s3 storage
+        self.storage_endpoint = read_from_environment("STORAGE_ENDPOINT", "http://127.0.0.1:9000")
 
-    options = disjunction_string.split("|")
-    identifiers, fallback_value = juxt(butlast, last)(options)
-    return first(chain(filter(truth, map(try_parse_env_var, identifiers)), [fallback_value]))
+        # User for s3 storage
+        self.storage_key = read_from_environment("STORAGE_KEY", "root")
+
+        # Password for s3 storage
+        self.storage_secret = read_from_environment("STORAGE_SECRET", "password")
+
+        # Connection string for Azure storage
+        self.storage_azureconnectionstring = read_from_environment("STORAGE_AZURECONNECTIONSTRING",
+                                                                   "DefaultEndpointsProtocol=...")