Move point to shell

app/point/config/config.go

@@ -1,39 +0,0 @@
-package config
-
-import (
-	routerconfig "github.com/v2ray/v2ray-core/app/router/config"
-	v2net "github.com/v2ray/v2ray-core/common/net"
-)
-
-type DetourTag string
-
-type ConnectionConfig interface {
-	Protocol() string
-	Settings() interface{}
-}
-
-type LogConfig interface {
-	AccessLog() string
-}
-
-type InboundDetourConfig interface {
-	Protocol() string
-	PortRange() v2net.PortRange
-	Settings() interface{}
-}
-
-type OutboundDetourConfig interface {
-	Protocol() string
-	Tag() DetourTag
-	Settings() interface{}
-}
-
-type PointConfig interface {
-	Port() uint16
-	LogConfig() LogConfig
-	RouterConfig() routerconfig.RouterConfig
-	InboundConfig() ConnectionConfig
-	OutboundConfig() ConnectionConfig
-	InboundDetours() []InboundDetourConfig
-	OutboundDetours() []OutboundDetourConfig
-}

app/point/config/errors.go

@@ -1,9 +0,0 @@
-package config
-
-import (
-	"errors"
-)
-
-var (
-	BadConfiguration = errors.New("Bad configuration.")
-)

app/point/config/json/connection.go

@@ -1,36 +0,0 @@
-package json
-
-import (
-	"encoding/json"
-
-	"github.com/v2ray/v2ray-core/common/log"
-	proxyconfig "github.com/v2ray/v2ray-core/proxy/common/config"
-	proxyjson "github.com/v2ray/v2ray-core/proxy/common/config/json"
-)
-
-type ConnectionConfig struct {
-	ProtocolString  string           `json:"protocol"`
-	SettingsMessage json.RawMessage  `json:"settings"`
-	Type            proxyconfig.Type `json:"-"`
-}
-
-func (c *ConnectionConfig) Protocol() string {
-	return c.ProtocolString
-}
-
-func (c *ConnectionConfig) Settings() interface{} {
-	return loadConnectionConfig(c.SettingsMessage, c.Protocol(), c.Type)
-}
-
-func loadConnectionConfig(message json.RawMessage, protocol string, cType proxyconfig.Type) interface{} {
-	configObj := proxyjson.CreateConfig(protocol, cType)
-	if configObj == nil {
-		panic("Unknown protocol " + protocol)
-	}
-	err := json.Unmarshal(message, configObj)
-	if err != nil {
-		log.Error("Unable to parse connection config: %v", err)
-		panic("Failed to parse connection config.")
-	}
-	return configObj
-}

app/point/config/json/inbound_detour.go

@@ -1,27 +0,0 @@
-package json
-
-import (
-	"encoding/json"
-
-	v2net "github.com/v2ray/v2ray-core/common/net"
-	v2netjson "github.com/v2ray/v2ray-core/common/net/json"
-	proxyconfig "github.com/v2ray/v2ray-core/proxy/common/config"
-)
-
-type InboundDetourConfig struct {
-	ProtocolValue  string               `json:"protocol"`
-	PortRangeValue *v2netjson.PortRange `json:"port"`
-	SettingsValue  json.RawMessage      `json:"settings"`
-}
-
-func (this *InboundDetourConfig) Protocol() string {
-	return this.ProtocolValue
-}
-
-func (this *InboundDetourConfig) PortRange() v2net.PortRange {
-	return this.PortRangeValue
-}
-
-func (this *InboundDetourConfig) Settings() interface{} {
-	return loadConnectionConfig(this.SettingsValue, this.ProtocolValue, proxyconfig.TypeInbound)
-}

app/point/config/json/json.go

