common.config_manager

  1import itertools
  2import threading
  3import pickle
  4import time
  5import json
  6
  7from pymemcache.client.base import Client as MemcacheClient
  8from pymemcache.exceptions import MemcacheError
  9from pymemcache import serde
 10from pathlib import Path
 11from common.lib.database import Database
 12
 13from common.lib.exceptions import ConfigException
 14from common.lib.config_definition import config_definition
 15
 16import configparser
 17import os
 18
 19class CacheMiss:
 20    """
 21    Helper class to distinguish memcache misses from true `None` values
 22    """
 23    pass
 24
 25class BaseConfigReader:
 26    """
 27    Helper class to unify various types of configuration readers
 28    """
 29    pass
 30
 31class ConfigManager(BaseConfigReader):
 32    db = None
 33    dbconn = None
 34    cache = {}
 35    logger = None
 36
 37    core_settings = {}
 38    config_definition = {}
 39    # Thread-local storage for a singleton memcache client per thread.
 40    # Prevents creating a new TCP connection per request in threaded/gunicorn contexts.
 41    _memcache_tls = threading.local()
 42
 43    def __init__(self, db=None):
 44        # ensure core settings (including database config) are loaded
 45        self.load_core_settings()
 46        self.load_user_settings()
 47        # Do not create a memcache client here; get_memcache() will lazily create per-thread.
 48
 49        # establish database connection if none available
 50        if db:
 51            self.with_db(db)
 52
 53    def with_db(self, db=None):
 54        """
 55        Initialise database
 56
 57        Not done on init, because something may need core settings before the
 58        database can be initialised
 59
 60        :param db:  Database object. If None, initialise it using the core config
 61        """
 62        if db or not self.db:
 63            if db and db.log and not self.logger:
 64                # borrow logger from database
 65                self.with_logger(db.log)
 66
 67            # Replace w/ db if provided else only initialise if not already
 68            self.db = db if db else Database(logger=self.logger, dbname=self.get("DB_NAME"), user=self.get("DB_USER"),
 69                                         password=self.get("DB_PASSWORD"), host=self.get("DB_HOST"),
 70                                         port=self.get("DB_PORT"), appname="config-reader")
 71        else:
 72            # self.db already initialized and no db provided
 73            pass
 74
 75    def with_logger(self, logger):
 76        """
 77        Attach logger to config manager
 78
 79        4CAT's logger has some features on top of the basic Python logger that
 80        are needed for further operation, e.g. the Debug2 log level.
 81
 82        :param Logger logger:
 83        """
 84        self.logger = logger
 85
 86    def load_user_settings(self):
 87        """
 88        Load settings configurable by the user
 89
 90        Does not load the settings themselves, but rather the definition so
 91        values can be validated, etc
 92        """
 93        # basic 4CAT settings
 94        self.config_definition.update(config_definition)
 95
 96        # module settings can't be loaded directly because modules need the
 97        # config manager to load, so that becomes circular
 98        # instead, this is cached on startup and then loaded here
 99        module_config_path = self.get("PATH_CONFIG").joinpath("module_config.bin")
