nite/sub2clash
1
Fork 0
mirror of https://github.com/bestnite/sub2clash.git synced 2025-06-17 20:53:18 +08:00
Code Issues Packages Projects Releases Wiki Activity

Refactor error handling

Browse Source
This commit is contained in:
nite
2025-06-12 11:33:13 +10:00
parent 2a042968d0
commit b80afd97f1
16 changed files with 304 additions and 122 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
parser/anytls.go
View File

@ -5,7 +5,6 @@ import (
"net/url"
"strings"
E "github.com/bestnite/sub2clash/error"
P "github.com/bestnite/sub2clash/model/proxy"
)
@ -29,13 +28,13 @@ func (p *AnytlsParser) GetType() string {
func (p *AnytlsParser) Parse(proxy string) (P.Proxy, error) {
if !hasPrefix(proxy, p.GetPrefixes()) {
return P.Proxy{}, &E.ParseError{Type: E.ErrInvalidPrefix, Raw: proxy}
return P.Proxy{}, &ParseError{Type: ErrInvalidPrefix, Raw: proxy}
}
link, err := url.Parse(proxy)
if err != nil {
return P.Proxy{}, &E.ParseError{
Type: E.ErrInvalidStruct,
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Message: "url parse error",
Raw: proxy,
}
@ -50,24 +49,24 @@ func (p *AnytlsParser) Parse(proxy string) (P.Proxy, error) {
query := link.Query()
server := link.Hostname()
if server == "" {
return P.Proxy{}, &E.ParseError{
Type: E.ErrInvalidStruct,
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Message: "missing server host",
Raw: proxy,
}
}
portStr := link.Port()
if portStr == "" {
return P.Proxy{}, &E.ParseError{
Type: E.ErrInvalidStruct,
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Message: "missing server port",
Raw: proxy,
}
}
port, err := ParsePort(portStr)
if err != nil {
return P.Proxy{}, &E.ParseError{
Type: E.ErrInvalidPort,
return P.Proxy{}, &ParseError{
Type: ErrInvalidPort,
Raw: portStr,
}
}

24
parser/errors.go Normal file
View File

@ -0,0 +1,24 @@
package parser
type ParseError struct {
Type ParseErrorType
Message string
Raw string
}
type ParseErrorType string
const (
ErrInvalidPrefix ParseErrorType = "invalid url prefix"
ErrInvalidStruct ParseErrorType = "invalid struct"
ErrInvalidPort ParseErrorType = "invalid port number"
ErrCannotParseParams ParseErrorType = "cannot parse query parameters"
ErrInvalidBase64 ParseErrorType = "invalid base64"
)
func (e *ParseError) Error() string {
if e.Message != "" {
return string(e.Type) + ": " + e.Message + " \"" + e.Raw + "\""
}
return string(e.Type)
}

19
parser/hysteria.go
View File

@ -6,7 +6,6 @@ import (
"strconv"
"strings"
E "github.com/bestnite/sub2clash/error"
P "github.com/bestnite/sub2clash/model/proxy"
)
@ -30,21 +29,21 @@ func (p *HysteriaParser) GetType() string {
func (p *HysteriaParser) Parse(proxy string) (P.Proxy, error) {
if !hasPrefix(proxy, p.GetPrefixes()) {
return P.Proxy{}, &E.ParseError{Type: E.ErrInvalidPrefix, Raw: proxy}
return P.Proxy{}, &ParseError{Type: ErrInvalidPrefix, Raw: proxy}
}
link, err := url.Parse(proxy)
if err != nil {
return P.Proxy{}, &E.ParseError{
Type: E.ErrInvalidStruct,
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Message: "url parse error",
Raw: proxy,
}
}
server := link.Hostname()
if server == "" {
return P.Proxy{}, &E.ParseError{
Type: E.ErrInvalidStruct,
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Message: "missing server host",
Raw: proxy,
}
@ -52,8 +51,8 @@ func (p *HysteriaParser) Parse(proxy string) (P.Proxy, error) {
portStr := link.Port()
if portStr == "" {
return P.Proxy{}, &E.ParseError{
Type: E.ErrInvalidStruct,
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Message: "missing server port",
Raw: proxy,
}
@ -61,8 +60,8 @@ func (p *HysteriaParser) Parse(proxy string) (P.Proxy, error) {
port, err := ParsePort(portStr)
if err != nil {
return P.Proxy{}, &E.ParseError{
Type: E.ErrInvalidPort,
return P.Proxy{}, &ParseError{
Type: ErrInvalidPort,
Message: err.Error(),
Raw: proxy,
}

19
parser/hysteria2.go
View File

@ -5,7 +5,6 @@ import (
"net/url"
"strings"
E "github.com/bestnite/sub2clash/error"
P "github.com/bestnite/sub2clash/model/proxy"
)
@ -29,13 +28,13 @@ func (p *Hysteria2Parser) GetType() string {
func (p *Hysteria2Parser) Parse(proxy string) (P.Proxy, error) {
if !hasPrefix(proxy, p.GetPrefixes()) {
return P.Proxy{}, &E.ParseError{Type: E.ErrInvalidPrefix, Raw: proxy}
return P.Proxy{}, &ParseError{Type: ErrInvalidPrefix, Raw: proxy}
}
link, err := url.Parse(proxy)
if err != nil {
return P.Proxy{}, &E.ParseError{
Type: E.ErrInvalidStruct,
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Message: "url parse error",
Raw: proxy,
}
@ -50,24 +49,24 @@ func (p *Hysteria2Parser) Parse(proxy string) (P.Proxy, error) {
query := link.Query()
server := link.Hostname()
if server == "" {
return P.Proxy{}, &E.ParseError{
Type: E.ErrInvalidStruct,
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Message: "missing server host",
Raw: proxy,
}
}
portStr := link.Port()
if portStr == "" {
return P.Proxy{}, &E.ParseError{
Type: E.ErrInvalidStruct,
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Message: "missing server port",
Raw: proxy,
}
}
port, err := ParsePort(portStr)
if err != nil {
return P.Proxy{}, &E.ParseError{
Type: E.ErrInvalidPort,
return P.Proxy{}, &ParseError{
Type: ErrInvalidPort,
Raw: portStr,
}
}

5
parser/registry.go
View File

@ -4,7 +4,6 @@ import (
"strings"
"sync"
E "github.com/bestnite/sub2clash/error"
P "github.com/bestnite/sub2clash/model/proxy"
)
@ -65,7 +64,7 @@ func GetAllParsers() map[string]ProxyParser {
func ParseProxyWithRegistry(proxy string) (P.Proxy, error) {
proxy = strings.TrimSpace(proxy)
if proxy == "" {
return P.Proxy{}, &E.ParseError{Type: E.ErrInvalidStruct, Raw: proxy, Message: "empty proxy string"}
return P.Proxy{}, &ParseError{Type: ErrInvalidStruct, Raw: proxy, Message: "empty proxy string"}
}
// 查找匹配的解析器
@ -75,5 +74,5 @@ func ParseProxyWithRegistry(proxy string) (P.Proxy, error) {
}
}
return P.Proxy{}, &E.ParseError{Type: E.ErrInvalidPrefix, Raw: proxy, Message: "unsupported protocol"}
return P.Proxy{}, &ParseError{Type: ErrInvalidPrefix, Raw: proxy, Message: "unsupported protocol"}
}

27
parser/shadowsocks.go
View File

@ -5,7 +5,6 @@ import (
"net/url"
"strings"
E "github.com/bestnite/sub2clash/error"
P "github.com/bestnite/sub2clash/model/proxy"
)
@ -33,7 +32,7 @@ func (p *ShadowsocksParser) GetType() string {
// Parse 解析Shadowsocks代理
func (p *ShadowsocksParser) Parse(proxy string) (P.Proxy, error) {
if !hasPrefix(proxy, p.GetPrefixes()) {
return P.Proxy{}, &E.ParseError{Type: E.ErrInvalidPrefix, Raw: proxy}
return P.Proxy{}, &ParseError{Type: ErrInvalidPrefix, Raw: proxy}
}
if !strings.Contains(proxy, "@") {
@ -46,8 +45,8 @@ func (p *ShadowsocksParser) Parse(proxy string) (P.Proxy, error) {
}
d, err := DecodeBase64(s[0])
if err != nil {
return P.Proxy{}, &E.ParseError{
Type: E.ErrInvalidStruct,
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Message: "url parse error",
Raw: proxy,
}
@ -60,8 +59,8 @@ func (p *ShadowsocksParser) Parse(proxy string) (P.Proxy, error) {
}
link, err := url.Parse(proxy)
if err != nil {
return P.Proxy{}, &E.ParseError{
Type: E.ErrInvalidStruct,
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Message: "url parse error",
Raw: proxy,
}
@ -69,8 +68,8 @@ func (p *ShadowsocksParser) Parse(proxy string) (P.Proxy, error) {
server := link.Hostname()
if server == "" {
return P.Proxy{}, &E.ParseError{
Type: E.ErrInvalidStruct,
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Message: "missing server host",
Raw: proxy,
}
@ -78,16 +77,16 @@ func (p *ShadowsocksParser) Parse(proxy string) (P.Proxy, error) {
portStr := link.Port()
if portStr == "" {
return P.Proxy{}, &E.ParseError{
Type: E.ErrInvalidStruct,
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Message: "missing server port",
Raw: proxy,
}
}
port, err := ParsePort(portStr)
if err != nil {
return P.Proxy{}, &E.ParseError{
Type: E.ErrInvalidStruct,
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Raw: proxy,
}
}
@ -108,8 +107,8 @@ func (p *ShadowsocksParser) Parse(proxy string) (P.Proxy, error) {
if isLikelyBase64(password) {
password, err = DecodeBase64(password)
if err != nil {
return P.Proxy{}, &E.ParseError{
Type: E.ErrInvalidStruct,
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Message: "password decode error",
Raw: proxy,
}

23
parser/shadowsocksr.go
View File

@ -5,7 +5,6 @@ import (
"strconv"
"strings"
E "github.com/bestnite/sub2clash/error"
P "github.com/bestnite/sub2clash/model/proxy"
)
@ -29,7 +28,7 @@ func (p *ShadowsocksRParser) GetType() string {
func (p *ShadowsocksRParser) Parse(proxy string) (P.Proxy, error) {
if !hasPrefix(proxy, p.GetPrefixes()) {
return P.Proxy{}, &E.ParseError{Type: E.ErrInvalidPrefix, Raw: proxy}
return P.Proxy{}, &ParseError{Type: ErrInvalidPrefix, Raw: proxy}
}
for _, prefix := range p.GetPrefixes() {
@ -41,8 +40,8 @@ func (p *ShadowsocksRParser) Parse(proxy string) (P.Proxy, error) {
proxy, err := DecodeBase64(proxy)
if err != nil {
return P.Proxy{}, &E.ParseError{
Type: E.ErrInvalidBase64,
return P.Proxy{}, &ParseError{
Type: ErrInvalidBase64,
Raw: proxy,
}
}
@ -54,16 +53,16 @@ func (p *ShadowsocksRParser) Parse(proxy string) (P.Proxy, error) {
obfs := parts[4]
password, err := DecodeBase64(parts[5])
if err != nil {
return P.Proxy{}, &E.ParseError{
Type: E.ErrInvalidStruct,
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Raw: proxy,
Message: err.Error(),
}
}
port, err := ParsePort(parts[1])
if err != nil {
return P.Proxy{}, &E.ParseError{
Type: E.ErrInvalidPort,
return P.Proxy{}, &ParseError{
Type: ErrInvalidPort,
Message: err.Error(),
Raw: proxy,
}
@ -75,8 +74,8 @@ func (p *ShadowsocksRParser) Parse(proxy string) (P.Proxy, error) {
if len(serverInfoAndParams) == 2 {
params, err := url.ParseQuery(serverInfoAndParams[1])
if err != nil {
return P.Proxy{}, &E.ParseError{
Type: E.ErrCannotParseParams,
return P.Proxy{}, &ParseError{
Type: ErrCannotParseParams,
Raw: proxy,
Message: err.Error(),
}
@ -93,8 +92,8 @@ func (p *ShadowsocksRParser) Parse(proxy string) (P.Proxy, error) {
remarks = server + ":" + strconv.Itoa(port)
}
if err != nil {
return P.Proxy{}, &E.ParseError{
Type: E.ErrInvalidStruct,
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Raw: proxy,
Message: err.Error(),
}

23
parser/socks.go
View File

@ -5,7 +5,6 @@ import (
"net/url"
"strings"
E "github.com/bestnite/sub2clash/error"
P "github.com/bestnite/sub2clash/model/proxy"
)
@ -28,37 +27,37 @@ func (p *SocksParser) GetType() string {
func (p *SocksParser) Parse(proxy string) (P.Proxy, error) {
if !hasPrefix(proxy, p.GetPrefixes()) {
return P.Proxy{}, &E.ParseError{Type: E.ErrInvalidPrefix, Raw: proxy}
return P.Proxy{}, &ParseError{Type: ErrInvalidPrefix, Raw: proxy}
}
link, err := url.Parse(proxy)
if err != nil {
return P.Proxy{}, &E.ParseError{
Type: E.ErrInvalidStruct,
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Message: "url parse error",
Raw: proxy,
}
}
server := link.Hostname()
if server == "" {
return P.Proxy{}, &E.ParseError{
Type: E.ErrInvalidStruct,
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Message: "missing server host",
Raw: proxy,
}
}
portStr := link.Port()
if portStr == "" {
return P.Proxy{}, &E.ParseError{
Type: E.ErrInvalidStruct,
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Message: "missing server port",
Raw: proxy,
}
}
port, err := ParsePort(portStr)
if err != nil {
return P.Proxy{}, &E.ParseError{
Type: E.ErrInvalidPort,
return P.Proxy{}, &ParseError{
Type: ErrInvalidPort,
Raw: portStr,
}
}
@ -75,8 +74,8 @@ func (p *SocksParser) Parse(proxy string) (P.Proxy, error) {
decodeStr, err := DecodeBase64(encodeStr)
splitStr := strings.Split(decodeStr, ":")
if err != nil {
return P.Proxy{}, &E.ParseError{
Type: E.ErrInvalidStruct,
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Message: "url parse error",
Raw: proxy,
}

19
parser/trojan.go
View File

@ -5,7 +5,6 @@ import (
"net/url"
"strings"
E "github.com/bestnite/sub2clash/error"
P "github.com/bestnite/sub2clash/model/proxy"
)
@ -29,13 +28,13 @@ func (p *TrojanParser) GetType() string {
func (p *TrojanParser) Parse(proxy string) (P.Proxy, error) {
if !hasPrefix(proxy, p.GetPrefixes()) {
return P.Proxy{}, &E.ParseError{Type: E.ErrInvalidPrefix, Raw: proxy}
return P.Proxy{}, &ParseError{Type: ErrInvalidPrefix, Raw: proxy}
}
link, err := url.Parse(proxy)
if err != nil {
return P.Proxy{}, &E.ParseError{
Type: E.ErrInvalidStruct,
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Message: "url parse error",
Raw: proxy,
}
@ -44,16 +43,16 @@ func (p *TrojanParser) Parse(proxy string) (P.Proxy, error) {
password := link.User.Username()
server := link.Hostname()
if server == "" {
return P.Proxy{}, &E.ParseError{
Type: E.ErrInvalidStruct,
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Message: "missing server host",
Raw: proxy,
}
}
portStr := link.Port()
if portStr == "" {
return P.Proxy{}, &E.ParseError{
Type: E.ErrInvalidStruct,
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Message: "missing server port",
Raw: proxy,
}
@ -61,8 +60,8 @@ func (p *TrojanParser) Parse(proxy string) (P.Proxy, error) {
port, err := ParsePort(portStr)
if err != nil {
return P.Proxy{}, &E.ParseError{
Type: E.ErrInvalidPort,
return P.Proxy{}, &ParseError{
Type: ErrInvalidPort,
Message: err.Error(),
Raw: proxy,
}

19
parser/vless.go
View File

@ -5,7 +5,6 @@ import (
"net/url"
"strings"
E "github.com/bestnite/sub2clash/error"
P "github.com/bestnite/sub2clash/model/proxy"
)
@ -29,13 +28,13 @@ func (p *VlessParser) GetType() string {
func (p *VlessParser) Parse(proxy string) (P.Proxy, error) {
if !hasPrefix(proxy, p.GetPrefixes()) {
return P.Proxy{}, &E.ParseError{Type: E.ErrInvalidPrefix, Raw: proxy}
return P.Proxy{}, &ParseError{Type: ErrInvalidPrefix, Raw: proxy}
}
link, err := url.Parse(proxy)
if err != nil {
return P.Proxy{}, &E.ParseError{
Type: E.ErrInvalidStruct,
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Message: "url parse error",
Raw: proxy,
}
@ -43,8 +42,8 @@ func (p *VlessParser) Parse(proxy string) (P.Proxy, error) {
server := link.Hostname()
if server == "" {
return P.Proxy{}, &E.ParseError{
Type: E.ErrInvalidStruct,
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Message: "missing server host",
Raw: proxy,
}
@ -52,8 +51,8 @@ func (p *VlessParser) Parse(proxy string) (P.Proxy, error) {
portStr := link.Port()
port, err := ParsePort(portStr)
if err != nil {
return P.Proxy{}, &E.ParseError{
Type: E.ErrInvalidPort,
return P.Proxy{}, &ParseError{
Type: ErrInvalidPort,
Message: err.Error(),
Raw: proxy,
}
@ -127,8 +126,8 @@ func (p *VlessParser) Parse(proxy string) (P.Proxy, error) {
hosts, err := url.QueryUnescape(host)
if err != nil {
return P.Proxy{}, &E.ParseError{
Type: E.ErrCannotParseParams,
return P.Proxy{}, &ParseError{
Type: ErrCannotParseParams,
Raw: proxy,
Message: err.Error(),
}

13
parser/vmess.go
View File

@ -6,7 +6,6 @@ import (
"strconv"
"strings"
E "github.com/bestnite/sub2clash/error"
P "github.com/bestnite/sub2clash/model/proxy"
)
@ -48,7 +47,7 @@ func (p *VmessParser) GetType() string {
func (p *VmessParser) Parse(proxy string) (P.Proxy, error) {
if !hasPrefix(proxy, p.GetPrefixes()) {
return P.Proxy{}, &E.ParseError{Type: E.ErrInvalidPrefix, Raw: proxy}
return P.Proxy{}, &ParseError{Type: ErrInvalidPrefix, Raw: proxy}
}
for _, prefix := range p.GetPrefixes() {
@ -59,13 +58,13 @@ func (p *VmessParser) Parse(proxy string) (P.Proxy, error) {
}
base64, err := DecodeBase64(proxy)
if err != nil {
return P.Proxy{}, &E.ParseError{Type: E.ErrInvalidBase64, Raw: proxy, Message: err.Error()}
return P.Proxy{}, &ParseError{Type: ErrInvalidBase64, Raw: proxy, Message: err.Error()}
}
var vmess VmessJson
err = json.Unmarshal([]byte(base64), &vmess)
if err != nil {
return P.Proxy{}, &E.ParseError{Type: E.ErrInvalidStruct, Raw: proxy, Message: err.Error()}
return P.Proxy{}, &ParseError{Type: ErrInvalidStruct, Raw: proxy, Message: err.Error()}
}
var port int
@ -73,8 +72,8 @@ func (p *VmessParser) Parse(proxy string) (P.Proxy, error) {
case string:
port, err = ParsePort(vmess.Port.(string))
if err != nil {
return P.Proxy{}, &E.ParseError{
Type: E.ErrInvalidPort,
return P.Proxy{}, &ParseError{
Type: ErrInvalidPort,
Message: err.Error(),
Raw: proxy,
}
@ -88,7 +87,7 @@ func (p *VmessParser) Parse(proxy string) (P.Proxy, error) {
case string:
aid, err = strconv.Atoi(vmess.Aid.(string))
if err != nil {
return P.Proxy{}, &E.ParseError{Type: E.ErrInvalidStruct, Raw: proxy, Message: err.Error()}
return P.Proxy{}, &ParseError{Type: ErrInvalidStruct, Raw: proxy, Message: err.Error()}
}
case float64:
aid = int(vmess.Aid.(float64))