Flask App factory PR #1 (#8418)

* First cut at app factory

* Setting things back to master

* Working with new FLASK_APP

* Still need to refactor Celery

* CLI mostly working

* Working on unit tests

* Moving cli stuff around a bit

* Removing get in config

* Defaulting test config

* Adding flask-testing

* flask-testing casing

* resultsbackend property bug

* Fixing up cli

* Quick fix for KV api

* Working on save slice

* Fixed core_tests

* Fixed utils_tests

* Most tests working - still need to dig into remaining app_context issue in tests

* All tests passing locally - need to update code comments

* Fixing dashboard tests again

* Blacking

* Sorting imports

* linting

* removing envvar mangling

* blacking

* Fixing unit tests

* isorting

* licensing

* fixing mysql tests

* fixing cypress?

* fixing .flaskenv

* fixing test app_ctx

* fixing cypress

* moving manifest processor around

* moving results backend manager around

* Cleaning up __init__ a bit more

* Addressing PR comments

* Addressing PR comments

* Blacking

* Fixes for running celery worker

* Tuning isort

* Blacking

superset/utils/cache.py

@@ -15,9 +15,12 @@
 # specific language governing permissions and limitations
 # under the License.
 # pylint: disable=C,R,W
-from flask import request
+from typing import Optional
 
-from superset import tables_cache
+from flask import Flask, request
+from flask_caching import Cache
+
+from superset.extensions import cache_manager
 
 
 def view_cache_key(*unused_args, **unused_kwargs) -> str:
@@ -43,7 +46,7 @@ def memoized_func(key=view_cache_key, attribute_in_key=None):
     """
 
     def wrap(f):
-        if tables_cache:
+        if cache_manager.tables_cache:
 
             def wrapped_f(self, *args, **kwargs):
                 if not kwargs.get("cache", True):
@@ -55,11 +58,13 @@ def memoized_func(key=view_cache_key, attribute_in_key=None):
                     )
                 else:
                     cache_key = key(*args, **kwargs)
-                o = tables_cache.get(cache_key)
+                o = cache_manager.tables_cache.get(cache_key)
                 if not kwargs.get("force") and o is not None:
                     return o
                 o = f(self, *args, **kwargs)
-                tables_cache.set(cache_key, o, timeout=kwargs.get("cache_timeout"))
+                cache_manager.tables_cache.set(
+                    cache_key, o, timeout=kwargs.get("cache_timeout")
+                )
                 return o
 
         else:

superset/utils/cache_manager.py

@@ -0,0 +1,56 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+from typing import Optional
+
+from flask import Flask
+from flask_caching import Cache
+
+
+class CacheManager:
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._tables_cache = None
+        self._cache = None
+
+    def init_app(self, app):
+        self._cache = self._setup_cache(app, app.config.get("CACHE_CONFIG"))
+        self._tables_cache = self._setup_cache(
+            app, app.config.get("TABLE_NAMES_CACHE_CONFIG")
+        )
+
+    @staticmethod
+    def _setup_cache(app: Flask, cache_config) -> Optional[Cache]:
+        """Setup the flask-cache on a flask app"""
+        if cache_config:
+            if isinstance(cache_config, dict):
+                if cache_config.get("CACHE_TYPE") != "null":
+                    return Cache(app, config=cache_config)
+            else:
+                # Accepts a custom cache initialization function,
+                # returning an object compatible with Flask-Caching API
+                return cache_config(app)
+
+        return None
+
+    @property
+    def tables_cache(self):
+        return self._tables_cache
+
+    @property
+    def cache(self):
+        return self._cache

superset/utils/core.py

@@ -791,20 +791,6 @@ def choicify(values):
     return [(v, v) for v in values]
 
 
-def setup_cache(app: Flask, cache_config) -> Optional[Cache]:
-    """Setup the flask-cache on a flask app"""
-    if cache_config:
-        if isinstance(cache_config, dict):
-            if cache_config["CACHE_TYPE"] != "null":
-                return Cache(app, config=cache_config)
-        else:
-            # Accepts a custom cache initialization function,
-            # returning an object compatible with Flask-Caching API
-            return cache_config(app)
-
-    return None
-
-
 def zlib_compress(data):
     """
     Compress things in a py2/3 safe fashion
@@ -832,19 +818,6 @@ def zlib_decompress(blob: bytes, decode: Optional[bool] = True) -> Union[bytes,
     return decompressed.decode("utf-8") if decode else decompressed
 
 
-_celery_app = None
-
-
-def get_celery_app(config):
-    global _celery_app
-    if _celery_app:
-        return _celery_app
-    _celery_app = celery.Celery()
-    _celery_app.config_from_object(config["CELERY_CONFIG"])
-    _celery_app.set_default()
-    return _celery_app
-
-
 def to_adhoc(filt, expressionType="SIMPLE", clause="where"):
     result = {
         "clause": clause.upper(),

superset/utils/feature_flag_manager.py

@@ -0,0 +1,39 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+from copy import deepcopy
+
+
+class FeatureFlagManager:
+    def __init__(self) -> None:
+        super().__init__()
+        self._get_feature_flags_func = None
+        self._feature_flags = None
+
+    def init_app(self, app):
+        self._get_feature_flags_func = app.config.get("GET_FEATURE_FLAGS_FUNC")
+        self._feature_flags = app.config.get("DEFAULT_FEATURE_FLAGS") or {}
+        self._feature_flags.update(app.config.get("FEATURE_FLAGS") or {})
+
+    def get_feature_flags(self):
+        if self._get_feature_flags_func:
+            return self._get_feature_flags_func(deepcopy(self._feature_flags))
+
+        return self._feature_flags
+
+    def is_feature_enabled(self, feature):
+        """Utility function for checking whether a feature is turned on"""
+        return self.get_feature_flags().get(feature)