v1.0.0

core/xray.go

@@ -0,0 +1,345 @@
+// +build !confonly
+
+package core
+
+import (
+	"context"
+	"reflect"
+	"sync"
+
+	"github.com/xtls/xray-core/v1/common"
+	"github.com/xtls/xray-core/v1/common/serial"
+	"github.com/xtls/xray-core/v1/features"
+	"github.com/xtls/xray-core/v1/features/dns"
+	"github.com/xtls/xray-core/v1/features/dns/localdns"
+	"github.com/xtls/xray-core/v1/features/inbound"
+	"github.com/xtls/xray-core/v1/features/outbound"
+	"github.com/xtls/xray-core/v1/features/policy"
+	"github.com/xtls/xray-core/v1/features/routing"
+	"github.com/xtls/xray-core/v1/features/stats"
+)
+
+// Server is an instance of Xray. At any time, there must be at most one Server instance running.
+type Server interface {
+	common.Runnable
+}
+
+// ServerType returns the type of the server.
+func ServerType() interface{} {
+	return (*Instance)(nil)
+}
+
+type resolution struct {
+	deps     []reflect.Type
+	callback interface{}
+}
+
+func getFeature(allFeatures []features.Feature, t reflect.Type) features.Feature {
+	for _, f := range allFeatures {
+		if reflect.TypeOf(f.Type()) == t {
+			return f
+		}
+	}
+	return nil
+}
+
+func (r *resolution) resolve(allFeatures []features.Feature) (bool, error) {
+	var fs []features.Feature
+	for _, d := range r.deps {
+		f := getFeature(allFeatures, d)
+		if f == nil {
+			return false, nil
+		}
+		fs = append(fs, f)
+	}
+
+	callback := reflect.ValueOf(r.callback)
+	var input []reflect.Value
+	callbackType := callback.Type()
+	for i := 0; i < callbackType.NumIn(); i++ {
+		pt := callbackType.In(i)
+		for _, f := range fs {
+			if reflect.TypeOf(f).AssignableTo(pt) {
+				input = append(input, reflect.ValueOf(f))
+				break
+			}
+		}
+	}
+
+	if len(input) != callbackType.NumIn() {
+		panic("Can't get all input parameters")
+	}
+
+	var err error
+	ret := callback.Call(input)
+	errInterface := reflect.TypeOf((*error)(nil)).Elem()
+	for i := len(ret) - 1; i >= 0; i-- {
+		if ret[i].Type() == errInterface {
+			v := ret[i].Interface()
+			if v != nil {
+				err = v.(error)
+			}
+			break
+		}
+	}
+
+	return true, err
+}
+
+// Instance combines all functionalities in Xray.
+type Instance struct {
+	access             sync.Mutex
+	features           []features.Feature
+	featureResolutions []resolution
+	running            bool
+
+	ctx context.Context
+}
+
+func AddInboundHandler(server *Instance, config *InboundHandlerConfig) error {
+	inboundManager := server.GetFeature(inbound.ManagerType()).(inbound.Manager)
+	rawHandler, err := CreateObject(server, config)
+	if err != nil {
+		return err
+	}
+	handler, ok := rawHandler.(inbound.Handler)
+	if !ok {
+		return newError("not an InboundHandler")
+	}
+	if err := inboundManager.AddHandler(server.ctx, handler); err != nil {
+		return err
+	}
+	return nil
+}
+
+func addInboundHandlers(server *Instance, configs []*InboundHandlerConfig) error {
+	for _, inboundConfig := range configs {
+		if err := AddInboundHandler(server, inboundConfig); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func AddOutboundHandler(server *Instance, config *OutboundHandlerConfig) error {
+	outboundManager := server.GetFeature(outbound.ManagerType()).(outbound.Manager)
+	rawHandler, err := CreateObject(server, config)
+	if err != nil {
+		return err
+	}
+	handler, ok := rawHandler.(outbound.Handler)
+	if !ok {
+		return newError("not an OutboundHandler")
+	}
+	if err := outboundManager.AddHandler(server.ctx, handler); err != nil {
+		return err
+	}
+	return nil
+}
+
+func addOutboundHandlers(server *Instance, configs []*OutboundHandlerConfig) error {
+	for _, outboundConfig := range configs {
+		if err := AddOutboundHandler(server, outboundConfig); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// RequireFeatures is a helper function to require features from Instance in context.
+// See Instance.RequireFeatures for more information.
+func RequireFeatures(ctx context.Context, callback interface{}) error {
+	v := MustFromContext(ctx)
+	return v.RequireFeatures(callback)
+}
+
+// New returns a new Xray instance based on given configuration.
+// The instance is not started at this point.
+// To ensure Xray instance works properly, the config must contain one Dispatcher, one InboundHandlerManager and one OutboundHandlerManager. Other features are optional.
+func New(config *Config) (*Instance, error) {
+	var server = &Instance{ctx: context.Background()}
+
+	done, err := initInstanceWithConfig(config, server)
+	if done {
+		return nil, err
+	}
+
+	return server, nil
+}
+
+func NewWithContext(ctx context.Context, config *Config) (*Instance, error) {
+	var server = &Instance{ctx: ctx}
+
+	done, err := initInstanceWithConfig(config, server)
+	if done {
+		return nil, err
+	}
+
+	return server, nil
+}
+
+func initInstanceWithConfig(config *Config, server *Instance) (bool, error) {
+	if config.Transport != nil {
+		features.PrintDeprecatedFeatureWarning("global transport settings")
+	}
+	if err := config.Transport.Apply(); err != nil {
+		return true, err
+	}
+
+	for _, appSettings := range config.App {
+		settings, err := appSettings.GetInstance()
+		if err != nil {
+			return true, err
+		}
+		obj, err := CreateObject(server, settings)
+		if err != nil {
+			return true, err
+		}
+		if feature, ok := obj.(features.Feature); ok {
+			if err := server.AddFeature(feature); err != nil {
+				return true, err
+			}
+		}
+	}
+
+	essentialFeatures := []struct {
+		Type     interface{}
+		Instance features.Feature
+	}{
+		{dns.ClientType(), localdns.New()},
+		{policy.ManagerType(), policy.DefaultManager{}},
+		{routing.RouterType(), routing.DefaultRouter{}},
+		{stats.ManagerType(), stats.NoopManager{}},
+	}
+
+	for _, f := range essentialFeatures {
+		if server.GetFeature(f.Type) == nil {
+			if err := server.AddFeature(f.Instance); err != nil {
+				return true, err
+			}
+		}
+	}
+
+	if server.featureResolutions != nil {
+		return true, newError("not all dependency are resolved.")
+	}
+
+	if err := addInboundHandlers(server, config.Inbound); err != nil {
+		return true, err
+	}
+
+	if err := addOutboundHandlers(server, config.Outbound); err != nil {
+		return true, err
+	}
+	return false, nil
+}
+
+// Type implements common.HasType.
+func (s *Instance) Type() interface{} {
+	return ServerType()
+}
+
+// Close shutdown the Xray instance.
+func (s *Instance) Close() error {
+	s.access.Lock()
+	defer s.access.Unlock()
+
+	s.running = false
+
+	var errors []interface{}
+	for _, f := range s.features {
+		if err := f.Close(); err != nil {
+			errors = append(errors, err)
+		}
+	}
+	if len(errors) > 0 {
+		return newError("failed to close all features").Base(newError(serial.Concat(errors...)))
+	}
+
+	return nil
+}
+
+// RequireFeatures registers a callback, which will be called when all dependent features are registered.
+// The callback must be a func(). All its parameters must be features.Feature.
+func (s *Instance) RequireFeatures(callback interface{}) error {
+	callbackType := reflect.TypeOf(callback)
+	if callbackType.Kind() != reflect.Func {
+		panic("not a function")
+	}
+
+	var featureTypes []reflect.Type
+	for i := 0; i < callbackType.NumIn(); i++ {
+		featureTypes = append(featureTypes, reflect.PtrTo(callbackType.In(i)))
+	}
+
+	r := resolution{
+		deps:     featureTypes,
+		callback: callback,
+	}
+	if finished, err := r.resolve(s.features); finished {
+		return err
+	}
+	s.featureResolutions = append(s.featureResolutions, r)
+	return nil
+}
+
+// AddFeature registers a feature into current Instance.
+func (s *Instance) AddFeature(feature features.Feature) error {
+	s.features = append(s.features, feature)
+
+	if s.running {
+		if err := feature.Start(); err != nil {
+			newError("failed to start feature").Base(err).WriteToLog()
+		}
+		return nil
+	}
+
+	if s.featureResolutions == nil {
+		return nil
+	}
+
+	var pendingResolutions []resolution
+	for _, r := range s.featureResolutions {
+		finished, err := r.resolve(s.features)
+		if finished && err != nil {
+			return err
+		}
+		if !finished {
+			pendingResolutions = append(pendingResolutions, r)
+		}
+	}
+	if len(pendingResolutions) == 0 {
+		s.featureResolutions = nil
+	} else if len(pendingResolutions) < len(s.featureResolutions) {
+		s.featureResolutions = pendingResolutions
+	}
+
+	return nil
+}
+
+// GetFeature returns a feature of the given type, or nil if such feature is not registered.
+func (s *Instance) GetFeature(featureType interface{}) features.Feature {
+	return getFeature(s.features, reflect.TypeOf(featureType))
+}
+
+// Start starts the Xray instance, including all registered features. When Start returns error, the state of the instance is unknown.
+// A Xray instance can be started only once. Upon closing, the instance is not guaranteed to start again.
+//
+// xray:api:stable
+func (s *Instance) Start() error {
+	s.access.Lock()
+	defer s.access.Unlock()
+
+	s.running = true
+	for _, f := range s.features {
+		if err := f.Start(); err != nil {
+			return err
+		}
+	}
+
+	newError("Xray ", Version(), " started").AtWarning().WriteToLog()
+
+	return nil
+}