Terminate if the configured signature doesn't match the function (#71)

Towards #1
Related to GoogleCloudPlatform/functions-framework-conformance#58

Author: kevmoo

.github/workflows/conformance.yml

@@ -55,6 +55,6 @@ jobs:
         functionType: 'cloudevent'
         useBuildpacks: false
         # Coordinate changes here with the documentation in `CONTRIBUTING.MD`
-        cmd: '"dart test/hello/bin/server.dart --target conformanceCloudEvent"'
+        cmd: '"dart test/hello/bin/server.dart --target conformanceCloudEvent --signature-type cloudevent"'
         validateMapping: false
         startDelay: 3

CONTRIBUTING.md

@@ -65,7 +65,7 @@ $ $FUNCTION_FRAMEWORK_CONFORMANCE_PATH/client/client -buildpacks=false -start-de
 #### Cloud events
 
 ```console
-$ $FUNCTION_FRAMEWORK_CONFORMANCE_PATH/client/client -buildpacks=false -start-delay 3 -type=cloudevent -cmd="dart test/hello/bin/server.dart --target conformanceCloudEvent" --validate-mapping=false
+$ $FUNCTION_FRAMEWORK_CONFORMANCE_PATH/client/client -buildpacks=false -start-delay 3 -type=cloudevent -cmd="dart test/hello/bin/server.dart --target conformanceCloudEvent --signature-type cloudevent" --validate-mapping=false
 ```
 
 This corespondes to the configuration in `.github/workflows/conformance.yml`.

functions_framework/CHANGELOG.md

@@ -1,4 +1,4 @@
-# 0.2.1-dev
+# 0.3.0-dev
 
 - Added support for basic Cloud Events.
   - Added `CloudEvent` type.

functions_framework/lib/functions_framework.dart

@@ -13,5 +13,5 @@
 // limitations under the License.
 
 export 'src/cloud_event.dart';
-export 'src/cloud_event_wrapper.dart';
+export 'src/cloud_event_wrapper.dart' show CloudEventHandler;
 export 'src/cloud_function.dart';

functions_framework/lib/serve.dart

@@ -22,20 +22,21 @@ import 'package:shelf/shelf.dart';
 import 'src/bad_configuration.dart';
 import 'src/cloud_metadata.dart';
 import 'src/function_config.dart';
+import 'src/function_endpoint.dart';
 import 'src/logging.dart';
 import 'src/run.dart';
 
-export 'src/cloud_event_wrapper.dart' show wrapCloudEventHandler;
+export 'src/function_endpoint.dart' show FunctionEndpoint;
 
 /// If there is an invalid configuration, [BadConfigurationException] will be
 /// thrown.
 ///
 /// If there are no configuration errors, this function will not return until
 /// the process has received signal [ProcessSignal.sigterm] or
 /// [ProcessSignal.sigint].
