mirror of
https://github.com/juanfont/headscale.git
synced 2026-11-19 11:57:07 +09:00
1 parent
c27285f224
commit
565aaf7e49
33 files changed
+1251
-387
No files matched your search
@@ -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)
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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
@@ -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")
|
||||
|
||||
|
||||
@@ -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)
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -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
@@ -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
|
||||
}
|
||||
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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)
|
||||
|
||||
|
||||
@@ -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...)
|
||||
}
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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(
|
||||
|
||||
@@ -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:") {
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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",
|
||||
|
||||
@@ -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)
|
||||
|
||||
|
||||
@@ -106,9 +106,6 @@ func generateDNSConfig(
|
||||
capMap tailcfg.NodeCapMap,
|
||||
) *tailcfg.DNSConfig {
|
||||
dnsConfig := cfg.CloneTailcfgDNSConfig()
|
||||
if dnsConfig == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
profile := nextDNSProfileFromCapMap(capMap)
|
||||
if profile != "" {
|
||||
|
||||
@@ -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")
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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())
|
||||
|
||||
@@ -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() })
|
||||
|
||||
@@ -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)
|
||||
|
||||
|
||||
@@ -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
@@ -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
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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
@@ -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)
|
||||
}
|
||||
@@ -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",
|
||||
|
||||
@@ -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
|
||||
}
|
||||
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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: ")
|
||||
|
||||
Reference in new issue
Block a user