add flag as part of FunctionInfo + tests

Author: hallvictoria

azure_functions_worker/bindings/__init__.py

@@ -8,7 +8,7 @@
 from .meta import has_implicit_output
 from .meta import is_trigger_binding, load_binding_registry
 from .meta import from_incoming_proto, to_outgoing_proto, \
-    to_outgoing_param_binding, set_deferred_bindings_flag
+    to_outgoing_param_binding, check_deferred_bindings_enabled
 from .out import Out
 
 
@@ -19,5 +19,5 @@
     'check_input_type_annotation', 'check_output_type_annotation',
     'has_implicit_output',
     'from_incoming_proto', 'to_outgoing_proto', 'TraceContext', 'RetryContext',
-    'to_outgoing_param_binding', 'set_deferred_bindings_flag'
+    'to_outgoing_param_binding', 'check_deferred_bindings_enabled'
 )

azure_functions_worker/bindings/meta.py

@@ -20,7 +20,6 @@
 
 BINDING_REGISTRY = None
 DEFERRED_BINDING_REGISTRY = None
-deferred_bindings_enabled = False
 deferred_bindings_cache = {}
 
 
@@ -259,12 +258,11 @@ def deferred_bindings_decode(binding: typing.Any,
         return deferred_binding_type
 
 
-def set_deferred_bindings_flag(param_anno: type):
-    # If flag hasn't already been set
-    # If DEFERRED_BINDING_REGISTRY is not None
-    # If the binding type is a deferred binding type
-    global deferred_bindings_enabled
-    if (not deferred_bindings_enabled
-            and DEFERRED_BINDING_REGISTRY is not None
-            and DEFERRED_BINDING_REGISTRY.check_supported_type(param_anno)):
-        deferred_bindings_enabled = True
+def check_deferred_bindings_enabled(param_anno: type,
+                                    deferred_bindings_enabled: bool) -> bool:
+    # If previous binding was SDK type, deferred_bindings_enabled will be
+    # True
+    return (deferred_bindings_enabled
+            or (DEFERRED_BINDING_REGISTRY is not None
+                and DEFERRED_BINDING_REGISTRY.check_supported_type(
+                    param_anno)))

azure_functions_worker/functions.py

@@ -31,6 +31,8 @@ class FunctionInfo(typing.NamedTuple):
     output_types: typing.Mapping[str, ParamTypeInfo]
     return_type: typing.Optional[ParamTypeInfo]
 
+    deferred_bindings_enabled: bool
+
 
 class FunctionLoadError(RuntimeError):
 
@@ -137,15 +139,19 @@ def validate_function_params(params: dict, bound_params: dict,
 
         input_types: typing.Dict[str, ParamTypeInfo] = {}
         output_types: typing.Dict[str, ParamTypeInfo] = {}
+        deferred_bindings_enabled = False
 
         for param in params.values():
             binding = bound_params[param.name]
 
             param_has_anno = param.name in annotations
             param_anno = annotations.get(param.name)
 
-            # Check the declared type
-            bindings_utils.set_deferred_bindings_flag(param_anno)
+            # Check if deferred bindings is enabled
+            deferred_bindings_enabled = (
+                bindings_utils.check_deferred_bindings_enabled(
+                    param_anno,
+                    deferred_bindings_enabled))
 
             if param_has_anno:
                 if typing_inspect.is_generic_type(param_anno):
@@ -245,7 +251,7 @@ def validate_function_params(params: dict, bound_params: dict,
                 output_types[param.name] = param_type_info
             else:
                 input_types[param.name] = param_type_info
-        return input_types, output_types
+        return input_types, output_types, deferred_bindings_enabled
 
     @staticmethod
     def get_function_return_type(annotations: dict, has_explicit_return: bool,
@@ -298,7 +304,8 @@ def add_func_to_registry_and_return_funcinfo(self, function,
                                                      str, ParamTypeInfo],
                                                  output_types: typing.Dict[
                                                      str, ParamTypeInfo],
-                                                 return_type: str):
+                                                 return_type: str,
+                                                 deferred_bindings_enabled: bool):
 
         function_info = FunctionInfo(
             func=function,
@@ -310,7 +317,8 @@ def add_func_to_registry_and_return_funcinfo(self, function,
             has_return=has_explicit_return or has_implicit_return,
             input_types=input_types,
             output_types=output_types,
-            return_type=return_type)
+            return_type=return_type,
+            deferred_bindings_enabled=deferred_bindings_enabled)
 
         self._functions[function_id] = function_info
         return function_info
@@ -347,10 +355,10 @@ def add_function(self, function_id: str,
                                                     annotations,
                                                     func_name)
 
-        input_types, output_types = self.validate_function_params(params,
-                                                                  bound_params,
-                                                                  annotations,
-                                                                  func_name)
+        input_types, output_types, _ = self.validate_function_params(params,
+                                                                     bound_params,
+                                                                     annotations,
+                                                                     func_name)
 
         return_type = \
             self.get_function_return_type(annotations,
@@ -366,7 +374,7 @@ def add_function(self, function_id: str,
                                                       has_explicit_return,
                                                       has_implicit_return,
                                                       input_types,
-                                                      output_types, return_type)
+                                                      output_types, return_type, _)
 
     def add_indexed_function(self, function):
         func = function.get_user_function()
@@ -404,10 +412,12 @@ def add_indexed_function(self, function):
                                                     annotations,
                                                     func_name)
 
-        input_types, output_types = self.validate_function_params(params,
-                                                                  bound_params,
-                                                                  annotations,
-                                                                  func_name)
+        (input_types, output_types,
+         deferred_bindings_enabled) = self.validate_function_params(
+            params,
+            bound_params,
+            annotations,
+            func_name)
 
         return_type = \
             self.get_function_return_type(annotations,
@@ -425,4 +435,5 @@ def add_indexed_function(self, function):
                                                           has_implicit_return,
                                                           input_types,
                                                           output_types,
-                                                          return_type)
+                                                          return_type,
+                                                          deferred_bindings_enabled)