-Future<void> serve(List<String> args, Map<String, Handler> handlers) async {
+Future<void> serve(List<String> args, Set<FunctionEndpoint> functions) async {
   try {
-    await _serve(args, handlers);
+    await _serve(args, functions);
   } on BadConfigurationException catch (e) {
     stderr.writeln(red.wrap(e.message));
     if (e.details != null) {
@@ -45,21 +46,32 @@ Future<void> serve(List<String> args, Map<String, Handler> handlers) async {
   }
 }
 
-Future<void> _serve(List<String> args, Map<String, Handler> handlers) async {
+Future<void> _serve(List<String> args, Set<FunctionEndpoint> functions) async {
   final configFromEnvironment = FunctionConfig.fromEnv();
 
   final config = FunctionConfig.fromArgs(
     args,
     defaults: configFromEnvironment,
   );
 
-  final handler = handlers[config.target];
-
-  if (handler == null) {
-    throw BadConfigurationException(
+  final function = functions.singleWhere(
+    (element) => element.target == config.target,
+    orElse: () => throw BadConfigurationException(
       'There is no handler configured for '
-      'FUNCTION_TARGET `${config.target}`.',
+      '$environmentKeyFunctionTarget `${config.target}`.',
+    ),
+  );
+
+  if (function.functionType == FunctionType.cloudevent &&
+      config.functionType == FunctionType.http) {
+    // See https://github.com/GoogleCloudPlatform/functions-framework-conformance/issues/58
+    stderr.writeln(
+      'The configured $environmentKeyFunctionTarget `${config.target}` has a '
+      'function type of `cloudevent` which is not compatible with the '
+      'configured $environmentKeyFunctionSignatureType of `http`.',
     );
+    exitCode = ExitCode.usage.code;
+    return;
   }
 
   final projectId = await CloudMetadata.projectId();
@@ -89,5 +101,5 @@ Future<void> _serve(List<String> args, Map<String, Handler> handlers) async {
   sigIntSub = ProcessSignal.sigint.watch().listen(signalHandler);
   sigTermSub = ProcessSignal.sigterm.watch().listen(signalHandler);
 
-  await run(config.port, handler, completer.future, loggingMiddleware);
+  await run(config.port, function.handler, completer.future, loggingMiddleware);
 }

functions_framework/lib/src/cloud_event_wrapper.dart

@@ -24,7 +24,7 @@ import 'cloud_event.dart';
 
 typedef CloudEventHandler = FutureOr<void> Function(CloudEvent request);
 
-Handler wrapCloudEventHandler(CloudEventHandler handler) => (request) async {
+Handler wrapCloudEventFunction(CloudEventHandler handler) => (request) async {
       CloudEvent event;
 
       try {

functions_framework/lib/src/function_config.dart

@@ -22,6 +22,9 @@ const defaultPort = 8080;
 const defaultFunctionType = FunctionType.http;
 const defaultFunctionTarget = 'function';
 
+const environmentKeyFunctionTarget = 'FUNCTION_TARGET';
+const environmentKeyFunctionSignatureType = 'FUNCTION_SIGNATURE_TYPE';
+
 const _portOpt = 'port';
 const _targetOpt = 'target';
 const _functionTypeOpt = 'signature-type';
@@ -62,7 +65,8 @@ class FunctionConfig {
 
     return FunctionConfig(
       port: port,
-      target: Platform.environment['FUNCTION_TARGET'] ?? defaultFunctionTarget,
+      target: Platform.environment[environmentKeyFunctionTarget] ??
+          defaultFunctionTarget,
       functionType: _parseFunctionType(
         Platform.environment['FUNCTION_SIGNATURE_TYPE'] ??
             _enumValue(FunctionType.http),
@@ -87,7 +91,7 @@ class FunctionConfig {
         _targetOpt,
         help: 'The name of the exported function to be invoked in response to '
             'requests.\n'
-            'Overrides the FUNCTION_TARGET environment variable.',
+            'Overrides the $environmentKeyFunctionTarget environment variable.',
       )
       ..addOption(
         _functionTypeOpt,

functions_framework/lib/src/function_endpoint.dart

@@ -0,0 +1,59 @@
+// Copyright 2021 Google LLC
+//
+// Licensed 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.
+
+import 'package:shelf/shelf.dart';
+
+import 'cloud_event_wrapper.dart';
+import 'function_config.dart';
+
+abstract class FunctionEndpoint {
+  final String target;
+
+  FunctionType get functionType;
+
+  Handler get handler;
+
+  const FunctionEndpoint(this.target);
+
+  const factory FunctionEndpoint.http(String target, Handler function) =
+      HttpFunctionEndPoint;
+
+  const factory FunctionEndpoint.cloudEvent(
+      String target, CloudEventHandler function) = CloudEventFunctionEndPoint;
+}
+
+class HttpFunctionEndPoint extends FunctionEndpoint {
+  final Handler function;
+
+  @override
+  FunctionType get functionType => FunctionType.http;
+
+  @override
+  Handler get handler => function;
+
+  const HttpFunctionEndPoint(String target, this.function) : super(target);
+}
+
+class CloudEventFunctionEndPoint extends FunctionEndpoint {
+  final CloudEventHandler function;
+
+  @override
+  FunctionType get functionType => FunctionType.cloudevent;
+
+  @override
+  Handler get handler => wrapCloudEventFunction(function);
+
+  const CloudEventFunctionEndPoint(String target, this.function)
+      : super(target);
+}

functions_framework/pubspec.yaml

@@ -1,5 +1,5 @@
 name: functions_framework
-version: 0.2.1-dev
+version: 0.3.0-dev
 description: >-
   FaaS (Function as a service) framework for writing portable Dart functions
 repository: https://github.com/GoogleCloudPlatform/functions-framework-dart

functions_framework_builder/lib/builder.dart

@@ -63,8 +63,6 @@ class _FunctionsFrameworkBuilder implements Builder {
 
       final function = element as FunctionElement;
 
-      final invokeExpression = validator.validate(function);
-
       final targetReader = annotatedElement.annotation.read('target');
 
       final targetName =
@@ -77,6 +75,8 @@ class _FunctionsFrameworkBuilder implements Builder {
         );
       }
 
+      final invokeExpression = validator.validate(targetName, function);
+
       entries[targetName] = invokeExpression;
     }
 
@@ -97,16 +97,14 @@ class _FunctionsFrameworkBuilder implements Builder {
 // limitations under the License.
 
 import 'package:functions_framework/serve.dart';
-import 'package:shelf/shelf.dart';
-
 import '${input.uri}' as $functionsLibraryPrefix;
 
 Future<void> main(List<String> args) async {
   await serve(args, _functions);
 }
 
-final _functions = <String, Handler>{
-${entries.entries.map((e) => "  '${e.key}': ${e.value},").join('\n')}
+const _functions = <FunctionEndpoint>{
+${entries.values.map((e) => "  $e,").join('\n')}
 };
 ''';
 

functions_framework_builder/lib/src/supported_function_types.dart

@@ -25,10 +25,10 @@ class SupportedFunctionTypes {
 
   SupportedFunctionTypes._(this._types);
 
-  String validate(FunctionElement element) {
+  String validate(String targetName, FunctionElement element) {
     for (var type in _types) {
       if (type.compatible(element)) {
-        return type.createReference(element);
+        return type.createReference(targetName, element);
       }
     }
     throw InvalidGenerationSourceError(
@@ -47,12 +47,13 @@ ${_types.map((e) => '  ${e.name} [${e.typeDescription}] from ${e.library}').join
             resolver,
             'package:shelf/shelf.dart',
             'Handler',
+            'FunctionEndpoint.http',
           ),
           await _SupportedFunctionType.create(
             resolver,
             'package:functions_framework/functions_framework.dart',
             'CloudEventHandler',
-            wrapperFunction: 'wrapCloudEventHandler',
+            'FunctionEndpoint.cloudEvent',
           ),
         ],
       );
@@ -63,21 +64,21 @@ class _SupportedFunctionType {
   final String name;
   final FunctionType type;
   final String typeDescription;
-  final String wrapperFunction;
+  final String constructor;
 
   _SupportedFunctionType(
     this.library,
     this.name,
     this.type, {
-    this.wrapperFunction,
+    this.constructor,
   }) : typeDescription = type.getDisplayString(withNullability: false);
 
   static Future<_SupportedFunctionType> create(
     Resolver resolver,
     String libraryUri,
-    String typeDefName, {
-    String wrapperFunction,
-  }) async {
+    String typeDefName,
+    String constructor,
+  ) async {
     final lib = await resolver.libraryFor(
       AssetId.resolve(libraryUri),
     );
@@ -94,7 +95,7 @@ class _SupportedFunctionType {
       libraryUri,
       typeDefName,
       functionType,
-      wrapperFunction: wrapperFunction,
+      constructor: constructor,
     );
   }
 
@@ -104,13 +105,6 @@ class _SupportedFunctionType {
         type,
       );
 
-  String createReference(FunctionElement element) {
-    var expression = '$functionsLibraryPrefix.${element.name}';
-
-    if (wrapperFunction != null) {
-      expression = '$wrapperFunction($expression)';
-    }
-
-    return expression;
-  }
+  String createReference(String targetName, FunctionElement element) =>
+      "$constructor('$targetName', $functionsLibraryPrefix.${element.name},)";
 }

functions_framework_builder/test/builder_test.dart

@@ -39,8 +39,11 @@ Response handleGet(Request request) => Response.ok('Hello, World!');
 ''',
       '''
 $_outputHeader
-final _functions = <String, Handler>{
-  'handleGet': function_library.handleGet,
+const _functions = <FunctionEndpoint>{
+  FunctionEndpoint.http(
+    'handleGet',
+    function_library.handleGet,
+  ),
 };
 ''',
     );
@@ -57,8 +60,11 @@ Response handleGet(Request request) => Response.ok('Hello, World!');
 ''',
       '''
 $_outputHeader
-final _functions = <String, Handler>{
-  'some function': function_library.handleGet,
+const _functions = <FunctionEndpoint>{
+  FunctionEndpoint.http(
+    'some function',
+    function_library.handleGet,
+  ),
 };
 ''',
     );
@@ -77,12 +83,16 @@ final _functions = <String, Handler>{
       'customResponse',
       'customResponseAsync',
       'customResponseFutureOr',
-    ].map((e) => "  '$e': function_library.$e,").join('\n');
+    ].map((e) => """
+  FunctionEndpoint.http(
+    '$e',
+    function_library.$e,
+  ),""").join('\n');
     await _generateTest(
       file.readAsStringSync(),
       '''
 $_outputHeader
-final _functions = <String, Handler>{
+const _functions = <FunctionEndpoint>{
 $lines
 };
 ''',
@@ -98,14 +108,16 @@ $lines
       'futureOrFunction',
       'optionalParam',
       'objectParam',
-    ]
-        .map((e) => "  '$e': wrapCloudEventHandler(function_library.$e),")
-        .join('\n');
+    ].map((e) => """
+  FunctionEndpoint.cloudEvent(
+    '$e',
+    function_library.$e,
+  ),""").join('\n');
     await _generateTest(
       file.readAsStringSync(),
       '''
 $_outputHeader
-final _functions = <String, Handler>{
+const _functions = <FunctionEndpoint>{
 $lines
 };
 ''',
@@ -265,8 +277,6 @@ String get _outputHeader => '''
 // limitations under the License.
 
 import 'package:functions_framework/serve.dart';
-import 'package:shelf/shelf.dart';
-
 import 'package:$_pkgName/functions.dart' as function_library;
 
 Future<void> main(List<String> args) async {