golang extension: implement GetAllHeaders in the cluster_specifier plugin. (envoyproxy#39094)

Fixes: envoyproxy#38644

- This is my first time working with Envoy and Cgo so there may be
better ways to implement this. I used
[copyHeaderMapToGo](https://github.com/envoyproxy/envoy/blob/61809bc1377543e3e6493157ab8fc96070867179/contrib/golang/upstreams/http/tcp/source/upstream_request.cc#L384-L414)
as a reference for this implementation.

ntegration testing - I would prefer to add some unit testing
as well for the Go -> Cgo code, but I didn't see existing examples of
this so I wasn't sure if it's common practice.


Signed-off-by: Kyle O'Connor <[email protected]>

Author: oconnorkyle

contrib/golang/router/cluster_specifier/source/cgo.cc

@@ -25,6 +25,16 @@ absl::string_view referGoString(void* str) {
 extern "C" {
 #endif
 
+// Assigns the number of request headers and their total byte size to the provided uint64 pointers.
+void envoyGoClusterSpecifierGetNumHeadersAndByteSize(unsigned long long header_ptr,
+                                                     void* header_num, void* byte_size) {
+  auto header = reinterpret_cast<Http::RequestHeaderMap*>(header_ptr);
+  auto go_header_num = reinterpret_cast<GoUint64*>(header_num);
+  auto go_byte_size = reinterpret_cast<GoUint64*>(byte_size);
+  *go_header_num = header->size();
+  *go_byte_size = header->byteSize();
+}
+
 // Get the value of the specified header key from the request header map.
 // Only use the first value when there are multiple values associated with the key.
 int envoyGoClusterSpecifierGetHeader(unsigned long long header_ptr, void* key, void* value) {
@@ -42,6 +52,41 @@ int envoyGoClusterSpecifierGetHeader(unsigned long long header_ptr, void* key, v
   return static_cast<int>(GetHeaderResult::Mising);
 }
 
+// Copies the request headers from `header_ptr` into the provided buffer `buf` and populates `strs`
+// with the string metadata of each key and value. `strs` points into `buf` which stores
+// concatenated raw header bytes in the format `key1val1key2val2...`. Note the buffer should
+// be allocated with sufficient memory to store the headers and `strs` is expected to be of length
+// twice the number of headers.
+void envoyGoClusterSpecifierGetAllHeaders(unsigned long long header_ptr, void* strs, void* buf) {
+  auto headers = reinterpret_cast<Http::RequestHeaderMap*>(header_ptr);
+  auto go_strs = reinterpret_cast<GoString*>(strs);
+  auto go_buf = reinterpret_cast<char*>(buf);
+  auto i = 0;
+  headers->iterate(
+      [&i, &go_strs, &go_buf](const Http::HeaderEntry& header) -> Http::HeaderMap::Iterate {
+        auto key = header.key().getStringView();
+        auto value = header.value().getStringView();
+
+        auto len = key.length();
+        go_strs[i].n = len;
+        go_strs[i].p = go_buf;
+        // go_buf is allocated in go heap memory with sufficient space for all headers.
+        memcpy(go_buf, key.data(), len); // NOLINT(safe-memcpy)
+        go_buf += len;
+        i++;
+
+        len = value.length();
+        go_strs[i].n = len;
+        if (len > 0) {
+          go_strs[i].p = go_buf;
+          memcpy(go_buf, value.data(), len); // NOLINT(safe-memcpy)
+          go_buf += len;
+        }
+        i++;
+        return Http::HeaderMap::Iterate::Continue;
+      });
+}
+
 // Log the message with the error level.
 void envoyGoClusterSpecifierLogError(unsigned long long plugin_ptr, void* msg) {
   auto msgStr = referGoString(msg);

contrib/golang/router/cluster_specifier/source/go/pkg/api/capi.go

@@ -19,5 +19,6 @@ package api
 
 type HttpCAPI interface {
 	HttpGetHeader(headerPtr uint64, key *string, value *string) bool
+	HttpGetAllHeaders(headerPtr uint64) map[string][]string
 	HttpLogError(pluginPtr uint64, msg *string)
 }

contrib/golang/router/cluster_specifier/source/go/pkg/api/cluster.go

@@ -37,4 +37,7 @@ type RequestHeaderMap interface {
 	// Get value of key
 	// If multiple values associated with this key, first one will be returned.
 	Get(key string) (string, bool)
+
+	// Get all the request headers mapped to their corresponding values.
+	GetAllHeaders() map[string][]string
 }

contrib/golang/router/cluster_specifier/source/go/pkg/cluster_specifier/api.h

@@ -6,8 +6,11 @@
 extern "C" {
 #endif
 
+void envoyGoClusterSpecifierGetNumHeadersAndByteSize(unsigned long long header_ptr,
+                                                     void* header_num, void* byte_size);
 int envoyGoClusterSpecifierGetHeader(unsigned long long header_ptr, void* key, void* value);
 void envoyGoClusterSpecifierLogError(unsigned long long plugin_ptr, void* msg);
+void envoyGoClusterSpecifierGetAllHeaders(unsigned long long header_ptr, void* strs, void* buf);
 
 #ifdef __cplusplus
 } // extern "C"

contrib/golang/router/cluster_specifier/source/go/pkg/cluster_specifier/capi_impl.go

@@ -30,6 +30,7 @@ package cluster_specifier
 */
 import "C"
 import (
+	"runtime"
 	"unsafe"
 
 	"github.com/envoyproxy/envoy/contrib/golang/router/cluster_specifier/source/go/pkg/api"
@@ -44,6 +45,34 @@ func (c *httpCApiImpl) HttpGetHeader(headerPtr uint64, key *string, value *strin
 	return int(found) == foundHeaderValue
 }
 
+func (c *httpCApiImpl) HttpGetAllHeaders(headerPtr uint64) map[string][]string {
+	var headerNum uint64
+	var headerBytes uint64
+	C.envoyGoClusterSpecifierGetNumHeadersAndByteSize(C.ulonglong(headerPtr), unsafe.Pointer(&headerNum), unsafe.Pointer(&headerBytes))
+
+	m := make(map[string][]string, headerNum)
+	if headerNum == 0 {
+		return m
+	}
+
+	strs := make([]string, headerNum*2)
+	buf := make([]byte, headerBytes)
+	C.envoyGoClusterSpecifierGetAllHeaders(C.ulonglong(headerPtr), unsafe.Pointer(unsafe.SliceData(strs)), unsafe.Pointer(unsafe.SliceData(buf)))
+
+	for i := uint64(0); i < headerNum*2; i += 2 {
+		key := strs[i]
+		value := strs[i+1]
+
+		if v, found := m[key]; !found {
+			m[key] = []string{value}
+		} else {
+			m[key] = append(v, value)
+		}
+	}
+	runtime.KeepAlive(buf)
+	return m
+}
+
 func (c *httpCApiImpl) HttpLogError(pluginPtr uint64, msg *string) {
 	C.envoyGoClusterSpecifierLogError(C.ulonglong(pluginPtr), unsafe.Pointer(msg))
 }

contrib/golang/router/cluster_specifier/source/go/pkg/cluster_specifier/type.go

@@ -32,3 +32,7 @@ func (h *httpHeaderMap) Get(key string) (string, bool) {
 	found := cAPI.HttpGetHeader(h.headerPtr, &key, &value)
 	return value, found
 }
+
+func (h *httpHeaderMap) GetAllHeaders() map[string][]string {
+	return cAPI.HttpGetAllHeaders(h.headerPtr)
+}

contrib/golang/router/cluster_specifier/test/golang_integration_test.cc

@@ -201,6 +201,59 @@ TEST_F(GolangClusterSpecifierIntegrationTest, Panic_Unknown) {
   cleanupUpstreamAndDownstream();
 }
 
+// Go plugin return cluster: "cluster_unknown"
+TEST_F(GolangClusterSpecifierIntegrationTest, GetAllHeaders_UnknownCluster) {
+  auto so_id = "simple";
+  auto yaml_string = absl::StrFormat(yaml_fmt, so_id, genSoPath(so_id), "");
+  initializeRoute(yaml_string);
+
+  codec_client_ = makeHttpConnection(lookupPort("http"));
+
+  Http::TestRequestHeaderMapImpl request_headers{
+      {":method", "GET"},         {":path", "/test"},          {":scheme", "http"},
+      {":authority", "test.com"}, {"custom_header_1", "true"}, {"custom_header_1", "false"}};
+
+  // custom_header_1 has at least one "true" value which will result in "cluster_unknown" being
+  // returned.
+  auto response = codec_client_->makeHeaderOnlyRequest(request_headers);
+
+  ASSERT_TRUE(response->waitForEndStream());
+  EXPECT_TRUE(response->complete());
+  EXPECT_THAT(response->headers(), Http::HttpStatusIs("503"));
+
+  cleanupUpstreamAndDownstream();
+}
+
+// Go plugin choose cluster: "cluster_0"
+TEST_F(GolangClusterSpecifierIntegrationTest, GetAllHeaders_DefaultCluster) {
+  auto so_id = "simple";
+  auto yaml_string = absl::StrFormat(yaml_fmt, so_id, genSoPath(so_id), "");
+  initializeRoute(yaml_string);
+
+  codec_client_ = makeHttpConnection(lookupPort("http"));
+
+  Http::TestResponseHeaderMapImpl response_headers{
+      {"server", "envoy"},
+      {":status", "200"},
+  };
+
+  Http::TestRequestHeaderMapImpl request_headers{{":method", "GET"},
+                                                 {":path", "/test"},
+                                                 {":scheme", "http"},
+                                                 {":authority", "test.com"},
+                                                 {"custom_header_1", "false"}};
+
+  // custom_header_1 has a single value set to "false" which will result in "cluster_0" being
+  // returned.
+  auto response = sendRequestAndWaitForResponse(request_headers, 0, response_headers, 0);
+
+  ASSERT_TRUE(response->waitForEndStream());
+  EXPECT_TRUE(response->complete());
+  EXPECT_EQ(response->headers().getStatusValue(), "200");
+
+  cleanupUpstreamAndDownstream();
+}
+
 } // namespace
 } // namespace Golang
 } // namespace Router

contrib/golang/router/cluster_specifier/test/test_data/simple/plugin.go

@@ -12,6 +12,19 @@ type clusterSpecifier struct {
 	panicPrefix   string
 }
 
+func headerHasTrueValue(headers map[string][]string, key string) bool {
+	values, ok := headers[key]
+	if !ok {
+		return false
+	}
+	for _, element := range values {
+		if element == "true" {
+			return true
+		}
+	}
+	return false
+}
+
 func (s *clusterSpecifier) Cluster(header api.RequestHeaderMap) string {
 	path, _ := header.Get(":path")
 
@@ -30,5 +43,9 @@ func (s *clusterSpecifier) Cluster(header api.RequestHeaderMap) string {
 		panic("test")
 	}
 
+	if headerHasTrueValue(header.GetAllHeaders(), "custom_header_1") {
+		return "cluster_unknown"
+	}
+
 	return "cluster_0"
 }