@@ -1,93 +0,0 @@
-package json
-
-import (
-	"encoding/json"
-	"io/ioutil"
-	"os"
-
-	"github.com/v2ray/v2ray-core/app/point/config"
-	routerconfig "github.com/v2ray/v2ray-core/app/router/config"
-	routerconfigjson "github.com/v2ray/v2ray-core/app/router/config/json"
-	"github.com/v2ray/v2ray-core/common/log"
-	proxyconfig "github.com/v2ray/v2ray-core/proxy/common/config"
-)
-
-// Config is the config for Point server.
-type Config struct {
-	PortValue            uint16                         `json:"port"` // Port of this Point server.
-	LogConfigValue       *LogConfig                     `json:"log"`
-	RouterConfigValue    *routerconfigjson.RouterConfig `json:"routing"`
-	InboundConfigValue   *ConnectionConfig              `json:"inbound"`
-	OutboundConfigValue  *ConnectionConfig              `json:"outbound"`
-	InboundDetoursValue  []*InboundDetourConfig         `json:"inboundDetour"`
-	OutboundDetoursValue []*OutboundDetourConfig        `json:"outboundDetour"`
-}
-
-func (config *Config) Port() uint16 {
-	return config.PortValue
-}
-
-func (config *Config) LogConfig() config.LogConfig {
-	if config.LogConfigValue == nil {
-		return nil
-	}
-	return config.LogConfigValue
-}
-
-func (this *Config) RouterConfig() routerconfig.RouterConfig {
-	if this.RouterConfigValue == nil {
-		return nil
-	}
-	return this.RouterConfigValue
-}
-
-func (config *Config) InboundConfig() config.ConnectionConfig {
-	if config.InboundConfigValue == nil {
-		return nil
-	}
-	return config.InboundConfigValue
-}
-
-func (config *Config) OutboundConfig() config.ConnectionConfig {
-	if config.OutboundConfigValue == nil {
-		return nil
-	}
-	return config.OutboundConfigValue
-}
-
-func (this *Config) InboundDetours() []config.InboundDetourConfig {
-	detours := make([]config.InboundDetourConfig, len(this.InboundDetoursValue))
-	for idx, detour := range this.InboundDetoursValue {
-		detours[idx] = detour
-	}
-	return detours
-}
-
-func (this *Config) OutboundDetours() []config.OutboundDetourConfig {
-	detours := make([]config.OutboundDetourConfig, len(this.OutboundDetoursValue))
-	for idx, detour := range this.OutboundDetoursValue {
-		detours[idx] = detour
-	}
-	return detours
-}
-
-func LoadConfig(file string) (*Config, error) {
-	fixedFile := os.ExpandEnv(file)
-	rawConfig, err := ioutil.ReadFile(fixedFile)
-	if err != nil {
-		log.Error("Failed to read server config file (%s): %v", file, err)
-		return nil, err
-	}
-
-	jsonConfig := &Config{}
-	err = json.Unmarshal(rawConfig, jsonConfig)
-	if err != nil {
-		log.Error("Failed to load server config: %v", err)
-		return nil, err
-	}
-
-	jsonConfig.InboundConfigValue.Type = proxyconfig.TypeInbound
-	jsonConfig.OutboundConfigValue.Type = proxyconfig.TypeOutbound
-
-	return jsonConfig, err
-}

app/point/config/json/json_test.go

