Skip to content

Agent Mesh

refactor(node): migrate service proxy from Director to Rewrite

Emin Aktase3d594c53da6
diff --git a/internal/node/service.go b/internal/node/service.go
index 06890d3e..2654cc5b 100644
--- a/internal/node/service.go
+++ b/internal/node/service.go
@@ -55,32 +55,20 @@ func newReverseProxyHandler(targetURL string) (http.Handler, error) {
if err != nil {
return nil, fmt.Errorf("invalid target URL: %w", err)
}
- proxy := httputil.NewSingleHostReverseProxy(u)
- if proxy.Rewrite != nil {
- originalRewrite := proxy.Rewrite
- proxy.Rewrite = func(pr *httputil.ProxyRequest) {
+ return &httputil.ReverseProxy{
+ Rewrite: func(pr *httputil.ProxyRequest) {
noTrailingSlash := pr.In.Header.Get(api.HeaderSamNoTrailingSlash) == "true"
- originalRewrite(pr)
+ pr.SetURL(u)
+ // Preserve the Host behavior of NewSingleHostReverseProxy.
+ pr.Out.Host = pr.In.Host
pr.Out.Header.Del(api.HeaderSamNoTrailingSlash)
if noTrailingSlash && !strings.HasSuffix(u.Path, "/") && strings.HasSuffix(pr.Out.URL.Path, "/") {
pr.Out.URL.Path = strings.TrimSuffix(pr.Out.URL.Path, "/")
}
+ pr.SetXForwarded()
logger.Debugf("[ReverseProxy] Forwarding to: %q", pr.Out.URL.String())
- }
- } else {
- originalDirector := proxy.Director
- proxy.Director = func(req *http.Request) {
- noTrailingSlash := req.Header.Get(api.HeaderSamNoTrailingSlash) == "true"
- req.Header.Del(api.HeaderSamNoTrailingSlash)
- originalDirector(req)
-
- if noTrailingSlash && !strings.HasSuffix(u.Path, "/") && strings.HasSuffix(req.URL.Path, "/") {
- req.URL.Path = strings.TrimSuffix(req.URL.Path, "/")
- }
- logger.Debugf("[ReverseProxy] Forwarding to: %q", req.URL.String())
- }
- }
- return proxy, nil
+ },
+ }, nil
}
func (b *baseService) Info() *api.ServiceInfo { return b.info }
diff --git a/internal/node/service_test.go b/internal/node/service_test.go
index d45a6134..03ec100f 100644
--- a/internal/node/service_test.go
+++ b/internal/node/service_test.go
@@ -61,6 +61,92 @@ func TestBaseService_InitURLBackend_BuildsReverseProxy(t *testing.T) {
}
}
+func TestNewReverseProxyHandler_RewritesRequests(t *testing.T) {
+ for _, tc := range []struct {
+ name string
+ targetURL string
+ requestURL string
+ noTrailingSlash bool
+ wantURL string
+ wantProto string
+ }{
+ {
+ name: "joins target path and query",
+ targetURL: "http://backend.example/base?upstream=one",
+ requestURL: "https://service.sam/child/?client=two",
+ wantURL: "http://backend.example/base/child/?upstream=one&client=two",
+ wantProto: "https",
+ },
+ {
+ name: "marker trims trailing slash",
+ targetURL: "http://backend.example/base?upstream=one",
+ requestURL: "http://service.sam/child/?client=two",
+ noTrailingSlash: true,
+ wantURL: "http://backend.example/base/child?upstream=one&client=two",
+ wantProto: "http",
+ },
+ {
+ name: "target trailing slash is retained",
+ targetURL: "http://backend.example/base/",
+ requestURL: "http://service.sam/child/",
+ noTrailingSlash: true,
+ wantURL: "http://backend.example/base/child/",
+ wantProto: "http",
+ },
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ handler, err := newReverseProxyHandler(tc.targetURL)
+ if err != nil {
+ t.Fatalf("newReverseProxyHandler: %v", err)
+ }
+ proxy := handler.(*httputil.ReverseProxy)
+ var forwarded *http.Request
+ proxy.Transport = roundTripFunc(func(req *http.Request) (*http.Response, error) {
+ forwarded = req.Clone(req.Context())
+ return &http.Response{
+ StatusCode: http.StatusNoContent,
+ Header: make(http.Header),
+ Body: http.NoBody,
+ }, nil
+ })
+ req := httptest.NewRequest(http.MethodGet, tc.requestURL, nil)
+ req.RemoteAddr = "192.0.2.1:12345"
+ if tc.noTrailingSlash {
+ req.Header.Set(api.HeaderSamNoTrailingSlash, "true")
+ }
+ req.Header.Set("Forwarded", "for=spoofed;host=spoofed;proto=spoofed")
+ req.Header.Set("X-Forwarded-For", "spoofed")
+ req.Header.Set("X-Forwarded-Host", "spoofed")
+ req.Header.Set("X-Forwarded-Proto", "spoofed")
+ recorder := httptest.NewRecorder()
+ proxy.ServeHTTP(recorder, req)
+ if recorder.Code != http.StatusNoContent {
+ t.Fatalf("status = %d, want %d", recorder.Code, http.StatusNoContent)
+ }
+ if forwarded == nil {
+ t.Fatal("request did not reach the upstream transport")
+ }
+ if got := forwarded.URL.String(); got != tc.wantURL {
+ t.Errorf("upstream URL = %q, want %q", got, tc.wantURL)
+ }
+ if forwarded.Host != req.Host {
+ t.Errorf("upstream Host = %q, want %q", forwarded.Host, req.Host)
+ }
+ for name, want := range map[string]string{
+ api.HeaderSamNoTrailingSlash: "",
+ "Forwarded": "",
+ "X-Forwarded-For": "192.0.2.1",
+ "X-Forwarded-Host": req.Host,
+ "X-Forwarded-Proto": tc.wantProto,
+ } {
+ if got := forwarded.Header.Get(name); got != want {
+ t.Errorf("upstream %s = %q, want %q", name, got, want)
+ }
+ }
+ })
+ }
+}
+
func TestBaseService_InitURLBackend_InvalidURL(t *testing.T) {
b := &baseService{
info: &api.ServiceInfo{Type: api.ServiceType_SERVICE_TYPE_INFERENCE, Name: "demo"},