Merge branch 'dev' into pthummar/eventGrid_E2E_tests

Author: pdthummar

azure_functions_worker/bindings/datumdef.py

@@ -1,10 +1,19 @@
 # Copyright (c) Microsoft Corporation. All rights reserved.
 # Licensed under the MIT License.
-
+import logging
 from typing import Any, Optional
 import json
 from .. import protos
 from ..logging import logger
+from typing import List
+try:
+    from http.cookies import SimpleCookie
+except ImportError:
+    from Cookie import SimpleCookie
+from dateutil import parser
+from dateutil.parser import ParserError
+from .nullable_converters import to_nullable_bool, to_nullable_string, \
+    to_nullable_double, to_nullable_timestamp
 
 
 class Datum:
@@ -99,8 +108,8 @@ def from_rpc_shared_memory(
             shmem: protos.RpcSharedMemory,
             shmem_mgr) -> Optional['Datum']:
         """
-        Reads the specified shared memory region and converts the read data into
-        a datum object of the corresponding type.
+        Reads the specified shared memory region and converts the read data
+        into a datum object of the corresponding type.
         """
         if shmem is None:
             logger.warning('Cannot read from shared memory. '
@@ -183,10 +192,83 @@ def datum_as_proto(datum: Datum) -> protos.TypedData:
                 k: v.value
                 for k, v in datum.value['headers'].items()
             },
+            cookies=parse_to_rpc_http_cookie_list(datum.value['cookies']),
             enable_content_negotiation=False,
             body=datum_as_proto(datum.value['body']),
         ))
     else:
         raise NotImplementedError(
             'unexpected Datum type: {!r}'.format(datum.type)
         )
+
+
+def parse_to_rpc_http_cookie_list(cookies: Optional[List[SimpleCookie]]):
+    if cookies is None:
+        return cookies
+
+    rpc_http_cookies = []
+
+    for cookie in cookies:
+        for name, cookie_entity in cookie.items():
+            rpc_http_cookies.append(
+                protos.RpcHttpCookie(name=name,
+                                     value=cookie_entity.value,
+                                     domain=to_nullable_string(
+                                         cookie_entity['domain'],
+                                         'cookie.domain'),
+                                     path=to_nullable_string(
+                                         cookie_entity['path'], 'cookie.path'),
+                                     expires=to_nullable_timestamp(
+                                         parse_cookie_attr_expires(
+                                             cookie_entity), 'cookie.expires'),
+                                     secure=to_nullable_bool(
+                                         bool(cookie_entity['secure']),
+                                         'cookie.secure'),
+                                     http_only=to_nullable_bool(
+                                         bool(cookie_entity['httponly']),
+                                         'cookie.httpOnly'),
+                                     same_site=parse_cookie_attr_same_site(
+                                         cookie_entity),
+                                     max_age=to_nullable_double(
+                                         cookie_entity['max-age'],
+                                         'cookie.maxAge')))
+
+    return rpc_http_cookies
+
+
+def parse_cookie_attr_expires(cookie_entity):
+    expires = cookie_entity['expires']
+
+    if expires is not None and len(expires) != 0:
+        try:
+            return parser.parse(expires)
+        except ParserError:
+            logging.error(
+                f"Can not parse value {expires} of expires in the cookie "
+                f"due to invalid format.")
+            raise
+        except OverflowError:
+            logging.error(
+                f"Can not parse value {expires} of expires in the cookie "
+                f"because the parsed date exceeds the largest valid C "
+                f"integer on your system.")
+            raise
+
+    return None
+
+
+def parse_cookie_attr_same_site(cookie_entity):
+    same_site = getattr(protos.RpcHttpCookie.SameSite, "None")
+    try:
+        raw_same_site_str = cookie_entity['samesite'].lower()
+
+        if raw_same_site_str == 'lax':
+            same_site = protos.RpcHttpCookie.SameSite.Lax
+        elif raw_same_site_str == 'strict':
+            same_site = protos.RpcHttpCookie.SameSite.Strict
+        elif raw_same_site_str == 'none':
+            same_site = protos.RpcHttpCookie.SameSite.ExplicitNone
+    except Exception:
+        return same_site
+
+    return same_site

azure_functions_worker/bindings/nullable_converters.py

