types: compute derived config values where they are used

Updates #1926
This commit is contained in:
Kristoffer Dalby authored and GitHub committed 2026-11-11 11:19:27 +00:00
1 parent c27285f224
commit 565aaf7e49
33 files changed
+1251 -387

No files matched your search

+2 -2
View File
@@ -64,8 +64,8 @@ func assertExampleConfig(t *testing.T) {
assert.Equal(t, "http://127.0.0.1:8080", cfg.ServerURL)
assert.Equal(t, "127.0.0.1:8080", cfg.Addr)
assert.Equal(t, "127.0.0.1:9090", cfg.MetricsAddr)
assert.Equal(t, types.DatabaseSqlite, cfg.Database.Type)
assert.Equal(t, "/var/lib/headscale/db.sqlite", cfg.Database.Sqlite.Path)
assert.True(t, cfg.Database.IsSQLite(), cfg.Database.Type)
assert.Equal(t, "/var/lib/headscale/db.sqlite", cfg.SQLitePath())
assert.Empty(t, cfg.TLS.ACME.Hostname)
assert.Equal(t, ":http", cfg.TLS.ACME.HTTPListen)
assert.Equal(t, "HTTP-01", cfg.TLS.ACME.ChallengeType)
+1 -2
View File
@@ -10,7 +10,6 @@ import (
"github.com/danielgtaylor/huma/v2"
"github.com/juanfont/headscale/hscontrol/types"
"github.com/juanfont/headscale/hscontrol/util"
)
func init() {
@@ -73,7 +72,7 @@ func registerPolicy(api huma.API, b Backend) {
return out, nil
case types.PolicyModeFile:
absPath := util.AbsolutePath(b.Cfg.ConfigDir, b.Cfg.Policy.Path)
absPath := b.Cfg.AbsPath(b.Cfg.Policy.Path)
f, err := os.Open(absPath)
if err != nil {
+1 -2
View File
@@ -16,7 +16,6 @@ import (
"github.com/juanfont/headscale/hscontrol/scope"
"github.com/juanfont/headscale/hscontrol/state"
"github.com/juanfont/headscale/hscontrol/types"
"github.com/juanfont/headscale/hscontrol/util"
"github.com/tailscale/hujson"
)
@@ -221,7 +220,7 @@ func currentPolicy(b Backend) ([]byte, error) {
return []byte(p.Data), nil
case types.PolicyModeFile:
path := util.AbsolutePath(b.Cfg.ConfigDir, b.Cfg.Policy.Path)
path := b.Cfg.AbsPath(b.Cfg.Policy.Path)
if path == "" {
return []byte(defaultPolicy), nil
}
+43 -66
View File
@@ -1,6 +1,7 @@
package hscontrol
import (
"cmp"
"context"
"crypto/ecdsa"
"crypto/elliptic"
@@ -13,7 +14,6 @@ import (
"math/big"
"net"
"net/http"
"net/netip"
"os"
"os/signal"
"path/filepath"
@@ -52,11 +52,8 @@ import (
"github.com/sasha-s/go-deadlock"
"golang.org/x/sync/errgroup"
"tailscale.com/envknob"
"tailscale.com/net/tsaddr"
"tailscale.com/tailcfg"
"tailscale.com/types/dnstype"
"tailscale.com/types/key"
"tailscale.com/util/dnsname"
)
var (
@@ -131,11 +128,33 @@ func NewHeadscale(cfg *types.Config) (*Headscale, error) {
runtime.SetBlockProfileRate(1)
}
noisePrivateKey, err := readOrCreatePrivateKey(cfg.NoisePrivateKeyPath)
noisePrivateKey, err := readOrCreatePrivateKey(cfg.AbsPath(cfg.NoisePrivateKeyPath))
if err != nil {
return nil, fmt.Errorf("reading or creating Noise protocol private key: %w", err)
}
provider := cfg.DNSChallenge.Provider
if provider == nil && cfg.DNSChallenge.ProviderName() != "" {
provider, err = cfg.DNSChallenge.NewProvider(types.ResolveSecret)
if err != nil {
return nil, fmt.Errorf("building dns.challenge.provider: %w", err)
}
}
// Only node certificates let a client pick what is published; a record
// shared by headscale's own certificate alone is harmless.
if iso, ok := provider.(dns.Isolator); ok && cfg.DNSConfig.Certificates.Enabled {
err = iso.CheckIsolation()
if err != nil {
// A Go-only provider may have no name.
name := cmp.Or(cfg.DNSChallenge.ProviderName(), fmt.Sprintf("%T", provider))
return nil, fmt.Errorf("%w for %s: %w", dns.ErrProviderConfig, name, err)
}
}
cfg.StartDNS(provider)
s, err := state.NewState(cfg)
if err != nil {
return nil, fmt.Errorf("init state: %w", err)
@@ -150,9 +169,9 @@ func NewHeadscale(cfg *types.Config) (*Headscale, error) {
if cfg.DNSConfig.Certificates.Enabled {
app.challenges = dns.NewChallenges(
cfg.DNSChallenge.Provider,
cfg.DNSConfig.Certificates.Zone,
cfg.DNSChallenge.Resolvers,
provider,
cfg.DNSConfig.CertificateZone(),
cfg.DNSChallenge.ResolverAddrs(),
cfg.DNSChallenge.PropagationTimeout,
)
}
@@ -235,53 +254,8 @@ func NewHeadscale(cfg *types.Config) (*Headscale, error) {
app.authProvider = authProvider
if app.cfg.TailcfgDNSConfig != nil && app.cfg.TailcfgDNSConfig.Proxied { // if MagicDNS
// Clients route reverse lookups for the Tailscale ranges themselves
// (magicDNSRootDomains in tailscale.com/ipn/ipnlocal) and SaaS sends
// no reverse routes, so only a prefix outside those ranges needs them.
outside := func(p, r netip.Prefix) bool {
return p.Bits() < r.Bits() || !r.Contains(p.Addr())
}
// TODO(kradalby): revisit why this takes a list.
var magicDNSDomains []dnsname.FQDN
if cfg.PrefixV4 != nil && outside(*cfg.PrefixV4, tsaddr.CGNATRange()) {
magicDNSDomains = append(
magicDNSDomains,
util.GenerateIPv4DNSRootDomain(*cfg.PrefixV4)...,
)
}
if cfg.PrefixV6 != nil && outside(*cfg.PrefixV6, tsaddr.TailscaleULARange()) {
magicDNSDomains = append(
magicDNSDomains,
util.GenerateIPv6DNSRootDomain(*cfg.PrefixV6)...,
)
}
// we might have routes already from Split DNS
if app.cfg.TailcfgDNSConfig.Routes == nil {
app.cfg.TailcfgDNSConfig.Routes = make(map[string][]*dnstype.Resolver)
}
for _, d := range magicDNSDomains {
// Empty non-nil slice rather than nil: tailcfg.DNSConfig.Clone
// and dns.Config.Clone in tailscale drop map entries whose
// value is nil (see tailscale.com/tailcfg/tailcfg_clone.go and
// tailscale.com/net/dns/dns_clone.go: `if sv == nil { continue }`).
// Sending nil here caused the client's wgengine LinkChange:major
// handler to clobber /etc/resolv.conf on every tunnel-IP rebind
// — the handler reapplies a Clone of lastDNSConfig and the magic
// DNS routes vanish, taking the resolver with them for ~6 min
// until the next route-changing netmap. Empty slice survives
// Clone and carries the same "resolve locally" semantics
// ([tailcfg.DNSConfig.Routes] documents the empty-resolver form).
app.cfg.TailcfgDNSConfig.Routes[d.WithoutTrailingDot()] = []*dnstype.Resolver{}
}
}
if cfg.DERP.ServerEnabled {
derpServerKey, err := readOrCreatePrivateKey(cfg.DERP.ServerPrivateKeyPath)
derpServerKey, err := readOrCreatePrivateKey(cfg.AbsPath(cfg.DERP.ServerPrivateKeyPath))
if err != nil {
return nil, fmt.Errorf("reading or creating DERP server private key: %w", err)
}
@@ -421,7 +395,7 @@ func (h *Headscale) scheduledTasks(ctx context.Context) {
log.Info().Msg("fetching DERPMap updates")
derpMap, err := backoff.Retry(ctx, func() (*tailcfg.DERPMap, error) { //nolint:contextcheck
derpMap, err := derp.GetDERPMap(h.cfg.DERP)
derpMap, err := derp.GetDERPMap(h.cfg.DERP, h.cfg.BaseDomain)
if err != nil {
return nil, err
}
@@ -615,7 +589,7 @@ func (h *Headscale) Serve() error {
// Start on the sources that loaded; only a map with no region at all,
// after the embedded region and the policy's derpMap, is fatal.
derpMap, derpErr := derp.GetDERPMap(h.cfg.DERP)
derpMap, derpErr := derp.GetDERPMap(h.cfg.DERP, h.cfg.BaseDomain)
if derpErr != nil {
log.Warn().Err(derpErr).Msg("skipping DERP map sources that failed to load")
}
@@ -875,7 +849,7 @@ func (h *Headscale) Serve() error {
var tailsqlCancel context.CancelFunc
if tailsqlEnabled {
if h.cfg.Database.Type != types.DatabaseSqlite {
if !h.cfg.Database.IsSQLite() {
//nolint:gocritic // exitAfterDefer: Fatal exits during initialization before servers start
log.Fatal().
Str("type", h.cfg.Database.Type).
@@ -892,7 +866,7 @@ func (h *Headscale) Serve() error {
tailsqlCtx, tailsqlCancel = context.WithCancel(ctx)
errorGroup.Go(func() error {
return runTailSQLService(tailsqlCtx, util.TSLogfWrapper(), tailsqlStateDir, h.cfg.Database.Sqlite.Path)
return runTailSQLService(tailsqlCtx, util.TSLogfWrapper(), tailsqlStateDir, h.cfg.SQLitePath())
})
}
@@ -1106,14 +1080,15 @@ func (h *Headscale) acmeTLSSettings(ctx context.Context) (*tlsBundle, error) {
switch acmeCfg.ChallengeType {
case types.DNS01ChallengeType:
resolvers := h.cfg.DNSChallenge.ResolverAddrs()
issuer.DNS01Solver = dns01Solver{
DNS01Solver: &certmagic.DNS01Solver{
DNSProvider: h.cfg.DNSChallenge.Provider,
DNSProvider: h.cfg.DNSProvider(),
TTL: dns.ChallengeTTL,
Resolvers: h.cfg.DNSChallenge.Resolvers,
Resolvers: resolvers,
Logger: logger,
},
wait: dns.AwaitTXT(h.cfg.DNSChallenge.Resolvers, h.cfg.DNSChallenge.PropagationTimeout),
wait: dns.AwaitTXT(resolvers, h.cfg.DNSChallenge.PropagationTimeout),
}
case types.TLSALPN01ChallengeType:
@@ -1152,7 +1127,7 @@ func (h *Headscale) acmeTLSSettings(ctx context.Context) (*tlsBundle, error) {
Logger: logger,
})
magic = certmagic.New(cache, certmagic.Config{
Storage: &certmagic.FileStorage{Path: acmeCfg.CacheDir},
Storage: &certmagic.FileStorage{Path: h.cfg.AbsPath(acmeCfg.CacheDir)},
Logger: logger,
})
@@ -1225,11 +1200,13 @@ func (h *Headscale) getTLSSettings(ctx context.Context) (*tlsBundle, error) {
return &tlsBundle{}, nil
}
certPath, keyPath := h.cfg.AbsPath(h.cfg.TLS.CertPath), h.cfg.AbsPath(h.cfg.TLS.KeyPath)
load := func() (*tls.Certificate, error) {
cert, err := tls.LoadX509KeyPair(h.cfg.TLS.CertPath, h.cfg.TLS.KeyPath)
cert, err := tls.LoadX509KeyPair(certPath, keyPath)
if err != nil {
return nil, fmt.Errorf("loading TLS keypair (tls.cert_path=%q, tls.key_path=%q): %w",
h.cfg.TLS.CertPath, h.cfg.TLS.KeyPath, err)
certPath, keyPath, err)
}
return &cert, nil
@@ -1263,14 +1240,14 @@ func (h *Headscale) getTLSSettings(ctx context.Context) (*tlsBundle, error) {
now, leaf := time.Now(), cert.Leaf
if now.Before(leaf.NotBefore) || now.After(leaf.NotAfter) {
return fmt.Errorf("%w (tls.cert_path=%q): valid from %s until %s",
errTLSCertificateNotValidNow, h.cfg.TLS.CertPath,
errTLSCertificateNotValidNow, certPath,
leaf.NotBefore.Format(time.RFC3339), leaf.NotAfter.Format(time.RFC3339))
}
current.Store(cert)
log.Info().
Str("cert_path", h.cfg.TLS.CertPath).
Str("cert_path", certPath).
Str("not_after", leaf.NotAfter.Format(time.RFC3339)).
Msg("TLS certificate reloaded")
+98
View File
@@ -4,9 +4,15 @@ import (
"context"
"net/http"
"net/http/httptest"
"os"
"path/filepath"
"testing"
"github.com/juanfont/headscale/hscontrol/dns"
"github.com/juanfont/headscale/hscontrol/types"
"github.com/libdns/cloudflare"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestSecurityHeaders(t *testing.T) {
@@ -79,3 +85,95 @@ func TestDebugHostGuard(t *testing.T) {
})
}
}
// TestNewHeadscaleDNSProvider pins that startup builds the provider
// dns.challenge.provider names, reading its secrets, unless Go set one, and
// refuses one that cannot keep node certificates apart.
func TestNewHeadscaleDNSProvider(t *testing.T) {
token := filepath.Join(t.TempDir(), "token")
require.NoError(t, os.WriteFile(token, []byte("from-file\n"), 0o600))
oneAccount := map[string]any{
"name": "acmedns", "username": "u", "password": "p",
"subdomain": "s", "server_url": "https://auth.acme-dns.io",
}
goOnly := &cloudflare.Provider{APIToken: "go-only"}
goOnlyAcmeDNS, err := dns.NewProvider("acmedns", oneAccount,
func(string) (any, bool) { return nil, false },
func(_, v string) (string, error) { return v, nil })
require.NoError(t, err)
tests := []struct {
name string
challenge types.DNSChallengeConfig
certificates bool
wantToken string
wantErr string
}{
{
name: "built from settings",
challenge: types.DNSChallengeConfig{ProviderSettings: map[string]any{"name": "cloudflare", "api_token": "file:" + token}},
wantToken: "from-file",
},
{
name: "go-only provider wins",
challenge: types.DNSChallengeConfig{
ProviderSettings: map[string]any{"name": "cloudflare", "api_token": "settings"},
Provider: goOnly,
},
wantToken: "go-only",
},
{
name: "unreadable secret",
challenge: types.DNSChallengeConfig{ProviderSettings: map[string]any{"name": "cloudflare", "api_token": "file:/nonexistent"}}, //nolint:gosec // a missing file, not a credential
wantErr: "dns.challenge.provider.api_token: ",
},
{
name: "one acme-dns account for node certificates",
challenge: types.DNSChallengeConfig{ProviderSettings: oneAccount},
certificates: true,
wantErr: "for acmedns: ",
},
{
name: "go-only provider named by its type",
challenge: types.DNSChallengeConfig{Provider: goOnlyAcmeDNS},
certificates: true,
wantErr: "for *dns.acmeDNS: ",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
tmpDir := t.TempDir()
cfg := types.Config{
ServerURL: "http://localhost:8080",
NoisePrivateKeyPath: tmpDir + "/noise_private.key",
Database: types.DatabaseConfig{
Type: "sqlite3",
Sqlite: types.SqliteConfig{Path: tmpDir + "/headscale_test.db"},
},
Policy: types.PolicyConfig{Mode: types.PolicyModeDB},
DNSConfig: types.DNSConfig{
MagicDNS: true,
BaseDomain: "ts.example.com",
Certificates: types.CertificatesConfig{Enabled: tt.certificates},
},
DNSChallenge: tt.challenge,
}
app, err := NewHeadscale(&cfg)
if tt.wantErr != "" {
require.ErrorContains(t, err, tt.wantErr)
return
}
require.NoError(t, err)
t.Cleanup(func() { _ = app.state.Close() })
provider, ok := cfg.DNSProvider().(*cloudflare.Provider)
require.True(t, ok, "provider is %T", cfg.DNSProvider())
assert.Equal(t, tt.wantToken, provider.APIToken)
})
}
}
+5 -6
View File
@@ -13,7 +13,6 @@ import (
"github.com/juanfont/headscale/hscontrol/dns"
policyv2 "github.com/juanfont/headscale/hscontrol/policy/v2"
"github.com/juanfont/headscale/hscontrol/types"
"github.com/juanfont/headscale/hscontrol/util"
"tailscale.com/types/key"
)
@@ -43,7 +42,7 @@ func Files(cfg *types.Config) []File {
var files []File
if cfg.Policy.Mode == types.PolicyModeFile && cfg.Policy.Path != "" {
p := util.AbsolutePath(cfg.ConfigDir, cfg.Policy.Path)
p := cfg.AbsPath(cfg.Policy.Path)
files = append(files, File{Key: "policy.path", Path: p, Check: func() error { return CheckPolicyFile(p) }})
}
@@ -55,7 +54,7 @@ func Files(cfg *types.Config) []File {
files = append(files, File{Key: "dns.extra_records_path", Path: p, Check: func() error { return CheckExtraRecordsFile(p) }})
}
if c, k := cfg.TLS.CertPath, cfg.TLS.KeyPath; c != "" {
if c, k := cfg.AbsPath(cfg.TLS.CertPath), cfg.AbsPath(cfg.TLS.KeyPath); c != "" {
files = append(files, File{
Key: "tls.cert_path, tls.key_path",
Path: c + ", " + k,
@@ -63,7 +62,7 @@ func Files(cfg *types.Config) []File {
})
}
noise := cfg.NoisePrivateKeyPath
noise := cfg.AbsPath(cfg.NoisePrivateKeyPath)
if noise != "" {
files = append(files, File{
Key: "noise.private_key_path", Path: noise, CreatedAtStartup: true,
@@ -71,7 +70,7 @@ func Files(cfg *types.Config) []File {
})
}
if d := cfg.DERP.ServerPrivateKeyPath; cfg.DERP.ServerEnabled && d != "" {
if d := cfg.AbsPath(cfg.DERP.ServerPrivateKeyPath); cfg.DERP.ServerEnabled && d != "" {
files = append(files, File{
Key: "derp.server.private_key_path", Path: d, CreatedAtStartup: true,
Check: func() error { return checkDERPKey(d, noise) },
@@ -101,7 +100,7 @@ func CheckPolicyFile(path string) error {
// CheckDERPMapFile parses a DERP map file as startup loads derp.paths.
func CheckDERPMapFile(path string) error {
_, err := derp.GetDERPMap(types.DERPConfig{Paths: []string{path}})
_, err := derp.GetDERPMap(types.DERPConfig{Paths: []string{path}}, "")
return err
}
+13 -11
View File
@@ -48,7 +48,7 @@ type HSDatabase struct {
//
//nolint:gocyclo // migration closures inflate the count; each is linear
func NewHeadscaleDatabase(cfg *types.Config) (*HSDatabase, error) {
dbConn, err := openDB(cfg.Database)
dbConn, err := openDB(cfg.Database, cfg.SQLitePath())
if err != nil {
return nil, err
}
@@ -457,7 +457,7 @@ WHERE auth_key_id IN (
// This is currently only done on sqlite as squibble does not
// support Postgres and we use our sqlite schema as our source of
// truth.
if cfg.Database.Type == types.DatabaseSqlite {
if cfg.Database.IsSQLite() {
sqlConn, err := dbConn.DB()
if err != nil {
return nil, fmt.Errorf("getting DB from gorm: %w", err)
@@ -496,7 +496,9 @@ WHERE auth_key_id IN (
return &db, err
}
func openDB(cfg types.DatabaseConfig) (*gorm.DB, error) {
// openDB opens the database cfg names; sqlitePath is database.sqlite.path
// resolved.
func openDB(cfg types.DatabaseConfig, sqlitePath string) (*gorm.DB, error) {
// TODO(kradalby): Integrate this with zerolog
var dbLogger logger.Interface
if cfg.Debug {
@@ -505,9 +507,9 @@ func openDB(cfg types.DatabaseConfig) (*gorm.DB, error) {
dbLogger = logger.Default.LogMode(logger.Silent)
}
switch cfg.Type {
case types.DatabaseSqlite:
dir := filepath.Dir(cfg.Sqlite.Path)
switch {
case cfg.IsSQLite():
dir := filepath.Dir(sqlitePath)
err := util.EnsureDir(dir)
if err != nil {
@@ -516,11 +518,11 @@ func openDB(cfg types.DatabaseConfig) (*gorm.DB, error) {
log.Info().
Str("database", types.DatabaseSqlite).
Str("path", cfg.Sqlite.Path).
Str("path", sqlitePath).
Msg("Opening database")
// Build SQLite configuration with pragmas set at connection time
sqliteConfig := sqliteconfig.Default(cfg.Sqlite.Path)
sqliteConfig := sqliteconfig.Default(sqlitePath)
if cfg.Sqlite.WriteAheadLog {
sqliteConfig.JournalMode = sqliteconfig.JournalModeWAL
sqliteConfig.WALAutocheckpoint = cfg.Sqlite.WALAutoCheckPoint
@@ -560,7 +562,7 @@ func openDB(cfg types.DatabaseConfig) (*gorm.DB, error) {
return db, nil
case types.DatabasePostgres:
case cfg.Type == types.DatabasePostgres:
// Log the DSN without the password.
redacted := cfg.Postgres
redacted.Pass = ""
@@ -599,7 +601,7 @@ func openDB(cfg types.DatabaseConfig) (*gorm.DB, error) {
}
func runMigrations(cfg types.DatabaseConfig, dbConn *gorm.DB, migrations *gormigrate.Gormigrate) error {
if cfg.Type == types.DatabaseSqlite {
if cfg.IsSQLite() {
if err := migrations.Migrate(); err != nil { //nolint:noinlineerr
return err
}
@@ -675,7 +677,7 @@ func (hsdb *HSDatabase) Close() error {
return err
}
if hsdb.cfg.Database.Type == types.DatabaseSqlite && hsdb.cfg.Database.Sqlite.WriteAheadLog {
if hsdb.cfg.Database.IsSQLite() && hsdb.cfg.Database.Sqlite.WriteAheadLog {
db.Exec("VACUUM") //nolint:errcheck,noctx
}
+2 -1
View File
@@ -1117,7 +1117,8 @@ func TestOpenDBReturnsOpenError(t *testing.T) {
)
require.NotPanics(t, func() {
db, err = openDB(tt.cfg(t))
cfg := tt.cfg(t)
db, err = openDB(cfg, cfg.Sqlite.Path)
})
require.Error(t, err)
assert.Nil(t, db)
+1 -2
View File
@@ -5,7 +5,6 @@ import (
"os"
"github.com/juanfont/headscale/hscontrol/types"
"github.com/juanfont/headscale/hscontrol/util"
"gorm.io/gorm"
"gorm.io/gorm/clause"
)
@@ -76,7 +75,7 @@ func PolicyBytes(tx *gorm.DB, cfg *types.Config) ([]byte, error) {
return nil, nil
}
absPath := util.AbsolutePath(cfg.ConfigDir, path)
absPath := cfg.AbsPath(path)
return os.ReadFile(absPath)
+4 -3
View File
@@ -237,8 +237,9 @@ func ApplyPolicy(base, pol *tailcfg.DERPMap) *tailcfg.DERPMap {
// GetDERPMap merges every configured DERP map source. A source that fails to
// load is skipped rather than failing the rest, as a derp.urls server is often
// a third party's: the map always holds what did load, and the error joins
// every failure for the caller to judge.
func GetDERPMap(cfg types.DERPConfig) (*tailcfg.DERPMap, error) {
// every failure for the caller to judge. shuffleSeed orders DERP nodes the
// same on every server of a tailnet.
func GetDERPMap(cfg types.DERPConfig, shuffleSeed string) (*tailcfg.DERPMap, error) {
var (
derpMaps []*tailcfg.DERPMap
errs []error
@@ -269,7 +270,7 @@ func GetDERPMap(cfg types.DERPConfig) (*tailcfg.DERPMap, error) {
}
derpMap := mergeDERPMaps(derpMaps)
shuffleDERPMap(derpMap, cfg.ShuffleSeed)
shuffleDERPMap(derpMap, shuffleSeed)
return derpMap, errors.Join(errs...)
}
+2 -2
View File
@@ -68,11 +68,11 @@ func TestGetDERPMapCarriesHomeParams(t *testing.T) {
999: 0.5
`), 0o600))
got, err := GetDERPMap(types.DERPConfig{DERPMap: base})
got, err := GetDERPMap(types.DERPConfig{DERPMap: base}, "")
require.NoError(t, err)
assert.Nil(t, got.HomeParams)
got, err = GetDERPMap(types.DERPConfig{DERPMap: base, Paths: []string{path}})
got, err = GetDERPMap(types.DERPConfig{DERPMap: base, Paths: []string{path}}, "")
require.NoError(t, err)
require.NotNil(t, got.HomeParams)
assert.Equal(t,
+3 -3
View File
@@ -277,11 +277,11 @@ func TestGetDERPMapKeepsOrderAcrossRefreshes(t *testing.T) {
source.Regions[id+1] = region
}
first, err := GetDERPMap(types.DERPConfig{DERPMap: source, ShuffleSeed: "stable.example.com"})
first, err := GetDERPMap(types.DERPConfig{DERPMap: source}, "stable.example.com")
require.NoError(t, err)
for range 5 {
next, err := GetDERPMap(types.DERPConfig{DERPMap: source, ShuffleSeed: "stable.example.com"})
next, err := GetDERPMap(types.DERPConfig{DERPMap: source}, "stable.example.com")
require.NoError(t, err)
if diff := cmp.Diff(first, next); diff != "" {
@@ -524,7 +524,7 @@ regions:
dm, err := GetDERPMap(types.DERPConfig{
URLs: []url.URL{*goodURL, *downURL},
Paths: []string{goodPath, brokenPath, filepath.Join(t.TempDir(), "missing.yaml")},
})
}, "")
require.ErrorIs(t, err, errDERPMapStatus)
require.ErrorContains(t, err, down.URL)
require.ErrorContains(t, err, brokenPath)
+15 -4
View File
@@ -94,12 +94,23 @@ func ProviderNames() []string {
return slices.Sorted(maps.Keys(providers))
}
// SettingNames returns the names of the named provider's settings, or nil
// for an unknown provider.
func SettingNames(provider string) []string {
entry, ok := providers[strings.ToLower(provider)]
if !ok {
return nil
}
return slices.Sorted(maps.Keys(jsonFields(entry.build())))
}
// NewProvider builds the named provider from its settings.
//
// settings holds the provider's keys as written in the configuration
// file. get looks up a single key and is consulted for every field of
// the provider, because environment variables only reach individual
// keys, never a map. secret resolves every string setting, nested ones
// settings holds the provider's keys as written, in any case. get looks up
// a single key as the provider spells it and is consulted for every field
// of the provider, so it wins over a differently cased spelling in
// settings. secret resolves every string setting, nested ones
// included, so any of them can be read from a file. Unknown keys are an
// error so a typo does not silently leave a credential empty.
func NewProvider(
+7
View File
@@ -47,6 +47,13 @@ func TestIsProviderSetting(t *testing.T) {
assert.False(t, IsProviderSetting("api_token_path"))
}
func TestSettingNames(t *testing.T) {
assert.Subset(t, SettingNames("cloudflare"), []string{"api_token", "zone_token"})
assert.Subset(t, SettingNames("CloudFlare"), []string{"api_token"}, "named as NewProvider names it")
assert.Nil(t, SettingNames("route53"))
assert.Nil(t, SettingNames(""))
}
// unreadSecret stands in for a caller that checks without reading files.
func unreadSecret(_, value string) (string, error) {
if strings.HasPrefix(value, "file:") {
+1 -1
View File
@@ -62,7 +62,7 @@ func NewBatcher(batchTime time.Duration, workers int, mapper *mapper) *Batcher {
// NewBatcherAndMapper creates a new [Batcher] with its [mapper].
func NewBatcherAndMapper(cfg *types.Config, state *state.State) *Batcher {
m := newMapper(cfg, state)
b := NewBatcher(cfg.Tuning.BatchChangeDelay, cfg.Tuning.BatcherWorkers, m)
b := NewBatcher(cfg.Tuning.BatchChangeDelay, cfg.Tuning.BatcherWorkerCount(), m)
m.batcher = b
return b
+1 -7
View File
@@ -201,7 +201,6 @@ func setupBatcherWithTestData(
},
Tuning: types.Tuning{
BatchChangeDelay: 10 * time.Millisecond,
BatcherWorkers: types.DefaultBatcherWorkers(), // Use same logic as config.go
NodeStoreBatchSize: state.TestBatchSize,
NodeStoreBatchTimeout: state.TestBatchTimeout,
},
@@ -233,7 +232,7 @@ func setupBatcherWithTestData(
tb.Fatalf("Failed to create state: %v", err)
}
derpMap, err := derp.GetDERPMap(cfg.DERP)
derpMap, err := derp.GetDERPMap(cfg.DERP, cfg.BaseDomain)
require.NoError(tb, err)
require.NotNil(tb, derpMap)
@@ -3143,11 +3142,6 @@ func TestDNSConfigOnlyWithSelfRefresh(t *testing.T) {
testData, cleanup := setupBatcherWithTestData(t, NewBatcherAndMapper, 1, 2, normalBufferSize)
defer cleanup()
testData.Config.TailcfgDNSConfig = &tailcfg.DNSConfig{
Proxied: true,
Domains: []string{"headscale.test"},
}
self := testData.Nodes[0].n.ID
mc := newMockNodeConnection(self)
@@ -14,13 +14,10 @@ import (
// through the shared lock so the run is race-free under -race.
func TestExtraRecordsConcurrentUpdateNoRace(t *testing.T) {
uid := uint(1)
cfg := &types.Config{
TailcfgDNSConfig: &tailcfg.DNSConfig{
ExtraRecords: []tailcfg.DNSRecord{
{Name: "initial.example.com", Type: "A", Value: "100.64.0.1"},
},
},
}
cfg := &types.Config{DNSConfig: types.DNSConfig{ExtraRecords: []tailcfg.DNSRecord{
{Name: "initial.example.com", Type: "A", Value: "100.64.0.1"},
}}}
cfg.StartDNS(nil)
node := (&types.Node{
Hostname: "race-node",
+1 -1
View File
@@ -79,7 +79,7 @@ func setupStormBatcher(tb testing.TB, nodeCount, workers int, policy string) (*T
st, err := state.NewState(cfg)
require.NoError(tb, err)
derpMap, err := derp.GetDERPMap(cfg.DERP)
derpMap, err := derp.GetDERPMap(cfg.DERP, cfg.BaseDomain)
require.NoError(tb, err)
st.SetDERPMap(derpMap)
-3
View File
@@ -106,9 +106,6 @@ func generateDNSConfig(
capMap tailcfg.NodeCapMap,
) *tailcfg.DNSConfig {
dnsConfig := cfg.CloneTailcfgDNSConfig()
if dnsConfig == nil {
return nil
}
profile := nextDNSProfileFromCapMap(capMap)
if profile != "" {
+24 -47
View File
@@ -58,8 +58,8 @@ func TestExitNodeFilteredSet(t *testing.T) {
t.Run(tt.name, func(t *testing.T) {
got := generateDNSConfig(
&types.Config{
BaseDomain: tt.baseDomain,
TailcfgDNSConfig: &tailcfg.DNSConfig{Proxied: tt.magicDNS},
BaseDomain: tt.baseDomain,
DNSConfig: types.DNSConfig{MagicDNS: tt.magicDNS, BaseDomain: tt.baseDomain},
},
(&types.Node{}).View(),
nil,
@@ -86,11 +86,9 @@ func TestDNSConfigMapResponse(t *testing.T) {
},
},
{
// Only MagicDNS answers for the base domain.
magicDNS: false,
want: &tailcfg.DNSConfig{
Domains: []string{"foobar.headscale.net"},
Proxied: false,
},
want: &tailcfg.DNSConfig{},
},
}
@@ -106,19 +104,11 @@ func TestDNSConfigMapResponse(t *testing.T) {
}
}
baseDomain := "foobar.headscale.net"
dnsConfigOrig := tailcfg.DNSConfig{
Routes: make(map[string][]*dnstype.Resolver),
Domains: []string{baseDomain},
Proxied: tt.magicDNS,
}
nodeInShared1 := mach("test_get_shared_nodes_1", "shared1", 1)
got := generateDNSConfig(
&types.Config{
TailcfgDNSConfig: &dnsConfigOrig,
DNSConfig: types.DNSConfig{MagicDNS: tt.magicDNS, BaseDomain: "foobar.headscale.net"},
},
nodeInShared1.View(),
nil,
@@ -135,15 +125,8 @@ func TestNextDNSCapMapRendering(t *testing.T) {
t.Parallel()
mkConfig := func(addrs ...string) *types.Config {
resolvers := make([]*dnstype.Resolver, len(addrs))
for i, a := range addrs {
resolvers[i] = &dnstype.Resolver{Addr: a}
}
return &types.Config{
TailcfgDNSConfig: &tailcfg.DNSConfig{
Resolvers: resolvers,
},
DNSConfig: types.DNSConfig{OverrideLocalDNS: true, Nameservers: types.Nameservers{Global: addrs}},
}
}
@@ -274,12 +257,10 @@ func TestNextDNSResolverCompat(t *testing.T) {
))
require.NoError(t, err)
resolvers := make([]*dnstype.Resolver, 0, len(c.Input.Tailnet.DNS.Nameservers))
for _, ns := range c.Input.Tailnet.DNS.Nameservers {
resolvers = append(resolvers, &dnstype.Resolver{Addr: ns})
}
cfg := &types.Config{TailcfgDNSConfig: &tailcfg.DNSConfig{Resolvers: resolvers}}
cfg := &types.Config{DNSConfig: types.DNSConfig{
OverrideLocalDNS: true,
Nameservers: types.Nameservers{Global: c.Input.Tailnet.DNS.Nameservers},
}}
// Mismatches by check, one entry per node.
diffs := map[string][]string{}
@@ -849,11 +830,10 @@ func TestGenerateDNSConfigNilHostinfoNoPanic(t *testing.T) {
// Hostinfo intentionally nil, as a legacy NULL host_info row loads.
}).View()
cfg := &types.Config{
TailcfgDNSConfig: &tailcfg.DNSConfig{
Resolvers: []*dnstype.Resolver{{Addr: "https://dns.nextdns.io/abc"}},
},
}
cfg := &types.Config{DNSConfig: types.DNSConfig{
OverrideLocalDNS: true,
Nameservers: types.Nameservers{Global: []string{"https://dns.nextdns.io/abc"}},
}}
require.NotPanics(t, func() {
generateDNSConfig(cfg, node, nil)
@@ -1215,7 +1195,7 @@ func TestGenerateMapResponseDebugOnlyOnFullMaps(t *testing.T) {
},
// Without these the DERP map and DNS config renders carry
// nothing and no frame is generated at all.
TailcfgDNSConfig: &tailcfg.DNSConfig{Proxied: true},
DNSConfig: types.DNSConfig{MagicDNS: true},
Tuning: types.Tuning{
NodeStoreBatchSize: state.TestBatchSize,
NodeStoreBatchTimeout: state.TestBatchTimeout,
@@ -1376,22 +1356,19 @@ func TestCertDomains(t *testing.T) {
baseDomain = "ts.example.com"
}
cfg := &types.Config{
BaseDomain: baseDomain,
DNSConfig: tt.dns,
DNSChallenge: types.DNSChallengeConfig{Provider: tt.provider},
TailcfgDNSConfig: &tailcfg.DNSConfig{
Proxied: true,
ExtraRecords: []tailcfg.DNSRecord{
{Name: "Grafana.ts.example.com", Type: "A", Value: "100.64.0.3"},
{Name: "grafana.svc.ts.example.com.", Type: "A", Value: "100.64.0.4"},
},
},
dnsCfg := tt.dns
dnsCfg.MagicDNS = true
dnsCfg.ExtraRecords = []tailcfg.DNSRecord{
{Name: "Grafana.ts.example.com", Type: "A", Value: "100.64.0.3"},
{Name: "grafana.svc.ts.example.com.", Type: "A", Value: "100.64.0.4"},
}
cfg := &types.Config{BaseDomain: baseDomain, DNSConfig: dnsCfg}
cfg.StartDNS(tt.provider)
got := generateDNSConfig(cfg, tt.node.View(), nil)
assert.Equal(t, tt.want, got.CertDomains)
assert.Nil(t, cfg.TailcfgDNSConfig.CertDomains, "global DNS config must stay untouched")
assert.Nil(t, cfg.CloneTailcfgDNSConfig().CertDomains, "global DNS config must stay untouched")
})
}
}
+2 -7
View File
@@ -54,7 +54,6 @@ func TestTailNode(t *testing.T) {
tests := []struct {
name string
node *types.Node
dnsConfig *tailcfg.DNSConfig
baseDomain string
want *tailcfg.Node
wantErr bool
@@ -65,7 +64,6 @@ func TestTailNode(t *testing.T) {
GivenName: "empty",
Hostinfo: &tailcfg.Hostinfo{},
},
dnsConfig: &tailcfg.DNSConfig{},
baseDomain: "",
want: &tailcfg.Node{
Name: "empty",
@@ -118,7 +116,6 @@ func TestTailNode(t *testing.T) {
ApprovedRoutes: []netip.Prefix{tsaddr.AllIPv4(), tsaddr.AllIPv6(), netip.MustParsePrefix("192.168.0.0/24")},
CreatedAt: created,
},
dnsConfig: &tailcfg.DNSConfig{},
baseDomain: "",
want: &tailcfg.Node{
ID: 0,
@@ -174,7 +171,6 @@ func TestTailNode(t *testing.T) {
GivenName: "minimal",
Hostinfo: &tailcfg.Hostinfo{},
},
dnsConfig: &tailcfg.DNSConfig{},
baseDomain: "example.com",
want: &tailcfg.Node{
// a node name should have a dot appended
@@ -203,9 +199,8 @@ func TestTailNode(t *testing.T) {
t.Parallel()
cfg := &types.Config{
BaseDomain: tt.baseDomain,
TailcfgDNSConfig: tt.dnsConfig,
Taildrop: types.TaildropConfig{Enabled: true},
BaseDomain: tt.baseDomain,
Taildrop: types.TaildropConfig{Enabled: true},
}
// Stub primary-route lookup: tt.node owns its SubnetRoutes,
+9 -16
View File
@@ -23,7 +23,6 @@ import (
"github.com/juanfont/headscale/hscontrol/types/change"
"tailscale.com/net/memnet"
"tailscale.com/tailcfg"
"tailscale.com/types/dnstype"
)
// TestServer is an in-process Headscale control server suitable for
@@ -121,8 +120,7 @@ func WithTaildropEnabled(enabled bool) ServerOption {
return func(c *serverConfig) { c.taildropEnabled = enabled }
}
// WithMagicDNS enables MagicDNS under domain, so map responses carry a
// [tailcfg.DNSConfig].
// WithMagicDNS enables MagicDNS under domain.
func WithMagicDNS(domain string) ServerOption {
return func(c *serverConfig) { c.magicDNSDomain = domain }
}
@@ -139,8 +137,8 @@ func WithCertificates(provider hsdns.Provider) ServerOption {
return func(c *serverConfig) { c.certProvider = provider }
}
// WithDNSResolvers sets the global DNS resolvers, so map responses carry a
// [tailcfg.DNSConfig].
// WithDNSResolvers sets the global DNS resolvers, overriding the nodes'
// local DNS.
func WithDNSResolvers(addrs ...string) ServerOption {
return func(c *serverConfig) { c.dnsResolvers = addrs }
}
@@ -199,14 +197,10 @@ func NewServer(tb testing.TB, opts ...ServerOption) *TestServer {
},
}
if sc.magicDNSDomain != "" || len(sc.dnsResolvers) > 0 {
cfg.TailcfgDNSConfig = &tailcfg.DNSConfig{}
}
if sc.magicDNSDomain != "" {
cfg.BaseDomain = sc.magicDNSDomain
cfg.TailcfgDNSConfig.Proxied = true
cfg.TailcfgDNSConfig.Domains = []string{sc.magicDNSDomain}
cfg.DNSConfig.MagicDNS = true
cfg.DNSConfig.BaseDomain = sc.magicDNSDomain
}
if sc.certProvider != nil {
@@ -214,8 +208,9 @@ func NewServer(tb testing.TB, opts ...ServerOption) *TestServer {
cfg.DNSChallenge.Provider = sc.certProvider
}
for _, addr := range sc.dnsResolvers {
cfg.TailcfgDNSConfig.Resolvers = append(cfg.TailcfgDNSConfig.Resolvers, &dnstype.Resolver{Addr: addr})
if len(sc.dnsResolvers) > 0 {
cfg.DNSConfig.OverrideLocalDNS = true
cfg.DNSConfig.Nameservers.Global = sc.dnsResolvers
}
app, err := hscontrol.NewHeadscale(&cfg)
@@ -323,9 +318,7 @@ func (s *TestServer) MemNet() *memnet.Network {
}
// SetExtraRecords replaces the extra DNS records and sends them to every
// node, as a reload of dns.extra_records_path does. The server needs
// [WithMagicDNS] or [WithDNSResolvers], which give it a DNS config to hold
// them.
// node, as a reload of dns.extra_records_path does.
func (s *TestServer) SetExtraRecords(records []tailcfg.DNSRecord) {
s.cfg.SetExtraRecords(records)
s.App.Change(change.ExtraRecords())
+4 -4
View File
@@ -41,10 +41,10 @@ func TestNewNodeStoreBumpsDuplicateNames(t *testing.T) {
func TestPutNodeBumpsPastReservedLabel(t *testing.T) {
cfg := persistTestConfig(t.TempDir() + "/headscale.db")
cfg.TailcfgDNSConfig = &tailcfg.DNSConfig{ExtraRecords: []tailcfg.DNSRecord{
cfg.DNSConfig.ExtraRecords = []tailcfg.DNSRecord{
{Name: "laptop." + cfg.BaseDomain},
{Name: "laptop-1." + cfg.BaseDomain},
}}
}
s, err := NewState(cfg)
require.NoError(t, err)
t.Cleanup(func() { _ = s.Close() })
@@ -55,9 +55,9 @@ func TestPutNodeBumpsPastReservedLabel(t *testing.T) {
func TestSetGivenNameRejectsReservedLabel(t *testing.T) {
cfg := persistTestConfig(t.TempDir() + "/headscale.db")
cfg.TailcfgDNSConfig = &tailcfg.DNSConfig{ExtraRecords: []tailcfg.DNSRecord{
cfg.DNSConfig.ExtraRecords = []tailcfg.DNSRecord{
{Name: "laptop." + cfg.BaseDomain},
}}
}
s, err := NewState(cfg)
require.NoError(t, err)
t.Cleanup(func() { _ = s.Close() })
+2 -2
View File
@@ -103,9 +103,9 @@ func persistTestConfig(dbPath string) *types.Config {
func TestLoadedDuplicateNamesAreResolvedInMemory(t *testing.T) {
dbPath := t.TempDir() + "/headscale.db"
cfg := persistTestConfig(dbPath)
cfg.TailcfgDNSConfig = &tailcfg.DNSConfig{ExtraRecords: []tailcfg.DNSRecord{
cfg.DNSConfig.ExtraRecords = []tailcfg.DNSRecord{
{Name: "grafana." + cfg.BaseDomain, Type: "A", Value: "100.64.0.100"},
}}
}
database, err := db.NewHeadscaleDatabase(cfg)
require.NoError(t, err)
+3 -2
View File
@@ -14,9 +14,10 @@ import (
func TestNodeNameCannotShadowExtraRecord(t *testing.T) {
cfg := persistTestConfig(t.TempDir() + "/headscale.db")
cfg.TailcfgDNSConfig = &tailcfg.DNSConfig{ExtraRecords: []tailcfg.DNSRecord{
cfg.DNSConfig.ExtraRecords = []tailcfg.DNSRecord{
{Name: "grafana." + cfg.BaseDomain, Type: "A", Value: "100.64.0.100"},
}}
}
cfg.StartDNS(nil) // as NewHeadscale does, so SetExtraRecords takes
s, err := NewState(cfg)
require.NoError(t, err)
t.Cleanup(func() { _ = s.Close() })
+254 -155
View File
@@ -5,6 +5,7 @@ import (
"errors"
"fmt"
"io/fs"
"maps"
"net"
"net/netip"
"net/url"
@@ -22,6 +23,7 @@ import (
"github.com/prometheus/common/model"
"github.com/rs/zerolog"
"github.com/rs/zerolog/log"
"github.com/spf13/cast"
"go4.org/netipx"
"tailscale.com/net/tsaddr"
"tailscale.com/tailcfg"
@@ -145,10 +147,6 @@ type Config struct {
// not directly converted into a [tailcfg.DNSConfig].
DNSConfig DNSConfig
// TailcfgDNSConfig is the tailcfg representation of the DNS configuration,
// it can be used directly when sending Netmaps to clients.
TailcfgDNSConfig *tailcfg.DNSConfig
DNSChallenge DNSChallengeConfig
UnixSocket string
@@ -166,12 +164,24 @@ type Config struct {
Tuning Tuning
// ConfigDir resolves relative paths such as policy.path.
// ConfigDir is where [Config.AbsPath] resolves relative paths.
ConfigDir string `json:"-"`
// UnreadSecrets are the file: secrets [CheckServerConfig] left unread,
// each as key and path.
UnreadSecrets []KV `json:"-"`
// dns is nil until [Config.StartDNS].
dns *liveDNS
}
// liveDNS is the DNS state of a running server: the tailcfg form, whose
// extra records the extra-records watcher replaces while map builds clone
// it, and the provider startup built.
type liveDNS struct {
mu sync.RWMutex
dns *tailcfg.DNSConfig
provider hsdns.Provider
}
type DNSConfig struct {
@@ -190,23 +200,72 @@ type DNSConfig struct {
// publishes its DNS-01 challenge through [DNSChallengeConfig].
type CertificatesConfig struct {
Enabled bool
// Zone is the public DNS zone challenge records are written to. It is
// base_domain unless base_domain sits below the zone apex.
// Zone is the public DNS zone challenge records are written to, when
// base_domain sits below the zone apex. See [DNSConfig.CertificateZone].
Zone string
}
// CertificateZone is the zone challenge records are written to:
// Certificates.Zone, else BaseDomain.
func (d DNSConfig) CertificateZone() string {
return cmp.Or(d.Certificates.Zone, d.BaseDomain)
}
// DNSChallengeConfig is the DNS provider answering ACME DNS-01
// challenges for node certificates and headscale's own certificate.
type DNSChallengeConfig struct {
PropagationTimeout time.Duration
Resolvers []string
ProviderName string
// Provider is nil when no provider is configured. It is built while
// loading so `headscale check config` reports bad provider settings,
// and never serialised because it holds credentials.
// ProviderSettings is dns.challenge.provider, name included. Never
// serialised: its settings are credentials.
ProviderSettings map[string]any `json:"-"`
// Provider is set only from Go, by an embedder or a test, and wins
// over ProviderSettings. The loader never sets it.
Provider hsdns.Provider `json:"-"`
}
// ProviderName is the provider ProviderSettings names, or "".
func (c DNSChallengeConfig) ProviderName() string {
return cast.ToString(c.ProviderSettings["name"])
}
// NewProvider builds the provider ProviderSettings names, handing secret
// each string setting under its full config key.
func (c DNSChallengeConfig) NewProvider(secret func(key, value string) (string, error)) (hsdns.Provider, error) {
return hsdns.NewProvider(
c.ProviderName(),
c.ProviderSettings,
func(key string) (any, bool) {
v, ok := c.ProviderSettings[key]
return v, ok
},
func(key, value string) (string, error) {
return secret(providerKey+"."+key, value)
},
)
}
// ResolverAddrs returns Resolvers as host:port, or the defaults when none
// are set. Like dns.nameservers, a resolver may be a bare IP.
func (c DNSChallengeConfig) ResolverAddrs() []string {
if len(c.Resolvers) == 0 {
return slices.Clone(defaultChallengeResolvers)
}
addrs := make([]string, len(c.Resolvers))
for i, r := range c.Resolvers {
addrs[i] = r
_, _, err := net.SplitHostPort(r)
if err != nil {
addrs[i] = net.JoinHostPort(r, "53")
}
}
return addrs
}
type Nameservers struct {
Global []string
Split map[string][]string
@@ -293,7 +352,7 @@ type GormConfig struct {
}
type DatabaseConfig struct {
// Type sets the database type, either "sqlite3" or "postgres"
// Type sets the database type: "sqlite", "sqlite3" or "postgres".
Type string
Debug bool
@@ -304,6 +363,11 @@ type DatabaseConfig struct {
Postgres PostgresConfig
}
// IsSQLite reports whether Type names SQLite, in either spelling.
func (d DatabaseConfig) IsSQLite() bool {
return d.Type == DatabaseSqlite || d.Type == "sqlite"
}
type TLSConfig struct {
CertPath string
KeyPath string
@@ -358,8 +422,6 @@ type DERPConfig struct {
UpdateFrequency time.Duration
IPv4 string
IPv6 string
// ShuffleSeed orders DERP nodes the same on every server of a tailnet.
ShuffleSeed string `json:"-"`
}
type LogTailConfig struct {
@@ -419,7 +481,7 @@ type Tuning struct {
NodeMapSessionBufferedChanSize int
// BatcherWorkers controls the number of parallel workers processing map
// updates for connected clients.
// updates for connected clients. See [Tuning.BatcherWorkerCount].
BatcherWorkers int
// RegisterCacheExpiration is how long registration cache entries remain
@@ -461,6 +523,15 @@ type Tuning struct {
NodeStoreBatchTimeout time.Duration
}
// BatcherWorkerCount is BatcherWorkers, or [DefaultBatcherWorkers] when unset.
func (t Tuning) BatcherWorkerCount() int {
if t.BatcherWorkers > 0 {
return t.BatcherWorkers
}
return DefaultBatcherWorkers()
}
func validatePKCEMethod(method string) error {
if method != PKCEMethodPlain && method != PKCEMethodS256 {
return errInvalidPKCEMethod
@@ -509,6 +580,21 @@ func (c *Config) Domain() string {
return u.Hostname()
}
// AbsPath resolves a path from the configuration against [Config.ConfigDir].
func (c *Config) AbsPath(p string) string {
return util.AbsolutePath(c.ConfigDir, p)
}
// SQLitePath is database.sqlite.path resolved, keeping SQLite's in-memory
// name, which is not a file.
func (c *Config) SQLitePath() string {
if c.Database.Sqlite.Path == ":memory:" {
return c.Database.Sqlite.Path
}
return c.AbsPath(c.Database.Sqlite.Path)
}
// ServesRoute reports whether an approved route is handed to clients. A
// single address inside the node ranges, in either spelling, names a node
// rather than a subnet, so it stays approved but is never served. 4via6
@@ -999,49 +1085,20 @@ func validateCertificatesConfig(v *configValidator) {
}
}
// dnsChallengeConfig builds the DNS-01 provider. Provider keys are read
// one by one, because environment variables never reach into a map.
// dnsChallengeConfig reads dns.challenge and builds the provider it names
// only to report bad settings; startup builds the one it uses.
func dnsChallengeConfig(secret func(key, value string) (string, error)) (DNSChallengeConfig, error) {
cfg := DNSChallengeConfig{
PropagationTimeout: src.Duration("dns.challenge.propagation_timeout"),
Resolvers: src.StringSlice("dns.challenge.resolvers"),
ProviderName: src.String("dns.challenge.provider.name"),
ProviderSettings: src.StringMap("dns.challenge.provider"),
}
if len(cfg.Resolvers) == 0 {
cfg.Resolvers = slices.Clone(defaultChallengeResolvers)
}
// Like dns.nameservers, a resolver may be a bare IP.
for i, r := range cfg.Resolvers {
_, _, err := net.SplitHostPort(r)
if err != nil {
cfg.Resolvers[i] = net.JoinHostPort(r, "53")
}
}
if cfg.ProviderName == "" {
if cfg.ProviderName() == "" {
return cfg, nil
}
provider, err := hsdns.NewProvider(
cfg.ProviderName,
src.StringMap("dns.challenge.provider"),
func(key string) (any, bool) {
key = "dns.challenge.provider." + key
// Provider fields are not in configKeys, so the source never
// maps their variables.
if v := os.Getenv(configEnvName(key)); v != "" {
return v, true
}
return src.Get(key), src.IsSet(key)
},
func(key, value string) (string, error) {
return secret("dns.challenge.provider."+key, value)
},
)
provider, err := cfg.NewProvider(secret)
if err != nil {
return cfg, err
}
@@ -1051,38 +1108,36 @@ func dnsChallengeConfig(secret func(key, value string) (string, error)) (DNSChal
if iso, ok := provider.(hsdns.Isolator); ok && src.Bool("dns.certificates.enabled") {
err = iso.CheckIsolation()
if err != nil {
return cfg, fmt.Errorf("%w for %s: %w", hsdns.ErrProviderConfig, cfg.ProviderName, err)
return cfg, fmt.Errorf("%w for %s: %w", hsdns.ErrProviderConfig, cfg.ProviderName(), err)
}
}
cfg.Provider = provider
return cfg, nil
}
func tlsConfig(dir string) TLSConfig {
func tlsConfig() TLSConfig {
return TLSConfig{
CertPath: util.AbsolutePath(dir, src.String("tls.cert_path")),
KeyPath: util.AbsolutePath(dir, src.String("tls.key_path")),
CertPath: src.String("tls.cert_path"),
KeyPath: src.String("tls.key_path"),
ACME: ACMEConfig{
Hostname: src.String("tls.acme.hostname"),
ChallengeType: src.String("tls.acme.challenge_type"),
HTTPListen: src.String("tls.acme.http_listen"),
URL: src.String("tls.acme.url"),
Email: src.String("tls.acme.email"),
CacheDir: util.AbsolutePath(dir, src.String("tls.acme.cache_dir")),
CacheDir: src.String("tls.acme.cache_dir"),
},
}
}
func derpConfig(dir string) DERPConfig {
func derpConfig() DERPConfig {
serverEnabled := src.Bool("derp.server.enabled")
serverRegionID := src.Int64("derp.server.region_id")
serverRegionCode := src.String("derp.server.region_code")
serverRegionName := src.String("derp.server.region_name")
serverVerifyClients := src.Bool("derp.server.verify_clients")
stunAddr := src.String("derp.server.stun_listen_addr")
privateKeyPath := util.AbsolutePath(dir, src.String("derp.server.private_key_path"))
privateKeyPath := src.String("derp.server.private_key_path")
ipv4 := src.String("derp.server.ipv4")
ipv6 := src.String("derp.server.ipv6")
automaticallyAddEmbeddedDerpRegion := src.Bool(
@@ -1127,7 +1182,6 @@ func derpConfig(dir string) DERPConfig {
IPv4: ipv4,
IPv6: ipv6,
AutomaticallyAddEmbeddedDerpRegion: automaticallyAddEmbeddedDerpRegion,
ShuffleSeed: src.String("dns.base_domain"),
}
}
@@ -1181,18 +1235,7 @@ func logConfig() LogConfig {
}
}
// sqlitePath resolves database.sqlite.path, keeping SQLite's in-memory
// name, which is not a file.
func sqlitePath(dir string) string {
path := src.String("database.sqlite.path")
if path == ":memory:" {
return path
}
return util.AbsolutePath(dir, path)
}
func databaseConfig(v *configValidator, secret func(key, value string) (string, error), dir string) DatabaseConfig {
func databaseConfig(v *configValidator, secret func(key, value string) (string, error)) DatabaseConfig {
debug := src.Bool("database.debug")
type_ := src.String("database.type")
@@ -1201,13 +1244,6 @@ func databaseConfig(v *configValidator, secret func(key, value string) (string,
slowThreshold := time.Duration(src.Int64("database.gorm.slow_threshold")) * time.Millisecond
parameterizedQueries := src.Bool("database.gorm.parameterized_queries")
switch type_ {
case DatabaseSqlite, DatabasePostgres:
break
case "sqlite":
type_ = "sqlite3"
}
pass := src.String("database.postgres.pass")
if type_ == DatabasePostgres {
pass = configSecret(v, secret, "database.postgres.pass", pass)
@@ -1223,7 +1259,7 @@ func databaseConfig(v *configValidator, secret func(key, value string) (string,
ParameterizedQueries: parameterizedQueries,
},
Sqlite: SqliteConfig{
Path: sqlitePath(dir),
Path: src.String("database.sqlite.path"),
WriteAheadLog: src.Bool("database.sqlite.write_ahead_log"),
WALAutoCheckPoint: src.Int("database.sqlite.wal_autocheckpoint"),
},
@@ -1261,7 +1297,7 @@ func dns() (DNSConfig, error) {
dns.SearchDomains = src.StringSlice("dns.search_domains")
dns.ExtraRecordsPath = src.String("dns.extra_records_path")
dns.Certificates.Enabled = src.Bool("dns.certificates.enabled")
dns.Certificates.Zone = cmp.Or(src.String("dns.certificates.zone"), dns.BaseDomain)
dns.Certificates.Zone = src.String("dns.certificates.zone")
if src.IsSet("dns.extra_records") {
var extraRecords []tailcfg.DNSRecord
@@ -1277,54 +1313,62 @@ func dns() (DNSConfig, error) {
return dns, nil
}
// parseResolvers converts nameserver strings into DNS resolvers.
// If a nameserver is a valid IP, it will be used as a regular resolver.
// If a nameserver is a valid URL, it will be used as a DoH resolver.
// If a nameserver is neither a valid URL nor a valid IP, it will be ignored.
// When domain is non-empty, it is included in the warning for invalid entries.
func parseResolvers(nameservers []string, domain string) []*dnstype.Resolver {
// parseResolvers converts nameserver strings into DNS resolvers: an IP is a
// plain resolver, a URL a DoH one. Anything else is skipped; the loader
// warns about it, see [DNSConfig.nameserverWarnings].
func parseResolvers(nameservers []string) []*dnstype.Resolver {
var resolvers []*dnstype.Resolver
for _, nsStr := range nameservers {
if _, err := netip.ParseAddr(nsStr); err == nil { //nolint:noinlineerr
resolvers = append(resolvers, &dnstype.Resolver{
Addr: nsStr,
})
continue
for _, ns := range nameservers {
if validNameserver(ns) {
resolvers = append(resolvers, &dnstype.Resolver{Addr: ns})
}
if _, err := url.Parse(nsStr); err == nil { //nolint:noinlineerr
resolvers = append(resolvers, &dnstype.Resolver{
Addr: nsStr,
})
continue
}
e := log.Warn().Str("nameserver", nsStr)
if domain != "" {
e = e.Str("domain", domain)
}
e.Msg("invalid nameserver, ignoring")
}
return resolvers
}
func validNameserver(ns string) bool {
_, addrErr := netip.ParseAddr(ns)
_, urlErr := url.Parse(ns)
return addrErr == nil || urlErr == nil
}
// nameserverWarnings lists each nameserver parseResolvers skips, so the
// load that reads the config reports it rather than each build of it.
func (d DNSConfig) nameserverWarnings() []string {
var warnings []string
check := func(key string, nameservers []string) {
for _, ns := range nameservers {
if !validNameserver(ns) {
warnings = append(warnings, fmt.Sprintf("invalid nameserver %q in %s, ignoring", ns, key))
}
}
}
check("dns.nameservers.global", d.Nameservers.Global)
for _, domain := range slices.Sorted(maps.Keys(d.Nameservers.Split)) {
check("dns.nameservers.split."+domain, d.Nameservers.Split[domain])
}
return warnings
}
// globalResolvers returns the global DNS resolvers
// defined in the config file.
func (d *DNSConfig) globalResolvers() []*dnstype.Resolver {
return parseResolvers(d.Nameservers.Global, "")
func (d DNSConfig) globalResolvers() []*dnstype.Resolver {
return parseResolvers(d.Nameservers.Global)
}
// splitResolvers returns a map of domain to DNS resolvers.
func (d *DNSConfig) splitResolvers() map[string][]*dnstype.Resolver {
func (d DNSConfig) splitResolvers() map[string][]*dnstype.Resolver {
routes := make(map[string][]*dnstype.Resolver)
for domain, nameservers := range d.Nameservers.Split {
routes[domain] = parseResolvers(nameservers, domain)
routes[domain] = parseResolvers(nameservers)
}
return routes
@@ -1357,6 +1401,48 @@ func dnsToTailcfgDNS(dns DNSConfig) *tailcfg.DNSConfig {
return &cfg
}
// TailcfgDNSConfig builds the DNS config clients get from DNSConfig and the
// IP prefixes. It is never nil.
func (c *Config) TailcfgDNSConfig() *tailcfg.DNSConfig {
cfg := dnsToTailcfgDNS(c.DNSConfig)
if !cfg.Proxied {
return cfg
}
// Clients route reverse lookups for the Tailscale ranges themselves
// (magicDNSRootDomains in tailscale.com/ipn/ipnlocal) and SaaS sends
// no reverse routes, so only a prefix outside those ranges needs them.
outside := func(p, r netip.Prefix) bool {
return p.Bits() < r.Bits() || !r.Contains(p.Addr())
}
var reverse []dnsname.FQDN
if c.PrefixV4 != nil && outside(*c.PrefixV4, tsaddr.CGNATRange()) {
reverse = append(reverse, util.GenerateIPv4DNSRootDomain(*c.PrefixV4)...)
}
if c.PrefixV6 != nil && outside(*c.PrefixV6, tsaddr.TailscaleULARange()) {
reverse = append(reverse, util.GenerateIPv6DNSRootDomain(*c.PrefixV6)...)
}
for _, d := range reverse {
// Empty non-nil slice rather than nil: tailcfg.DNSConfig.Clone
// and dns.Config.Clone in tailscale drop map entries whose
// value is nil (see tailscale.com/tailcfg/tailcfg_clone.go and
// tailscale.com/net/dns/dns_clone.go: `if sv == nil { continue }`).
// Sending nil here caused the client's wgengine LinkChange:major
// handler to clobber /etc/resolv.conf on every tunnel-IP rebind
// — the handler reapplies a Clone of lastDNSConfig and the magic
// DNS routes vanish, taking the resolver with them for ~6 min
// until the next route-changing netmap. Empty slice survives
// Clone and carries the same "resolve locally" semantics
// ([tailcfg.DNSConfig.Routes] documents the empty-resolver form).
cfg.Routes[d.WithoutTrailingDot()] = []*dnstype.Resolver{}
}
return cfg
}
// warnBanner prints a highly visible warning banner to the log output.
// It wraps the provided lines in an ASCII-art box with a "Warning!" header.
// This is intended for critical configuration issues that users must not ignore.
@@ -1443,7 +1529,7 @@ func LoadCLIConfig() (*Config, error) {
// Over the unix socket the CLI needs no key, so it is not read.
cliAPIKey := src.String("cli.api_key")
if src.String("cli.address") != "" {
cliAPIKey = configSecret(v, resolveSecret, "cli.api_key", cliAPIKey)
cliAPIKey = configSecret(v, ResolveSecret, "cli.api_key", cliAPIKey)
}
err := v.Err()
@@ -1470,7 +1556,7 @@ func LoadCLIConfig() (*Config, error) {
// LoadServerConfig returns the full Headscale configuration to
// host a Headscale server. This is called as part of `headscale serve`.
func LoadServerConfig() (*Config, error) {
return loadServerConfig(resolveSecret)
return loadServerConfig(ResolveSecret)
}
// CheckServerConfig validates the server configuration as
@@ -1622,8 +1708,12 @@ func loadServerConfig(secret func(key, value string) (string, error)) (*Config,
})
}
for _, w := range dnsConfig.nameserverWarnings() {
log.Warn().Msg(w)
}
dir := configDir()
derpConfig := derpConfig(dir)
derpConfig := derpConfig()
logTailConfig := logtailConfig()
dnsChallenge, err := dnsChallengeConfig(secret)
@@ -1636,7 +1726,7 @@ func loadServerConfig(secret func(key, value string) (string, error)) (*Config,
v.Add(&ConfigError{
Reason: "dns.challenge.provider is invalid",
Current: []KV{{"dns.challenge.provider.name", dnsChallenge.ProviderName}},
Current: []KV{{"dns.challenge.provider.name", dnsChallenge.ProviderName()}},
Detail: err.Error(),
Allowed: allowed,
Hint: `check the provider name and its settings; any string setting can be read from a file with "file:<path>"`,
@@ -1651,7 +1741,7 @@ func loadServerConfig(secret func(key, value string) (string, error)) (*Config,
oidcClientSecret = configSecret(v, secret, "oidc.client_secret", oidcClientSecret)
}
database := databaseConfig(v, secret, dir)
database := databaseConfig(v, secret)
serverURL := strings.TrimRight(src.String("server_url"), "/")
@@ -1686,7 +1776,7 @@ func loadServerConfig(secret func(key, value string) (string, error)) (*Config,
PrefixV6: prefix6,
IPAllocation: alloc,
NoisePrivateKeyPath: util.AbsolutePath(dir, src.String("noise.private_key_path")),
NoisePrivateKeyPath: src.String("noise.private_key_path"),
BaseDomain: dnsConfig.BaseDomain,
DERP: derpConfig,
@@ -1710,11 +1800,10 @@ func loadServerConfig(secret func(key, value string) (string, error)) (*Config,
Database: database,
TLS: tlsConfig(dir),
TLS: tlsConfig(),
DNSConfig: dnsConfig,
TailcfgDNSConfig: dnsToTailcfgDNS(dnsConfig),
DNSChallenge: dnsChallenge,
DNSConfig: dnsConfig,
DNSChallenge: dnsChallenge,
UnixSocket: src.String("unix_socket"),
UnixSocketPermission: socketPerm,
@@ -1765,13 +1854,7 @@ func loadServerConfig(secret func(key, value string) (string, error)) (*Config,
NodeMapSessionBufferedChanSize: src.Int(
"tuning.node_mapsession_buffered_chan_size",
),
BatcherWorkers: func() int {
if workers := src.Int("tuning.batcher_workers"); workers > 0 {
return workers
}
return DefaultBatcherWorkers()
}(),
BatcherWorkers: src.Int("tuning.batcher_workers"),
RegisterCacheExpiration: src.Duration("tuning.register_cache_expiration"),
RegisterCacheMaxEntries: src.Int("tuning.register_cache_max_entries"),
NodeStoreBatchSize: src.Int("tuning.node_store_batch_size"),
@@ -1843,23 +1926,35 @@ func isSafeServerURL(serverURL, baseDomain string) error {
return nil
}
// tailcfgDNSMu guards concurrent access to the mutable ExtraRecords of
// [Config.TailcfgDNSConfig] between the extra-records file watcher (writer)
// and the per-client map builds that clone it (readers). It is a package-level
// lock so [Config] stays freely copyable during construction.
var tailcfgDNSMu sync.RWMutex
// StartDNS builds the DNS config clients get, from here on changed only by
// [Config.SetExtraRecords], and keeps provider for [Config.DNSProvider].
// Call it before the config is shared.
func (c *Config) StartDNS(provider hsdns.Provider) {
c.dns = &liveDNS{dns: c.TailcfgDNSConfig(), provider: provider}
}
// CloneTailcfgDNSConfig returns a deep copy of [Config.TailcfgDNSConfig], or
// nil if none is set. Safe for concurrent use with [Config.SetExtraRecords].
func (c *Config) CloneTailcfgDNSConfig() *tailcfg.DNSConfig {
tailcfgDNSMu.RLock()
defer tailcfgDNSMu.RUnlock()
if c.TailcfgDNSConfig == nil {
return nil
// DNSProvider returns the provider [Config.StartDNS] was given, else the
// Go-only DNSChallenge.Provider.
func (c *Config) DNSProvider() hsdns.Provider {
if c.dns != nil {
return c.dns.provider
}
return c.TailcfgDNSConfig.Clone()
return c.DNSChallenge.Provider
}
// CloneTailcfgDNSConfig returns a deep copy of the started DNS config, or a
// fresh [Config.TailcfgDNSConfig] before [Config.StartDNS]. Safe for
// concurrent use with [Config.SetExtraRecords].
func (c *Config) CloneTailcfgDNSConfig() *tailcfg.DNSConfig {
if c.dns == nil {
return c.TailcfgDNSConfig()
}
c.dns.mu.RLock()
defer c.dns.mu.RUnlock()
return c.dns.dns.Clone()
}
// HasExtraRecord reports whether an extra DNS record is exactly name,
@@ -1873,14 +1968,15 @@ func (c *Config) HasExtraRecord(name string) bool {
// a subdomain of it. Case is ignored, as in TLS name matching; name is
// lowercase.
func (c *Config) extraRecordAt(name string, orBelow bool) bool {
tailcfgDNSMu.RLock()
defer tailcfgDNSMu.RUnlock()
records := c.DNSConfig.ExtraRecords
if c.dns != nil {
c.dns.mu.RLock()
defer c.dns.mu.RUnlock()
if c.TailcfgDNSConfig == nil {
return false
records = c.dns.dns.ExtraRecords
}
for _, r := range c.TailcfgDNSConfig.ExtraRecords {
for _, r := range records {
rn := strings.ToLower(strings.TrimSuffix(r.Name, "."))
if rn == name || (orBelow && strings.HasSuffix(rn, "."+name)) {
return true
@@ -1901,15 +1997,18 @@ func (c *Config) TailcfgDebug() *tailcfg.Debug {
return &tailcfg.Debug{DisableLogTail: true}
}
// SetExtraRecords replaces the ExtraRecords of [Config.TailcfgDNSConfig]. Safe
// for concurrent use with [Config.CloneTailcfgDNSConfig].
// SetExtraRecords replaces the extra records of the started DNS config; it
// does nothing before [Config.StartDNS]. Safe for concurrent use with
// [Config.CloneTailcfgDNSConfig].
func (c *Config) SetExtraRecords(records []tailcfg.DNSRecord) {
tailcfgDNSMu.Lock()
defer tailcfgDNSMu.Unlock()
if c.TailcfgDNSConfig != nil {
c.TailcfgDNSConfig.ExtraRecords = lowercaseRecordNames(records)
if c.dns == nil {
return
}
c.dns.mu.Lock()
defer c.dns.mu.Unlock()
c.dns.dns.ExtraRecords = lowercaseRecordNames(records)
}
// lowercaseRecordNames normalizes DNS record names to lowercase, as DNS names
+40 -4
View File
@@ -22,7 +22,10 @@ import (
"github.com/tailscale/hujson"
)
const configEnvPrefix = "HEADSCALE_"
const (
configEnvPrefix = "HEADSCALE_"
providerKey = "dns.challenge.provider"
)
// configFileNames is the per-directory search order. TOML and .env are not
// read, but still found, so an old file is rejected by name, not skipped.
@@ -586,7 +589,9 @@ func (s *configSource) loadEnv(environ []string) error {
// into it. The value stays a raw string, which the cast accessors parse as
// JSON, unless the JSON object held a removed form, dropped here, or a
// per-field variable (HEADSCALE_DNS_CHALLENGE_PROVIDER_NAME) has to be
// layered on top: then the parsed object is set.
// layered on top: then the parsed object is set. The provider's is always
// parsed, as its name is looked up inside it; one that does not decode is
// no provider.
for _, key := range slices.Sorted(maps.Keys(openLayer)) {
val := openLayer[key]
s.k.Delete(key)
@@ -611,8 +616,12 @@ func (s *configSource) loadEnv(environ []string) error {
})
var v any = val
if decoded && (dropped || shared) {
switch {
case decoded && (dropped || shared || key == providerKey):
v = parsed
case key == providerKey:
continue
}
err := s.k.Set(key, v)
@@ -621,7 +630,34 @@ func (s *configSource) loadEnv(environ []string) error {
}
}
return s.k.Load(confmap.Provider(layer, "."), nil)
err := s.k.Load(confmap.Provider(layer, "."), nil)
if err != nil {
return err
}
return s.foldProviderEnv(env)
}
// foldProviderEnv sets each HEADSCALE_DNS_CHALLENGE_PROVIDER_<SETTING> of
// the provider named once the rest is loaded. Settings depend on the
// provider, so configKeys cannot list them; a variable no setting of it has
// is ignored, as the prefix is reserved.
func (s *configSource) foldProviderEnv(env map[string]string) error {
settings := cast.ToStringMap(s.k.Get(providerKey))
folded := false
for _, setting := range hsdns.SettingNames(cast.ToString(settings["name"])) {
if v := env[configEnvName(providerKey+"."+setting)]; v != "" {
settings[setting] = v
folded = true
}
}
if !folded {
return nil
}
return s.k.Set(providerKey, settings)
}
func reservedEnv(name string) bool {
+101
View File
@@ -597,3 +597,104 @@ func TestConfigSourceProviderEnv(t *testing.T) {
assert.Equal(t, "x", got["api_token"])
assert.NotContains(t, got, "other")
}
// TestProviderEnvFold pins that HEADSCALE_DNS_CHALLENGE_PROVIDER_<SETTING>
// reaches the settings of the provider named anywhere, and that a variable
// no provider setting has is ignored without a word.
func TestProviderEnvFold(t *testing.T) {
base := `---
server_url: https://headscale.example.com
noise:
private_key_path: noise_private.key
prefixes:
v4: 100.64.0.0/10
database:
type: sqlite
dns:
magic_dns: true
override_local_dns: false
base_domain: ts.example.com
`
tests := []struct {
name string
yaml string
env map[string]string
want map[string]any
}{
{
name: "named in the file",
yaml: base + " challenge:\n provider:\n name: cloudflare\n",
env: map[string]string{"HEADSCALE_DNS_CHALLENGE_PROVIDER_API_TOKEN": "x"},
want: map[string]any{"name": "cloudflare", "api_token": "x"},
},
{
name: "named by its variable",
yaml: base,
env: map[string]string{
"HEADSCALE_DNS_CHALLENGE_PROVIDER_NAME": "cloudflare",
"HEADSCALE_DNS_CHALLENGE_PROVIDER_API_TOKEN": "x",
},
want: map[string]any{"name": "cloudflare", "api_token": "x"},
},
{
name: "named in the json variable",
yaml: base,
env: map[string]string{"HEADSCALE_DNS_CHALLENGE_PROVIDER": `{"name":"cloudflare","api_token":"json"}`},
want: map[string]any{"name": "cloudflare", "api_token": "json"},
},
{
name: "setting variable beats the json variable",
yaml: base,
env: map[string]string{
"HEADSCALE_DNS_CHALLENGE_PROVIDER": `{"name":"cloudflare","api_token":"json"}`,
"HEADSCALE_DNS_CHALLENGE_PROVIDER_API_TOKEN": "env",
},
want: map[string]any{"name": "cloudflare", "api_token": "env"},
},
{
name: "name variable beats the json variable",
yaml: base + " challenge:\n provider:\n name: powerdns\n",
env: map[string]string{
"HEADSCALE_DNS_CHALLENGE_PROVIDER": `{"name":"rfc2136","api_token":"json"}`,
"HEADSCALE_DNS_CHALLENGE_PROVIDER_NAME": "cloudflare",
},
want: map[string]any{"name": "cloudflare", "api_token": "json"},
},
{
name: "variable for no setting of the provider",
yaml: base + " challenge:\n provider:\n name: cloudflare\n api_token: tok\n",
env: map[string]string{"HEADSCALE_DNS_CHALLENGE_PROVIDER_BOGUS": "1"},
want: map[string]any{"name": "cloudflare", "api_token": "tok"},
},
{
name: "setting variable without a provider",
yaml: base,
env: map[string]string{"HEADSCALE_DNS_CHALLENGE_PROVIDER_API_TOKEN": "x"},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
for k, v := range tt.env {
t.Setenv(k, v)
}
dir := t.TempDir()
require.NoError(t, os.WriteFile(filepath.Join(dir, "config.yaml"), []byte(tt.yaml), 0o600))
require.NoError(t, LoadConfig(dir, false))
assert.Empty(t, src.Warnings())
cfg, err := CheckServerConfig()
require.NoError(t, err)
if len(tt.want) == 0 {
assert.Empty(t, cfg.DNSChallenge.ProviderSettings)
return
}
assert.Equal(t, tt.want, cfg.DNSChallenge.ProviderSettings)
})
}
}
+603 -22
View File
@@ -16,6 +16,7 @@ import (
"strconv"
"strings"
"testing"
"time"
"github.com/google/go-cmp/cmp"
"github.com/google/go-cmp/cmp/cmpopts"
@@ -74,7 +75,6 @@ func TestReadConfig(t *testing.T) {
{Name: "prometheus.myvpn.example.com", Type: "A", Value: "100.64.0.4"},
},
SearchDomains: []string{"test.com", "bar.com"},
Certificates: CertificatesConfig{Zone: "example.com"},
},
},
{
@@ -141,7 +141,6 @@ func TestReadConfig(t *testing.T) {
{Name: "prometheus.myvpn.example.com", Type: "A", Value: "100.64.0.4"},
},
SearchDomains: []string{"test.com", "bar.com"},
Certificates: CertificatesConfig{Zone: "example.com"},
},
},
{
@@ -340,7 +339,6 @@ func TestReadConfigFromEnv(t *testing.T) {
// {Name: "prometheus.myvpn.example.com", Type: "A", Value: "100.64.0.4"},
// },
SearchDomains: []string{"test.com", "bar.com"},
Certificates: CertificatesConfig{Zone: "example.com"},
},
},
}
@@ -1273,8 +1271,8 @@ func TestConfigJSONOmitsSecrets(t *testing.T) {
APIKey: secretAPIKey,
},
DNSChallenge: DNSChallengeConfig{
ProviderName: "cloudflare",
Provider: &cloudflare.Provider{APIToken: secretDNSToken},
ProviderSettings: map[string]any{"name": "cloudflare", "api_token": secretDNSToken},
Provider: &cloudflare.Provider{APIToken: secretDNSToken},
},
}
@@ -1400,14 +1398,212 @@ func TestExtraRecordsAreLowercased(t *testing.T) {
t.Errorf("dnsToTailcfgDNS extra records mismatch (-want +got):\n%s", diff)
}
cfg := &Config{TailcfgDNSConfig: &tailcfg.DNSConfig{}}
cfg := &Config{}
cfg.StartDNS(nil)
cfg.SetExtraRecords(mixed)
if diff := cmp.Diff(want, cfg.TailcfgDNSConfig.ExtraRecords); diff != "" {
if diff := cmp.Diff(want, cfg.CloneTailcfgDNSConfig().ExtraRecords); diff != "" {
t.Errorf("SetExtraRecords mismatch (-want +got):\n%s", diff)
}
}
func TestTailcfgDNSConfig(t *testing.T) {
cgnat := netip.MustParsePrefix("100.64.0.0/10")
ten := netip.MustParsePrefix("10.0.0.0/8")
ula := netip.MustParsePrefix("fd7a:115c:a1e0::/48")
fd00 := netip.MustParsePrefix("fd00::/48")
tests := []struct {
name string
cfg Config
want *tailcfg.DNSConfig
}{
{
name: "empty",
want: &tailcfg.DNSConfig{Routes: map[string][]*dnstype.Resolver{}},
},
{
name: "magic dns with base domain",
cfg: Config{DNSConfig: DNSConfig{MagicDNS: true, BaseDomain: "example.com", SearchDomains: []string{"corp.com"}}},
want: &tailcfg.DNSConfig{
Proxied: true,
Domains: []string{"example.com", "corp.com"},
Routes: map[string][]*dnstype.Resolver{},
},
},
{
name: "override local dns",
cfg: Config{DNSConfig: DNSConfig{OverrideLocalDNS: true, Nameservers: Nameservers{Global: []string{"1.1.1.1"}}}},
want: &tailcfg.DNSConfig{
Resolvers: []*dnstype.Resolver{{Addr: "1.1.1.1"}},
Routes: map[string][]*dnstype.Resolver{},
},
},
{
name: "fallback resolvers",
cfg: Config{DNSConfig: DNSConfig{Nameservers: Nameservers{Global: []string{"1.1.1.1"}}}},
want: &tailcfg.DNSConfig{
FallbackResolvers: []*dnstype.Resolver{{Addr: "1.1.1.1"}},
Routes: map[string][]*dnstype.Resolver{},
},
},
{
name: "split dns",
cfg: Config{DNSConfig: DNSConfig{Nameservers: Nameservers{Split: map[string][]string{"corp.com": {"10.0.0.1"}}}}},
want: &tailcfg.DNSConfig{
Routes: map[string][]*dnstype.Resolver{"corp.com": {{Addr: "10.0.0.1"}}},
},
},
{
name: "magic dns reverse routes outside cgnat",
cfg: Config{
PrefixV4: &ten,
DNSConfig: DNSConfig{MagicDNS: true, BaseDomain: "example.com"},
},
want: &tailcfg.DNSConfig{
Proxied: true,
Domains: []string{"example.com"},
Routes: map[string][]*dnstype.Resolver{"10.in-addr.arpa": {}},
},
},
{
name: "magic dns reverse routes outside ula",
cfg: Config{
PrefixV6: &fd00,
DNSConfig: DNSConfig{MagicDNS: true, BaseDomain: "example.com"},
},
want: &tailcfg.DNSConfig{
Proxied: true,
Domains: []string{"example.com"},
Routes: map[string][]*dnstype.Resolver{"0.0.0.0.0.0.0.0.0.0.d.f.ip6.arpa": {}},
},
},
{
name: "magic dns inside cgnat and ula",
cfg: Config{
PrefixV4: &cgnat,
PrefixV6: &ula,
DNSConfig: DNSConfig{MagicDNS: true, BaseDomain: "example.com"},
},
want: &tailcfg.DNSConfig{
Proxied: true,
Domains: []string{"example.com"},
Routes: map[string][]*dnstype.Resolver{},
},
},
{
name: "no reverse routes without magic dns",
cfg: Config{PrefixV4: &ten},
want: &tailcfg.DNSConfig{Routes: map[string][]*dnstype.Resolver{}},
},
{
name: "extra record names lowercased",
cfg: Config{DNSConfig: DNSConfig{ExtraRecords: []tailcfg.DNSRecord{
{Name: "Grafana.Example.com", Type: "A", Value: "100.64.0.3"},
}}},
want: &tailcfg.DNSConfig{
Routes: map[string][]*dnstype.Resolver{},
ExtraRecords: []tailcfg.DNSRecord{{Name: "grafana.example.com", Type: "A", Value: "100.64.0.3"}},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// No EquateEmpty: a reverse route must be an empty, non-nil slice.
if diff := cmp.Diff(tt.want, tt.cfg.TailcfgDNSConfig()); diff != "" {
t.Errorf("TailcfgDNSConfig() mismatch (-want +got):\n%s", diff)
}
})
}
}
func TestLiveDNS(t *testing.T) {
goOnly := &cloudflare.Provider{APIToken: "go-only"}
cfg := &Config{
DNSConfig: DNSConfig{
MagicDNS: true,
BaseDomain: "example.com",
ExtraRecords: []tailcfg.DNSRecord{{Name: "Old.example.com", Type: "A", Value: "100.64.0.1"}},
},
DNSChallenge: DNSChallengeConfig{Provider: goOnly},
}
assert.Equal(t, cfg.TailcfgDNSConfig(), cfg.CloneTailcfgDNSConfig())
assert.Same(t, goOnly, cfg.DNSProvider())
assert.True(t, cfg.HasExtraRecord("old.example.com."))
// Nothing holds the records before StartDNS.
cfg.SetExtraRecords([]tailcfg.DNSRecord{{Name: "early.example.com", Type: "A", Value: "100.64.0.9"}})
assert.False(t, cfg.HasExtraRecord("early.example.com"))
assert.Equal(t, cfg.DNSConfig.ExtraRecords[0].Value, cfg.CloneTailcfgDNSConfig().ExtraRecords[0].Value)
started := &cloudflare.Provider{APIToken: "started"}
cfg.StartDNS(started)
cfg.SetExtraRecords([]tailcfg.DNSRecord{{Name: "A.Example.com", Type: "A", Value: "100.64.0.2"}})
clone := cfg.CloneTailcfgDNSConfig()
assert.Equal(t, []tailcfg.DNSRecord{{Name: "a.example.com", Type: "A", Value: "100.64.0.2"}}, clone.ExtraRecords)
assert.True(t, cfg.HasExtraRecord("A.Example.com."))
assert.False(t, cfg.HasExtraRecord("old.example.com"))
assert.Same(t, started, cfg.DNSProvider())
clone.ExtraRecords = nil
assert.Len(t, cfg.CloneTailcfgDNSConfig().ExtraRecords, 1, "a clone is a copy")
}
// TestNameserverWarnings pins that the config check reports a nameserver
// clients will not get, and that building the DNS config does not report it
// again.
func TestNameserverWarnings(t *testing.T) {
yaml := `---
server_url: https://headscale.example.com
noise:
private_key_path: noise_private.key
prefixes:
v4: 100.64.0.0/10
database:
type: sqlite
dns:
magic_dns: true
base_domain: ts.example.com
override_local_dns: true
nameservers:
global: ["1.1.1.1", "1.1.1.1:53"]
split:
corp.example.com: ["[2606:4700::1111]:53"]
`
dir := t.TempDir()
require.NoError(t, os.WriteFile(filepath.Join(dir, "config.yaml"), []byte(yaml), 0o600))
require.NoError(t, LoadConfig(dir, false))
var buf bytes.Buffer
oldLogger, oldLevel := log.Logger, zerolog.GlobalLevel()
log.Logger = zerolog.New(&buf)
t.Cleanup(func() {
log.Logger = oldLogger
zerolog.SetGlobalLevel(oldLevel)
})
cfg, err := CheckServerConfig()
require.NoError(t, err)
logged := buf.String()
assert.Contains(t, logged, `invalid nameserver \"1.1.1.1:53\" in dns.nameservers.global, ignoring`)
assert.Contains(t, logged, `invalid nameserver \"[2606:4700::1111]:53\" in dns.nameservers.split.corp.example.com, ignoring`)
assert.NotContains(t, logged, `\"1.1.1.1\" in`)
buf.Reset()
cfg.StartDNS(nil)
assert.Equal(t, []*dnstype.Resolver{{Addr: "1.1.1.1"}}, cfg.CloneTailcfgDNSConfig().Resolvers)
assert.Empty(t, buf.String(), "built once, reported once: by the load")
}
func TestDNSChallengeConfig(t *testing.T) {
secret := filepath.Join(t.TempDir(), "token")
require.NoError(t, os.WriteFile(secret, []byte("file-token\n"), 0o600))
@@ -1443,7 +1639,7 @@ dns:
{
name: "disabled by default",
yaml: base,
// Zone follows base_domain even when unused, so it is never empty.
// CertificateZone follows base_domain even when unused, so it is never empty.
wantZone: "ts.example.com",
wantNoProv: true,
wantResolvers: []string{"1.1.1.1:53", "8.8.8.8:53"},
@@ -1877,25 +2073,31 @@ tls:
}
require.NoError(t, err)
assert.Equal(t, tt.wantZone, cfg.DNSConfig.Certificates.Zone)
assert.Equal(t, tt.wantZone, cfg.DNSConfig.CertificateZone())
if tt.wantResolvers != nil {
assert.Equal(t, tt.wantResolvers, cfg.DNSChallenge.Resolvers)
assert.Equal(t, tt.wantResolvers, cfg.DNSChallenge.ResolverAddrs())
}
// The loader only validates the provider; startup builds it.
assert.Nil(t, cfg.DNSChallenge.Provider)
if tt.wantNoProv {
assert.Nil(t, cfg.DNSChallenge.Provider)
assert.Empty(t, cfg.DNSChallenge.ProviderName())
return
}
built, err := cfg.DNSChallenge.NewProvider(ResolveSecret)
require.NoError(t, err)
if tt.wantProvider != "" {
assert.Equal(t, tt.wantProvider, fmt.Sprintf("%T", cfg.DNSChallenge.Provider))
assert.Equal(t, tt.wantProvider, fmt.Sprintf("%T", built))
return
}
if iso, ok := cfg.DNSChallenge.Provider.(hsdns.Isolator); ok {
if iso, ok := built.(hsdns.Isolator); ok {
if tt.wantIsolates != "" {
assert.True(t, iso.Isolates(tt.wantIsolates))
}
@@ -1903,8 +2105,8 @@ tls:
return
}
provider, ok := cfg.DNSChallenge.Provider.(*cloudflare.Provider)
require.True(t, ok, "provider is %T", cfg.DNSChallenge.Provider)
provider, ok := built.(*cloudflare.Provider)
require.True(t, ok, "provider is %T", built)
assert.Equal(t, tt.wantToken, provider.APIToken)
})
}
@@ -2455,6 +2657,328 @@ func TestConfigCompat(t *testing.T) {
}
}
// compatConfig is the JSON shape of Config the goldens were written in,
// frozen so Config can change without a golden diff; compatView renders
// into it.
type compatConfig struct {
ServerURL string
Addr string
MetricsAddr string
TrustedProxies []netip.Prefix
Node compatNodeConfig
PreAuthKeys compatPreAuthKeysConfig
PrefixV4 *netip.Prefix
PrefixV6 *netip.Prefix
IPAllocation string
NoisePrivateKeyPath string
BaseDomain string
Log compatLogConfig
DisableUpdateCheck bool
Database compatDatabaseConfig
DERP compatDERPConfig
TLS compatTLSConfig
DNSConfig compatDNSConfig
TailcfgDNSConfig *tailcfg.DNSConfig
DNSChallenge compatDNSChallengeConfig
UnixSocket string
UnixSocketPermission fs.FileMode
OIDC compatOIDCConfig
LogTail compatLogTailConfig
Taildrop compatTaildropConfig
AutoUpdate compatAutoUpdateConfig
CLI compatCLIConfig
Policy compatPolicyConfig
Tuning compatTuning
}
type compatNodeConfig struct {
Expiry time.Duration
Ephemeral compatEphemeralConfig
Routes compatRouteConfig
}
type compatEphemeralConfig struct{ InactivityTimeout time.Duration }
type compatRouteConfig struct{ HA compatHARouteConfig }
type compatHARouteConfig struct{ ProbeInterval, ProbeTimeout time.Duration }
type compatPreAuthKeysConfig struct{ RevokedRetention time.Duration }
type compatLogConfig struct {
Format string
Level zerolog.Level
}
type compatDatabaseConfig struct {
Type string
Debug bool
Gorm compatGormConfig
Sqlite compatSqliteConfig
Postgres compatPostgresConfig
}
type compatGormConfig struct {
Debug bool
SlowThreshold time.Duration
SkipErrRecordNotFound bool
ParameterizedQueries bool
}
type compatSqliteConfig struct {
Path string
WriteAheadLog bool
WALAutoCheckPoint int
}
type compatPostgresConfig struct {
Host string
Port int
Name string
User string
Ssl string
MaxOpenConnections int
MaxIdleConnections int
ConnMaxIdleTimeSecs int
}
type compatDERPConfig struct {
ServerEnabled bool
AutomaticallyAddEmbeddedDerpRegion bool
ServerRegionID tailcfg.DERPRegionID
ServerRegionCode string
ServerRegionName string
ServerPrivateKeyPath string
ServerVerifyClients bool
STUNAddr string
URLs []url.URL
Paths []string
DERPMap *tailcfg.DERPMap
AutoUpdate bool
UpdateFrequency time.Duration
IPv4 string
IPv6 string
}
type compatTLSConfig struct {
CertPath string
KeyPath string
ACME compatACMEConfig
}
type compatACMEConfig struct {
Hostname string
ChallengeType string
HTTPListen string
URL string
Email string
CacheDir string
}
type compatDNSConfig struct {
MagicDNS bool
BaseDomain string
OverrideLocalDNS bool
Nameservers compatNameservers
SearchDomains []string
ExtraRecords []tailcfg.DNSRecord
ExtraRecordsPath string
Certificates compatCertificatesConfig
}
type compatNameservers struct {
Global []string
Split map[string][]string
}
type compatCertificatesConfig struct {
Enabled bool
Zone string
}
type compatDNSChallengeConfig struct {
PropagationTimeout time.Duration
Resolvers []string
ProviderName string
}
type compatOIDCConfig struct {
OnlyStartIfOIDCIsAvailable bool
Issuer string
ClientID string
Scope []string
ExtraParams map[string]string
AllowedDomains []string
AllowedUsers []string
AllowedGroups []string
EmailVerifiedRequired bool
UseExpiryFromToken bool
PKCE compatPKCEConfig
}
type compatPKCEConfig struct {
Enabled bool
Method string
}
type compatLogTailConfig struct{ Enabled bool }
type compatTaildropConfig struct{ Enabled bool }
type compatAutoUpdateConfig struct{ Enabled bool }
type compatCLIConfig struct {
Address string
Timeout time.Duration
Insecure bool
}
type compatPolicyConfig struct {
Path string
Mode string
}
type compatTuning struct {
NotifierSendTimeout time.Duration
BatchChangeDelay time.Duration
NodeMapSessionBufferedChanSize int
BatcherWorkers int
RegisterCacheExpiration time.Duration
RegisterCacheMaxEntries int
NodeStoreBatchSize int
NodeStoreBatchTimeout time.Duration
}
// compatView renders cfg in the golden shape, deriving the values the
// loader used to store resolved.
func compatView(cfg *Config) compatConfig {
pg := cfg.Database.Postgres
oidc := cfg.OIDC
ch := cfg.DNSChallenge
acme := cfg.TLS.ACME
dbType := cfg.Database.Type
if cfg.Database.IsSQLite() {
dbType = DatabaseSqlite
}
tuning := compatTuning(cfg.Tuning)
tuning.BatcherWorkers = cfg.Tuning.BatcherWorkerCount()
return compatConfig{
ServerURL: cfg.ServerURL,
Addr: cfg.Addr,
MetricsAddr: cfg.MetricsAddr,
TrustedProxies: cfg.TrustedProxies,
Node: compatNodeConfig{
Expiry: cfg.Node.Expiry,
Ephemeral: compatEphemeralConfig(cfg.Node.Ephemeral),
Routes: compatRouteConfig{HA: compatHARouteConfig(cfg.Node.Routes.HA)},
},
PreAuthKeys: compatPreAuthKeysConfig(cfg.PreAuthKeys),
PrefixV4: cfg.PrefixV4,
PrefixV6: cfg.PrefixV6,
IPAllocation: string(cfg.IPAllocation),
NoisePrivateKeyPath: cfg.AbsPath(cfg.NoisePrivateKeyPath),
BaseDomain: cfg.BaseDomain,
Log: compatLogConfig(cfg.Log),
DisableUpdateCheck: cfg.DisableUpdateCheck,
Database: compatDatabaseConfig{
Type: dbType,
Debug: cfg.Database.Debug,
Gorm: compatGormConfig(cfg.Database.Gorm),
Sqlite: compatSqliteConfig{
Path: cfg.SQLitePath(),
WriteAheadLog: cfg.Database.Sqlite.WriteAheadLog,
WALAutoCheckPoint: cfg.Database.Sqlite.WALAutoCheckPoint,
},
Postgres: compatPostgresConfig{
Host: pg.Host,
Port: pg.Port,
Name: pg.Name,
User: pg.User,
Ssl: pg.Ssl,
MaxOpenConnections: pg.MaxOpenConnections,
MaxIdleConnections: pg.MaxIdleConnections,
ConnMaxIdleTimeSecs: pg.ConnMaxIdleTimeSecs,
},
},
DERP: compatDERPConfig{
ServerEnabled: cfg.DERP.ServerEnabled,
AutomaticallyAddEmbeddedDerpRegion: cfg.DERP.AutomaticallyAddEmbeddedDerpRegion,
ServerRegionID: cfg.DERP.ServerRegionID,
ServerRegionCode: cfg.DERP.ServerRegionCode,
ServerRegionName: cfg.DERP.ServerRegionName,
ServerPrivateKeyPath: cfg.AbsPath(cfg.DERP.ServerPrivateKeyPath),
ServerVerifyClients: cfg.DERP.ServerVerifyClients,
STUNAddr: cfg.DERP.STUNAddr,
URLs: cfg.DERP.URLs,
Paths: cfg.DERP.Paths,
DERPMap: cfg.DERP.DERPMap,
AutoUpdate: cfg.DERP.AutoUpdate,
UpdateFrequency: cfg.DERP.UpdateFrequency,
IPv4: cfg.DERP.IPv4,
IPv6: cfg.DERP.IPv6,
},
TLS: compatTLSConfig{
CertPath: cfg.AbsPath(cfg.TLS.CertPath),
KeyPath: cfg.AbsPath(cfg.TLS.KeyPath),
ACME: compatACMEConfig{
Hostname: acme.Hostname,
ChallengeType: acme.ChallengeType,
HTTPListen: acme.HTTPListen,
URL: acme.URL,
Email: acme.Email,
CacheDir: cfg.AbsPath(acme.CacheDir),
},
},
DNSConfig: compatDNSConfig{
MagicDNS: cfg.DNSConfig.MagicDNS,
BaseDomain: cfg.DNSConfig.BaseDomain,
OverrideLocalDNS: cfg.DNSConfig.OverrideLocalDNS,
Nameservers: compatNameservers(cfg.DNSConfig.Nameservers),
SearchDomains: cfg.DNSConfig.SearchDomains,
ExtraRecords: cfg.DNSConfig.ExtraRecords,
ExtraRecordsPath: cfg.DNSConfig.ExtraRecordsPath,
Certificates: compatCertificatesConfig{
Enabled: cfg.DNSConfig.Certificates.Enabled,
Zone: cfg.DNSConfig.CertificateZone(),
},
},
TailcfgDNSConfig: cfg.TailcfgDNSConfig(),
DNSChallenge: compatDNSChallengeConfig{
PropagationTimeout: ch.PropagationTimeout,
Resolvers: ch.ResolverAddrs(),
ProviderName: ch.ProviderName(),
},
UnixSocket: cfg.UnixSocket,
UnixSocketPermission: cfg.UnixSocketPermission,
OIDC: compatOIDCConfig{
OnlyStartIfOIDCIsAvailable: oidc.OnlyStartIfOIDCIsAvailable,
Issuer: oidc.Issuer,
ClientID: oidc.ClientID,
Scope: oidc.Scope,
ExtraParams: oidc.ExtraParams,
AllowedDomains: oidc.AllowedDomains,
AllowedUsers: oidc.AllowedUsers,
AllowedGroups: oidc.AllowedGroups,
EmailVerifiedRequired: oidc.EmailVerifiedRequired,
UseExpiryFromToken: oidc.UseExpiryFromToken,
PKCE: compatPKCEConfig(oidc.PKCE),
},
LogTail: compatLogTailConfig(cfg.LogTail),
Taildrop: compatTaildropConfig(cfg.Taildrop),
AutoUpdate: compatAutoUpdateConfig(cfg.AutoUpdate),
CLI: compatCLIConfig{
Address: cfg.CLI.Address,
Timeout: cfg.CLI.Timeout,
Insecure: cfg.CLI.Insecure,
},
Policy: compatPolicyConfig{Path: cfg.Policy.Path, Mode: string(cfg.Policy.Mode)},
Tuning: tuning,
}
}
// loadCompat loads one fixture set the way headscale does, from a temp dir
// so relative paths and the error text do not depend on the checkout.
func loadCompat(t *testing.T, file, envFile string, cli bool) compatRecord {
@@ -2513,11 +3037,23 @@ func loadCompat(t *testing.T, file, envFile string, cli bool) compatRecord {
}
if cfg != nil {
if cfg.Tuning.BatcherWorkers == DefaultBatcherWorkers() {
cfg.Tuning.BatcherWorkers = 0 // depends on runtime.NumCPU
view := compatView(cfg)
if cli {
// The CLI loader sets only what client commands read; compatView
// would derive server values from the zero rest.
view = compatConfig{
Log: view.Log,
DisableUpdateCheck: view.DisableUpdateCheck,
UnixSocket: view.UnixSocket,
CLI: view.CLI,
}
}
raw, err := json.Marshal(cfg)
if view.Tuning.BatcherWorkers == DefaultBatcherWorkers() {
view.Tuning.BatcherWorkers = 0 // depends on runtime.NumCPU
}
raw, err := json.Marshal(view)
require.NoError(t, err)
rec.Config = json.RawMessage(norm(string(raw)))
@@ -2708,9 +3244,10 @@ dns:
cfg, err := LoadServerConfig()
require.NoError(t, err)
assert.Equal(t, filepath.Join(dir, "noise.key"), cfg.NoisePrivateKeyPath)
assert.Equal(t, "./noise.key", cfg.NoisePrivateKeyPath)
assert.Equal(t, filepath.Join(dir, "noise.key"), cfg.AbsPath(cfg.NoisePrivateKeyPath))
assert.Equal(t, "./policy.hujson", cfg.Policy.Path)
assert.Equal(t, filepath.Join(dir, "policy.hujson"), util.AbsolutePath(cfg.ConfigDir, cfg.Policy.Path))
assert.Equal(t, filepath.Join(dir, "policy.hujson"), cfg.AbsPath(cfg.Policy.Path))
}
// TestSQLiteMemoryPath: ":memory:" names SQLite's in-memory database, not a
@@ -2739,8 +3276,52 @@ func TestSQLiteMemoryPath(t *testing.T) {
cfg, err := LoadServerConfig()
require.NoError(t, err)
assert.Equal(t, ":memory:", cfg.Database.Sqlite.Path)
assert.True(t, filepath.IsAbs(cfg.NoisePrivateKeyPath), cfg.NoisePrivateKeyPath)
assert.Equal(t, ":memory:", cfg.SQLitePath())
assert.True(t, filepath.IsAbs(cfg.AbsPath(cfg.NoisePrivateKeyPath)), cfg.AbsPath(cfg.NoisePrivateKeyPath))
})
}
}
// TestDerivedValues pins the values computed from what the configuration
// says, which the loader stores as written.
func TestDerivedValues(t *testing.T) {
etc := &Config{ConfigDir: "/etc/hs"}
sqlite := func(path string) *Config {
return &Config{ConfigDir: "/etc/hs", Database: DatabaseConfig{Sqlite: SqliteConfig{Path: path}}}
}
resolvers := func(r ...string) DNSChallengeConfig { return DNSChallengeConfig{Resolvers: r} }
tests := []struct {
name string
got, want any
}{
{"relative path", etc.AbsPath("./noise.key"), "/etc/hs/noise.key"},
{"absolute path", etc.AbsPath("/var/lib/hs/noise.key"), "/var/lib/hs/noise.key"},
{"no config dir", (&Config{}).AbsPath("./noise.key"), "./noise.key"},
{"empty path", etc.AbsPath(""), ""},
{"sqlite relative", sqlite("db.sqlite").SQLitePath(), "/etc/hs/db.sqlite"},
{"sqlite memory", sqlite(":memory:").SQLitePath(), ":memory:"},
{"sqlite", DatabaseConfig{Type: "sqlite"}.IsSQLite(), true},
{"sqlite3", DatabaseConfig{Type: "sqlite3"}.IsSQLite(), true},
{"postgres", DatabaseConfig{Type: "postgres"}.IsSQLite(), false},
{"workers unset", Tuning{}.BatcherWorkerCount(), DefaultBatcherWorkers()},
{"workers set", Tuning{BatcherWorkers: 7}.BatcherWorkerCount(), 7},
{"zone unset", DNSConfig{BaseDomain: "ts.example.com"}.CertificateZone(), "ts.example.com"},
{"zone set", DNSConfig{BaseDomain: "ts.example.com", Certificates: CertificatesConfig{Zone: "example.com"}}.CertificateZone(), "example.com"},
{"resolvers unset", resolvers().ResolverAddrs(), []string{"1.1.1.1:53", "8.8.8.8:53"}},
{"resolver bare IPv4", resolvers("9.9.9.9").ResolverAddrs(), []string{"9.9.9.9:53"}},
{"resolver bare IPv6", resolvers("2620:fe::fe").ResolverAddrs(), []string{"[2620:fe::fe]:53"}},
{"resolver with port", resolvers("[::1]:5353").ResolverAddrs(), []string{"[::1]:5353"}},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
assert.Equal(t, tt.want, tt.got)
})
}
// Callers share the config, so deriving must not write to it.
written := []string{"9.9.9.9"}
resolvers(written...).ResolverAddrs()
assert.Equal(t, []string{"9.9.9.9"}, written)
}
+1 -1
View File
@@ -14,7 +14,7 @@ func TestDerpConfigSkipsMalformedURL(t *testing.T) {
"://bad",
}})
cfg := derpConfig("")
cfg := derpConfig()
if len(cfg.URLs) != 1 {
t.Fatalf("expected the malformed derp.urls entry to be skipped, got %d urls: %v",
+1 -1
View File
@@ -944,7 +944,7 @@ func (nv NodeView) CertDomain(cfg *Config) (string, bool) {
// A node may publish only its own name's challenge, which keeps it from
// other names' certificates only where the provider answers each name's
// challenge apart.
if iso, ok := cfg.DNSChallenge.Provider.(hsdns.Isolator); ok && !iso.Isolates(domain) {
if iso, ok := cfg.DNSProvider().(hsdns.Isolator); ok && !iso.Isolates(domain) {
return "", false
}
+2 -2
View File
@@ -11,11 +11,11 @@ import (
var errSecretEmpty = errors.New("file is empty")
// resolveSecret returns value, or the trimmed contents of the file named
// ResolveSecret returns value, or the trimmed contents of the file named
// by "file:<path>" (Tailscale's form), which keeps the secret out of the
// config and the environment. Variables in the path are expanded so a
// systemd credential can be named by ${CREDENTIALS_DIRECTORY}.
func resolveSecret(key, value string) (string, error) {
func ResolveSecret(key, value string) (string, error) {
path, ok := strings.CutPrefix(value, "file:")
if !ok {
return value, nil
+1 -1
View File
@@ -31,7 +31,7 @@ func TestResolveSecret(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := resolveSecret("oidc.client_secret", tt.value)
got, err := ResolveSecret("oidc.client_secret", tt.value)
if tt.wantErr != "" {
require.ErrorContains(t, err, tt.wantErr)
require.ErrorContains(t, err, "oidc.client_secret: ")