Merge branch 'dev' into wangbill/asgi-wsgi-fix

Author: YunchuWang

CODEOWNERS

@@ -9,4 +9,6 @@
 # AZURE FUNCTIONS TEAM
 # For all file changes, github would automatically include the following people in the PRs.
 #
-* @vrdmr @gavin-aguiar @YunchuWang @pdthummar @hallvictoria
+
+* @vrdmr @gavin-aguiar @YunchuWang @pdthummar @hallvictoria
+

azure/functions/__init__.py

@@ -97,4 +97,4 @@
     'HttpMethod'
 )
 
-__version__ = '1.19.0'
+__version__ = '1.20.0b1'

azure/functions/_http_asgi.py

@@ -5,6 +5,7 @@
 import logging
 import asyncio
 from asyncio import Event, Queue
+from urllib.parse import ParseResult, urlparse
 from warnings import warn
 from wsgiref.headers import Headers
 
@@ -22,6 +23,8 @@ def __init__(self, func_req: HttpRequest,
         self.asgi_version = ASGI_VERSION
         self.asgi_spec_version = ASGI_SPEC_VERSION
         self._headers = func_req.headers
+        url: ParseResult = urlparse(func_req.url)
+        self.asgi_url_scheme = url.scheme
         super().__init__(func_req, func_ctx)
 
     def _get_encoded_http_headers(self) -> List[Tuple[bytes, bytes]]:
@@ -49,7 +52,7 @@ def to_asgi_http_scope(self):
             "asgi.spec_version": self.asgi_spec_version,
             "http_version": "1.1",
             "method": self.request_method,
-            "scheme": "https",
+            "scheme": self.asgi_url_scheme,
             "path": self.path_info,
             "raw_path": _raw_path,
             "query_string": _query_string,

azure/functions/decorators/constants.py

@@ -30,3 +30,7 @@
 DAPR_INVOKE = "daprInvoke"
 DAPR_PUBLISH = "daprPublish"
 DAPR_BINDING = "daprBinding"
+ORCHESTRATION_TRIGGER = "orchestrationTrigger"
+ACTIVITY_TRIGGER = "activityTrigger"
+ENTITY_TRIGGER = "entityTrigger"
+DURABLE_CLIENT = "durableClient"

azure/functions/decorators/function_app.py

@@ -277,6 +277,42 @@ def __init__(self, *args, **kwargs):
         self._function_builders: List[FunctionBuilder] = []
         self._app_script_file: str = SCRIPT_FILE_NAME
 
+    def _invoke_df_decorator(self, df_decorator):
+        """
+        Invoke a Durable Functions decorator from the DF SDK, and store the
+        resulting :class:`FunctionBuilder` object within the `DecoratorApi`.
+
+        """
+
+        @self._configure_function_builder
+        def wrap(fb):
+            def decorator():
+                function_builder = df_decorator(fb._function._func)
+
+                # remove old function builder from `self` and replace
+                # it with the result of the DF decorator
+                self._function_builders.pop()
+                self._function_builders.append(function_builder)
+                return function_builder
+            return decorator()
+        return wrap
+
+    def _get_durable_blueprint(self):
+        """Attempt to import the Durable Functions SDK from which DF decorators are
+        implemented.
+        """
+
+        try:
+            import azure.durable_functions as df
+            df_bp = df.Blueprint()
+            return df_bp
+        except ImportError:
+            error_message = "Attempted to use a Durable Functions decorator, "\
+                "but the `azure-functions-durable` SDK package could not be "\
+                "found. Please install `azure-functions-durable` to use "\
+                "Durable Functions."
+            raise Exception(error_message)
+
     @property
     def app_script_file(self) -> str:
         """Name of function app script file in which all the functions
@@ -443,6 +479,59 @@ def decorator():
 
         return wrap
 
+    def orchestration_trigger(self, context_name: str,
+                              orchestration: Optional[str] = None):
+        """Register an Orchestrator Function.
+
+        Parameters
+        ----------
+        context_name: str
+            Parameter name of the DurableOrchestrationContext object.
+        orchestration: Optional[str]
+            Name of Orchestrator Function.
+            By default, the name of the method is used.
+        """
+        df_bp = self._get_durable_blueprint()
+        df_decorator = df_bp.orchestration_trigger(context_name,
+                                                   orchestration)
+        result = self._invoke_df_decorator(df_decorator)
+        return result
+
+    def entity_trigger(self, context_name: str,
+                       entity_name: Optional[str] = None):
+        """Register an Entity Function.
+
+        Parameters
+        ----------
+        context_name: str
+            Parameter name of the Entity input.
+        entity_name: Optional[str]
+            Name of Entity Function.
+        """
+
+        df_bp = self._get_durable_blueprint()
+        df_decorator = df_bp.entity_trigger(context_name,
+                                            entity_name)
+        result = self._invoke_df_decorator(df_decorator)
+        return result
+
+    def activity_trigger(self, input_name: str,
+                         activity: Optional[str] = None):
+        """Register an Activity Function.
+
+        Parameters
+        ----------
+        input_name: str
+            Parameter name of the Activity input.
+        activity: Optional[str]
+            Name of Activity Function.
+        """
+
+        df_bp = self._get_durable_blueprint()
+        df_decorator = df_bp.activity_trigger(input_name, activity)
+        result = self._invoke_df_decorator(df_decorator)
+        return result
+
     def timer_trigger(self,
                       arg_name: str,
                       schedule: str,
@@ -1350,6 +1439,37 @@ def decorator():
 class BindingApi(DecoratorApi, ABC):
     """Interface to extend for using existing binding decorator functions."""
 
+    def durable_client_input(self,
+                             client_name: str,
+                             task_hub: Optional[str] = None,
+                             connection_name: Optional[str] = None
+                             ):
+        """Register a Durable-client Function.
+
+        Parameters
+        ----------
+        client_name: str
+            Parameter name of durable client.
+        task_hub: Optional[str]
+            Used in scenarios where multiple function apps share the
+            same storage account but need to be isolated from each other.
+            If not specified, the default value from host.json is used.
+            This value must match the value used by the target
+            orchestrator functions.
+        connection_name: Optional[str]
+            The name of an app setting that contains a storage account
+            connection string.  The storage account represented by this
+            connection string must be the same one used by the target
+            orchestrator functions. If not specified, the default storage
+            account connection string for the function app is used.
+        """
+        df_bp = self._get_durable_blueprint()
+        df_decorator = df_bp.durable_client_input(client_name,
+                                                  task_hub,
+                                                  connection_name)
+        result = self._invoke_df_decorator(df_decorator)
+        return result
+
     def service_bus_queue_output(self,
                                  arg_name: str,
                                  connection: str,

setup.py

@@ -12,7 +12,8 @@
         'pytest',
         'pytest-cov',
         'requests==2.*',
-        'coverage'
+        'coverage',
+        'azure-functions-durable'
     ]
 }
 

tests/decorators/test_decorators.py

@@ -6,7 +6,8 @@
     HTTP_OUTPUT, QUEUE, QUEUE_TRIGGER, SERVICE_BUS, SERVICE_BUS_TRIGGER, \
     EVENT_HUB, EVENT_HUB_TRIGGER, COSMOS_DB, COSMOS_DB_TRIGGER, BLOB, \
     BLOB_TRIGGER, EVENT_GRID_TRIGGER, EVENT_GRID, TABLE, WARMUP_TRIGGER, \
-    SQL, SQL_TRIGGER
+    SQL, SQL_TRIGGER, ORCHESTRATION_TRIGGER, ACTIVITY_TRIGGER, \
+    ENTITY_TRIGGER, DURABLE_CLIENT
 from azure.functions.decorators.core import DataType, AuthLevel, \
     BindingDirection, AccessRights, Cardinality
 from azure.functions.decorators.function_app import FunctionApp
@@ -160,6 +161,84 @@ def dummy():
             ]
         })
 
+    def test_orchestration_trigger(self):
+        app = self.func_app
+
+        @app.orchestration_trigger("context")
+        def dummy1(context):
+            pass
+
+        func = self._get_user_function(app)
+        assert_json(self, func, {
+            "scriptFile": "function_app.py",
+            "bindings": [
+                {
+                    "name": "context",
+                    "type": ORCHESTRATION_TRIGGER,
+                    "direction": BindingDirection.IN
+                }
+            ]
+        })
+
+    def test_activity_trigger(self):
+        app = self.func_app
+
+        @app.activity_trigger("arg")
+        def dummy2(arg):
+            pass
+
+        func = self._get_user_function(app)
+        assert_json(self, func, {
+            "scriptFile": "function_app.py",
+            "bindings": [
+                {
+                    "name": "arg",
+                    "type": ACTIVITY_TRIGGER,
+                    "direction": BindingDirection.IN
+                }
+            ]
+        })
+
+    def test_entity_trigger(self):
+        app = self.func_app
+
+        @app.entity_trigger("context")
+        def dummy3(context):
+            pass
+
+        func = self._get_user_function(app)
+        assert_json(self, func, {
+            "scriptFile": "function_app.py",
+            "bindings": [
+                {
+                    "name": "context",
+                    "type": ENTITY_TRIGGER,
+                    "direction": BindingDirection.IN,
+                }
+            ]
+        })
+
+    def test_durable_client(self):
+        app = self.func_app
+
+        @app.generic_trigger(arg_name="req", type=HTTP_TRIGGER)
+        @app.durable_client_input(client_name="client")
+        def dummy(client):
+            pass
+
+        func = self._get_user_function(app)
+
+        self.assertEqual(len(func.get_bindings()), 2)
+        self.assertTrue(func.is_http_function())
+
+        output = func.get_bindings()[0]
+
+        self.assertEqual(output.get_dict_repr(), {
+            "direction": BindingDirection.IN,
+            "type": DURABLE_CLIENT,
+            "name": "client"
+        })
+
     def test_route_default_args(self):
         app = self.func_app
 

tests/test_http_asgi.py

@@ -198,7 +198,19 @@ def test_middleware_calls_app(self):
         test_body = b'Hello world!'
         app.response_body = test_body
         app.response_code = 200
-        req = func.HttpRequest(method='get', url='/test', body=b'')
+        req = self._generate_func_request()
+        response = AsgiMiddleware(app).handle(req)
+
+        # Verify asserted
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.get_body(), test_body)
+
+    def test_middleware_calls_app_http(self):
+        app = MockAsgiApplication()
+        test_body = b'Hello world!'
+        app.response_body = test_body
+        app.response_code = 200
+        req = self._generate_func_request(url="http://a.b.com")
         response = AsgiMiddleware(app).handle(req)
 
         # Verify asserted