azure_functions_worker/loader.py

@@ -245,13 +245,7 @@ def index_function_app(function_path: str):
 
 
 def get_fx_raw_bindings(indexed_function, function_info):
-    # If the flag is True, we know that:
-    # 1. Library is imported
-    # 2. At least one binding is a defined deferred binding type
-    # 3. DEFERRED_BINDING_REGISTRY is not None
-    if bindings.meta.deferred_bindings_enabled:
-        # Reset the flag
-        bindings.meta.deferred_bindings_enabled = False
+    if function_info.deferred_bindings_enabled:
         return bindings.meta.DEFERRED_BINDING_REGISTRY.get_raw_bindings(
             indexed_function, function_info.input_types)
 

tests/extension_tests/deferred_bindings_tests/deferred_bindings_blob_functions/function_app.py

@@ -197,6 +197,25 @@ def bc_and_inputstream_input(req: func.HttpRequest, client: bindings.BlobClient,
     return output_msg
 
 
+@app.function_name(name="inputstream_and_bc_input")
+@app.route(route="inputstream_and_bc_input")
+@app.blob_input(arg_name="blob",
+                path="python-worker-tests/test-blob-extension-str.txt",
+                data_type="STRING",
+                connection="AzureWebJobsStorage")
+@app.blob_input(arg_name="client",
+                path="python-worker-tests/test-blob-extension-str.txt",
+                data_type="STRING",
+                connection="AzureWebJobsStorage")
+def inputstream_and_bc_input(req: func.HttpRequest, blob: func.InputStream,
+                             client: bindings.BlobClient) -> str:
+    output_msg = ""
+    file = blob.read().decode('utf-8')
+    client_file = client.download_blob(encoding='utf-8').readall()
+    output_msg = file + " - input stream " + client_file + " - blob client"
+    return output_msg
+
+
 @app.function_name(name="type_undefined")
 @app.route(route="type_undefined")
 @app.blob_input(arg_name="file",

tests/extension_tests/deferred_bindings_tests/test_deferred_bindings.py

@@ -3,11 +3,16 @@
 import unittest
 import sys
 
+import azure.functions as func
+
 from azure_functions_worker import protos
 from azure_functions_worker.bindings import datumdef, meta
 from tests.utils import testutils
 
-from azure.functions.extension.blob import BlobClient, BlobClientConverter
+# Even if the tests are skipped for <=3.8, the library is still imported as
+# it is used for these tests.
+if sys.version_info.minor >= 9:
+    from azure.functions.extension.blob import BlobClient, BlobClientConverter
 
 DEFERRED_BINDINGS_ENABLED_DIR = testutils.EXTENSION_TESTS_FOLDER / \
     'deferred_bindings_tests' / \
@@ -73,7 +78,6 @@ async def test_non_deferred_bindings_metadata(self):
             self.assertIsInstance(r.response, protos.FunctionMetadataResponse)
             self.assertEqual(r.response.result.status,
                              protos.StatusResult.Success)
-            self.assertFalse(meta.deferred_bindings_enabled)
 
 
 @unittest.skipIf(sys.version_info.minor <= 8, "The base extension"
@@ -117,3 +121,22 @@ def test_deferred_bindings_decode(self):
                                             pytype=BlobClient, datum=datum, metadata={})
 
         self.assertIsNotNone(obj)
+
+    async def test_check_deferred_bindings_enabled(self):
+        async with testutils.start_mockhost(
+                script_root=DEFERRED_BINDINGS_DISABLED_DIR) as host:
+            await host.init_worker()
+
+            self.assertFalse(meta.check_deferred_bindings_enabled(
+                func.InputStream,
+                False))
+            self.assertTrue(meta.check_deferred_bindings_enabled(
+                func.InputStream,
+                True))
+
+            self.assertTrue(meta.check_deferred_bindings_enabled(
+                BlobClient,
+                False))
+            self.assertTrue(meta.check_deferred_bindings_enabled(
+                BlobClient,
+                True))

tests/extension_tests/deferred_bindings_tests/test_deferred_bindings_blob_functions.py

@@ -150,6 +150,15 @@ def test_bc_and_inputstream_input(self):
         self.assertEqual(r.status_code, 200)
         self.assertEqual(r.text, 'test-data - input stream test-data - blob client')
 
+    def test_inputstream_and_bc_input(self):
+        r = self.webhost.request('POST', 'put_blob_str', data='test-data')
+        self.assertEqual(r.status_code, 200)
+        self.assertEqual(r.text, 'OK')
+
+        r = self.webhost.request('GET', 'inputstream_and_bc_input')
+        self.assertEqual(r.status_code, 200)
+        self.assertEqual(r.text, 'test-data - input stream test-data - blob client')
+
     def test_type_undefined(self):
         r = self.webhost.request('POST', 'put_blob_str', data='test-data')
         self.assertEqual(r.status_code, 200)
@@ -159,8 +168,6 @@ def test_type_undefined(self):
         self.assertEqual(r.status_code, 200)
         self.assertEqual(r.text, 'test-data')
 
-        self.assertFalse(meta.deferred_bindings_enabled)
-
     def test_caching(self):
         # Cache is empty at the start
         self.assertEqual(meta.deferred_bindings_cache, {})