@@ -1,73 +0,0 @@
-package json_test
-
-import (
-	"path/filepath"
-	"testing"
-
-	"github.com/v2ray/v2ray-core/app/point/config/json"
-	_ "github.com/v2ray/v2ray-core/proxy/dokodemo/config/json"
-	_ "github.com/v2ray/v2ray-core/proxy/freedom/config/json"
-	_ "github.com/v2ray/v2ray-core/proxy/socks/config/json"
-	_ "github.com/v2ray/v2ray-core/proxy/vmess/config/json"
-
-	"github.com/v2ray/v2ray-core/testing/unit"
-)
-
-func TestClientSampleConfig(t *testing.T) {
-	assert := unit.Assert(t)
-
-	// TODO: fix for Windows
-	baseDir := "$GOPATH/src/github.com/v2ray/v2ray-core/release/config"
-
-	pointConfig, err := json.LoadConfig(filepath.Join(baseDir, "vpoint_socks_vmess.json"))
-	assert.Error(err).IsNil()
-
-	assert.Uint16(pointConfig.Port()).Positive()
-	assert.Pointer(pointConfig.InboundConfig()).IsNotNil()
-	assert.Pointer(pointConfig.OutboundConfig()).IsNotNil()
-
-	assert.String(pointConfig.InboundConfig().Protocol()).Equals("socks")
-	assert.Pointer(pointConfig.InboundConfig().Settings()).IsNotNil()
-
-	assert.String(pointConfig.OutboundConfig().Protocol()).Equals("vmess")
-	assert.Pointer(pointConfig.OutboundConfig().Settings()).IsNotNil()
-}
-
-func TestServerSampleConfig(t *testing.T) {
-	assert := unit.Assert(t)
-
-	// TODO: fix for Windows
-	baseDir := "$GOPATH/src/github.com/v2ray/v2ray-core/release/config"
-
-	pointConfig, err := json.LoadConfig(filepath.Join(baseDir, "vpoint_vmess_freedom.json"))
-	assert.Error(err).IsNil()
-
-	assert.Uint16(pointConfig.Port()).Positive()
-	assert.Pointer(pointConfig.InboundConfig()).IsNotNil()
-	assert.Pointer(pointConfig.OutboundConfig()).IsNotNil()
-
-	assert.String(pointConfig.InboundConfig().Protocol()).Equals("vmess")
-	assert.Pointer(pointConfig.InboundConfig().Settings()).IsNotNil()
-
-	assert.String(pointConfig.OutboundConfig().Protocol()).Equals("freedom")
-	assert.Pointer(pointConfig.OutboundConfig().Settings()).IsNotNil()
-}
-
-func TestDetourConfig(t *testing.T) {
-	assert := unit.Assert(t)
-
-	// TODO: fix for Windows
-	baseDir := "$GOPATH/src/github.com/v2ray/v2ray-core/release/config"
-
-	pointConfig, err := json.LoadConfig(filepath.Join(baseDir, "vpoint_dns_detour.json"))
-	assert.Error(err).IsNil()
-
-	detours := pointConfig.InboundDetours()
-	assert.Int(len(detours)).Equals(1)
-
-	detour := detours[0]
-	assert.String(detour.Protocol()).Equals("dokodemo-door")
-	assert.Uint16(detour.PortRange().From()).Equals(uint16(28394))
-	assert.Uint16(detour.PortRange().To()).Equals(uint16(28394))
-	assert.Pointer(detour.Settings()).IsNotNil()
-}

app/point/config/json/log.go

@@ -1,9 +0,0 @@
-package json
-
-type LogConfig struct {
-	AccessLogValue string `json:"access"`
-}
-
-func (config *LogConfig) AccessLog() string {
-	return config.AccessLogValue
-}

app/point/config/json/outbound_detour.go

@@ -1,26 +0,0 @@
-package json
-
-import (
-	"encoding/json"
-
-	"github.com/v2ray/v2ray-core/app/point/config"
-	proxyconfig "github.com/v2ray/v2ray-core/proxy/common/config"
-)
-
-type OutboundDetourConfig struct {
-	ProtocolValue string          `json:"protocol"`
-	TagValue      string          `json:"tag"`
-	SettingsValue json.RawMessage `json:"settings"`
-}
-
-func (this *OutboundDetourConfig) Protocol() string {
-	return this.ProtocolValue
-}
-
-func (this *OutboundDetourConfig) Tag() config.DetourTag {
-	return config.DetourTag(this.TagValue)
-}
-
-func (this *OutboundDetourConfig) Settings() interface{} {
-	return loadConnectionConfig(this.SettingsValue, this.ProtocolValue, proxyconfig.TypeOutbound)
-}