@@ -0,0 +1,111 @@
+from datetime import datetime
+from typing import Optional, Union
+
+from google.protobuf.timestamp_pb2 import Timestamp
+
+from azure_functions_worker import protos
+
+
+def to_nullable_string(nullable: Optional[str], property_name: str) -> \
+        Optional[protos.NullableString]:
+    """Converts string input to an 'NullableString' to be sent through the
+    RPC layer. Input that is not a string but is also not null or undefined
+    logs a function app level warning.
+
+    :param nullable Input to be converted to an NullableString if it is a
+    valid string
+    :param property_name The name of the property that the caller will
+    assign the output to. Used for debugging.
+    """
+    if isinstance(nullable, str):
+        return protos.NullableString(value=nullable)
+
+    if nullable is not None:
+        raise TypeError(
+            f"A 'str' type was expected instead of a '{type(nullable)}' "
+            f"type. Cannot parse value {nullable} of '{property_name}'.")
+
+    return None
+
+
+def to_nullable_bool(nullable: Optional[bool], property_name: str) -> \
+        Optional[protos.NullableBool]:
+    """Converts boolean input to an 'NullableBool' to be sent through the
+    RPC layer. Input that is not a boolean but is also not null or undefined
+    logs a function app level warning.
+
+    :param nullable Input to be converted to an NullableBool if it is a
+    valid boolean
+    :param property_name The name of the property that the caller will
+    assign the output to. Used for debugging.
+    """
+    if isinstance(nullable, bool):
+        return protos.NullableBool(value=nullable)
+
+    if nullable is not None:
+        raise TypeError(
+            f"A 'bool' type was expected instead of a '{type(nullable)}' "
+            f"type. Cannot parse value {nullable} of '{property_name}'.")
+
+    return None
+
+
+def to_nullable_double(nullable: Optional[Union[str, int, float]],
+                       property_name: str) -> \
+        Optional[protos.NullableDouble]:
+    """Converts int or float or str that parses to a number to an
+    'NullableDouble' to be sent through the RPC layer. Input that is not a
+    valid number but is also not null or undefined logs a function app level
+    warning.
+    :param nullable Input to be converted to an NullableDouble if it is a
+    valid number
+    :param property_name The name of the property that the caller will
+    assign the output to. Used for debugging.
+    """
+    if isinstance(nullable, int) or isinstance(nullable, float):
+        return protos.NullableDouble(value=nullable)
+    elif isinstance(nullable, str):
+        if len(nullable) == 0:
+            return None
+
+        try:
+            return protos.NullableDouble(value=float(nullable))
+        except Exception:
+            raise TypeError(
+                f"Cannot parse value {nullable} of '{property_name}' to "
+                f"float.")
+
+    if nullable is not None:
+        raise TypeError(
+            f"A 'int' or 'float'"
+            f" type was expected instead of a '{type(nullable)}' "
+            f"type. Cannot parse value {nullable} of '{property_name}'.")
+
+    return None
+
+
+def to_nullable_timestamp(date_time: Optional[Union[datetime, int]],
+                          property_name: str) -> protos.NullableTimestamp:
+    """Converts Date or number input to an 'NullableTimestamp' to be sent
+    through the RPC layer. Input that is not a Date or number but is also
+    not null or undefined logs a function app level warning.
+
+    :param date_time Input to be converted to an NullableTimestamp if it is
+    valid input
+    :param property_name The name of the property that the caller will
+    assign the output to. Used for debugging.
+    """
+    if date_time is not None:
+        try:
+            time_in_seconds = date_time if isinstance(date_time,
+                                                      int) else \
+                date_time.timestamp()
+
+            return protos.NullableTimestamp(
+                value=Timestamp(seconds=int(time_in_seconds)))
+        except Exception:
+            raise TypeError(
+                f"A 'datetime' or 'int'"
+                f" type was expected instead of a '{type(date_time)}' "
+                f"type. Cannot parse value {date_time} of '{property_name}'.")
+    return None

azure_functions_worker/dispatcher.py

@@ -206,12 +206,6 @@ def on_logging(self, record: logging.LogRecord, formatted_msg: str) -> None:
         if invocation_id is not None:
             log['invocation_id'] = invocation_id
 
