perf: check internet with DNS lookup (#1034)

DNS lookups are much cheaper than HTTP requests since we only need to check if the Internet is available.

See: https://stackoverflow.com/a/50058255

dns/index.go

@@ -4,7 +4,7 @@ import (
 	"time"
 
 	"github.com/jeessy2/ddns-go/v6/config"
-	"github.com/jeessy2/ddns-go/v6/dns/internal"
+	"github.com/jeessy2/ddns-go/v6/dns/internet"
 	"github.com/jeessy2/ddns-go/v6/util"
 )
 
@@ -34,7 +34,7 @@ var (
 
 // RunTimer 定时运行
 func RunTimer(delay time.Duration) {
-	internal.WaitForNetworkConnected(addresses)
+	internet.Wait(addresses)
 
 	for {
 		RunOnce()

dns/internet/wait.go

@@ -0,0 +1,56 @@
+// Package internet implements utilities for checking the Internet connection.
+package internet
+
+import (
+	"strings"
+	"time"
+
+	"github.com/jeessy2/ddns-go/v6/util"
+)
+
+const (
+	// fallbackDNS used when a fallback occurs.
+	fallbackDNS = "1.1.1.1"
+
+	// delay is the delay time for each DNS lookup.
+	delay = time.Second * 5
+)
+
+// Wait blocks until the Internet is connected.
+//
+// See also:
+//
+//   - https://stackoverflow.com/a/50058255
+//   - https://github.com/ddev/ddev/blob/v1.22.7/pkg/globalconfig/global_config.go#L776
+func Wait(addresses []string) {
+	// fallbase in case loopback DNS is unavailable and only once.
+	fallback := false
+
+	for {
+		for _, addr := range addresses {
+			err := util.LookupHost(addr)
+			// Internet is connected.
+			if err == nil {
+				return
+			}
+
+			if !fallback && isLoopback(err) {
+				util.Log("本机DNS异常! 将默认使用 %s, 可参考文档通过 -dns 自定义 DNS 服务器", fallbackDNS)
+				util.SetDNS(fallbackDNS)
+
+				fallback = true
+				continue
+			}
+
+			util.Log("等待网络连接: %s", err)
+
+			util.Log("%s 后重试...", delay)
+			time.Sleep(delay)
+		}
+	}
+}
+
+// isLoopback checks if the error is a loopback error.
+func isLoopback(e error) bool {
+	return strings.Contains(e.Error(), "[::1]:53")
+}

main.go

@@ -12,7 +12,6 @@ import (
 	"os/exec"
 	"path/filepath"
 	"strconv"
-	"strings"
 	"time"
 
 	"github.com/jeessy2/ddns-go/v6/config"
@@ -85,11 +84,7 @@ func main() {
 		util.SetInsecureSkipVerify()
 	}
 	if *customDNSServer != "" {
-		if !strings.Contains(*customDNSServer, ":") {
-			util.NewDialerResolver(*customDNSServer + ":53")
-		} else {
-			util.NewDialerResolver(*customDNSServer)
-		}
+		util.SetDNS(*customDNSServer)
 	}
 	os.Setenv(util.IPCacheTimesENV, strconv.Itoa(*ipCacheTimes))
 	switch *serviceType {

util/net_resolver.go

@@ -5,25 +5,26 @@ import (
 	"net"
 )
 
-// NewDialerResolver 使用 s 将 dialer.Resolver 设置为新的 net.Resolver。
-//
-// s：用于创建新 net.Resolver 的字符串。
-func NewDialerResolver(s string) {
-	dialer.Resolver = newNetResolver(s)
-}
-
-// newNetResolver 当 s 不为空时返回使用 s 的 Go 内置 DNS 解析器。
-//
-// s：net.Resolver 的 DNS 服务器地址。
-func newNetResolver(s string) *net.Resolver {
-	if s == "" {
-		return net.DefaultResolver
+// SetDNS sets the dialer.Resolver to use the given DNS server.
+func SetDNS(dns string) {
+	// Error means that the given DNS doesn't have a port. Add it.
+	if _, _, err := net.SplitHostPort(dns); err != nil {
+		dns = net.JoinHostPort(dns, "53")
 	}
 
-	return &net.Resolver{
+	dialer.Resolver = &net.Resolver{
 		PreferGo: true,
 		Dial: func(ctx context.Context, network, address string) (net.Conn, error) {
-			return net.Dial("udp", s)
+			return net.Dial(network, dns)
 		},
 	}
 }
+
+// LookupHost looks up the host based on the given URL using the dialer.Resolver.
+// A wrapper for [net.Resolver.LookupHost].
+func LookupHost(url string) error {
+	name := toHostname(url)
+
+	_, err := dialer.Resolver.LookupHost(context.Background(), name)
+	return err
+}

util/net_resolver_test.go

@@ -1,28 +1,38 @@
 package util
 
-import (
-	"context"
-	"testing"
+import "testing"
+
+const (
+	testDNS = "1.1.1.1"
+	testURL = "https://cloudflare.com"
 )
 
-// TestNewDialerResolver 测试传递 DNS 服务器地址时能否设置 dialer.Resolver。
-func TestNewDialerResolver(t *testing.T) {
-	// 测试前重置以确保正常设置
-	dialer.Resolver = nil
+func TestSetDNS(t *testing.T) {
+	SetDNS(testDNS)
 
-	NewDialerResolver("1.1.1.1:53")
 	if dialer.Resolver == nil {
 		t.Error("Failed to set dialer.Resolver")
 	}
-
-	// 测试后重置以确保与测试前的值一致
-	dialer.Resolver = nil
 }
 
-// TestNewNetResolver 测试能否通过 newNetResolver 返回的 net.Resolver 解析域名的 IP。
-func TestNewNetResolver(t *testing.T) {
-	_, err := newNetResolver("1.1.1.1:53").LookupIP(context.Background(), "ip", "cloudflare.com")
-	if err != nil {
-		t.Errorf("Failed to lookup IP, err: %v", err)
-	}
+func TestLookupHost(t *testing.T) {
+	t.Run("Valid URL", func(t *testing.T) {
+		if err := LookupHost(testURL); err != nil {
+			t.Errorf("Expected nil error, got %v", err)
+		}
+	})
+
+	t.Run("Invalid URL", func(t *testing.T) {
+		if err := LookupHost("invalidurl"); err == nil {
+			t.Error("Expected error, got nil")
+		}
+	})
+
+	t.Run("After SetDNS", func(t *testing.T) {
+		SetDNS(testDNS)
+
+		if err := LookupHost(testURL); err != nil {
+			t.Errorf("Expected nil error, got %v", err)
+		}
+	})
 }

util/string.go

@@ -2,8 +2,7 @@ package util
 
 import "strings"
 
-// WriteString 使用 strings.Builder 生成字符串并返回 string
-// https://pkg.go.dev/strings#Builder
+// WriteString creates a new string using [strings.Builder].
 func WriteString(strs ...string) string {
 	var b strings.Builder
 	for _, str := range strs {
@@ -12,3 +11,15 @@ func WriteString(strs ...string) string {
 
 	return b.String()
 }
+
+// toHostname normalizes a URL with a https scheme to just its hostname.
+//
+// See also:
+//
+//   - https://github.com/moby/moby/blob/v25.0.3/registry/auth.go#L132
+func toHostname(url string) string {
+	stripped := url
+	stripped = strings.TrimPrefix(stripped, "https://")
+
+	return strings.Split(stripped, "/")[0]
+}

util/string_test.go

@@ -0,0 +1,43 @@
+package util
+
+import "testing"
+
+func TestWriteString(t *testing.T) {
+	tests := []struct {
+		input    []string
+		expected string
+	}{
+		{[]string{"hello", "world"}, "helloworld"},
+		{[]string{"", "test"}, "test"},
+		{[]string{"hello", " ", "world"}, "hello world"},
+		{[]string{""}, ""},
+	}
+
+	for _, tt := range tests {
+		result := WriteString(tt.input...)
+		if result != tt.expected {
+			t.Errorf("Expected %s, but got %s", tt.expected, result)
+		}
+	}
+}
+
+func TestToHostname(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected string
+	}{
+		{"With https scheme", "https://www.example.com", "www.example.com"},
+		{"With path", "www.example.com/path", "www.example.com"},
+		{"With https scheme and path", "https://www.example.com/path", "www.example.com"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := toHostname(tt.input)
+			if result != tt.expected {
+				t.Errorf("Expected %s, but got %s", tt.expected, result)
+			}
+		})
+	}
+}