app/point/config/testing/mocks/config.go

@@ -1,105 +0,0 @@
-package mocks
-
-import (
-	"github.com/v2ray/v2ray-core/app/point/config"
-	routerconfig "github.com/v2ray/v2ray-core/app/router/config"
-	v2net "github.com/v2ray/v2ray-core/common/net"
-)
-
-type ConnectionConfig struct {
-	ProtocolValue string
-	SettingsValue interface{}
-}
-
-func (config *ConnectionConfig) Protocol() string {
-	return config.ProtocolValue
-}
-
-func (config *ConnectionConfig) Settings() interface{} {
-	return config.SettingsValue
-}
-
-type LogConfig struct {
-	AccessLogValue string
-}
-
-type PortRange struct {
-	FromValue uint16
-	ToValue   uint16
-}
-
-func (this *PortRange) From() uint16 {
-	return this.FromValue
-}
-
-func (this *PortRange) To() uint16 {
-	return this.ToValue
-}
-
-type InboundDetourConfig struct {
-	ConnectionConfig
-	PortRangeValue *PortRange
-}
-
-func (this *InboundDetourConfig) PortRange() v2net.PortRange {
-	return this.PortRangeValue
-}
-
-type OutboundDetourConfig struct {
-	ConnectionConfig
-	TagValue config.DetourTag
-}
-
-func (this *OutboundDetourConfig) Tag() config.DetourTag {
-	return this.TagValue
-}
-
-func (config *LogConfig) AccessLog() string {
-	return config.AccessLogValue
-}
-
-type Config struct {
-	PortValue            uint16
-	LogConfigValue       *LogConfig
-	RouterConfigValue    routerconfig.RouterConfig
-	InboundConfigValue   *ConnectionConfig
-	OutboundConfigValue  *ConnectionConfig
-	InboundDetoursValue  []*InboundDetourConfig
-	OutboundDetoursValue []*OutboundDetourConfig
-}
-
-func (config *Config) Port() uint16 {
-	return config.PortValue
-}
-
-func (config *Config) LogConfig() config.LogConfig {
-	return config.LogConfigValue
-}
-
-func (this *Config) RouterConfig() routerconfig.RouterConfig {
-	return this.RouterConfigValue
-}
-
-func (config *Config) InboundConfig() config.ConnectionConfig {
-	return config.InboundConfigValue
-}
-
-func (config *Config) OutboundConfig() config.ConnectionConfig {
-	return config.OutboundConfigValue
-}
-
-func (this *Config) InboundDetours() []config.InboundDetourConfig {
-	detours := make([]config.InboundDetourConfig, len(this.InboundDetoursValue))
-	for idx, detour := range this.InboundDetoursValue {
-		detours[idx] = detour
-	}
-	return detours
-}
-
-func (this *Config) OutboundDetours() []config.OutboundDetourConfig {
-	detours := make([]config.OutboundDetourConfig, len(this.OutboundDetoursValue))
-	for idx, detour := range this.OutboundDetoursValue {
-		detours[idx] = detour
-	}
-	return detours
-}

app/point/inbound_detour.go

