add the default proxy strategy

Author: charleszheng44

cmd/server/main.go

@@ -297,7 +297,10 @@ func (o *ProxyRunOptions) Validate() error {
 	if o.proxyStrategies != "" {
 		pss := strings.Split(o.proxyStrategies, ",")
 		for _, ps := range pss {
-			if ps != string(server.ProxyStrategyDestHost) {
+			switch ps {
+			case string(server.ProxyStrategyDestHost):
+			case string(server.ProxyStrategyDefault):
+			default:
 				return fmt.Errorf("unknown proxy strategy: %s, available strategy is: destHost", ps)
 			}
 		}
@@ -330,7 +333,7 @@ func newProxyRunOptions() *ProxyRunOptions {
 		agentServiceAccount:       "",
 		kubeconfigPath:            "",
 		authenticationAudience:    "",
-		proxyStrategies:           "",
+		proxyStrategies:           "default",
 	}
 	return &o
 }
@@ -381,7 +384,10 @@ func (p *Proxy) run(o *ProxyRunOptions) error {
 		AuthenticationAudience: o.authenticationAudience,
 	}
 	klog.V(1).Infoln("Starting master server for client connections.")
-	ps := server.GenProxyStrategiesFromStr(o.proxyStrategies)
+	ps, err := server.GenProxyStrategiesFromStr(o.proxyStrategies)
+	if err != nil {
+		return err
+	}
 	server := server.NewProxyServer(o.serverID, ps, int(o.serverCount), authOpt)
 
 	masterStop, err := p.runMasterServer(ctx, o, server)

pkg/server/backend_manager.go

@@ -33,23 +33,26 @@ import (
 type ProxyStrategy string
 
 const (
+	ProxyStrategyDefault  ProxyStrategy = "default"
 	ProxyStrategyDestHost ProxyStrategy = "destHost"
 )
 
 // GenProxyStrategiesFromStr generates the list of proxy strategies from the
 // comma-seperated string, i.e., destHost.
-func GenProxyStrategiesFromStr(proxyStrategies string) []ProxyStrategy {
+func GenProxyStrategiesFromStr(proxyStrategies string) ([]ProxyStrategy, error) {
 	var ps []ProxyStrategy
 	strs := strings.Split(proxyStrategies, ",")
 	for _, s := range strs {
 		switch s {
 		case string(ProxyStrategyDestHost):
 			ps = append(ps, ProxyStrategyDestHost)
+		case string(ProxyStrategyDefault):
+			ps = append(ps, ProxyStrategyDefault)
 		default:
-			klog.V(4).InfoS("Unknown proxy strategy", "strategy", s)
+			return nil, fmt.Errorf("Unknown proxy strategy %s", s)
 		}
 	}
-	return ps
+	return ps, nil
 }
 
 type Backend interface {
@@ -168,7 +171,7 @@ func containIdType(idTypes []pkgagent.IdentifierType, idType pkgagent.Identifier
 // AddBackend adds a backend.
 func (s *DefaultBackendStorage) AddBackend(identifier string, idType pkgagent.IdentifierType, conn agent.AgentService_ConnectServer) Backend {
 	if !containIdType(s.idTypes, idType) {
-		klog.V(4).InfoS("fial to add backend", "backend", identifier, "error", &ErrWrongIDType{idType, s.idTypes})
+		klog.V(4).InfoS("fail to add backend", "backend", identifier, "error", &ErrWrongIDType{idType, s.idTypes})
 		return nil
 	}
 	klog.V(2).InfoS("Register backend for agent", "connection", conn, "agentID", identifier)

pkg/server/server.go

@@ -296,10 +296,12 @@ func NewProxyServer(serverID string, proxyStrategies []ProxyStrategy, serverCoun
 		switch ps {
 		case ProxyStrategyDestHost:
 			bms = append(bms, NewDestHostBackendManager())
+		case ProxyStrategyDefault:
+			bms = append(bms, NewDefaultBackendManager())
 		default:
+			klog.V(4).InfoS("Unknonw proxy strategy", "strategy", ps)
 		}
 	}
-	bms = append(bms, NewDefaultBackendManager())
 
 	return &ProxyServer{
 		frontends:                  make(map[string](map[int64]*ProxyClientConnection)),
@@ -308,9 +310,8 @@ func NewProxyServer(serverID string, proxyStrategies []ProxyStrategy, serverCoun
 		serverCount:                serverCount,
 		BackendManagers:            bms,
 		AgentAuthenticationOptions: agentAuthenticationOptions,
-		// use the last backendmanager, i.e., default backendmanager,
-		// as the Readiness Manager
-		Readiness:       bms[len(bms)-1],
+		// use the first backendmanager as the Readiness Manager
+		Readiness:       bms[0],
 		proxyStrategies: proxyStrategies,
 	}
 }

pkg/server/server_test.go

@@ -159,7 +159,7 @@ func TestAgentTokenAuthenticationErrorsToken(t *testing.T) {
 				conn.EXPECT().Recv().Return(nil, io.EOF)
 			}
 
-			p := NewProxyServer("", []ProxyStrategy{}, 1, &AgentTokenAuthenticationOptions{
+			p := NewProxyServer("", []ProxyStrategy{ProxyStrategyDefault}, 1, &AgentTokenAuthenticationOptions{
 				Enabled:             true,
 				KubernetesClient:    kcs,
 				AgentNamespace:      tc.wantNamespace,
@@ -187,15 +187,15 @@ func TestAddRemoveFrontends(t *testing.T) {
 	agent2ConnID2 := new(ProxyClientConnection)
 	agent3ConnID1 := new(ProxyClientConnection)
 
-	p := NewProxyServer("", []ProxyStrategy{}, 1, nil)
+	p := NewProxyServer("", []ProxyStrategy{ProxyStrategyDefault}, 1, nil)
 	p.addFrontend("agent1", int64(1), agent1ConnID1)
 	p.removeFrontend("agent1", int64(1))
 	expectedFrontends := make(map[string]map[int64]*ProxyClientConnection)
 	if e, a := expectedFrontends, p.frontends; !reflect.DeepEqual(e, a) {
 		t.Errorf("expected %v, got %v", e, a)
 	}
 
-	p = NewProxyServer("", []ProxyStrategy{}, 1, nil)
+	p = NewProxyServer("", []ProxyStrategy{ProxyStrategyDefault}, 1, nil)
 	p.addFrontend("agent1", int64(1), agent1ConnID1)
 	p.addFrontend("agent1", int64(2), agent1ConnID2)
 	p.addFrontend("agent2", int64(1), agent2ConnID1)

tests/proxy_test.go

@@ -274,7 +274,7 @@ func runGRPCProxyServerWithServerCount(serverCount int) (proxy, *server.ProxySer
 	var err error
 	var lis, lis2 net.Listener
 
-	server := server.NewProxyServer(uuid.New().String(), []server.ProxyStrategy{}, serverCount, &server.AgentTokenAuthenticationOptions{})
+	server := server.NewProxyServer(uuid.New().String(), []server.ProxyStrategy{server.ProxyStrategyDefault}, serverCount, &server.AgentTokenAuthenticationOptions{})
 	grpcServer := grpc.NewServer()
 	agentServer := grpc.NewServer()
 	cleanup := func() {
@@ -312,7 +312,7 @@ func runGRPCProxyServerWithServerCount(serverCount int) (proxy, *server.ProxySer
 
 func runHTTPConnProxyServer() (proxy, func(), error) {
 	var proxy proxy
-	s := server.NewProxyServer(uuid.New().String(), []server.ProxyStrategy{}, 0, &server.AgentTokenAuthenticationOptions{})
+	s := server.NewProxyServer(uuid.New().String(), []server.ProxyStrategy{server.ProxyStrategyDefault}, 0, &server.AgentTokenAuthenticationOptions{})
 	agentServer := grpc.NewServer()
 
 	agentproto.RegisterAgentServiceServer(agentServer, s)