1
0
mirror of https://github.com/v2fly/v2ray-core.git synced 2024-12-22 18:17:52 -05:00
v2fly/v2ray.go

157 lines
4.8 KiB
Go
Raw Normal View History

2016-10-12 10:46:02 -04:00
package core
2015-09-05 11:48:38 -04:00
import (
"context"
2017-02-10 10:54:51 -05:00
"v2ray.com/core/common"
2015-09-05 11:48:38 -04:00
)
2017-02-10 10:25:54 -05:00
// Server is an instance of V2Ray. At any time, there must be at most one Server instance running.
// Deprecated. Use Instance directly.
2017-02-10 10:25:54 -05:00
type Server interface {
common.Runnable
2017-02-10 10:25:54 -05:00
}
// Feature is the interface for V2Ray features. All features must implement this interface.
// All existing features have an implementation in app directory. These features can be replaced by third-party ones.
type Feature interface {
common.Runnable
2017-02-22 05:30:52 -05:00
}
// Instance combines all functionalities in V2Ray.
type Instance struct {
dnsClient syncDNSClient
policyManager syncPolicyManager
dispatcher syncDispatcher
router syncRouter
ihm syncInboundHandlerManager
ohm syncOutboundHandlerManager
features []Feature
2017-02-10 10:25:54 -05:00
}
// New returns a new V2Ray instance based on given configuration.
// The instance is not started at this point.
// To make sure V2Ray 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 = new(Instance)
2015-09-12 05:51:42 -04:00
2017-02-01 17:05:27 -05:00
if err := config.Transport.Apply(); err != nil {
2016-10-14 16:21:45 -04:00
return nil, err
2016-06-01 19:49:25 -04:00
}
ctx := context.WithValue(context.Background(), v2rayKey, server)
2016-05-18 02:05:52 -04:00
2017-02-01 17:05:27 -05:00
for _, appSettings := range config.App {
2017-02-01 15:35:40 -05:00
settings, err := appSettings.GetInstance()
if err != nil {
return nil, err
}
2018-01-10 08:47:23 -05:00
if _, err := common.CreateObject(ctx, settings); err != nil {
2017-02-01 15:35:40 -05:00
return nil, err
}
}
for _, inbound := range config.Inbound {
rawHandler, err := common.CreateObject(ctx, inbound)
2017-01-13 07:41:40 -05:00
if err != nil {
2017-01-06 09:32:36 -05:00
return nil, err
}
handler, ok := rawHandler.(InboundHandler)
if !ok {
return nil, newError("not an InboundHandler")
2017-02-10 10:54:51 -05:00
}
if err := server.InboundHandlerManager().AddHandler(ctx, handler); err != nil {
2017-01-13 07:41:40 -05:00
return nil, err
}
2017-01-06 09:32:36 -05:00
}
2016-11-10 17:41:28 -05:00
for _, outbound := range config.Outbound {
rawHandler, err := common.CreateObject(ctx, outbound)
2017-01-13 07:41:40 -05:00
if err != nil {
2017-01-06 09:32:36 -05:00
return nil, err
}
handler, ok := rawHandler.(OutboundHandler)
if !ok {
return nil, newError("not an OutboundHandler")
}
if err := server.OutboundHandlerManager().AddHandler(ctx, handler); err != nil {
2017-11-27 16:09:30 -05:00
return nil, err
}
2016-12-16 09:39:47 -05:00
}
2015-12-05 16:55:45 -05:00
return server, nil
}
// Close shutdown the V2Ray instance.
func (s *Instance) Close() {
for _, f := range s.features {
f.Close()
2015-10-31 19:11:41 -04:00
}
}
2015-10-31 19:11:41 -04:00
// Start starts the V2Ray instance, including all registered features. When Start returns error, the state of the instance is unknown.
func (s *Instance) Start() error {
for _, f := range s.features {
if err := f.Start(); err != nil {
2018-01-10 08:47:23 -05:00
return err
2016-10-15 18:46:08 -04:00
}
2015-11-22 11:41:52 -05:00
}
newError("V2Ray started").AtWarning().WriteToLog()
return nil
}
// RegisterFeature registers the given feature into V2Ray.
// If feature is one of the following types, the corressponding feature in this Instance
// will be replaced: DNSClient, PolicyManager, Router, Dispatcher, InboundHandlerManager, OutboundHandlerManager.
func (s *Instance) RegisterFeature(feature interface{}, instance Feature) error {
switch feature.(type) {
case DNSClient, *DNSClient:
s.dnsClient.Set(instance.(DNSClient))
case PolicyManager, *PolicyManager:
s.policyManager.Set(instance.(PolicyManager))
case Router, *Router:
s.router.Set(instance.(Router))
case Dispatcher, *Dispatcher:
s.dispatcher.Set(instance.(Dispatcher))
case InboundHandlerManager, *InboundHandlerManager:
s.ihm.Set(instance.(InboundHandlerManager))
case OutboundHandlerManager, *OutboundHandlerManager:
s.ohm.Set(instance.(OutboundHandlerManager))
2016-05-18 11:12:04 -04:00
}
s.features = append(s.features, instance)
return nil
}
2016-05-18 11:12:04 -04:00
// DNSClient returns the DNSClient used by this Instance. The returned DNSClient is always functional.
func (s *Instance) DNSClient() DNSClient {
return &(s.dnsClient)
2015-09-05 11:48:38 -04:00
}
// PolicyManager returns the PolicyManager used by this Instance. The returned PolicyManager is always functional.
func (s *Instance) PolicyManager() PolicyManager {
return &(s.policyManager)
2016-01-03 18:33:25 -05:00
}
// Router returns the Router used by this Instance. The returned Router is always functional.
func (s *Instance) Router() Router {
return &(s.router)
}
2015-10-31 19:11:41 -04:00
// Dispatcher returns the Dispatcher used by this Instance. If Dispatcher was not registered before, the returned value doesn't work, although it is not nil.
func (s *Instance) Dispatcher() Dispatcher {
return &(s.dispatcher)
}
// InboundHandlerManager returns the InboundHandlerManager used by this Instance. If InboundHandlerManager was not registered before, the returned value doesn't work.
func (s *Instance) InboundHandlerManager() InboundHandlerManager {
return &(s.ihm)
}
// OutboundHandlerManager returns the OutboundHandlerManager used by this Instance. If OutboundHandlerManager was not registered before, the returned value doesn't work.
func (s *Instance) OutboundHandlerManager() OutboundHandlerManager {
return &(s.ohm)
2015-09-06 16:10:42 -04:00
}