*: Correct gRFC A1 implementation

clientconn.go

@@ -225,7 +225,7 @@ func Dial(target string, opts ...DialOption) (*ClientConn, error) {
 func DialContext(ctx context.Context, target string, opts ...DialOption) (conn *ClientConn, err error) {
 	// At the end of this method, we kick the channel out of idle, rather than
 	// waiting for the first rpc.
-	opts = append([]DialOption{withDefaultScheme("passthrough")}, opts...)
+	opts = append([]DialOption{withDefaultScheme("passthrough"), WithTargetResolutionEnabled()}, opts...)
 	cc, err := NewClient(target, opts...)
 	if err != nil {
 		return nil, err

dialoptions.go

@@ -94,6 +94,11 @@ type dialOptions struct {
 	idleTimeout                 time.Duration
 	defaultScheme               string
 	maxCallAttempts             int
+	// TargetResolutionEnabled specifies if the target resolution on client is
+	// enabled even when proxy is enabled.
+	TargetResolutionEnabled bool
+	// UseProxy specifies if a proxy should be used.
+	UseProxy bool
 }
 
 // DialOption configures how we set up the connection.
@@ -377,7 +382,15 @@ func WithInsecure() DialOption {
 // later release.
 func WithNoProxy() DialOption {
 	return newFuncDialOption(func(o *dialOptions) {
-		o.copts.UseProxy = false
+		o.UseProxy = false
+	})
+}
+
+// WithTargetResolutionEnabled returns a DialOption which enables target
+// resolution on client.
+func WithTargetResolutionEnabled() DialOption {
+	return newFuncDialOption(func(o *dialOptions) {
+		o.TargetResolutionEnabled = true
 	})
 }
 
@@ -662,14 +675,15 @@ func defaultDialOptions() dialOptions {
 		copts: transport.ConnectOptions{
 			ReadBufferSize:  defaultReadBufSize,
 			WriteBufferSize: defaultWriteBufSize,
-			UseProxy:        true,
 			UserAgent:       grpcUA,
 			BufferPool:      mem.DefaultBufferPool(),
 		},
-		bs:              internalbackoff.DefaultExponential,
-		idleTimeout:     30 * time.Minute,
-		defaultScheme:   "dns",
-		maxCallAttempts: defaultMaxCallAttempts,
+		bs:                      internalbackoff.DefaultExponential,
+		idleTimeout:             30 * time.Minute,
+		defaultScheme:           "dns",
+		maxCallAttempts:         defaultMaxCallAttempts,
+		UseProxy:                true,
+		TargetResolutionEnabled: false,
 	}
 }
 

internal/internal.go

@@ -238,6 +238,11 @@ var (
 	// SetBufferPoolingThresholdForTesting updates the buffer pooling threshold, for
 	// testing purposes.
 	SetBufferPoolingThresholdForTesting any // func(int)
+
+	// HTTPSProxyFromEnvironmentForTesting returns the URL of the proxy to use
+	// for testing purposes. It is used to override the `http.ProxyFromEnvironment`
+	// function for testing purposes.
+	HTTPSProxyFromEnvironmentForTesting any // func(*http.Request) (*url.URL, error)
 )
 
 // HealthChecker defines the signature of the client-side LB channel health

internal/proxyattributes/proxyattributes.go

@@ -0,0 +1,64 @@
+/*
+ *
+ * Copyright 2024 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// Package proxyattributes contains functions for getting and setting proxy
+// attributes like the CONNECT address and user info.
+package proxyattributes
+
+import (
+	"net/url"
+
+	"google.golang.org/grpc/resolver"
+)
+
+type keyType string
+
+const userAndConnectAddrKey = keyType("grpc.resolver.delegatingresolver.userAndConnectAddr")
+
+type attr struct {
+	user *url.Userinfo
+	addr string
+}
+
+// Populate returns a copy of addr with attributes containing the
+// provided user and connect address, which are needed during the CONNECT
+// handshake for a proxy connection.
+func Populate(resAddr resolver.Address, user *url.Userinfo, addr string) resolver.Address {
+	resAddr.Attributes = resAddr.Attributes.WithValue(userAndConnectAddrKey, attr{user: user, addr: addr})
+	return resAddr
+}
+
+// ProxyConnectAddr returns the proxy connect address in resolver.Address, or nil
+// if not present. The returned data should not be mutated.
+func ProxyConnectAddr(addr resolver.Address) string {
+	attribute := addr.Attributes.Value(userAndConnectAddrKey)
+	if attribute != nil {
+		return attribute.(attr).addr
+	}
+	return ""
+}
+
+// User returns the user info in the resolver.Address, or nil if not present.
+// The returned data should not be mutated.
+func User(addr resolver.Address) *url.Userinfo {
+	attribute := addr.Attributes.Value(userAndConnectAddrKey)
+	if attribute != nil {
+		return attribute.(attr).user
+	}
+	return nil
+}

internal/proxyattributes/proxyattributes_test.go

@@ -0,0 +1,103 @@
+/*
+ *
+ * Copyright 2024 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+package proxyattributes
+
+import (
+	"net/url"
+	"testing"
+
+	"google.golang.org/grpc/attributes"
+	"google.golang.org/grpc/internal/grpctest"
+	"google.golang.org/grpc/resolver"
+)
+
+type s struct {
+	grpctest.Tester
+}
+
+func Test(t *testing.T) {
+	grpctest.RunSubTests(t, s{})
+}
+
+// TestProxyConnectAddr tests ProxyConnectAddr returns the coorect connect
+// address in the attribute.
+func (s) TestProxyConnectAddr(t *testing.T) {
+	addr := resolver.Address{
+		Addr:       "test-address",
+		Attributes: attributes.New(userAndConnectAddrKey, attr{user: nil, addr: "proxy-address"}),
+	}
+
+	// Validate ProxyConnectAddr returns empty string for missing attributes
+	if got, want := ProxyConnectAddr(addr), "proxy-address"; got != want {
+		t.Errorf("Unexpected ConnectAddr proxy atrribute = %v, want : %v", got, want)
+	}
+}
+
+// TestUser tests User returns the correct user in the attribute.
+func (s) TestUser(t *testing.T) {
+	user := url.UserPassword("username", "password")
+	addr := resolver.Address{
+		Addr:       "test-address",
+		Attributes: attributes.New(userAndConnectAddrKey, attr{user: user, addr: ""}),
+	}
+
+	// Validate User returns nil for missing attributes
+	if got, want := User(addr), user; got != want {
+		t.Errorf("unexpected User proxy attribute = %v, want %v", got, want)
+	}
+}
+
+// TestEmptyProxyAttribute tests ProxyConnectAddr and User return empty string
+// and nil respectively when not set.
+func (s) TestEmptyProxyAttribute(t *testing.T) {
+	addr := resolver.Address{
+		Addr: "test-address",
+	}
+
+	// Validate ProxyConnectAddr returns empty string for missing attributes
+	if got := ProxyConnectAddr(addr); got != "" {
+		t.Errorf("Unexpected ConnectAddr proxy atrribute = %v, want empty string", got)
+	}
+	// Validate User returns nil for missing attributes
+	if got := User(addr); got != nil {
+		t.Errorf("unexpected User proxy attribute = %v, want nil", got)
+	}
+}
+
+// TestPopulate tests Populate returns a copy of addr with attributes
+// containing correct user and connect address.
+func (s) TestPopulate(t *testing.T) {
+	addr := resolver.Address{
+		Addr: "test-address",
+	}
+	user := url.UserPassword("username", "password")
+	connectAddr := "proxy-address"
+
+	// Call Populate and validate attributes
+	populatedAddr := Populate(addr, user, connectAddr)
+
+	// Verify that the returned address is updated correctly
+	if got, want := ProxyConnectAddr(populatedAddr), connectAddr; got != want {
+		t.Errorf("Unexpected ConnectAddr proxy atrribute = %v, want %v", got, want)
+	}
+
+	if got, want := User(populatedAddr), user; got != want {
+		t.Errorf("unexpected User proxy attribute = %v, want %v", got, want)
+	}
+}