100        if module_config_path.exists():
101            try:
102                with module_config_path.open("rb") as infile:
103                    retries = 0
104                    module_config = None
105                    # if 4CAT is being run in two different containers
106                    # (front-end and back-end) they might both be running this
107                    # bit of code at the same time. If the file is half-written
108                    # loading it will fail, so allow for a few retries
109                    while retries < 3:
110                        try:
111                            module_config = pickle.load(infile)
112                            break
113                        except Exception:  # this can be a number of exceptions, all with the same recovery path
114                            time.sleep(0.1)
115                            retries += 1
116                            continue
117
118                    if module_config is None:
119                        # not really a way to gracefully recover from this, but
120                        # we can at least describe the error
121                        raise RuntimeError("Could not read module_config.bin. The 4CAT developers did a bad job of "
122                                           "preventing this. Shame on them!")
123
124                    self.config_definition.update(module_config)
125            except (ValueError, TypeError):
126                pass
127
128    def load_core_settings(self):
129        """
130        Load 4CAT core settings
131
132        These are (mostly) stored in config.ini and cannot be changed from the
133        web interface.
134
135        :return:
136        """
137        config_file = Path(__file__).parent.parent.joinpath("config/config.ini")
138        config_reader = configparser.ConfigParser()
139        in_docker = False
140        if config_file.exists():
141            config_reader.read(config_file)
142            if config_reader["DOCKER"].getboolean("use_docker_config"):
143                # Can use throughtout 4CAT to know if Docker environment
144                in_docker = True
145        else:
146            # config should be created!
147            raise ConfigException("No config/config.ini file exists! Update and rename the config.ini-example file.")
148        
149        # Set up core settings
150        # Using Path.joinpath() will ensure paths are relative to ROOT_PATH or absolute (if /some/path is provided)
151        root_path = Path(os.path.abspath(os.path.dirname(__file__))).joinpath("..").resolve() # better don"t change this
152
153        self.core_settings.update({
154            "CONFIG_FILE": config_file.resolve(),
155            "USING_DOCKER": in_docker,
156            "DB_HOST": config_reader["DATABASE"].get("db_host"),
157            "DB_PORT": config_reader["DATABASE"].get("db_port"),
158            "DB_USER": config_reader["DATABASE"].get("db_user"),
159            "DB_NAME": config_reader["DATABASE"].get("db_name"),
160            "DB_PASSWORD": config_reader["DATABASE"].get("db_password"),
161
162            "API_HOST": config_reader["API"].get("api_host"),
163            "API_PORT": config_reader["API"].getint("api_port"),
164
165            "MEMCACHE_SERVER": config_reader.get("MEMCACHE", option="memcache_host", fallback=None),
166
167            "PATH_ROOT": root_path,
168            "PATH_CONFIG": root_path.joinpath("config"), # .current-version, config.ini are hardcoded here via docker/docker_setup.py and helper-scripts/migrate.py
169            "PATH_EXTENSIONS": root_path.joinpath("config/extensions"), # Must match setup.py and migrate.py
170            "PATH_LOGS": root_path.joinpath(config_reader["PATHS"].get("path_logs", "")),
171            "PATH_IMAGES": root_path.joinpath(config_reader["PATHS"].get("path_images", "")),
172            "PATH_DATA": root_path.joinpath(config_reader["PATHS"].get("path_data", "")),
173            "PATH_LOCKFILE": root_path.joinpath(config_reader["PATHS"].get("path_lockfile", "")),
174            "PATH_SESSIONS": root_path.joinpath(config_reader["PATHS"].get("path_sessions", "")),
175
176            "ANONYMISATION_SALT": config_reader["GENERATE"].get("anonymisation_salt"),
177            "SECRET_KEY": config_reader["GENERATE"].get("secret_key")
178        })
179
180
181    def get_memcache(self):
182        """
183        Get (or create) a thread-local memcache client
184
185        The config reader can optionally use Memcache to keep fetched values in
186        memory.
187        """
188        # Reuse per-thread client if already initialised.
189        existing = getattr(self._memcache_tls, "client", None)
190        if existing:
191            return existing
192
193        server = self.get("MEMCACHE_SERVER")
194        if server:
195            try:
196                memcache = MemcacheClient(server, serde=serde.pickle_serde, key_prefix=b"4cat-config")
197                # do one test fetch to test if connection is valid
198                memcache.set("4cat-init-dummy", time.time())
199                memcache.init_thread_id = threading.get_ident()
200                self._memcache_tls.client = memcache
201                return memcache
202            except (SystemError, ValueError, MemcacheError, ConnectionError, OSError):
203                # we have no access to the logger here so we simply pass
204                # later we can detect elsewhere that a memcache address is
205                # configured but no connection is there - then we can log
206                # config reader still works without memcache
207                pass
208
209        return None
210
211    def close_memcache(self):
212        """Close and dispose this thread's memcache client.
213
214        Call from gunicorn worker_exit or application teardown to ensure
215        sockets are closed explicitly instead of relying on GC/process exit.
216        """
217        client = getattr(self._memcache_tls, "client", None)
218        if client:
219            try:
220                client.close()
221            except Exception:
222                pass
223            finally:
224                try:
225                    del self._memcache_tls.client
226                except AttributeError:
227                    pass
228        
229
230    def ensure_database(self):
231        """
232        Ensure the database is in sync with the config definition
233
234        Deletes all stored settings not defined in 4CAT, and creates a global
235        setting for all settings not yet in the database.
236        """
237        self.with_db()
238
239        # create global values for known keys with the default
240        known_settings = self.get_all_setting_names()
241        for setting, parameters in self.config_definition.items():
242            if setting in known_settings:
243                continue
244
245            self.db.log.debug(f"Creating setting: {setting} with default value {parameters.get('default', '')}")
246            self.set(setting, parameters.get("default", ""))
247
248        # make sure settings and user table are in sync
249        user_tags = list(set(itertools.chain(*[u["tags"] for u in self.db.fetchall("SELECT DISTINCT tags FROM users")])))
250        known_tags = [t["tag"] for t in self.db.fetchall("SELECT DISTINCT tag FROM settings")]
251        tag_order = self.get("flask.tag_order")
252
253        for tag in known_tags:
254            # add tags used by a setting to tag order
255            if tag and tag not in tag_order:
256                tag_order.append(tag)
257
258        for tag in user_tags:
259            # add tags used by a user to tag order
260            if tag and tag not in tag_order:
261                tag_order.append(tag)
262
263        # admin tag should always be first in order
264        if "admin" in tag_order:
265            tag_order.remove("admin")
266
267        tag_order.insert(0, "admin")
268
269        self.set("flask.tag_order", tag_order)
270        self.db.commit()
271
272    def get_all_setting_names(self, with_core=True):
273        """
274        Get names of all settings
275
276        For when the value doesn't matter!
277
278        :param bool with_core:  Also include core (i.e. config.ini) settings
279        :return list:  List of setting names known by the database and core settings
280        """
281        # attempt to initialise the database connection so we can include
282        # user settings
283        if not self.db:
284            self.with_db()
285
286        settings = list(self.core_settings.keys()) if with_core else []
287        settings.extend([s["name"] for s in self.db.fetchall("SELECT DISTINCT name FROM settings")])
288
289        return settings
290
291    def get_all(self, is_json=False, user=None, tags=None, with_core=True, memcache=None):
292        """
293        Get all known settings
294
295        This is *not optimised* but used rarely enough that that doesn't
296        matter so much.
297
298        :param bool is_json:  if True, the value is returned as stored and not
299        interpreted as JSON if it comes from the database
300        :param user:  User object or name. Adds a tag `user:[username]` in
301        front of the tag list.
302        :param tags:  Tag or tags for the required setting. If a tag is
303        provided, the method checks if a special value for the setting exists
304        with the given tag, and returns that if one exists. First matching tag
305        wins.
306        :param bool with_core:  Also include core (i.e. config.ini) settings
307        :param MemcacheClient memcache:  Memcache client. If `None`, a thread-local client will be used.
308
309        :return dict: Setting value, as a dictionary with setting names as keys
310        and setting values as values.
311        """
312        for setting in self.get_all_setting_names(with_core=with_core):
313            yield setting, self.get(setting, None, is_json, user, tags, memcache)
314
315
316    def get(self, attribute_name, default=None, is_json=False, user=None, tags=None, memcache=None):
317        """
318        Get a setting's value from the database
319
320        If the setting does not exist, the provided fallback value is returned.
321
322        :param str attribute_name:  Setting to return.
323        :param default:  Value to return if setting does not exist
324        :param bool is_json:  if True, the value is returned as stored and not
325        interpreted as JSON if it comes from the database
326        :param user:  User object or name. Adds a tag `user:[username]` in
327        front of the tag list.
328        :param tags:  Tag or tags for the required setting. If a tag is
329        provided, the method checks if a special value for the setting exists
330        with the given tag, and returns that if one exists. First matching tag
331        wins.
332    :param MemcacheClient memcache:  Memcache client. If `None`, a thread-local client will be used.
333
334        :return:  Setting value, or the provided fallback, or `None`.
335        """
336        # core settings are not from the database
337        # they are therefore also not memcached - too little gain
338        if type(attribute_name) is not str:
339            raise TypeError(f"attribute_name must be a str, {attribute_name.__class__.__name__} given")
340
341        if attribute_name in self.core_settings:
342            # we never get to the database or memcache part of this method if
343            # this is a core setting we already know
344            return self.core_settings[attribute_name]
345
346        # if trying to access a setting that's not a core setting, attempt to
347        # initialise the database connection
348        if not self.db:
349            self.with_db()
350
351        # get tags to look for
352        # copy() because else we keep adding onto the same list, which
353        # interacts badly with get_all()
354        if tags:
355            tags = tags.copy()
356        tags = self.get_active_tags(user, tags, memcache)
357
358        # now we have all tags - get the config values for each (if available)
359        # and then return the first matching one. Add the 'empty' tag at the
360        # end to fall back to the global value if no specific one exists.
361        tags.append("")
362
363        # Obtain thread-local memcache client if not explicitly given.
364        if not memcache:
365            memcache = self.get_memcache()
366
367        # first check if we have all the values in memcache, in which case we
368        # do not need a database query
369        if memcache:
370            if threading.get_ident() != memcache.init_thread_id:
371                raise RuntimeError("Thread-unsafe use of memcache! Please make sure you are using a configuration "
372                                   "wrapper to read with a thread-local memcache connection.")
373
374            cached_values = {tag: memcache.get(self._get_memcache_id(attribute_name, tag), default=CacheMiss) for tag in tags}
375
376        else:
377            cached_values = {t: CacheMiss for t in tags}
378
379        # for the tags we could not get from memcache, run a database query
380        # (and save to cache if possible)
381        missing_tags = [t for t in cached_values if cached_values[t] is CacheMiss]
382        if missing_tags:
383            # query database for any values within the required tags
384            query = "SELECT * FROM settings WHERE name = %s AND tag IN %s"
385            replacements = (attribute_name, tuple(missing_tags))
386            queried_settings = {setting["tag"]: setting["value"] for setting in self.db.fetchall(query, replacements)}
387
388            if memcache:
389                for tag, value in queried_settings.items():
390                    memcache.set(self._get_memcache_id(attribute_name, tag), value)
391
392            cached_values.update(queried_settings)
393
394        # there may be some tags for which we still do not have a value at
395        # this point. these simply do not have a tag-specific value but that in
396        # itself is worth caching, otherwise we're going to query for a
397        # non-existent value each time.
398        # so: cache a magic value for such setting/tag combinations, and
399        # replace the magic value with a CacheMiss in the dict that will be
400        # parsed
401        unconfigured_magic = "__unconfigured__"
402        if memcache:
403            for tag in [t for t in cached_values if cached_values[t] is CacheMiss]:
404                # should this be more magic?
405                memcache.set(self._get_memcache_id(attribute_name, tag), unconfigured_magic)
406
407            for tag in [t for t in cached_values if cached_values[t] == unconfigured_magic]:
408                cached_values[tag] = CacheMiss
409
410        # now we may still have some CacheMisses in the values dict, if there
411        # was no setting in the database with that tag. So, find the first
412        # value that is not a CacheMiss. If nothing matches, try the global tag
413        # and if even that does not match (no setting saved at all) return the
414        # default
415        for tag in tags:
416            if tag in cached_values and cached_values.get(tag) is not CacheMiss:
417                value = cached_values[tag]
418                break
419        else:
420            value = None
421
422        # parse some values...
423        if not is_json and value is not None:
424            value = json.loads(value)
425        # TODO: Which default should have priority? The provided default feels like it should be the highest priority, but I think that is an old implementation and perhaps should be removed. - Dale
426        elif value is None and attribute_name in self.config_definition and "default" in self.config_definition[attribute_name]:
427            value = self.config_definition[attribute_name]["default"]
428        elif value is None and default is not None:
429            value = default
430
431        return value
432
433    def get_active_tags(self, user=None, tags=None, memcache=None):
434        """
435        Get active tags for given user/tag list
436
437        Used internally to harmonize tag setting for various methods, but can
438        also be called directly to verify tag activation.
439
440        :param user:  User object or name. Adds a tag `user:[username]` in
441        front of the tag list.
442        :param tags:  Tag or tags for the required setting. If a tag is
443        provided, the method checks if a special value for the setting exists
444        with the given tag, and returns that if one exists. First matching tag
445        wins.
446    :param MemcacheClient memcache:  Memcache client. If `None`, a thread-local client will be used.
447        :return list:  List of tags
448        """
449        # be flexible about the input types here
450        if tags is None:
451            tags = []
452        elif type(tags) is str:
453            tags = [tags]
454
455        user = self._normalise_user(user)
456
457        # user-specific settings are just a special type of tag (which takes
458        # precedence), same goes for user groups. so if a user was passed, get
459        # that user's tags (including the 'special' user: tag) and add them
460        # to the list
461        if user:
462            user_tags = CacheMiss
463            
464            if not memcache:
465                memcache = self.get_memcache()
466                
467            if memcache:
468                memcache_id = f"_usertags-{user}"
469                user_tags = memcache.get(memcache_id, default=CacheMiss)
470
471            if user_tags is CacheMiss:
472                user_tags = self.db.fetchone("SELECT tags FROM users WHERE name = %s", (user,))
473                if user_tags and memcache:
474                    memcache.set(memcache_id, user_tags)
475
476            if user_tags:
477                try:
478                    tags.extend(user_tags["tags"])
479                except (TypeError, ValueError):
480                    # should be a JSON list, but isn't
481                    pass
482
483            tags.insert(0, f"user:{user}")
484
485        return tags
486
487    def set(self, attribute_name, value, is_json=False, tag="", overwrite_existing=True, memcache=None):
488        """
489        Insert OR set value for a setting
490
491        If overwrite_existing=True and the setting exists, the setting is updated; if overwrite_existing=False and the
492        setting exists the setting is not updated.
493
494        :param str attribute_name:  Attribute to set
495        :param value:  Value to set (will be serialised as JSON)
496        :param bool is_json:  True for a value that is already a serialised JSON string; False if value is object that needs to
497                          be serialised into a JSON string
498        :param bool overwrite_existing: True will overwrite existing setting, False will do nothing if setting exists
499        :param str tag:  Tag to write setting for
500    :param MemcacheClient memcache:  Memcache client. If `None`, a thread-local client will be used.
501
502        :return int: number of updated rows
503        """
504        # Check value is valid JSON
505        if is_json:
506            try:
507                json.dumps(json.loads(value))
508            except json.JSONDecodeError:
509                return None
510        else:
511            try:
512                value = json.dumps(value)
513            except json.JSONDecodeError:
514                return None
515
516        if attribute_name in self.config_definition and self.config_definition.get(attribute_name).get("global"):
517            tag = ""
518
519        if overwrite_existing:
520            query = "INSERT INTO settings (name, value, tag) VALUES (%s, %s, %s) ON CONFLICT (name, tag) DO UPDATE SET value = EXCLUDED.value"
521        else:
522            query = "INSERT INTO settings (name, value, tag) VALUES (%s, %s, %s) ON CONFLICT DO NOTHING"
523
524        self.db.execute(query, (attribute_name, value, tag))
525        updated_rows = self.db.cursor.rowcount
526        self.db.log.debug(f"Updated setting for {attribute_name}: {value} (tag: {tag})")
527
528        if not memcache:
529            memcache = self.get_memcache()
530
531        if memcache:
532            # invalidate any cached value for this setting
533            memcache_id = self._get_memcache_id(attribute_name, tag)
534            memcache.delete(memcache_id)
535
536        return updated_rows
537
538    def delete_for_tag(self, attribute_name, tag):
539        """
540        Delete config override for a given tag
541
542        :param str attribute_name:
543        :param str tag:
544        :return int: number of deleted rows
545        """
546        self.db.delete("settings", where={"name": attribute_name, "tag": tag})
547        updated_rows = self.db.cursor.rowcount
548        client = self.get_memcache()
549        if client:
550            client.delete(self._get_memcache_id(attribute_name, tag))
551        return updated_rows
552
553    def clear_cache(self):
554        """
555        Clear cached configuration values
556
557        Called when the backend restarts - helps start with a blank slate.
558        """
559        client = self.get_memcache()
560        if not client:
561            return
562        client.flush_all()
563
564    def uncache_user_tags(self, users):
565        """
566        Clear cached user tags
567
568        User tags are cached with memcache if possible to avoid unnecessary
569        database roundtrips. This method clears the cached user tags, in case
570        a tag is added/deleted from a user.
571
572        :param list users:  List of users, as usernames or User objects
573        """
574        client = self.get_memcache()
575        if client:
576            for user in users:
577                user = self._normalise_user(user)
578                client.delete(f"_usertags-{user}")
579
580    def _normalise_user(self, user):
581        """
582        Normalise user object
583
584        Users may be passed as a username, a user object, or a proxy of such an
585        object. This method normalises this to a string (the username), or
586        `None` if no user is provided.
587
588        :param user:  User value to normalise
589        :return str|None:  Normalised value
590        """
591
592        # can provide either a string or user object
593        if type(user) is not str:
594            if type(user).__name__ == "LocalProxy":
595                # passed on from Flask
596                user = user._get_current_object()
597
598            if hasattr(user, "get_id"):
599                user = user.get_id()
600            elif user != None:  # noqa: E711
601                # werkzeug.local.LocalProxy (e.g., user not yet logged in) wraps None; use '!=' instead of 'is not'
602                raise TypeError(
603                    f"_normalise_user() expects None, a User object or a string for argument 'user', {type(user).__name__} given"
604                )
605
606        return user
607
608    def _get_memcache_id(self, attribute_name, tags=None):
609        """
610        Generate a memcache key for a config setting request
611
612        This includes the relevant user name/tags because the value may be
613        different depending on the value of these parameters.
614
615        :param str attribute_name:
616        :param str|list tags:
617        :return str:
618        """
619        if tags and isinstance(tags, str):
620            tags = [tags]
621
622        tag_bit = []
623        if tags:
624            tag_bit.append("|".join(tags))
625
626        memcache_id = attribute_name
627        if tag_bit:
628            memcache_id += f"-{'-'.join(tag_bit)}"
629
630        return memcache_id.encode("ascii")
631
632    def __getattr__(self, attr):
633        """
634        Getter so we can directly request values
635
636        :param attr:  Config setting to get
637        :return:  Value
638        """
639
640        if attr in dir(self):
641            # an explicitly defined attribute should always be called in favour
642            # of this passthrough
643            attribute = getattr(self, attr)
644            return attribute
645        else:
646            return self.get(attr)
647
648
649class ConfigWrapper(BaseConfigReader):
650    """
651    Wrapper for the config manager
652
653    Allows setting a default set of tags or user, so that all subsequent calls
654    to `get()` are done for those tags or that user. Can also adjust tags based
655    on the HTTP request, if used in a Flask context.
656    """
657    def __init__(self, config, user=None, tags=None, request=None):
658        """
659        Initialise config wrapper
660
661        :param ConfigManager config:  Initialised config manager
662        :param user:  User to get settings for
663        :param tags:  Tags to get settings for
664        :param request:  Request to get headers from. This can be used to set
665        a particular tag based on the HTTP headers of the request, e.g. to
666        serve 4CAT with a different configuration based on the proxy server
667        used.
668        """
669        if type(config) is ConfigWrapper:
670            # let's not do nested wrappers, but copy properties unless
671            # provided explicitly
672            self.user = user if user else config.user
673            self.tags = tags if tags else config.tags
674            self.request = request if request else config.request
675            self.config = config.config
676            # legacy: previous versions cached a per-request memcache client; now resolved inside ConfigManager
677        else:
678            self.config = config
679            self.user = user
680            self.tags = tags
681            self.request = request
682
683        # this ensures the user object in turn reads from the wrapper
684        if self.user:
685            self.user.with_config(self, rewrap=False)
686
687
688    def set(self, *args, **kwargs):
689        """
690        Wrap `set()`
691
692        :param args:
693        :param kwargs:
694        :return:
695        """
696        if "tag" not in kwargs and self.tags:
697            kwargs["tag"] = self.tags
698
699        # ConfigManager resolves thread-local memcache internally
700
701        return self.config.set(*args, **kwargs)
702
703    def get_all(self, *args, **kwargs):
704        """
705        Wrap `get_all()`
706
707        Takes the `user`, `tags` and `request` given when initialised into
708        account. If `tags` is set explicitly, the HTTP header-based override
709        is not applied.
710
711        :param args:
712        :param kwargs:
713        :return:
714        """
715        if "user" not in kwargs and self.user:
716            kwargs["user"] = self.user
717
718        if "tags" not in kwargs:
719            kwargs["tags"] = self.tags if self.tags else []
720            kwargs["tags"] = self.request_override(kwargs["tags"])
721
722        # ConfigManager resolves thread-local memcache internally
723
724        return self.config.get_all(*args, **kwargs)
725
726    def get(self, *args, **kwargs):
727        """
728        Wrap `get()`
729
730        Takes the `user`, `tags` and `request` given when initialised into
731        account. If `tags` is set explicitly, the HTTP header-based override
732        is not applied.
733
734        :param args:
735        :param kwargs:
736        :return:
737        """
738        if "user" not in kwargs:
739            kwargs["user"] = self.user
740
741        if "tags" not in kwargs:
742            kwargs["tags"] = self.tags if self.tags else []
743            kwargs["tags"] = self.request_override(kwargs["tags"])
744
745        # ConfigManager resolves thread-local memcache internally
746
747        return self.config.get(*args, **kwargs)
748
749    def get_active_tags(self, user=None, tags=None):
750        """
751        Wrap `get_active_tags()`
752
753        Takes the `user`, `tags` and `request` given when initialised into
754        account. If `tags` is set explicitly, the HTTP header-based override
755        is not applied.
756
757        :param user:
758        :param tags:
759        :return list:
760        """
761        active_tags = self.config.get_active_tags(user, tags)
762        if not tags:
763            active_tags = self.request_override(active_tags)
764        return active_tags
765
766    def request_override(self, tags):
767        """
768        Force tag via HTTP request headers
769
770        To facilitate loading different configurations based on the HTTP
771        request, the request object can be passed to the ConfigWrapper and
772        if a certain request header is set, the value of that header will be
773        added to the list of tags to consider when retrieving settings.
774
775        See the flask.proxy_secret config setting; this is used to prevent
776        users from changing configuration by forging the header.
777
778        :param list|str tags:  List of tags to extend based on request
779        :return list:  Amended list of tags
780        """
781        if type(tags) is str:
782            tags = [tags]
783
784        # use self.config.get here, not self.get, because else we get infinite
785        # recursion (since self.get can call this method)
786        if self.request and self.request.headers.get("X-4Cat-Config-Tag") and \
787            self.config.get("flask.proxy_secret") and \
788            self.request.headers.get("X-4Cat-Config-Via-Proxy") == self.config.get("flask.proxy_secret"):
789            # need to ensure not just anyone can add this header to their
790            # request!
791            # to this end, the second header must be set to the secret value;
792            # if it is not set, assume the headers are not being configured by
793            # the proxy server
794            if not tags:
795                tags = []
796
797            # can never set admin tag via headers (should always be user-based)
798            forbidden_overrides = ("admin",)
799            tags += [tag for tag in self.request.headers.get("X-4Cat-Config-Tag").split(",") if tag not in forbidden_overrides]
800
801        return tags
802
803
804    def __getattr__(self, item):
805        """
806        Generic wrapper
807
808        Just pipe everything through to the config object
809
810        :param item:
811        :return:
812        """
813        if hasattr(self.config, item):
814            return getattr(self.config, item)
815        elif hasattr(self, item):
816            return getattr(self, item)
817        else:
818            raise AttributeError(f"'{self.__name__}' object has no attribute '{item}'")
819
820
821class CoreConfigManager(ConfigManager):
822    """
823    A configuration reader that can only read from core settings
824
825    Can be used in thread-unsafe context and when no database is present.
826    """
827    def with_db(self, db=None):
828        """
829        Raise a RuntimeError when trying to link a database connection
830
831        :param db:
832        """
833        raise RuntimeError("Trying to read non-core configuration value from a CoreConfigManager")