mirror of
https://github.com/XTLS/Xray-core.git
synced 2024-09-06 08:19:20 +03:00
* v5: Health Check & LeastLoad Strategy (rebased from 2c5a71490368500a982018a74a6d519c7e121816) Some changes will be necessary to integrate it into V2Ray * Update proto * parse duration conf with time.Parse() * moving health ping to observatory as a standalone component * moving health ping to observatory as a standalone component: auto generated file * add initialization for health ping * incorporate changes in router implementation * support principle target output * add v4 json support for BurstObservatory & fix balancer reference * update API command * remove cancelled API * return zero length value when observer is not found * remove duplicated targeted dispatch * adjust test with updated structure * bug fix for observer * fix strategy selector * fix strategy least load * Fix ticker usage ticker.Close does not close ticker.C * feat: Replace default Health Ping URL to HTTPS (#1991) * fix selectLeastLoad() returns wrong number of nodes (#2083) * Test: fix leastload strategy unit test * fix(router): panic caused by concurrent map read and write (#2678) * Clean up code --------- Co-authored-by: Jebbs <qjebbs@gmail.com> Co-authored-by: Shelikhoo <xiaokangwang@outlook.com> Co-authored-by: 世界 <i@sekai.icu> Co-authored-by: Bernd Eichelberger <46166740+4-FLOSS-Free-Libre-Open-Source-Software@users.noreply.github.com> Co-authored-by: 秋のかえで <autmaple@protonmail.com> Co-authored-by: Rinka <kujourinka@gmail.com>
134 lines
3.9 KiB
Go
134 lines
3.9 KiB
Go
package command
|
|
|
|
//go:generate go run github.com/xtls/xray-core/common/errors/errorgen
|
|
|
|
import (
|
|
"context"
|
|
"time"
|
|
|
|
"github.com/xtls/xray-core/common"
|
|
"github.com/xtls/xray-core/core"
|
|
"github.com/xtls/xray-core/features/routing"
|
|
"github.com/xtls/xray-core/features/stats"
|
|
"google.golang.org/grpc"
|
|
)
|
|
|
|
// routingServer is an implementation of RoutingService.
|
|
type routingServer struct {
|
|
router routing.Router
|
|
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{
|
|
router: router,
|
|
routingStats: routingStats,
|
|
}
|
|
}
|
|
|
|
func (s *routingServer) TestRoute(ctx context.Context, request *TestRouteRequest) (*RoutingContext, error) {
|
|
if request.RoutingContext == nil {
|
|
return nil, newError("Invalid routing request.")
|
|
}
|
|
route, err := s.router.PickRoute(AsRoutingContext(request.RoutingContext))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if request.PublishResult && s.routingStats != nil {
|
|
ctx, _ := context.WithTimeout(context.Background(), 4*time.Second)
|
|
s.routingStats.Publish(ctx, route)
|
|
}
|
|
return AsProtobufMessage(request.FieldSelectors)(route), nil
|
|
}
|
|
|
|
func (s *routingServer) SubscribeRoutingStats(request *SubscribeRoutingStatsRequest, stream RoutingService_SubscribeRoutingStatsServer) error {
|
|
if s.routingStats == nil {
|
|
return newError("Routing statistics not enabled.")
|
|
}
|
|
genMessage := AsProtobufMessage(request.FieldSelectors)
|
|
subscriber, err := stats.SubscribeRunnableChannel(s.routingStats)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer stats.UnsubscribeClosableChannel(s.routingStats, subscriber)
|
|
for {
|
|
select {
|
|
case value, ok := <-subscriber:
|
|
if !ok {
|
|
return newError("Upstream closed the subscriber channel.")
|
|
}
|
|
route, ok := value.(routing.Route)
|
|
if !ok {
|
|
return newError("Upstream sent malformed statistics.")
|
|
}
|
|
err := stream.Send(genMessage(route))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
case <-stream.Context().Done():
|
|
return stream.Context().Err()
|
|
}
|
|
}
|
|
}
|
|
|
|
func (s *routingServer) mustEmbedUnimplementedRoutingServiceServer() {}
|
|
|
|
type service struct {
|
|
v *core.Instance
|
|
}
|
|
|
|
func (s *service) Register(server *grpc.Server) {
|
|
common.Must(s.v.RequireFeatures(func(router routing.Router, stats stats.Manager) {
|
|
rs := NewRoutingServer(router, nil)
|
|
RegisterRoutingServiceServer(server, rs)
|
|
|
|
// For compatibility purposes
|
|
vCoreDesc := RoutingService_ServiceDesc
|
|
vCoreDesc.ServiceName = "v2ray.core.app.router.command.RoutingService"
|
|
server.RegisterService(&vCoreDesc, rs)
|
|
}))
|
|
}
|
|
|
|
func init() {
|
|
common.Must(common.RegisterConfig((*Config)(nil), func(ctx context.Context, cfg interface{}) (interface{}, error) {
|
|
s := core.MustFromContext(ctx)
|
|
return &service{v: s}, nil
|
|
}))
|
|
}
|