refactor dependency resolution

app/commander/commander.go

@@ -12,29 +12,46 @@ import (
 	"v2ray.com/core"
 	"v2ray.com/core/common"
 	"v2ray.com/core/common/signal/done"
+	"v2ray.com/core/features"
 	"v2ray.com/core/features/outbound"
 )
 
 // Commander is a V2Ray feature that provides gRPC methods to external clients.
 type Commander struct {
 	sync.Mutex
-	server *grpc.Server
-	config Config
-	v      *core.Instance
-	ohm    outbound.Manager
+	server   *grpc.Server
+	services []Service
+	ohm      outbound.Manager
+	tag      string
 }
 
 // NewCommander creates a new Commander based on the given config.
 func NewCommander(ctx context.Context, config *Config) (*Commander, error) {
-	v := core.MustFromContext(ctx)
 	c := &Commander{
-		config: *config,
-		ohm:    v.OutboundHandlerManager(),
-		v:      v,
+		tag: config.Tag,
 	}
-	if err := v.RegisterFeature(c); err != nil {
-		return nil, err
+
+	v := core.MustFromContext(ctx)
+	v.RequireFeatures([]interface{}{outbound.ManagerType()}, func(fs []features.Feature) {
+		c.ohm = fs[0].(outbound.Manager)
+	})
+
+	for _, rawConfig := range config.Service {
+		config, err := rawConfig.GetInstance()
+		if err != nil {
+			return nil, err
+		}
+		rawService, err := common.CreateObject(ctx, config)
+		if err != nil {
+			return nil, err
+		}
+		service, ok := rawService.(Service)
+		if !ok {
+			return nil, newError("not a Service.")
+		}
+		c.services = append(c.services, service)
 	}
+
 	return c, nil
 }
 
@@ -47,19 +64,7 @@ func (c *Commander) Type() interface{} {
 func (c *Commander) Start() error {
 	c.Lock()
 	c.server = grpc.NewServer()
-	for _, rawConfig := range c.config.Service {
-		config, err := rawConfig.GetInstance()
-		if err != nil {
-			return err
-		}
-		rawService, err := core.CreateObject(c.v, config)
-		if err != nil {
-			return err
-		}
-		service, ok := rawService.(Service)
-		if !ok {
-			return newError("not a Service.")
-		}
+	for _, service := range c.services {
 		service.Register(c.server)
 	}
 	c.Unlock()
@@ -75,12 +80,12 @@ func (c *Commander) Start() error {
 		}
 	}()
 
-	if err := c.ohm.RemoveHandler(context.Background(), c.config.Tag); err != nil {
+	if err := c.ohm.RemoveHandler(context.Background(), c.tag); err != nil {
 		newError("failed to remove existing handler").WriteToLog()
 	}
 
 	return c.ohm.AddHandler(context.Background(), &Outbound{
-		tag:      c.config.Tag,
+		tag:      c.tag,
 		listener: listener,
 	})
 }

app/dispatcher/default.go

@@ -16,6 +16,7 @@ import (
 	"v2ray.com/core/common/protocol"
 	"v2ray.com/core/common/session"
 	"v2ray.com/core/common/vio"
+	"v2ray.com/core/features"
 	"v2ray.com/core/features/outbound"
 	"v2ray.com/core/features/policy"
 	"v2ray.com/core/features/routing"
@@ -91,17 +92,22 @@ type DefaultDispatcher struct {
 
 // NewDefaultDispatcher create a new DefaultDispatcher.
 func NewDefaultDispatcher(ctx context.Context, config *Config) (*DefaultDispatcher, error) {
+	d := &DefaultDispatcher{}
+
 	v := core.MustFromContext(ctx)
-	d := &DefaultDispatcher{
-		ohm:    v.OutboundHandlerManager(),
-		router: v.Router(),
-		policy: v.PolicyManager(),
-		stats:  v.Stats(),
-	}
+	v.RequireFeatures([]interface{}{outbound.ManagerType(), routing.RouterType(), policy.ManagerType()}, func(fs []features.Feature) {
+		d.ohm = fs[0].(outbound.Manager)
+		d.router = fs[1].(routing.Router)
+		d.policy = fs[2].(policy.Manager)
+	})
+	v.RequireFeatures([]interface{}{core.ServerType()}, func([]features.Feature) {
+		f := v.GetFeature(stats.ManagerType())
+		if f == nil {
+			return
+		}
+		d.stats = f.(stats.Manager)
+	})
 
-	if err := v.RegisterFeature(d); err != nil {
-		return nil, newError("unable to register Dispatcher").Base(err)
-	}
 	return d, nil
 }
 

app/dns/server.go

@@ -7,6 +7,8 @@ import (
 	"sync"
 	"time"
 
+	"v2ray.com/core/features/routing"
+
 	"v2ray.com/core"
 	"v2ray.com/core/common"
 	"v2ray.com/core/common/net"
@@ -42,9 +44,6 @@ func New(ctx context.Context, config *Config) (*Server, error) {
 	server.hosts = hosts
 
 	v := core.MustFromContext(ctx)
-	if err := v.RegisterFeature(server); err != nil {
-		return nil, newError("unable to register DNSClient.").Base(err)
-	}
 
 	addNameServer := func(endpoint *net.Endpoint) int {
 		address := endpoint.Address.AsAddress()
@@ -56,7 +55,12 @@ func New(ctx context.Context, config *Config) (*Server, error) {
 				dest.Network = net.Network_UDP
 			}
 			if dest.Network == net.Network_UDP {
-				server.servers = append(server.servers, NewClassicNameServer(dest, v.Dispatcher(), server.clientIP))
+				idx := len(server.servers)
+				server.servers = append(server.servers, nil)
+				v.RequireFeatures([]interface{}{routing.DispatcherType()}, func(fs []features.Feature) {
+					dispatcher := fs[0].(routing.Dispatcher)
+					server.servers[idx] = NewClassicNameServer(dest, dispatcher, server.clientIP)
+				})
 			}
 		}
 		return len(server.servers) - 1

app/dns/server_test.go

@@ -13,6 +13,7 @@ import (
 	_ "v2ray.com/core/app/proxyman/outbound"
 	"v2ray.com/core/common/net"
 	"v2ray.com/core/common/serial"
+	feature_dns "v2ray.com/core/features/dns"
 	"v2ray.com/core/proxy/freedom"
 	"v2ray.com/core/testing/servers/udp"
 	. "v2ray.com/ext/assert"
@@ -85,7 +86,7 @@ func TestUDPServer(t *testing.T) {
 	v, err := core.New(config)
 	assert(err, IsNil)
 
-	client := v.DNSClient()
+	client := v.GetFeature(feature_dns.ClientType()).(feature_dns.Client)
 
 	ips, err := client.LookupIP("google.com")
 	assert(err, IsNil)
@@ -171,7 +172,7 @@ func TestPrioritizedDomain(t *testing.T) {
 	v, err := core.New(config)
 	assert(err, IsNil)
 
-	client := v.DNSClient()
+	client := v.GetFeature(feature_dns.ClientType()).(feature_dns.Client)
 
 	startTime := time.Now()
 	ips, err := client.LookupIP("google.com")

app/log/log.go

@@ -6,7 +6,6 @@ import (
 	"context"
 	"sync"
 
-	"v2ray.com/core"
 	"v2ray.com/core/common"
 	"v2ray.com/core/common/log"
 )
@@ -28,11 +27,6 @@ func New(ctx context.Context, config *Config) (*Instance, error) {
 	}
 	log.RegisterHandler(g)
 
-	v := core.FromContext(ctx)
-	if v != nil {
-		common.Must(v.RegisterFeature(g))
-	}
-
 	return g, nil
 }
 

app/policy/manager.go

@@ -3,7 +3,6 @@ package policy
 import (
 	"context"
 
-	"v2ray.com/core"
 	"v2ray.com/core/common"
 	"v2ray.com/core/features/policy"
 )
@@ -28,13 +27,6 @@ func New(ctx context.Context, config *Config) (*Instance, error) {
 		}
 	}
 
-	v := core.FromContext(ctx)
-	if v != nil {
-		if err := v.RegisterFeature(m); err != nil {
-			return nil, newError("unable to register PolicyManager in core").Base(err).AtError()
-		}
-	}
-
 	return m, nil
 }
 

app/proxyman/command/command.go

@@ -4,8 +4,10 @@ import (
 	"context"
 
 	grpc "google.golang.org/grpc"
+
 	"v2ray.com/core"
 	"v2ray.com/core/common"
+	"v2ray.com/core/features"
 	"v2ray.com/core/features/inbound"
 	"v2ray.com/core/features/outbound"
 	"v2ray.com/core/proxy"
@@ -136,11 +138,14 @@ type service struct {
 }
 
 func (s *service) Register(server *grpc.Server) {
-	RegisterHandlerServiceServer(server, &handlerServer{
-		s:   s.v,
-		ihm: s.v.InboundHandlerManager(),
-		ohm: s.v.OutboundHandlerManager(),
+	hs := &handlerServer{
+		s: s.v,
+	}
+	s.v.RequireFeatures([]interface{}{inbound.ManagerType(), outbound.ManagerType()}, func(fs []features.Feature) {
+		hs.ihm = fs[0].(inbound.Manager)
+		hs.ohm = fs[1].(outbound.Manager)
 	})
+	RegisterHandlerServiceServer(server, hs)
 }
 
 func init() {

app/proxyman/inbound/always.go

@@ -10,6 +10,7 @@ import (
 	"v2ray.com/core/common/dice"
 	"v2ray.com/core/common/net"
 	"v2ray.com/core/common/serial"
+	"v2ray.com/core/features/policy"
 	"v2ray.com/core/features/stats"
 	"v2ray.com/core/proxy"
 	"v2ray.com/core/transport/internet"
@@ -19,9 +20,9 @@ func getStatCounter(v *core.Instance, tag string) (stats.Counter, stats.Counter)
 	var uplinkCounter stats.Counter
 	var downlinkCounter stats.Counter
 
-	policy := v.PolicyManager()
-	statsManager := v.Stats()
+	policy := v.GetFeature(policy.ManagerType()).(policy.Manager)
 	if len(tag) > 0 && policy.ForSystem().Stats.InboundUplink {
+		statsManager := v.GetFeature(stats.ManagerType()).(stats.Manager)
 		name := "inbound>>>" + tag + ">>>traffic>>>uplink"
 		c, _ := stats.GetOrRegisterCounter(statsManager, name)
 		if c != nil {
@@ -29,6 +30,7 @@ func getStatCounter(v *core.Instance, tag string) (stats.Counter, stats.Counter)
 		}
 	}
 	if len(tag) > 0 && policy.ForSystem().Stats.InboundDownlink {
+		statsManager := v.GetFeature(stats.ManagerType()).(stats.Manager)
 		name := "inbound>>>" + tag + ">>>traffic>>>downlink"
 		c, _ := stats.GetOrRegisterCounter(statsManager, name)
 		if c != nil {

app/proxyman/inbound/inbound.go

@@ -27,10 +27,6 @@ func New(ctx context.Context, config *proxyman.InboundConfig) (*Manager, error)
 	m := &Manager{
 		taggedHandlers: make(map[string]inbound.Handler),
 	}
-	v := core.MustFromContext(ctx)
-	if err := v.RegisterFeature(m); err != nil {
-		return nil, newError("unable to register InboundHandlerManager").Base(err)
-	}
 	return m, nil
 }
 

app/proxyman/mux/mux.go

@@ -8,6 +8,8 @@ import (
 	"sync"
 	"time"
 
+	"v2ray.com/core/features"
+
 	"v2ray.com/core"
 	"v2ray.com/core/app/proxyman"
 	"v2ray.com/core/common"
@@ -304,9 +306,11 @@ type Server struct {
 
 // NewServer creates a new mux.Server.
 func NewServer(ctx context.Context) *Server {
-	s := &Server{
-		dispatcher: core.MustFromContext(ctx).Dispatcher(),
-	}
+	s := &Server{}
+	v := core.MustFromContext(ctx)
+	v.RequireFeatures([]interface{}{routing.DispatcherType()}, func(fs []features.Feature) {
+		s.dispatcher = fs[0].(routing.Dispatcher)
+	})
 	return s
 }
 

app/proxyman/outbound/handler.go

@@ -29,7 +29,7 @@ func NewHandler(ctx context.Context, config *core.OutboundHandlerConfig) (outbou
 	v := core.MustFromContext(ctx)
 	h := &Handler{
 		config:          config,
-		outboundManager: v.OutboundHandlerManager(),
+		outboundManager: v.GetFeature(outbound.ManagerType()).(outbound.Manager),
 	}
 
 	if config.SenderSettings != nil {

app/proxyman/outbound/outbound.go

@@ -26,10 +26,6 @@ func New(ctx context.Context, config *proxyman.OutboundConfig) (*Manager, error)
 	m := &Manager{
 		taggedHandler: make(map[string]outbound.Handler),
 	}
-	v := core.MustFromContext(ctx)
-	if err := v.RegisterFeature(m); err != nil {
-		return nil, newError("unable to register outbound.Manager").Base(err)
-	}
 	return m, nil
 }
 

app/router/router.go

@@ -9,6 +9,7 @@ import (
 	"v2ray.com/core/common"
 	"v2ray.com/core/common/net"
 	"v2ray.com/core/common/session"
+	"v2ray.com/core/features"
 	"v2ray.com/core/features/dns"
 	"v2ray.com/core/features/routing"
 	"v2ray.com/core/proxy"
@@ -23,11 +24,9 @@ type Router struct {
 
 // NewRouter creates a new Router based on the given config.
 func NewRouter(ctx context.Context, config *Config) (*Router, error) {
-	v := core.MustFromContext(ctx)
 	r := &Router{
 		domainStrategy: config.DomainStrategy,
 		rules:          make([]Rule, len(config.Rule)),
-		dns:            v.DNSClient(),
 	}
 
 	for idx, rule := range config.Rule {
@@ -39,9 +38,10 @@ func NewRouter(ctx context.Context, config *Config) (*Router, error) {
 		r.rules[idx].Condition = cond
 	}
 
-	if err := v.RegisterFeature(r); err != nil {
-		return nil, newError("unable to register Router").Base(err)
-	}
+	v := core.MustFromContext(ctx)
+	v.RequireFeatures([]interface{}{dns.ClientType()}, func(fs []features.Feature) {
+		r.dns = fs[0].(dns.Client)
+	})
 	return r, nil
 }
 

app/router/router_test.go

@@ -12,6 +12,7 @@ import (
 	"v2ray.com/core/common/net"
 	"v2ray.com/core/common/serial"
 	"v2ray.com/core/common/session"
+	"v2ray.com/core/features/routing"
 	. "v2ray.com/ext/assert"
 )
 
@@ -38,7 +39,7 @@ func TestSimpleRouter(t *testing.T) {
 	v, err := core.New(config)
 	common.Must(err)
 
-	r := v.Router()
+	r := v.GetFeature(routing.RouterType()).(routing.Router)
 
 	ctx := withOutbound(&session.Outbound{Target: net.TCPDestination(net.DomainAddress("v2ray.com"), 80)})
 	tag, err := r.PickRoute(ctx)

app/stats/command/command.go

@@ -79,7 +79,8 @@ type service struct {
 }
 
 func (s *service) Register(server *grpc.Server) {
-	RegisterStatsServiceServer(server, NewStatsServer(s.v.Stats()))
+	f := s.v.GetFeature(feature_stats.ManagerType())
+	RegisterStatsServiceServer(server, NewStatsServer(f.(feature_stats.Manager)))
 }
 
 func init() {

app/stats/stats.go

@@ -7,7 +7,6 @@ import (
 	"sync"
 	"sync/atomic"
 
-	"v2ray.com/core"
 	"v2ray.com/core/features/stats"
 )
 
@@ -42,13 +41,6 @@ func NewManager(ctx context.Context, config *Config) (*Manager, error) {
 		counters: make(map[string]*Counter),
 	}
 
-	v := core.FromContext(ctx)
-	if v != nil {
-		if err := v.RegisterFeature(m); err != nil {
-			return nil, newError("failed to register StatManager").Base(err)
-		}
-	}
-
 	return m, nil
 }