incorporate changes in router implementation

app/router/command/command.go

@@ -6,14 +6,11 @@ import (
 	"context"
 	"time"
 
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/codes"
-	"google.golang.org/grpc/status"
-
 	core "github.com/v2fly/v2ray-core/v4"
 	"github.com/v2fly/v2ray-core/v4/common"
 	"github.com/v2fly/v2ray-core/v4/features/routing"
 	"github.com/v2fly/v2ray-core/v4/features/stats"
+	"google.golang.org/grpc"
 )
 
 // routingServer is an implementation of RoutingService.
@@ -22,6 +19,41 @@ type routingServer struct {
 	routingStats stats.Channel
 }
 
+func (s *routingServer) GetBalancerInfo(ctx context.Context, request *GetBalancerInfoRequest) (*GetBalancerInfoResponse, error) {
+	var ret GetBalancerInfoResponse
+	ret.Balancer = &BalancerMsg{}
+	if bo, ok := s.router.(routing.BalancerOverrider); ok {
+		{
+			res, err := bo.GetOverrideTarget(request.GetTag())
+			if err != nil {
+				return nil, err
+			}
+			ret.Balancer.Override = &OverrideInfo{
+				Target: res,
+			}
+		}
+	}
+
+	if pt, ok := s.router.(routing.BalancerPrincipleTarget); ok {
+		{
+			res, err := pt.GetPrincipleTarget(request.GetTag())
+			if err != nil {
+				newError("unable to obtain principle target").Base(err).AtInfo().WriteToLog()
+			} else {
+				ret.Balancer.PrincipleTarget = &PrincipleTargetInfo{Tag: res}
+			}
+		}
+	}
+	return &ret, nil
+}
+
+func (s *routingServer) OverrideBalancerTarget(ctx context.Context, request *OverrideBalancerTargetRequest) (*OverrideBalancerTargetResponse, error) {
+	if bo, ok := s.router.(routing.BalancerOverrider); ok {
+		return &OverrideBalancerTargetResponse{}, bo.SetOverrideTarget(request.BalancerTag, request.Target)
+	}
+	return nil, newError("unsupported router implementation")
+}
+
 // NewRoutingServer creates a statistics service with statistics manager.
 func NewRoutingServer(router routing.Router, routingStats stats.Channel) RoutingServiceServer {
 	return &routingServer{
@@ -75,80 +107,6 @@ func (s *routingServer) SubscribeRoutingStats(request *SubscribeRoutingStatsRequ
 	}
 }
 
-func (s *routingServer) GetBalancers(ctx context.Context, request *GetBalancersRequest) (*GetBalancersResponse, error) {
-	h, ok := s.router.(routing.RouterChecker)
-	if !ok {
-		return nil, status.Errorf(codes.Unavailable, "current router is not a health checker")
-	}
-	results, err := h.GetBalancersInfo(request.BalancerTags)
-	if err != nil {
-		return nil, status.Errorf(codes.Internal, err.Error())
-	}
-	rsp := &GetBalancersResponse{
-		Balancers: make([]*BalancerMsg, 0),
-	}
-	for _, result := range results {
-		var override *OverrideSelectingMsg
-		if result.Override != nil {
-			override = &OverrideSelectingMsg{
-				Until:   result.Override.Until.Local().String(),
-				Selects: result.Override.Selects,
-			}
-		}
-		stat := &BalancerMsg{
-			Tag:              result.Tag,
-			StrategySettings: result.Strategy.Settings,
-			Titles:           result.Strategy.ValueTitles,
-			Override:         override,
-			Selects:          make([]*OutboundMsg, 0),
-			Others:           make([]*OutboundMsg, 0),
-		}
-		for _, item := range result.Strategy.Selects {
-			stat.Selects = append(stat.Selects, &OutboundMsg{
-				Tag:    item.Tag,
-				Values: item.Values,
-			})
-		}
-		for _, item := range result.Strategy.Others {
-			stat.Others = append(stat.Others, &OutboundMsg{
-				Tag:    item.Tag,
-				Values: item.Values,
-			})
-		}
-		rsp.Balancers = append(rsp.Balancers, stat)
-	}
-	return rsp, nil
-}
-func (s *routingServer) CheckBalancers(ctx context.Context, request *CheckBalancersRequest) (*CheckBalancersResponse, error) {
-	h, ok := s.router.(routing.RouterChecker)
-	if !ok {
-		return nil, status.Errorf(codes.Unavailable, "current router is not a health checker")
-	}
-	go func() {
-		err := h.CheckBalancers(request.BalancerTags)
-		if err != nil {
-			newError("CheckBalancers error:", err).AtInfo().WriteToLog()
-		}
-	}()
-	return &CheckBalancersResponse{}, nil
-}
-
-func (s *routingServer) OverrideSelecting(ctx context.Context, request *OverrideSelectingRequest) (*OverrideSelectingResponse, error) {
-	bo, ok := s.router.(routing.BalancingOverrider)
-	if !ok {
-		return nil, status.Errorf(codes.Unavailable, "current router doesn't support balancing override")
-	}
-	err := bo.OverrideSelecting(
-		request.BalancerTag,
-		request.Selectors,
-		time.Duration(request.Validity),
-	)
-	if err != nil {
-		return nil, status.Errorf(codes.InvalidArgument, err.Error())
-	}
-	return &OverrideSelectingResponse{}, nil
-}
-
 func (s *routingServer) mustEmbedUnimplementedRoutingServiceServer() {}
 
 type service struct {