-        # XXX: When an exception field is set in RpcLog, WebHost doesn't
-        # wait for the call result and simply aborts the execution.
-        #
-        # if record.exc_info and record.exc_info[1] is not None:
-        #     log['exception'] = self._serialize_exception(record.exc_info[1])
-
         self._grpc_resp_queue.put_nowait(
             protos.StreamingMessage(
                 request_id=self.request_id,

azure_functions_worker/loader.py

@@ -143,18 +143,19 @@ def index_function_app(function_path: str):
     module_name = pathlib.Path(function_path).stem
     imported_module = importlib.import_module(module_name)
 
-    from azure.functions import FunctionApp
-    app: Optional[FunctionApp] = None
+    from azure.functions import FunctionRegister
+    app: Optional[FunctionRegister] = None
     for i in imported_module.__dir__():
-        if isinstance(getattr(imported_module, i, None), FunctionApp):
+        if isinstance(getattr(imported_module, i, None), FunctionRegister):
             if not app:
                 app = getattr(imported_module, i, None)
             else:
                 raise ValueError(
-                    "Multiple instances of FunctionApp are defined")
+                    f"More than one {app.__class__.__name__} or other top "
+                    f"level function app instances are defined.")
 
     if not app:
-        raise ValueError("Could not find instance of FunctionApp in "
+        raise ValueError("Could not find top level function app instances in "
                          f"{SCRIPT_FILE_NAME}.")
 
     return app.get_functions()

azure_functions_worker/protos/__init__.py

@@ -24,10 +24,18 @@
     ParameterBinding,
     TypedData,
     RpcHttp,
+    RpcHttpCookie,
     RpcLog,
     RpcSharedMemory,
     RpcDataType,
     CloseSharedMemoryResourcesRequest,
     CloseSharedMemoryResourcesResponse,
     FunctionsMetadataRequest,
     FunctionMetadataResponse)
+
+from .shared.NullableTypes_pb2 import (
+    NullableString,
+    NullableBool,
+    NullableDouble,
+    NullableTimestamp
+)

setup.py

@@ -105,7 +105,7 @@
     "grpcio~=1.43.0",
     "grpcio-tools~=1.43.0",
     "protobuf~=3.19.3",
-    'azure-functions==1.11.3b2',
+    "azure-functions==1.11.3b2",
     "python-dateutil~=2.8.2"
 ]
 

tests/endtoend/blueprint_functions/functions_in_blueprint_only/blueprint.py

@@ -0,0 +1,31 @@
+import logging
+
+import azure.functions as func
+
+bp = func.Blueprint()
+
+
+@bp.route(route="default_template")
+def default_template(req: func.HttpRequest) -> func.HttpResponse:
+    logging.info('Python HTTP trigger function processed a request.')
+
+    name = req.params.get('name')
+    if not name:
+        try:
+            req_body = req.get_json()
+        except ValueError:
+            pass
+        else:
+            name = req_body.get('name')
+
+    if name:
+        return func.HttpResponse(
+            f"Hello, {name}. This HTTP triggered function "
+            f"executed successfully.")
+    else:
+        return func.HttpResponse(
+            "This HTTP triggered function executed successfully. "
+            "Pass a name in the query string or in the request body for a"
+            " personalized response.",
+            status_code=200
+        )

tests/endtoend/blueprint_functions/functions_in_blueprint_only/function_app.py

@@ -0,0 +1,6 @@
+import azure.functions as func
+from blueprint import bp
+
+app = func.FunctionApp()
+
+app.register_functions(bp)

tests/endtoend/blueprint_functions/functions_in_both_blueprint_functionapp/blueprint.py

@@ -0,0 +1,31 @@
+import logging
+
+import azure.functions as func
+
+bp = func.Blueprint()
+
+
+@bp.route(route="default_template")
+def default_template(req: func.HttpRequest) -> func.HttpResponse:
+    logging.info('Python HTTP trigger function processed a request.')
+
+    name = req.params.get('name')
+    if not name:
+        try:
+            req_body = req.get_json()
+        except ValueError:
+            pass
+        else:
+            name = req_body.get('name')
+
+    if name:
+        return func.HttpResponse(
+            f"Hello, {name}. This HTTP triggered function "
+            f"executed successfully.")
+    else:
+        return func.HttpResponse(
+            "This HTTP triggered function executed successfully. "
+            "Pass a name in the query string or in the request body for a"
+            " personalized response.",
+            status_code=200
+        )

tests/endtoend/blueprint_functions/functions_in_both_blueprint_functionapp/function_app.py

@@ -0,0 +1,13 @@
+import azure.functions as func
+
+from blueprint import bp
+
+app = func.FunctionApp()
+
+app.register_blueprint(bp)
+
+
+@app.route(route="return_http")
+def return_http(req: func.HttpRequest):
+    return func.HttpResponse('<h1>Hello World™</h1>',
+                             mimetype='text/html')