diff --git a/common/cmdarg/cmdarg.go b/common/cmdarg/cmdarg.go new file mode 100644 index 00000000..f524eb37 --- /dev/null +++ b/common/cmdarg/cmdarg.go @@ -0,0 +1,16 @@ +package cmdarg + +import "strings" + +// Arg is used by flag to accept multiple argument. +type Arg []string + +func (c *Arg) String() string { + return strings.Join([]string(*c), " ") +} + +// Set is the method flag package calls +func (c *Arg) Set(value string) error { + *c = append(*c, value) + return nil +} diff --git a/common/log/logger.go b/common/log/logger.go index 9a2591cb..a6b8316b 100644 --- a/common/log/logger.go +++ b/common/log/logger.go @@ -119,6 +119,15 @@ func CreateStdoutLogWriter() WriterCreator { } } +// CreateStderrLogWriter returns a LogWriterCreator that creates LogWriter for stderr. +func CreateStderrLogWriter() WriterCreator { + return func() Writer { + return &consoleLogWriter{ + logger: log.New(os.Stderr, "", log.Ldate|log.Ltime), + } + } +} + // CreateFileLogWriter returns a LogWriterCreator that creates LogWriter for the given file. func CreateFileLogWriter(path string) (WriterCreator, error) { file, err := os.OpenFile(path, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0600) diff --git a/common/platform/ctlcmd/ctlcmd.go b/common/platform/ctlcmd/ctlcmd.go index ed770b55..1fad1e74 100644 --- a/common/platform/ctlcmd/ctlcmd.go +++ b/common/platform/ctlcmd/ctlcmd.go @@ -4,6 +4,7 @@ import ( "io" "os" "os/exec" + "strings" "v2ray.com/core/common/buf" "v2ray.com/core/common/platform" @@ -35,10 +36,15 @@ func Run(args []string, input io.Reader) (buf.MultiBuffer, error) { if err := cmd.Wait(); err != nil { msg := "failed to execute v2ctl" if errBuffer.Len() > 0 { - msg += ": " + errBuffer.MultiBuffer.String() + msg += ": \n" + strings.TrimSpace(errBuffer.MultiBuffer.String()) } return nil, newError(msg).Base(err) } + // log stderr, info message + if !errBuffer.IsEmpty() { + newError(" \n", strings.TrimSpace(errBuffer.MultiBuffer.String())).AtInfo().WriteToLog() + } + return outBuffer.MultiBuffer, nil } diff --git a/common/platform/platform.go b/common/platform/platform.go index 4fa253d9..b57a98fd 100644 --- a/common/platform/platform.go +++ b/common/platform/platform.go @@ -83,3 +83,10 @@ func GetConfigurationPath() string { configPath := NewEnvFlag(name).GetValue(getExecutableDir) return filepath.Join(configPath, "config.json") } + +// GetConfDirPath reads "v2ray.location.confdir" +func GetConfDirPath() string { + const name = "v2ray.location.confdir" + configPath := NewEnvFlag(name).GetValue(func() string { return "" }) + return configPath +} diff --git a/config.go b/config.go index d328a87b..bcadbb18 100755 --- a/config.go +++ b/config.go @@ -9,6 +9,8 @@ import ( "github.com/golang/protobuf/proto" "v2ray.com/core/common" "v2ray.com/core/common/buf" + "v2ray.com/core/common/cmdarg" + "v2ray.com/core/main/confloader" ) // ConfigFormat is a configurable format of V2Ray config file. @@ -19,7 +21,7 @@ type ConfigFormat struct { } // ConfigLoader is a utility to load V2Ray config from external source. -type ConfigLoader func(input io.Reader) (*Config, error) +type ConfigLoader func(input interface{}) (*Config, error) var ( configLoaderByName = make(map[string]*ConfigFormat) @@ -54,7 +56,10 @@ func getExtension(filename string) string { } // LoadConfig loads config with given format from given source. -func LoadConfig(formatName string, filename string, input io.Reader) (*Config, error) { +// input accepts 2 different types: +// * []string slice of multiple filename/url(s) to open to read +// * io.Reader that reads a config content (the original way) +func LoadConfig(formatName string, filename string, input interface{}) (*Config, error) { ext := getExtension(filename) if len(ext) > 0 { if f, found := configLoaderByExt[ext]; found { @@ -69,12 +74,8 @@ func LoadConfig(formatName string, filename string, input io.Reader) (*Config, e return nil, newError("Unable to load config in ", formatName).AtWarning() } -func loadProtobufConfig(input io.Reader) (*Config, error) { +func loadProtobufConfig(data []byte) (*Config, error) { config := new(Config) - data, err := buf.ReadAllToBytes(input) - if err != nil { - return nil, err - } if err := proto.Unmarshal(data, config); err != nil { return nil, err } @@ -85,6 +86,21 @@ func init() { common.Must(RegisterConfigLoader(&ConfigFormat{ Name: "Protobuf", Extension: []string{"pb"}, - Loader: loadProtobufConfig, + Loader: func(input interface{}) (*Config, error) { + switch v := input.(type) { + case cmdarg.Arg: + r, err := confloader.LoadConfig(v[0]) + common.Must(err) + data, err := buf.ReadAllToBytes(r) + common.Must(err) + return loadProtobufConfig(data) + case io.Reader: + data, err := buf.ReadAllToBytes(v) + common.Must(err) + return loadProtobufConfig(data) + default: + return nil, newError("unknow type") + } + }, })) } diff --git a/infra/conf/serial/loader.go b/infra/conf/serial/loader.go index 1d084778..f7ecf2db 100644 --- a/infra/conf/serial/loader.go +++ b/infra/conf/serial/loader.go @@ -38,7 +38,9 @@ func findOffset(b []byte, o int) *offset { return &offset{line: line, char: char} } -func LoadJSONConfig(reader io.Reader) (*core.Config, error) { +// DecodeJSONConfig reads from reader and decode the config into *conf.Config +// syntax error could be detected. +func DecodeJSONConfig(reader io.Reader) (*conf.Config, error) { jsonConfig := &conf.Config{} jsonContent := bytes.NewBuffer(make([]byte, 0, 10240)) @@ -62,6 +64,15 @@ func LoadJSONConfig(reader io.Reader) (*core.Config, error) { return nil, newError("failed to read config file").Base(err) } + return jsonConfig, nil +} + +func LoadJSONConfig(reader io.Reader) (*core.Config, error) { + jsonConfig, err := DecodeJSONConfig(reader) + if err != nil { + return nil, err + } + pbConfig, err := jsonConfig.Build() if err != nil { return nil, newError("failed to parse json config").Base(err) diff --git a/infra/conf/v2ray.go b/infra/conf/v2ray.go index 58c9c6da..56c1a2a4 100644 --- a/infra/conf/v2ray.go +++ b/infra/conf/v2ray.go @@ -2,6 +2,8 @@ package conf import ( "encoding/json" + "log" + "os" "strings" "v2ray.com/core" @@ -31,6 +33,8 @@ var ( "mtproto": func() interface{} { return new(MTProtoClientConfig) }, "dns": func() interface{} { return new(DnsOutboundConfig) }, }, "protocol", "settings") + + ctllog = log.New(os.Stderr, "v2ctl> ", 0) ) func toProtocolList(s []string) ([]proxyman.KnownProtocols, error) { @@ -304,6 +308,94 @@ type Config struct { Reverse *ReverseConfig `json:"reverse"` } +func (c *Config) findInboundTag(tag string) int { + found := -1 + for idx, ib := range c.InboundConfigs { + if ib.Tag == tag { + found = idx + break + } + } + return found +} + +func (c *Config) findOutboundTag(tag string) int { + found := -1 + for idx, ob := range c.OutboundConfigs { + if ob.Tag == tag { + found = idx + break + } + } + return found +} + +// Override method accepts another Config overrides the current attribute +func (c *Config) Override(o *Config, fn string) { + + // only process the non-deprecated members + + if o.LogConfig != nil { + c.LogConfig = o.LogConfig + } + if o.RouterConfig != nil { + c.RouterConfig = o.RouterConfig + } + if o.DNSConfig != nil { + c.DNSConfig = o.DNSConfig + } + if o.Transport != nil { + c.Transport = o.Transport + } + if o.Policy != nil { + c.Policy = o.Policy + } + if o.Api != nil { + c.Api = o.Api + } + if o.Stats != nil { + c.Stats = o.Stats + } + if o.Reverse != nil { + c.Reverse = o.Reverse + } + + // update the Inbound in slice if the only one in overide config has same tag + if len(o.InboundConfigs) > 0 { + if len(c.InboundConfigs) > 0 && len(o.InboundConfigs) == 1 { + if idx := c.findInboundTag(o.InboundConfigs[0].Tag); idx > -1 { + c.InboundConfigs[idx] = o.InboundConfigs[0] + ctllog.Println("[", fn, "] updated inbound with tag: ", o.InboundConfigs[0].Tag) + } else { + c.InboundConfigs = append(c.InboundConfigs, o.InboundConfigs[0]) + ctllog.Println("[", fn, "] appended inbound with tag: ", o.InboundConfigs[0].Tag) + } + } else { + c.InboundConfigs = o.InboundConfigs + } + } + + // update the Outbound in slice if the only one in overide config has same tag + if len(o.OutboundConfigs) > 0 { + if len(c.OutboundConfigs) > 0 && len(o.OutboundConfigs) == 1 { + if idx := c.findOutboundTag(o.OutboundConfigs[0].Tag); idx > -1 { + c.OutboundConfigs[idx] = o.OutboundConfigs[0] + ctllog.Println("[", fn, "] updated outbound with tag: ", o.OutboundConfigs[0].Tag) + } else { + if strings.Contains(strings.ToLower(fn), "tail") { + c.OutboundConfigs = append(c.OutboundConfigs, o.OutboundConfigs[0]) + ctllog.Println("[", fn, "] appended outbound with tag: ", o.OutboundConfigs[0].Tag) + } else { + c.OutboundConfigs = append(o.OutboundConfigs, c.OutboundConfigs...) + ctllog.Println("[", fn, "] prepended outbound with tag: ", o.OutboundConfigs[0].Tag) + } + } + } else { + c.OutboundConfigs = o.OutboundConfigs + } + } +} + func applyTransportConfig(s *StreamConfig, t *TransportConfig) { if s.TCPSettings == nil { s.TCPSettings = t.TCPConfig diff --git a/infra/conf/v2ray_test.go b/infra/conf/v2ray_test.go index d324d3ea..8c59a7ae 100644 --- a/infra/conf/v2ray_test.go +++ b/infra/conf/v2ray_test.go @@ -6,6 +6,7 @@ import ( "testing" "github.com/golang/protobuf/proto" + "github.com/google/go-cmp/cmp" "v2ray.com/core" "v2ray.com/core/app/dispatcher" "v2ray.com/core/app/log" @@ -369,3 +370,80 @@ func TestMuxConfig_Build(t *testing.T) { }) } } + +func TestConfig_Override(t *testing.T) { + tests := []struct { + name string + orig *Config + over *Config + fn string + want *Config + }{ + {"combine/empty", + &Config{}, + &Config{ + LogConfig: &LogConfig{}, + RouterConfig: &RouterConfig{}, + DNSConfig: &DnsConfig{}, + Transport: &TransportConfig{}, + Policy: &PolicyConfig{}, + Api: &ApiConfig{}, + Stats: &StatsConfig{}, + Reverse: &ReverseConfig{}, + }, + "", + &Config{ + LogConfig: &LogConfig{}, + RouterConfig: &RouterConfig{}, + DNSConfig: &DnsConfig{}, + Transport: &TransportConfig{}, + Policy: &PolicyConfig{}, + Api: &ApiConfig{}, + Stats: &StatsConfig{}, + Reverse: &ReverseConfig{}, + }, + }, + {"combine/newattr", + &Config{InboundConfigs: []InboundDetourConfig{InboundDetourConfig{Tag: "old"}}}, + &Config{LogConfig: &LogConfig{}}, "", + &Config{LogConfig: &LogConfig{}, InboundConfigs: []InboundDetourConfig{InboundDetourConfig{Tag: "old"}}}}, + {"replace/inbounds", + &Config{InboundConfigs: []InboundDetourConfig{InboundDetourConfig{Tag: "pos0"}, InboundDetourConfig{Protocol: "vmess", Tag: "pos1"}}}, + &Config{InboundConfigs: []InboundDetourConfig{InboundDetourConfig{Tag: "pos1", Protocol: "kcp"}}}, + "", + &Config{InboundConfigs: []InboundDetourConfig{InboundDetourConfig{Tag: "pos0"}, InboundDetourConfig{Tag: "pos1", Protocol: "kcp"}}}}, + {"replace/inbounds-replaceall", + &Config{InboundConfigs: []InboundDetourConfig{InboundDetourConfig{Tag: "pos0"}, InboundDetourConfig{Protocol: "vmess", Tag: "pos1"}}}, + &Config{InboundConfigs: []InboundDetourConfig{InboundDetourConfig{Tag: "pos1", Protocol: "kcp"}, InboundDetourConfig{Tag: "pos2", Protocol: "kcp"}}}, + "", + &Config{InboundConfigs: []InboundDetourConfig{InboundDetourConfig{Tag: "pos1", Protocol: "kcp"}, InboundDetourConfig{Tag: "pos2", Protocol: "kcp"}}}}, + {"replace/notag-append", + &Config{InboundConfigs: []InboundDetourConfig{InboundDetourConfig{}, InboundDetourConfig{Protocol: "vmess"}}}, + &Config{InboundConfigs: []InboundDetourConfig{InboundDetourConfig{Tag: "pos1", Protocol: "kcp"}}}, + "", + &Config{InboundConfigs: []InboundDetourConfig{InboundDetourConfig{}, InboundDetourConfig{Protocol: "vmess"}, InboundDetourConfig{Tag: "pos1", Protocol: "kcp"}}}}, + {"replace/outbounds", + &Config{OutboundConfigs: []OutboundDetourConfig{OutboundDetourConfig{Tag: "pos0"}, OutboundDetourConfig{Protocol: "vmess", Tag: "pos1"}}}, + &Config{OutboundConfigs: []OutboundDetourConfig{OutboundDetourConfig{Tag: "pos1", Protocol: "kcp"}}}, + "", + &Config{OutboundConfigs: []OutboundDetourConfig{OutboundDetourConfig{Tag: "pos0"}, OutboundDetourConfig{Tag: "pos1", Protocol: "kcp"}}}}, + {"replace/outbounds-prepend", + &Config{OutboundConfigs: []OutboundDetourConfig{OutboundDetourConfig{Tag: "pos0"}, OutboundDetourConfig{Protocol: "vmess", Tag: "pos1"}}}, + &Config{OutboundConfigs: []OutboundDetourConfig{OutboundDetourConfig{Tag: "pos1", Protocol: "kcp"}, OutboundDetourConfig{Tag: "pos2", Protocol: "kcp"}}}, + "config.json", + &Config{OutboundConfigs: []OutboundDetourConfig{OutboundDetourConfig{Tag: "pos1", Protocol: "kcp"}, OutboundDetourConfig{Tag: "pos2", Protocol: "kcp"}}}}, + {"replace/outbounds-append", + &Config{OutboundConfigs: []OutboundDetourConfig{OutboundDetourConfig{Tag: "pos0"}, OutboundDetourConfig{Protocol: "vmess", Tag: "pos1"}}}, + &Config{OutboundConfigs: []OutboundDetourConfig{OutboundDetourConfig{Tag: "pos2", Protocol: "kcp"}}}, + "config_tail.json", + &Config{OutboundConfigs: []OutboundDetourConfig{OutboundDetourConfig{Tag: "pos0"}, OutboundDetourConfig{Protocol: "vmess", Tag: "pos1"}, OutboundDetourConfig{Tag: "pos2", Protocol: "kcp"}}}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + tt.orig.Override(tt.over, tt.fn) + if r := cmp.Diff(tt.orig, tt.want); r != "" { + t.Error(r) + } + }) + } +} diff --git a/infra/control/command.go b/infra/control/command.go index a261646a..1edeac10 100644 --- a/infra/control/command.go +++ b/infra/control/command.go @@ -2,6 +2,8 @@ package control import ( "fmt" + "log" + "os" "strings" ) @@ -18,6 +20,7 @@ type Command interface { var ( commandRegistry = make(map[string]Command) + ctllog = log.New(os.Stderr, "v2ctl> ", 0) ) func RegisterCommand(cmd Command) error { diff --git a/infra/control/config.go b/infra/control/config.go new file mode 100644 index 00000000..504975a8 --- /dev/null +++ b/infra/control/config.go @@ -0,0 +1,88 @@ +package control + +import ( + "bytes" + "io" + "io/ioutil" + "os" + "strings" + + "github.com/golang/protobuf/proto" + "v2ray.com/core/common" + "v2ray.com/core/infra/conf" + "v2ray.com/core/infra/conf/serial" +) + +// ConfigCommand is the json to pb convert struct +type ConfigCommand struct{} + +// Name for cmd usage +func (c *ConfigCommand) Name() string { + return "config" +} + +// Description for help usage +func (c *ConfigCommand) Description() Description { + return Description{ + Short: "merge multiple json config", + Usage: []string{"v2ctl config config.json c1.json c2.json .json"}, + } +} + +// Execute real work here. +func (c *ConfigCommand) Execute(args []string) error { + if len(args) < 1 { + return newError("empty config list") + } + + conf := &conf.Config{} + for _, arg := range args { + ctllog.Println("Read config: ", arg) + r, err := c.LoadArg(arg) + common.Must(err) + c, err := serial.DecodeJSONConfig(r) + if err != nil { + ctllog.Fatalln(err) + } + conf.Override(c, arg) + } + + pbConfig, err := conf.Build() + if err != nil { + return err + } + + bytesConfig, err := proto.Marshal(pbConfig) + if err != nil { + return newError("failed to marshal proto config").Base(err) + } + + if _, err := os.Stdout.Write(bytesConfig); err != nil { + return newError("failed to write proto config").Base(err) + } + + return nil +} + +// LoadArg loads one arg, maybe an remote url, or local file path +func (c *ConfigCommand) LoadArg(arg string) (out io.Reader, err error) { + + var data []byte + if strings.HasPrefix(arg, "http://") || strings.HasPrefix(arg, "https://") { + data, err = FetchHTTPContent(arg) + } else if arg == "stdin:" { + data, err = ioutil.ReadAll(os.Stdin) + } else { + data, err = ioutil.ReadFile(arg) + } + + if err != nil { + return + } + out = bytes.NewBuffer(data) + return +} + +func init() { + common.Must(RegisterCommand(&ConfigCommand{})) +} diff --git a/infra/control/fetch.go b/infra/control/fetch.go index 167c7483..a9deef25 100644 --- a/infra/control/fetch.go +++ b/infra/control/fetch.go @@ -5,6 +5,7 @@ import ( "net/url" "os" "strings" + "time" "v2ray.com/core/common" "v2ray.com/core/common/buf" @@ -23,46 +24,54 @@ func (c *FetchCommand) Description() Description { } } -func (c *FetchCommand) isValidScheme(scheme string) bool { - scheme = strings.ToLower(scheme) - return scheme == "http" || scheme == "https" -} - func (c *FetchCommand) Execute(args []string) error { if len(args) < 1 { return newError("empty url") } - target := args[0] + content, err := FetchHTTPContent(args[0]) + if err != nil { + return newError("failed to read HTTP response").Base(err) + } + + os.Stdout.Write(content) + return nil +} + +// FetchHTTPContent dials https for remote content +func FetchHTTPContent(target string) ([]byte, error) { + parsedTarget, err := url.Parse(target) if err != nil { - return newError("invalid URL: ", target).Base(err) + return nil, newError("invalid URL: ", target).Base(err) } - if !c.isValidScheme(parsedTarget.Scheme) { - return newError("invalid scheme: ", parsedTarget.Scheme) + + if s := strings.ToLower(parsedTarget.Scheme); s != "http" && s != "https" { + return nil, newError("invalid scheme: ", parsedTarget.Scheme) } - client := &http.Client{} + client := &http.Client{ + Timeout: 30 * time.Second, + } resp, err := client.Do(&http.Request{ Method: "GET", URL: parsedTarget, Close: true, }) if err != nil { - return newError("failed to dial to ", target).Base(err) + return nil, newError("failed to dial to ", target).Base(err) } + defer resp.Body.Close() if resp.StatusCode != 200 { - return newError("unexpected HTTP status code: ", resp.StatusCode) + return nil, newError("unexpected HTTP status code: ", resp.StatusCode) } content, err := buf.ReadAllToBytes(resp.Body) if err != nil { - return newError("failed to read HTTP response").Base(err) + return nil, newError("failed to read HTTP response").Base(err) } - os.Stdout.Write(content) - - return nil + return content, nil } func init() { diff --git a/infra/control/main/main.go b/infra/control/main/main.go index 5c41aeb0..e78fa5d1 100644 --- a/infra/control/main/main.go +++ b/infra/control/main/main.go @@ -5,7 +5,8 @@ import ( "fmt" "os" - _ "v2ray.com/core/infra/conf/command" + commlog "v2ray.com/core/common/log" + // _ "v2ray.com/core/infra/conf/command" "v2ray.com/core/infra/control" ) @@ -17,6 +18,8 @@ func getCommandName() string { } func main() { + // let the v2ctl prints log at stderr + commlog.RegisterHandler(commlog.NewLogger(commlog.CreateStderrLogWriter())) name := getCommandName() cmd := control.GetCommand(name) if cmd == nil { diff --git a/main/confloader/confloader.go b/main/confloader/confloader.go index 9edf6909..d52b5b89 100644 --- a/main/confloader/confloader.go +++ b/main/confloader/confloader.go @@ -5,15 +5,30 @@ import ( "os" ) -type configFileLoader func(string) (io.ReadCloser, error) +type configFileLoader func(string) (io.Reader, error) +type extconfigLoader func([]string) (io.Reader, error) var ( EffectiveConfigFileLoader configFileLoader + EffectiveExtConfigLoader extconfigLoader ) -func LoadConfig(file string) (io.ReadCloser, error) { +// LoadConfig reads from a path/url/stdin +// actual work is in external module +func LoadConfig(file string) (io.Reader, error) { if EffectiveConfigFileLoader == nil { + newError("external config module not loaded, reading from stdin").AtInfo().WriteToLog() return os.Stdin, nil } return EffectiveConfigFileLoader(file) } + +// LoadExtConfig calls v2ctl to handle multiple config +// the actual work also in external module +func LoadExtConfig(files []string) (io.Reader, error) { + if EffectiveExtConfigLoader == nil { + return nil, newError("external config module not loaded").AtError() + } + + return EffectiveExtConfigLoader(files) +} diff --git a/main/confloader/errors.generated.go b/main/confloader/errors.generated.go new file mode 100644 index 00000000..deda6e51 --- /dev/null +++ b/main/confloader/errors.generated.go @@ -0,0 +1,9 @@ +package confloader + +import "v2ray.com/core/common/errors" + +type errPathObjHolder struct{} + +func newError(values ...interface{}) *errors.Error { + return errors.New(values...).WithPathObj(errPathObjHolder{}) +} diff --git a/main/confloader/external/external.go b/main/confloader/external/external.go index 75dcdea3..a16f0c7a 100644 --- a/main/confloader/external/external.go +++ b/main/confloader/external/external.go @@ -1,48 +1,86 @@ package external +//go:generate errorgen + import ( + "bytes" "io" + "io/ioutil" + "net/http" + "net/url" "os" "strings" + "time" "v2ray.com/core/common/buf" "v2ray.com/core/common/platform/ctlcmd" "v2ray.com/core/main/confloader" ) -//go:generate errorgen +func ConfigLoader(arg string) (out io.Reader, err error) { + + var data []byte + if strings.HasPrefix(arg, "http://") || strings.HasPrefix(arg, "https://") { + data, err = FetchHTTPContent(arg) + } else if arg == "stdin:" { + data, err = ioutil.ReadAll(os.Stdin) + } else { + data, err = ioutil.ReadFile(arg) + } + + if err != nil { + return + } + out = bytes.NewBuffer(data) + return +} + +func FetchHTTPContent(target string) ([]byte, error) { -func loadConfigFile(configFile string) (io.ReadCloser, error) { - if configFile == "stdin:" { - return os.Stdin, nil + parsedTarget, err := url.Parse(target) + if err != nil { + return nil, newError("invalid URL: ", target).Base(err) + } + + if s := strings.ToLower(parsedTarget.Scheme); s != "http" && s != "https" { + return nil, newError("invalid scheme: ", parsedTarget.Scheme) + } + + client := &http.Client{ + Timeout: 30 * time.Second, } + resp, err := client.Do(&http.Request{ + Method: "GET", + URL: parsedTarget, + Close: true, + }) + if err != nil { + return nil, newError("failed to dial to ", target).Base(err) + } + defer resp.Body.Close() - if strings.HasPrefix(configFile, "http://") || strings.HasPrefix(configFile, "https://") { - content, err := ctlcmd.Run([]string{"fetch", configFile}, nil) - if err != nil { - return nil, err - } - return &buf.MultiBufferContainer{ - MultiBuffer: content, - }, nil + if resp.StatusCode != 200 { + return nil, newError("unexpected HTTP status code: ", resp.StatusCode) } - fixedFile := os.ExpandEnv(configFile) - file, err := os.Open(fixedFile) + content, err := buf.ReadAllToBytes(resp.Body) if err != nil { - return nil, newError("config file not readable").Base(err) + return nil, newError("failed to read HTTP response").Base(err) } - defer file.Close() - content, err := buf.ReadFrom(file) + return content, nil +} + +func ExtConfigLoader(files []string) (io.Reader, error) { + buf, err := ctlcmd.Run(append([]string{"config"}, files...), os.Stdin) if err != nil { - return nil, newError("failed to load config file: ", fixedFile).Base(err).AtWarning() + return nil, err } - return &buf.MultiBufferContainer{ - MultiBuffer: content, - }, nil + + return strings.NewReader(buf.String()), nil } func init() { - confloader.EffectiveConfigFileLoader = loadConfigFile + confloader.EffectiveConfigFileLoader = ConfigLoader + confloader.EffectiveExtConfigLoader = ExtConfigLoader } diff --git a/main/json/config_json.go b/main/json/config_json.go index 45c6374d..59bcc63d 100644 --- a/main/json/config_json.go +++ b/main/json/config_json.go @@ -7,22 +7,28 @@ import ( "v2ray.com/core" "v2ray.com/core/common" - "v2ray.com/core/common/buf" - "v2ray.com/core/common/platform/ctlcmd" + "v2ray.com/core/common/cmdarg" + "v2ray.com/core/infra/conf/serial" + "v2ray.com/core/main/confloader" ) func init() { common.Must(core.RegisterConfigLoader(&core.ConfigFormat{ Name: "JSON", Extension: []string{"json"}, - Loader: func(input io.Reader) (*core.Config, error) { - jsonContent, err := ctlcmd.Run([]string{"config"}, input) - if err != nil { - return nil, newError("failed to execute v2ctl to convert config file.").Base(err).AtWarning() + Loader: func(input interface{}) (*core.Config, error) { + switch v := input.(type) { + case cmdarg.Arg: + r, err := confloader.LoadExtConfig(v) + if err != nil { + return nil, newError("failed to execute v2ctl to convert config file.").Base(err).AtWarning() + } + return core.LoadConfig("protobuf", "", r) + case io.Reader: + return serial.LoadJSONConfig(v) + default: + return nil, newError("unknow type") } - return core.LoadConfig("protobuf", "", &buf.MultiBufferContainer{ - MultiBuffer: jsonContent, - }) }, })) } diff --git a/main/jsonem/errors.generated.go b/main/jsonem/errors.generated.go new file mode 100644 index 00000000..48961bce --- /dev/null +++ b/main/jsonem/errors.generated.go @@ -0,0 +1,9 @@ +package jsonem + +import "v2ray.com/core/common/errors" + +type errPathObjHolder struct{} + +func newError(values ...interface{}) *errors.Error { + return errors.New(values...).WithPathObj(errPathObjHolder{}) +} diff --git a/main/jsonem/jsonem.go b/main/jsonem/jsonem.go index 7b58bb9b..6000e285 100644 --- a/main/jsonem/jsonem.go +++ b/main/jsonem/jsonem.go @@ -1,15 +1,38 @@ package jsonem import ( + "io" + "v2ray.com/core" "v2ray.com/core/common" + "v2ray.com/core/common/cmdarg" + "v2ray.com/core/infra/conf" "v2ray.com/core/infra/conf/serial" + "v2ray.com/core/main/confloader" ) func init() { common.Must(core.RegisterConfigLoader(&core.ConfigFormat{ Name: "JSON", Extension: []string{"json"}, - Loader: serial.LoadJSONConfig, + Loader: func(input interface{}) (*core.Config, error) { + switch v := input.(type) { + case cmdarg.Arg: + cf := &conf.Config{} + for _, arg := range v { + newError("Reading config: ", arg).AtInfo().WriteToLog() + r, err := confloader.LoadConfig(arg) + common.Must(err) + c, err := serial.DecodeJSONConfig(r) + common.Must(err) + cf.Override(c, arg) + } + return cf.Build() + case io.Reader: + return serial.LoadJSONConfig(v) + default: + return nil, newError("unknow type") + } + }, })) } diff --git a/main/main.go b/main/main.go index a5d3a447..481b998c 100644 --- a/main/main.go +++ b/main/main.go @@ -5,24 +5,28 @@ package main import ( "flag" "fmt" + "io/ioutil" + "log" "os" "os/signal" + "path" "path/filepath" "runtime" "strings" "syscall" "v2ray.com/core" + "v2ray.com/core/common/cmdarg" "v2ray.com/core/common/platform" - "v2ray.com/core/main/confloader" _ "v2ray.com/core/main/distro/all" ) var ( - configFile = flag.String("config", "", "Config file for V2Ray.") - version = flag.Bool("version", false, "Show current version of V2Ray.") - test = flag.Bool("test", false, "Test config file only, without launching V2Ray server.") - format = flag.String("format", "json", "Format of input file.") + configFiles cmdarg.Arg // "Config file for V2Ray.", the option is customed type, parse in main + configDir string + version = flag.Bool("version", false, "Show current version of V2Ray.") + test = flag.Bool("test", false, "Test config file only, without launching V2Ray server.") + format = flag.String("format", "json", "Format of input file.") ) func fileExists(file string) bool { @@ -30,23 +34,54 @@ func fileExists(file string) bool { return err == nil && !info.IsDir() } -func getConfigFilePath() string { - if len(*configFile) > 0 { - return *configFile +func dirExists(file string) bool { + info, err := os.Stat(file) + return err == nil && info.IsDir() +} + +func readConfDir(dirPath string) { + confs, err := ioutil.ReadDir(dirPath) + if err != nil { + log.Fatalln(err) + } + for _, f := range confs { + if strings.HasSuffix(f.Name(), ".json") { + configFiles.Set(path.Join(dirPath, f.Name())) + } + } +} + +func getConfigFilePath() (cmdarg.Arg, error) { + if dirExists(configDir) { + readConfDir(configDir) + } + if len(configFiles) > 0 { + return configFiles, nil } if workingDir, err := os.Getwd(); err == nil { configFile := filepath.Join(workingDir, "config.json") if fileExists(configFile) { - return configFile + log.Println("Using default config: ", configFile) + return cmdarg.Arg{configFile}, nil } } if configFile := platform.GetConfigurationPath(); fileExists(configFile) { - return configFile + log.Println("Using config from env: ", configFile) + return cmdarg.Arg{configFile}, nil + } + + if envConfDir := platform.GetConfDirPath(); dirExists(envConfDir) { + log.Println("Using confdir from env: ", envConfDir) + readConfDir(envConfDir) + if len(configFiles) > 0 { + return configFiles, nil + } } - return "" + log.Println("Using config from STDIN") + return cmdarg.Arg{"stdin:"}, nil } func GetConfigFormat() string { @@ -59,16 +94,14 @@ func GetConfigFormat() string { } func startV2Ray() (core.Server, error) { - configFile := getConfigFilePath() - configInput, err := confloader.LoadConfig(configFile) + configFiles, err := getConfigFilePath() if err != nil { - return nil, newError("failed to load config: ", configFile).Base(err) + return nil, err } - defer configInput.Close() - config, err := core.LoadConfig(GetConfigFormat(), configFile, configInput) + config, err := core.LoadConfig(GetConfigFormat(), configFiles[0], configFiles) if err != nil { - return nil, newError("failed to read config file: ", configFile).Base(err) + return nil, newError("failed to read config files: [", configFiles.String(), "]").Base(err) } server, err := core.New(config) @@ -87,6 +120,9 @@ func printVersion() { } func main() { + flag.Var(&configFiles, "config", "Config file for V2Ray. Multiple assign is accepted (only json). Latter ones overrides the former ones.") + flag.Var(&configFiles, "c", "Short alias of -config") + flag.StringVar(&configDir, "confdir", "", "A dir with multiple json config") flag.Parse() printVersion() @@ -97,7 +133,7 @@ func main() { server, err := startV2Ray() if err != nil { - fmt.Println(err.Error()) + fmt.Println(err) // Configuration error. Exit with a special value to prevent systemd from restarting. os.Exit(23) }