144 lines
3.5 KiB
Go
144 lines
3.5 KiB
Go
package api
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"maps"
|
|
"net/http"
|
|
"net/url"
|
|
"regexp"
|
|
"slices"
|
|
"strings"
|
|
)
|
|
|
|
type Provider string
|
|
|
|
const (
|
|
Cloudflare Provider = "cloudflare"
|
|
IfConfigCo Provider = "ifconfigco"
|
|
IPInfo Provider = "ipinfo"
|
|
IP2Location Provider = "ip2location"
|
|
)
|
|
|
|
const echoipPrefix = "echoip#"
|
|
|
|
type NameToken struct {
|
|
Name string
|
|
Token string
|
|
}
|
|
|
|
func New(nameTokenPairs []NameToken, client *http.Client) (
|
|
fetchers []Fetcher, err error,
|
|
) {
|
|
fetchers = make([]Fetcher, len(nameTokenPairs))
|
|
for i, nameTokenPair := range nameTokenPairs {
|
|
provider, err := ParseProvider(nameTokenPair.Name)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("parsing API name: %w", err)
|
|
}
|
|
switch {
|
|
case provider == Cloudflare:
|
|
fetchers[i] = newCloudflare(client)
|
|
case provider == IfConfigCo:
|
|
const ifConfigCoURL = "https://ifconfig.co"
|
|
fetchers[i] = newEchoip(client, ifConfigCoURL)
|
|
case provider == IPInfo:
|
|
fetchers[i] = newIPInfo(client, nameTokenPair.Token)
|
|
case provider == IP2Location:
|
|
fetchers[i] = newIP2Location(client, nameTokenPair.Token)
|
|
case strings.HasPrefix(string(provider), echoipPrefix):
|
|
url := strings.TrimPrefix(string(provider), echoipPrefix)
|
|
fetchers[i] = newEchoip(client, url)
|
|
default:
|
|
panic("provider not valid: " + provider)
|
|
}
|
|
}
|
|
return fetchers, nil
|
|
}
|
|
|
|
var regexEchoipURL = regexp.MustCompile(`^http(s|):\/\/.+$`)
|
|
|
|
var ErrProviderNotValid = errors.New("API name is not valid")
|
|
|
|
func ParseProvider(s string) (provider Provider, err error) {
|
|
possibleProviders := []Provider{
|
|
Cloudflare,
|
|
IfConfigCo,
|
|
IP2Location,
|
|
IPInfo,
|
|
}
|
|
stringToProvider := make(map[string]Provider, len(possibleProviders))
|
|
for _, provider := range possibleProviders {
|
|
stringToProvider[string(provider)] = provider
|
|
}
|
|
provider, ok := stringToProvider[strings.ToLower(s)]
|
|
if ok {
|
|
return provider, nil
|
|
}
|
|
|
|
customPrefixToURLRegex := map[string]*regexp.Regexp{
|
|
echoipPrefix: regexEchoipURL,
|
|
}
|
|
for prefix, urlRegex := range customPrefixToURLRegex {
|
|
match, err := checkCustomURL(s, prefix, urlRegex)
|
|
if !match {
|
|
continue
|
|
} else if err != nil {
|
|
return "", err
|
|
}
|
|
return Provider(s), nil
|
|
}
|
|
|
|
providerStrings := make([]string, 0, len(stringToProvider)+len(customPrefixToURLRegex))
|
|
for _, providerString := range slices.Sorted(maps.Keys(stringToProvider)) {
|
|
providerStrings = append(providerStrings, `"`+providerString+`"`)
|
|
}
|
|
for _, prefix := range slices.Sorted(maps.Keys(customPrefixToURLRegex)) {
|
|
providerStrings = append(providerStrings, "a custom "+prefix+" url")
|
|
}
|
|
|
|
return "", fmt.Errorf(`%w: %q can only be %s`,
|
|
ErrProviderNotValid, s, orStrings(providerStrings))
|
|
}
|
|
|
|
var ErrCustomURLNotValid = errors.New("custom URL is not valid")
|
|
|
|
func checkCustomURL(s, prefix string, regex *regexp.Regexp) (match bool, err error) {
|
|
if !strings.HasPrefix(s, prefix) {
|
|
return false, nil
|
|
}
|
|
s = strings.TrimPrefix(s, prefix)
|
|
_, err = url.Parse(s)
|
|
if err != nil {
|
|
return true, fmt.Errorf("%s %w: %w", prefix, ErrCustomURLNotValid, err)
|
|
}
|
|
|
|
if regex.MatchString(s) {
|
|
return true, nil
|
|
}
|
|
|
|
return true, fmt.Errorf("%s %w: %q does not match regular expression: %s",
|
|
prefix, ErrCustomURLNotValid, s, regex)
|
|
}
|
|
|
|
func orStrings(strings []string) (result string) {
|
|
return joinStrings(strings, "or")
|
|
}
|
|
|
|
func joinStrings(strings []string, lastJoin string) (result string) {
|
|
if len(strings) == 0 {
|
|
return ""
|
|
}
|
|
|
|
result = strings[0]
|
|
for i := 1; i < len(strings); i++ {
|
|
if i < len(strings)-1 {
|
|
result += ", " + strings[i]
|
|
} else {
|
|
result += " " + lastJoin + " " + strings[i]
|
|
}
|
|
}
|
|
|
|
return result
|
|
}
|