@@ -1,56 +0,0 @@
-package point
-
-import (
-	"github.com/v2ray/v2ray-core/app/point/config"
-	"github.com/v2ray/v2ray-core/common/log"
-	"github.com/v2ray/v2ray-core/common/retry"
-	"github.com/v2ray/v2ray-core/proxy/common/connhandler"
-)
-
-type InboundConnectionHandlerWithPort struct {
-	port    uint16
-	handler connhandler.InboundConnectionHandler
-}
-
-type InboundDetourHandler struct {
-	point  *Point
-	config config.InboundDetourConfig
-	ich    []*InboundConnectionHandlerWithPort
-}
-
-func (this *InboundDetourHandler) Initialize() error {
-	ichFactory := connhandler.GetInboundConnectionHandlerFactory(this.config.Protocol())
-	if ichFactory == nil {
-		log.Error("Unknown inbound connection handler factory %s", this.config.Protocol())
-		return config.BadConfiguration
-	}
-
-	ports := this.config.PortRange()
-	this.ich = make([]*InboundConnectionHandlerWithPort, 0, ports.From()-ports.To()+1)
-	for i := ports.From(); i <= ports.To(); i++ {
-		ichConfig := this.config.Settings()
-		ich, err := ichFactory.Create(this.point, ichConfig)
-		if err != nil {
-			log.Error("Failed to create inbound connection handler: %v", err)
-			return err
-		}
-		this.ich = append(this.ich, &InboundConnectionHandlerWithPort{
-			port:    i,
-			handler: ich,
-		})
-	}
-	return nil
-}
-
-func (this *InboundDetourHandler) Start() error {
-	for _, ich := range this.ich {
-		return retry.Timed(100 /* times */, 100 /* ms */).On(func() error {
-			err := ich.handler.Listen(ich.port)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	return nil
-}

app/point/point.go

@@ -1,149 +0,0 @@
-package point
-
-import (
-	"github.com/v2ray/v2ray-core/app/point/config"
-	"github.com/v2ray/v2ray-core/app/router"
-	"github.com/v2ray/v2ray-core/common/log"
-	v2net "github.com/v2ray/v2ray-core/common/net"
-	"github.com/v2ray/v2ray-core/common/retry"
-	"github.com/v2ray/v2ray-core/proxy/common/connhandler"
-	"github.com/v2ray/v2ray-core/transport/ray"
-)
-
-// Point is an single server in V2Ray system.
-type Point struct {
-	port   uint16
-	ich    connhandler.InboundConnectionHandler
-	och    connhandler.OutboundConnectionHandler
-	idh    []*InboundDetourHandler
-	odh    map[config.DetourTag]connhandler.OutboundConnectionHandler
-	router router.Router
-}
-
-// NewPoint returns a new Point server based on given configuration.
-// The server is not started at this point.
-func NewPoint(pConfig config.PointConfig) (*Point, error) {
-	var vpoint = new(Point)
-	vpoint.port = pConfig.Port()
-
-	ichFactory := connhandler.GetInboundConnectionHandlerFactory(pConfig.InboundConfig().Protocol())
-	if ichFactory == nil {
-		log.Error("Unknown inbound connection handler factory %s", pConfig.InboundConfig().Protocol())
-		return nil, config.BadConfiguration
-	}
-	ichConfig := pConfig.InboundConfig().Settings()
-	ich, err := ichFactory.Create(vpoint, ichConfig)
-	if err != nil {
-		log.Error("Failed to create inbound connection handler: %v", err)
-		return nil, err
-	}
-	vpoint.ich = ich
-
-	ochFactory := connhandler.GetOutboundConnectionHandlerFactory(pConfig.OutboundConfig().Protocol())
-	if ochFactory == nil {
-		log.Error("Unknown outbound connection handler factory %s", pConfig.OutboundConfig().Protocol())
-		return nil, config.BadConfiguration
-	}
-	ochConfig := pConfig.OutboundConfig().Settings()
-	och, err := ochFactory.Create(ochConfig)
-	if err != nil {
-		log.Error("Failed to create outbound connection handler: %v", err)
-		return nil, err
-	}
-	vpoint.och = och
-
-	detours := pConfig.InboundDetours()
-	if len(detours) > 0 {
-		vpoint.idh = make([]*InboundDetourHandler, len(detours))
-		for idx, detourConfig := range detours {
-			detourHandler := &InboundDetourHandler{
-				point:  vpoint,
-				config: detourConfig,
-			}
-			err := detourHandler.Initialize()
-			if err != nil {
-				return nil, err
-			}
-			vpoint.idh[idx] = detourHandler
-		}
-	}
-
-	outboundDetours := pConfig.OutboundDetours()
-	if len(outboundDetours) > 0 {
-		vpoint.odh = make(map[config.DetourTag]connhandler.OutboundConnectionHandler)
-		for _, detourConfig := range outboundDetours {
-			detourFactory := connhandler.GetOutboundConnectionHandlerFactory(detourConfig.Protocol())
-			if detourFactory == nil {
-				log.Error("Unknown detour outbound connection handler factory %s", detourConfig.Protocol())
-				return nil, config.BadConfiguration
-			}
-			detourHandler, err := detourFactory.Create(detourConfig.Settings())
-			if err != nil {
-				log.Error("Failed to create detour outbound connection handler: %v", err)
-				return nil, err
-			}
-			vpoint.odh[detourConfig.Tag()] = detourHandler
-		}
-	}
-
-	routerConfig := pConfig.RouterConfig()
-	if routerConfig != nil {
-		r, err := router.CreateRouter(routerConfig.Strategy(), routerConfig.Settings())
-		if err != nil {
-			log.Error("Failed to create router: %v", err)
-			return nil, config.BadConfiguration
-		}
-		vpoint.router = r
-	}
-
-	return vpoint, nil
-}
-
-// Start starts the Point server, and return any error during the process.
-// In the case of any errors, the state of the server is unpredicatable.
-func (this *Point) Start() error {
-	if this.port <= 0 {
-		log.Error("Invalid port %d", this.port)
-		return config.BadConfiguration
-	}
-
-	err := retry.Timed(100 /* times */, 100 /* ms */).On(func() error {
-		err := this.ich.Listen(this.port)
-		if err != nil {
-			return err
-		}
-		log.Warning("Point server started on port %d", this.port)
-		return nil
-	})
-	if err != nil {
-		return err
-	}
-
-	for _, detourHandler := range this.idh {
-		err := detourHandler.Start()
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (this *Point) DispatchToOutbound(packet v2net.Packet) ray.InboundRay {
-	direct := ray.NewRay()
-	dest := packet.Destination()
-
-	if this.router != nil {
-		tag, err := this.router.TakeDetour(dest)
-		if err == nil {
-			handler, found := this.odh[tag]
-			if found {
-				go handler.Dispatch(packet, direct)
-				return direct
-			}
-		}
-	}
-
-	go this.och.Dispatch(packet, direct)
-	return direct
-}

app/router/router.go

@@ -3,8 +3,8 @@ package router
 import (
 	"errors"
 
-	"github.com/v2ray/v2ray-core/app/point/config"
 	v2net "github.com/v2ray/v2ray-core/common/net"
+	"github.com/v2ray/v2ray-core/shell/point/config"
 )
 
 var (

app/router/rules/config/json/rules.go

@@ -1,8 +1,8 @@
 package json
 
 import (
-	"github.com/v2ray/v2ray-core/app/point/config"
 	v2net "github.com/v2ray/v2ray-core/common/net"
+	"github.com/v2ray/v2ray-core/shell/point/config"
 )
 
 type Rule struct {

app/router/rules/config/rules.go

@@ -1,8 +1,8 @@
 package config
 
 import (
-	"github.com/v2ray/v2ray-core/app/point/config"
 	v2net "github.com/v2ray/v2ray-core/common/net"
+	"github.com/v2ray/v2ray-core/shell/point/config"
 )
 
 type Rule interface {

app/router/rules/router.go

@@ -3,11 +3,11 @@ package rules
 import (
 	"errors"
 
-	pointconfig "github.com/v2ray/v2ray-core/app/point/config"
 	"github.com/v2ray/v2ray-core/app/router"
 	"github.com/v2ray/v2ray-core/app/router/rules/config"
 	"github.com/v2ray/v2ray-core/app/router/rules/config/json"
 	v2net "github.com/v2ray/v2ray-core/common/net"
+	pointconfig "github.com/v2ray/v2ray-core/shell/point/config"
 )
 
 var (