feat: support mapping of legacy GCF events

google/cloud/functions/CMakeLists.txt

@@ -47,6 +47,8 @@ add_library(
     internal/parse_cloud_event_http.h
     internal/parse_cloud_event_json.cc
     internal/parse_cloud_event_json.h
+    internal/parse_cloud_event_legacy.cc
+    internal/parse_cloud_event_legacy.h
     internal/parse_cloud_event_storage.cc
     internal/parse_cloud_event_storage.h
     internal/parse_options.cc
@@ -97,6 +99,7 @@ if (BUILD_TESTING)
         internal/framework_impl_test.cc
         internal/parse_cloud_event_http_test.cc
         internal/parse_cloud_event_json_test.cc
+        internal/parse_cloud_event_legacy_test.cc
         internal/parse_cloud_event_storage_test.cc
         internal/parse_options_test.cc
         internal/wrap_request_test.cc

google/cloud/functions/cloud_event.cc

@@ -13,7 +13,7 @@
 // limitations under the License.
 
 #include "google/cloud/functions/cloud_event.h"
-#include <absl/time/time.h>
+#include <absl/time/time.h>  // NOLINT(modernize-deprecated-headers)
 
 namespace google::cloud::functions {
 inline namespace FUNCTIONS_FRAMEWORK_CPP_NS {

google/cloud/functions/internal/parse_cloud_event_http.cc

@@ -14,40 +14,48 @@
 
 #include "google/cloud/functions/internal/parse_cloud_event_http.h"
 #include "google/cloud/functions/internal/parse_cloud_event_json.h"
+#include "google/cloud/functions/internal/parse_cloud_event_legacy.h"
 #include "google/cloud/functions/internal/parse_cloud_event_storage.h"
 
 namespace google::cloud::functions_internal {
 inline namespace FUNCTIONS_FRAMEWORK_CPP_NS {
 
+bool HasHeader(BeastRequest const& request, std::string_view header) {
+  return request.count(header) != 0;
+}
+
+bool HasMinimalCloudEventHeaders(BeastRequest const& request) {
+  char const* minimal_headers[] = {"ce-id", "ce-source", "ce-type"};
+  return std::all_of(std::begin(minimal_headers), std::end(minimal_headers),
+                     [&request](auto h) { return HasHeader(request, h); });
+}
+
 functions::CloudEvent ParseCloudEventHttpBinary(BeastRequest const& request) {
-  auto has_header = [&request](std::string_view header) {
-    return request.find(header) != request.end();
-  };
   std::string spec_version = functions::CloudEvent::kDefaultSpecVersion;
-  if (has_header("ce-specversion")) {
+  if (HasHeader(request, "ce-specversion")) {
     spec_version = request["ce-specversion"];
   }
   functions::CloudEvent event(std::string(request.at("ce-id")),
                               std::string(request.at("ce-source")),
                               std::string(request.at("ce-type")), spec_version);
-  if (has_header("ce-datacontenttype")) {
-    if (has_header("Content-Type") &&
+  if (HasHeader(request, "ce-datacontenttype")) {
+    if (HasHeader(request, "Content-Type") &&
         request["ce-datacontenttype"] != request["Content-Type"]) {
       throw std::invalid_argument(
           "Mismatched ce-datacontentype and Content-Type header values");
     }
     event.set_data_content_type(std::string(request["ce-datacontenttype"]));
-  } else if (has_header("Content-Type")) {
+  } else if (HasHeader(request, "Content-Type")) {
     event.set_data_content_type(std::string(request["Content-Type"]));
   }
 
-  if (has_header("ce-dataschema")) {
+  if (HasHeader(request, "ce-dataschema")) {
     event.set_data_schema(std::string(request["ce-dataschema"]));
   }
-  if (has_header("ce-subject")) {
+  if (HasHeader(request, "ce-subject")) {
     event.set_subject(std::string(request["ce-subject"]));
   }
-  if (has_header("ce-time")) {
+  if (HasHeader(request, "ce-time")) {
     event.set_time(std::string(request["ce-time"]));
   }
 
@@ -60,16 +68,20 @@ functions::CloudEvent ParseCloudEventHttpBinary(BeastRequest const& request) {
 
 std::vector<functions::CloudEvent> ParseCloudEventHttp(
     BeastRequest const& request) {
-  if (request.count("content-type") == 0) {
+  if (!HasHeader(request, "content-type")) {
     return {ParseCloudEventStorage(ParseCloudEventHttpBinary(request))};
   }
-  auto content_type = request["content-type"];
+  auto const content_type = request["content-type"];
   if (content_type.rfind("application/cloudevents-batch+json", 0) == 0) {
     return ParseCloudEventJsonBatch(request.body());
   }
   if (content_type.rfind("application/cloudevents+json", 0) == 0) {
     return {ParseCloudEventJson(request.body())};
   }
+  if (content_type.rfind("application/json", 0) == 0 &&
+      !HasMinimalCloudEventHeaders(request)) {
+    return {ParseCloudEventLegacy(request.body())};
+  }
   return {ParseCloudEventStorage(ParseCloudEventHttpBinary(request))};
 }