From b80afd97f1379420d6162230885e4bad16c2b59a Mon Sep 17 00:00:00 2001 From: nite Date: Thu, 12 Jun 2025 11:33:13 +1000 Subject: [PATCH] Refactor error handling --- common/database/database.go | 11 +- common/errors.go | 192 +++++++++++++++++++++++ common/mkdir.go | 7 +- common/sub.go | 25 ++- common/template.go | 3 +- parser/anytls.go | 19 ++- error/parse_error.go => parser/errors.go | 2 +- parser/hysteria.go | 19 ++- parser/hysteria2.go | 19 ++- parser/registry.go | 5 +- parser/shadowsocks.go | 27 ++-- parser/shadowsocksr.go | 23 ++- parser/socks.go | 23 ++- parser/trojan.go | 19 ++- parser/vless.go | 19 ++- parser/vmess.go | 13 +- 16 files changed, 304 insertions(+), 122 deletions(-) create mode 100644 common/errors.go rename error/parse_error.go => parser/errors.go (97%) diff --git a/common/database/database.go b/common/database/database.go index 26d639c..b104513 100644 --- a/common/database/database.go +++ b/common/database/database.go @@ -2,9 +2,9 @@ package database import ( "encoding/json" - "errors" "path/filepath" + "github.com/bestnite/sub2clash/common" "github.com/bestnite/sub2clash/model" "go.etcd.io/bbolt" @@ -17,13 +17,16 @@ func ConnectDB() error { db, err := bbolt.Open(path, 0600, nil) if err != nil { - return err + return common.NewDatabaseConnectError(err) } DB = db return db.Update(func(tx *bbolt.Tx) error { _, err := tx.CreateBucketIfNotExists([]byte("ShortLinks")) - return err + if err != nil { + return common.NewDatabaseConnectError(err) + } + return nil }) } @@ -33,7 +36,7 @@ func FindShortLinkByHash(hash string) (*model.ShortLink, error) { b := tx.Bucket([]byte("ShortLinks")) v := b.Get([]byte(hash)) if v == nil { - return errors.New("ShortLink not found") + return common.NewRecordNotFoundError("ShortLink", hash) } return json.Unmarshal(v, &shortLink) }) diff --git a/common/errors.go b/common/errors.go new file mode 100644 index 0000000..2be4cc5 --- /dev/null +++ b/common/errors.go @@ -0,0 +1,192 @@ +package common + +import ( + "errors" + "fmt" +) + +// CommonError represents a structured error type for the common package +type CommonError struct { + Code ErrorCode + Message string + Cause error +} + +// ErrorCode represents different types of errors +type ErrorCode string + +const ( + // Directory operation errors + ErrDirCreation ErrorCode = "DIRECTORY_CREATION_FAILED" + ErrDirAccess ErrorCode = "DIRECTORY_ACCESS_FAILED" + + // File operation errors + ErrFileNotFound ErrorCode = "FILE_NOT_FOUND" + ErrFileRead ErrorCode = "FILE_READ_FAILED" + ErrFileWrite ErrorCode = "FILE_WRITE_FAILED" + ErrFileCreate ErrorCode = "FILE_CREATE_FAILED" + + // Network operation errors + ErrNetworkRequest ErrorCode = "NETWORK_REQUEST_FAILED" + ErrNetworkResponse ErrorCode = "NETWORK_RESPONSE_FAILED" + + // Template and configuration errors + ErrTemplateLoad ErrorCode = "TEMPLATE_LOAD_FAILED" + ErrTemplateParse ErrorCode = "TEMPLATE_PARSE_FAILED" + ErrConfigInvalid ErrorCode = "CONFIG_INVALID" + + // Subscription errors + ErrSubscriptionLoad ErrorCode = "SUBSCRIPTION_LOAD_FAILED" + ErrSubscriptionParse ErrorCode = "SUBSCRIPTION_PARSE_FAILED" + + // Regex errors + ErrRegexCompile ErrorCode = "REGEX_COMPILE_FAILED" + ErrRegexInvalid ErrorCode = "REGEX_INVALID" + + // Database errors + ErrDatabaseConnect ErrorCode = "DATABASE_CONNECTION_FAILED" + ErrDatabaseQuery ErrorCode = "DATABASE_QUERY_FAILED" + ErrRecordNotFound ErrorCode = "RECORD_NOT_FOUND" + + // Validation errors + ErrValidation ErrorCode = "VALIDATION_FAILED" + ErrInvalidInput ErrorCode = "INVALID_INPUT" +) + +// Error returns the string representation of the error +func (e *CommonError) Error() string { + if e.Cause != nil { + return fmt.Sprintf("[%s] %s: %v", e.Code, e.Message, e.Cause) + } + return fmt.Sprintf("[%s] %s", e.Code, e.Message) +} + +// Unwrap returns the underlying error +func (e *CommonError) Unwrap() error { + return e.Cause +} + +// Is allows error comparison +func (e *CommonError) Is(target error) bool { + if t, ok := target.(*CommonError); ok { + return e.Code == t.Code + } + return false +} + +// NewError creates a new CommonError +func NewError(code ErrorCode, message string, cause error) *CommonError { + return &CommonError{ + Code: code, + Message: message, + Cause: cause, + } +} + +// NewSimpleError creates a new CommonError without a cause +func NewSimpleError(code ErrorCode, message string) *CommonError { + return &CommonError{ + Code: code, + Message: message, + } +} + +// Convenience constructors for common error types + +// Directory errors +func NewDirCreationError(dirPath string, cause error) *CommonError { + return NewError(ErrDirCreation, fmt.Sprintf("failed to create directory: %s", dirPath), cause) +} + +func NewDirAccessError(dirPath string, cause error) *CommonError { + return NewError(ErrDirAccess, fmt.Sprintf("failed to access directory: %s", dirPath), cause) +} + +// File errors +func NewFileNotFoundError(filePath string) *CommonError { + return NewSimpleError(ErrFileNotFound, fmt.Sprintf("file not found: %s", filePath)) +} + +func NewFileReadError(filePath string, cause error) *CommonError { + return NewError(ErrFileRead, fmt.Sprintf("failed to read file: %s", filePath), cause) +} + +func NewFileWriteError(filePath string, cause error) *CommonError { + return NewError(ErrFileWrite, fmt.Sprintf("failed to write file: %s", filePath), cause) +} + +func NewFileCreateError(filePath string, cause error) *CommonError { + return NewError(ErrFileCreate, fmt.Sprintf("failed to create file: %s", filePath), cause) +} + +// Network errors +func NewNetworkRequestError(url string, cause error) *CommonError { + return NewError(ErrNetworkRequest, fmt.Sprintf("network request failed for URL: %s", url), cause) +} + +func NewNetworkResponseError(message string, cause error) *CommonError { + return NewError(ErrNetworkResponse, message, cause) +} + +// Template errors +func NewTemplateLoadError(template string, cause error) *CommonError { + return NewError(ErrTemplateLoad, fmt.Sprintf("failed to load template: %s", template), cause) +} + +func NewTemplateParseError(cause error) *CommonError { + return NewError(ErrTemplateParse, "failed to parse template", cause) +} + +// Subscription errors +func NewSubscriptionLoadError(url string, cause error) *CommonError { + return NewError(ErrSubscriptionLoad, fmt.Sprintf("failed to load subscription: %s", url), cause) +} + +func NewSubscriptionParseError(cause error) *CommonError { + return NewError(ErrSubscriptionParse, "failed to parse subscription", cause) +} + +// Regex errors +func NewRegexCompileError(pattern string, cause error) *CommonError { + return NewError(ErrRegexCompile, fmt.Sprintf("failed to compile regex pattern: %s", pattern), cause) +} + +func NewRegexInvalidError(paramName string, cause error) *CommonError { + return NewError(ErrRegexInvalid, fmt.Sprintf("invalid regex in parameter: %s", paramName), cause) +} + +// Database errors +func NewDatabaseConnectError(cause error) *CommonError { + return NewError(ErrDatabaseConnect, "failed to connect to database", cause) +} + +func NewRecordNotFoundError(recordType string, id string) *CommonError { + return NewSimpleError(ErrRecordNotFound, fmt.Sprintf("%s not found: %s", recordType, id)) +} + +// Validation errors +func NewValidationError(field string, message string) *CommonError { + return NewSimpleError(ErrValidation, fmt.Sprintf("validation failed for %s: %s", field, message)) +} + +func NewInvalidInputError(paramName string, value string) *CommonError { + return NewSimpleError(ErrInvalidInput, fmt.Sprintf("invalid input for parameter %s: %s", paramName, value)) +} + +// IsErrorCode checks if an error has a specific error code +func IsErrorCode(err error, code ErrorCode) bool { + var commonErr *CommonError + if errors.As(err, &commonErr) { + return commonErr.Code == code + } + return false +} + +// GetErrorCode extracts the error code from an error +func GetErrorCode(err error) (ErrorCode, bool) { + var commonErr *CommonError + if errors.As(err, &commonErr) { + return commonErr.Code, true + } + return "", false +} diff --git a/common/mkdir.go b/common/mkdir.go index 9ac0bcd..6c74a06 100644 --- a/common/mkdir.go +++ b/common/mkdir.go @@ -1,7 +1,6 @@ package common import ( - "errors" "os" ) @@ -18,13 +17,13 @@ func MKDir(dir string) error { func MkEssentialDir() error { if err := MKDir("subs"); err != nil { - return errors.New("create subs dir failed" + err.Error()) + return NewDirCreationError("subs", err) } if err := MKDir("logs"); err != nil { - return errors.New("create logs dir failed" + err.Error()) + return NewDirCreationError("logs", err) } if err := MKDir("data"); err != nil { - return errors.New("create data dir failed" + err.Error()) + return NewDirCreationError("data", err) } return nil } diff --git a/common/sub.go b/common/sub.go index fbf77eb..910b554 100644 --- a/common/sub.go +++ b/common/sub.go @@ -3,7 +3,6 @@ package common import ( "crypto/sha256" "encoding/hex" - "errors" "fmt" "io" "net/url" @@ -110,26 +109,26 @@ func BuildSub(clashType model.ClashType, query model.SubConfig, template string, logger.Logger.Debug( "load template failed", zap.String("template", template), zap.Error(err), ) - return nil, errors.New("加载模板失败: " + err.Error()) + return nil, NewTemplateLoadError(template, err) } } else { unescape, err := url.QueryUnescape(template) if err != nil { - return nil, errors.New("加载模板失败: " + err.Error()) + return nil, NewTemplateLoadError(template, err) } templateBytes, err = LoadTemplate(unescape) if err != nil { logger.Logger.Debug( "load template failed", zap.String("template", template), zap.Error(err), ) - return nil, errors.New("加载模板失败: " + err.Error()) + return nil, NewTemplateLoadError(unescape, err) } } err = yaml.Unmarshal(templateBytes, &temp) if err != nil { logger.Logger.Debug("parse template failed", zap.Error(err)) - return nil, errors.New("解析模板失败: " + err.Error()) + return nil, NewTemplateParseError(err) } var proxyList []P.Proxy @@ -143,7 +142,7 @@ func BuildSub(clashType model.ClashType, query model.SubConfig, template string, logger.Logger.Debug( "load subscription failed", zap.String("url", query.Subs[i]), zap.Error(err), ) - return nil, errors.New("加载订阅失败: " + err.Error()) + return nil, NewSubscriptionLoadError(query.Subs[i], err) } err = yaml.Unmarshal(data, &sub) @@ -161,7 +160,7 @@ func BuildSub(clashType model.ClashType, query model.SubConfig, template string, zap.String("data", string(data)), zap.Error(err), ) - return nil, errors.New("加载订阅失败: " + err.Error()) + return nil, NewSubscriptionParseError(err) } p := parser.ParseProxies(strings.Split(base64, "\n")...) newProxies = p @@ -193,7 +192,7 @@ func BuildSub(clashType model.ClashType, query model.SubConfig, template string, yamlBytes, err := yaml.Marshal(proxyList[i]) if err != nil { logger.Logger.Debug("marshal proxy failed", zap.Error(err)) - return nil, errors.New("marshal proxy failed: " + err.Error()) + return nil, fmt.Errorf("marshal proxy failed: %w", err) } key := string(yamlBytes) if _, exist := proxies[key]; !exist { @@ -209,7 +208,7 @@ func BuildSub(clashType model.ClashType, query model.SubConfig, template string, removeReg, err := regexp.Compile(query.Remove) if err != nil { logger.Logger.Debug("remove regexp compile failed", zap.Error(err)) - return nil, errors.New("remove 参数非法: " + err.Error()) + return nil, NewRegexInvalidError("remove", err) } if removeReg.MatchString(proxyList[i].Name) { @@ -227,7 +226,7 @@ func BuildSub(clashType model.ClashType, query model.SubConfig, template string, replaceReg, err := regexp.Compile(v) if err != nil { logger.Logger.Debug("replace regexp compile failed", zap.Error(err)) - return nil, errors.New("replace 参数非法: " + err.Error()) + return nil, NewRegexInvalidError("replace", err) } replaceRegs = append(replaceRegs, replaceReg) } @@ -312,15 +311,15 @@ func FetchSubscriptionUserInfo(url string, userAgent string, retryTimes int) (st resp, err := client.R().SetHeader("User-Agent", userAgent).Head(url) if err != nil { logger.Logger.Debug("创建 HEAD 请求失败", zap.Error(err)) - return "", err + return "", NewNetworkRequestError(url, err) } defer resp.Body.Close() if userInfo := resp.Header().Get("subscription-userinfo"); userInfo != "" { return userInfo, nil } - logger.Logger.Debug("目标 URL 未返回 subscription-userinfo 头", zap.Error(err)) - return "", err + logger.Logger.Debug("subscription-userinfo header not found in response") + return "", NewNetworkResponseError("subscription-userinfo header not found", nil) } func MergeSubAndTemplate(temp *model.Subscription, sub *model.Subscription, igcg bool) { diff --git a/common/template.go b/common/template.go index 925e7dd..a628364 100644 --- a/common/template.go +++ b/common/template.go @@ -1,7 +1,6 @@ package common import ( - "errors" "io" "os" ) @@ -23,5 +22,5 @@ func LoadTemplate(templatePath string) ([]byte, error) { } return result, nil } - return nil, errors.New("模板文件不存在") + return nil, NewFileNotFoundError(templatePath) } diff --git a/parser/anytls.go b/parser/anytls.go index 8abe820..d54b7a3 100644 --- a/parser/anytls.go +++ b/parser/anytls.go @@ -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, } } diff --git a/error/parse_error.go b/parser/errors.go similarity index 97% rename from error/parse_error.go rename to parser/errors.go index 2662d64..af95f0b 100644 --- a/error/parse_error.go +++ b/parser/errors.go @@ -1,4 +1,4 @@ -package error +package parser type ParseError struct { Type ParseErrorType diff --git a/parser/hysteria.go b/parser/hysteria.go index 8f70c3d..8ac1122 100644 --- a/parser/hysteria.go +++ b/parser/hysteria.go @@ -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, } diff --git a/parser/hysteria2.go b/parser/hysteria2.go index 3d3b454..47460a1 100644 --- a/parser/hysteria2.go +++ b/parser/hysteria2.go @@ -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, } } diff --git a/parser/registry.go b/parser/registry.go index 881c4e1..ea21e2d 100644 --- a/parser/registry.go +++ b/parser/registry.go @@ -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"} } diff --git a/parser/shadowsocks.go b/parser/shadowsocks.go index c9ee025..dd45acd 100644 --- a/parser/shadowsocks.go +++ b/parser/shadowsocks.go @@ -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, } diff --git a/parser/shadowsocksr.go b/parser/shadowsocksr.go index f156966..d6848f6 100644 --- a/parser/shadowsocksr.go +++ b/parser/shadowsocksr.go @@ -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(), } diff --git a/parser/socks.go b/parser/socks.go index c0c07db..c829d4f 100644 --- a/parser/socks.go +++ b/parser/socks.go @@ -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, } diff --git a/parser/trojan.go b/parser/trojan.go index ff011a0..f3c65cc 100644 --- a/parser/trojan.go +++ b/parser/trojan.go @@ -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, } diff --git a/parser/vless.go b/parser/vless.go index 8b4aace..e36d9d9 100644 --- a/parser/vless.go +++ b/parser/vless.go @@ -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(), } diff --git a/parser/vmess.go b/parser/vmess.go index 842beb4..d030a1f 100644 --- a/parser/vmess.go +++ b/parser/vmess.go @@ -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))