fix: add option to disable dns resolve

Signed-off-by: hlts2 <[email protected]>

internal/net/grpc/client.go

@@ -87,30 +87,32 @@ type Client interface {
 	GetDialOption() []DialOption
 	GetCallOption() []CallOption
 	GetBackoff() backoff.Backoff
+	SetDisableResolveDNSAddr(addr string, disabled bool)
 	ConnectedAddrs() []string
 	Close(ctx context.Context) error
 }
 
 type gRPCClient struct {
-	addrs               map[string]struct{}
-	poolSize            uint64
-	clientCount         uint64
-	conns               sync.Map[string, pool.Conn]
-	hcDur               time.Duration
-	prDur               time.Duration
-	dialer              net.Dialer
-	enablePoolRebalance bool
-	resolveDNS          bool
-	dopts               []DialOption
-	copts               []CallOption
-	roccd               string // reconnection old connection closing duration
-	eg                  errgroup.Group
-	bo                  backoff.Backoff
-	cb                  circuitbreaker.CircuitBreaker
-	gbo                 gbackoff.Config // grpc's original backoff configuration
-	mcd                 time.Duration   // minimum connection timeout duration
-	group               singleflight.Group[pool.Conn]
-	crl                 sync.Map[string, bool] // connection request list
+	addrs                  map[string]struct{}
+	poolSize               uint64
+	clientCount            uint64
+	conns                  sync.Map[string, pool.Conn]
+	hcDur                  time.Duration
+	prDur                  time.Duration
+	dialer                 net.Dialer
+	enablePoolRebalance    bool
+	disableResolveDNSAddrs sync.Map[string, bool]
+	resolveDNS             bool
+	dopts                  []DialOption
+	copts                  []CallOption
+	roccd                  string // reconnection old connection closing duration
+	eg                     errgroup.Group
+	bo                     backoff.Backoff
+	cb                     circuitbreaker.CircuitBreaker
+	gbo                    gbackoff.Config // grpc's original backoff configuration
+	mcd                    time.Duration   // minimum connection timeout duration
+	group                  singleflight.Group[pool.Conn]
+	crl                    sync.Map[string, bool] // connection request list
 
 	ech            <-chan error
 	monitorRunning atomic.Bool
@@ -946,6 +948,12 @@ func (g *gRPCClient) GetBackoff() backoff.Backoff {
 	return g.bo
 }
 
+func (g *gRPCClient) SetDisableResolveDNSAddr(addr string, disabled bool) {
+	// NOTE: When connecting to multiple locations, it was necessary to switch dynamically, so implementation was added.
+	// There is no setting for disable on the helm chart side, so I used this implementation.
+	g.disableResolveDNSAddrs.Store(addr, disabled)
+}
+
 func (g *gRPCClient) Connect(
 	ctx context.Context, addr string, dopts ...DialOption,
 ) (conn pool.Conn, err error) {
@@ -975,7 +983,13 @@ func (g *gRPCClient) Connect(
 			pool.WithAddr(addr),
 			pool.WithSize(g.poolSize),
 			pool.WithDialOptions(append(g.dopts, dopts...)...),
-			pool.WithResolveDNS(g.resolveDNS),
+			pool.WithResolveDNS(func() bool {
+				disabled, ok := g.disableResolveDNSAddrs.Load(addr)
+				if ok && disabled {
+					return false
+				}
+				return g.resolveDNS
+			}()),
 		}
 		if g.bo != nil {
 			opts = append(opts, pool.WithBackoff(g.bo))

pkg/gateway/mirror/service/gateway.go

@@ -16,6 +16,7 @@ package service
 import (
 	"context"
 	"reflect"
+	"strings"
 
 	"github.com/vdaas/vald/internal/client/v1/client/mirror"
 	"github.com/vdaas/vald/internal/errors"
@@ -143,11 +144,21 @@ func (g *gateway) Do(
 	if target == "" {
 		return nil, errors.ErrTargetNotFound
 	}
-	return g.client.GRPCClient().Do(g.ForwardedContext(ctx, g.podName), target,
+	fctx := g.ForwardedContext(ctx, g.podName)
+	res, err = g.client.GRPCClient().Do(fctx, target,
 		func(ictx context.Context, conn *grpc.ClientConn, copts ...grpc.CallOption) (any, error) {
 			return f(ictx, target, NewMirrorClient(conn), copts...)
 		},
 	)
+	if err != nil {
+		return g.client.GRPCClient().RoundRobin(fctx, func(ictx context.Context, conn *grpc.ClientConn, copts ...grpc.CallOption) (any, error) {
+			if strings.EqualFold(conn.Target(), target) {
+				return nil, errors.ErrTargetNotFound
+			}
+			return f(ictx, conn.Target(), NewMirrorClient(conn), copts...)
+		})
+	}
+	return res, nil
 }
 
 // DoMulti performs a gRPC operation on multiple targets using the provided function.

pkg/gateway/mirror/service/mirror.go

@@ -319,6 +319,7 @@ func (m *mirr) Connect(ctx context.Context, targets ...*payload.Mirror_Target) e
 		if !m.isSelfMirrorAddr(addr) && !m.isGatewayAddr(addr) {
 			_, ok := m.addrs.Load(addr)
 			if !ok || !m.IsConnected(ctx, addr) {
+				m.gateway.GRPCClient().SetDisableResolveDNSAddr(addr, true)
 				_, err := m.gateway.GRPCClient().Connect(ctx, addr)
 				if err != nil {
 					m.addrs.Delete(addr)