platform: modularize api/gui, add docs-tests-web foundation, and refresh root config

selective-vpn-api/app/resolver_bridge_dns.go

@@ -0,0 +1,171 @@
+package app
+
+import (
+	"strings"
+	"time"
+
+	resolverpkg "selective-vpn-api/app/resolver"
+)
+
+func loadDNSConfig(path string, logf func(string, ...any)) dnsConfig {
+	cfg := resolverpkg.LoadDNSConfig(
+		path,
+		resolverpkg.DNSConfig{
+			Default:  []string{defaultDNS1, defaultDNS2},
+			Meta:     []string{defaultMeta1, defaultMeta2},
+			SmartDNS: smartDNSAddr(),
+			Mode:     string(DNSModeDirect),
+		},
+		resolverpkg.DNSConfigDeps{
+			ActivePool:         loadEnabledDNSUpstreamPool(),
+			IsSmartDNSForced:   smartDNSForced(),
+			SmartDNSAddr:       smartDNSAddr(),
+			SmartDNSForcedMode: string(DNSModeSmartDNS),
+			ResolveFallbackPool: func() []string {
+				return resolverFallbackPool()
+			},
+			MergeDNSUpstreamPools: func(primary, fallback []string) []string {
+				return mergeDNSUpstreamPools(primary, fallback)
+			},
+			NormalizeDNSUpstream: func(raw string, defaultPort string) string {
+				return normalizeDNSUpstream(raw, defaultPort)
+			},
+			NormalizeSmartDNSAddr: normalizeSmartDNSAddr,
+			NormalizeDNSResolverMode: func(raw string) string {
+				return string(normalizeDNSResolverMode(DNSResolverMode(raw), false))
+			},
+		},
+		logf,
+	)
+	return dnsConfig{
+		Default:  cfg.Default,
+		Meta:     cfg.Meta,
+		SmartDNS: cfg.SmartDNS,
+		Mode:     DNSResolverMode(cfg.Mode),
+	}
+}
+
+type resolverCooldownAdapter struct {
+	inner *dnsRunCooldown
+}
+
+func (a resolverCooldownAdapter) ShouldSkip(upstream string, now int64) bool {
+	if a.inner == nil {
+		return false
+	}
+	return a.inner.shouldSkip(upstream, now)
+}
+
+func (a resolverCooldownAdapter) ObserveSuccess(upstream string) {
+	if a.inner == nil {
+		return
+	}
+	a.inner.observeSuccess(upstream)
+}
+
+func (a resolverCooldownAdapter) ObserveError(upstream string, kind resolverpkg.DNSErrorKind, now int64) (bool, int) {
+	if a.inner == nil {
+		return false, 0
+	}
+	return a.inner.observeError(upstream, dnsErrorKind(kind), now)
+}
+
+func toResolverPolicy(policy dnsAttemptPolicy) resolverpkg.DNSAttemptPolicy {
+	return resolverpkg.DNSAttemptPolicy{
+		TryLimit:     policy.TryLimit,
+		DomainBudget: policy.DomainBudget,
+		StopOnNX:     policy.StopOnNX,
+	}
+}
+
+func resolveHostGo(host string, cfg dnsConfig, metaSpecial []string, wildcards wildcardMatcher, timeout time.Duration, cooldown *dnsRunCooldown, logf func(string, ...any)) ([]string, dnsMetrics) {
+	return resolverpkg.ResolveHost(
+		host,
+		resolverpkg.DNSConfig{
+			Default:  cfg.Default,
+			Meta:     cfg.Meta,
+			SmartDNS: cfg.SmartDNS,
+			Mode:     string(cfg.Mode),
+		},
+		metaSpecial,
+		func(h string) bool { return wildcards.Match(h) },
+		timeout,
+		resolverCooldownAdapter{inner: cooldown},
+		func(dnsCount int) resolverpkg.DNSAttemptPolicy {
+			return toResolverPolicy(directDNSAttemptPolicy(dnsCount))
+		},
+		func(dnsCount int) resolverpkg.DNSAttemptPolicy {
+			return toResolverPolicy(wildcardDNSAttemptPolicy(dnsCount))
+		},
+		smartDNSFallbackForTimeoutEnabled(),
+		logf,
+	)
+}
+
+func digA(host string, dnsList []string, timeout time.Duration, logf func(string, ...any)) ([]string, dnsMetrics) {
+	policy := toResolverPolicy(defaultDNSAttemptPolicy(len(dnsList)))
+	return resolverpkg.DigAWithPolicy(host, dnsList, timeout, policy, nil, logf)
+}
+
+func digAWithPolicy(host string, dnsList []string, timeout time.Duration, logf func(string, ...any), policy dnsAttemptPolicy, cooldown *dnsRunCooldown) ([]string, dnsMetrics) {
+	return resolverpkg.DigAWithPolicy(host, dnsList, timeout, toResolverPolicy(policy), resolverCooldownAdapter{inner: cooldown}, logf)
+}
+
+func applyResolverDNSModeRuntime(cfg dnsConfig, opts ResolverOpts) dnsConfig {
+	out := resolverpkg.ApplyDNSModeRuntime(resolverpkg.DNSModeRuntimeInput{
+		Config: resolverpkg.DNSConfig{
+			Default:  cfg.Default,
+			Meta:     cfg.Meta,
+			SmartDNS: cfg.SmartDNS,
+			Mode:     string(cfg.Mode),
+		},
+		Mode:            string(opts.Mode),
+		ViaSmartDNS:     opts.ViaSmartDNS,
+		SmartDNSAddr:    opts.SmartDNSAddr,
+		SmartDNSForced:  smartDNSForced(),
+		SmartDNSDefault: smartDNSAddr(),
+		NormalizeMode: func(mode string, viaSmartDNS bool) string {
+			return string(normalizeDNSResolverMode(DNSResolverMode(mode), viaSmartDNS))
+		},
+		NormalizeSmartDNSAddr: normalizeSmartDNSAddr,
+	})
+	return dnsConfig{
+		Default:  out.Default,
+		Meta:     out.Meta,
+		SmartDNS: out.SmartDNS,
+		Mode:     DNSResolverMode(out.Mode),
+	}
+}
+
+func logResolverDNSMode(cfg dnsConfig, wildcards wildcardMatcher, logf func(string, ...any)) {
+	resolverpkg.LogDNSMode(
+		resolverpkg.DNSConfig{
+			Default:  cfg.Default,
+			Meta:     cfg.Meta,
+			SmartDNS: cfg.SmartDNS,
+			Mode:     string(cfg.Mode),
+		},
+		wildcards.Count(),
+		logf,
+	)
+}
+
+func parseStaticEntriesGo(lines []string, logf func(string, ...any)) (entries [][3]string, skipped int) {
+	return resolverpkg.ParseStaticEntries(lines, logf)
+}
+
+func resolveStaticLabels(entries [][3]string, cfg dnsConfig, ptrCache map[string]any, ttl int, logf func(string, ...any)) (map[string][]string, int, int) {
+	dnsForPtr := defaultDNS1
+	if len(cfg.Default) > 0 && strings.TrimSpace(cfg.Default[0]) != "" {
+		dnsForPtr = cfg.Default[0]
+	}
+	return resolverpkg.ResolveStaticLabels(entries, dnsForPtr, ptrCache, ttl, logf)
+}
+
+func digPTR(ip, upstream string, timeout time.Duration, logf func(string, ...any)) ([]string, error) {
+	return resolverpkg.DigPTR(ip, upstream, timeout, logf)
+}
+
+func logResolverSummary(input resolverpkg.ResolverSummaryLogInput, logf func(string, ...any)) {
+	resolverpkg.LogResolverSummary(input, logf)
+}