Compare commits
2
Commits
2c19a2ca35
...
e143ffbca8
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
e143ffbca8 | ||
|
|
b43402a631 |
No files matched your search
@@ -73,9 +73,13 @@ notification endpoint set, changes show only on the dashboard; see
|
||||
to discover all authoritative nameservers (NS records) for each domain.
|
||||
- Queries **every** discovered authoritative nameserver independently.
|
||||
- Stores the domain's NS record set, as its parent zone's servers delegate it,
|
||||
and the IPv4 and IPv6 addresses each nameserver's name resolves to.
|
||||
and the IPv4 and IPv6 addresses each nameserver's name resolves to. The set is
|
||||
only ever the domain's own delegation: a domain that its parent zone's servers
|
||||
answer does not exist, or has no delegation, has no nameservers. When they do
|
||||
not answer, the check fails and the set from the previous check is kept.
|
||||
- Any change triggers a notification:
|
||||
- NS added to or removed from that set.
|
||||
- NS added to or removed from that set. A domain that had nameservers on the
|
||||
previous check and no longer exists gets one with all of them removed.
|
||||
- NS address change: a nameserver that stays in the set resolves to
|
||||
different addresses than on the previous check. A nameserver added or
|
||||
removed gets only the NS change notification. When the lookup of a
|
||||
@@ -86,7 +90,9 @@ notification endpoint set, changes show only on the dashboard; see
|
||||
records, stored per nameserver. Their changes are notified as a hostname's
|
||||
are, as a record change, NS query failure, NS recovery, inconsistency or CNAME
|
||||
address change, in a message that starts `Domain:` where a hostname's starts
|
||||
`Hostname:`.
|
||||
`Hostname:`. A domain with no nameservers of its own has these records asked
|
||||
at the servers of the zone it is in, as a hostname has: for a `.com` domain
|
||||
that does not exist, the `.com` servers, which answer that it does not exist.
|
||||
|
||||
### DNS Hostname Monitoring (Subdomains)
|
||||
|
||||
@@ -94,7 +100,10 @@ notification endpoint set, changes show only on the dashboard; see
|
||||
via the Public Suffix List).
|
||||
- Every **1 hour** by default, performs a full iterative trace to discover the
|
||||
authoritative nameservers of the zone the hostname is in, which is not always
|
||||
its last two labels (a name under `co.uk`, or in a delegated subdomain).
|
||||
its last two labels (a name under `co.uk`, or in a delegated subdomain). The
|
||||
trace moves from a name to its parent only when the servers asked answer that
|
||||
the name has no delegation of its own. When they do not answer, the check
|
||||
fails and the hostname's records from the previous check are kept.
|
||||
- Queries **each** authoritative nameserver independently for **all** record
|
||||
types: A, AAAA, CNAME, MX, TXT, SRV, CAA, NS.
|
||||
- Stores results **per nameserver**. The state for a hostname is not a merged
|
||||
@@ -239,7 +248,8 @@ dnswatcher includes an unauthenticated, read-only web dashboard at the root URL
|
||||
per nameserver and status, shown as a hostname's are.
|
||||
- **Hostnames** with per-nameserver DNS records and status. For a nameserver
|
||||
whose query failed, the reason is shown in place of the records.
|
||||
- **Ports** with open/closed state and associated hostnames.
|
||||
- **Ports** with open/closed state and the domains and hostnames that resolve to
|
||||
each address, in separate columns.
|
||||
- **TLS certificates** with CN, issuer, expiry, and status. For a failed check,
|
||||
the reason is shown in place of CN, issuer and expiry.
|
||||
- **Recent alerts** (last 100 notifications sent since the process started),
|
||||
@@ -272,7 +282,9 @@ In `/api/v1/status`, each nameserver entry and certificate entry whose `status`
|
||||
is `error` also has `error`, the reason, as in the state file (see State File
|
||||
Format). A domain's own records are in its entry in `domains`, under
|
||||
`recordsByNameserver`, in the form a hostname's entry in `hostnames` has them
|
||||
under `nameservers`; `hostnames` and `counts.hostnames` hold no domain.
|
||||
under `nameservers`; `hostnames` and `counts.hostnames` hold no domain. A port
|
||||
entry lists the domains that resolve to its address in `domains`, and the
|
||||
hostnames in `hostnames`.
|
||||
|
||||
`/metrics` is served only when `DNSWATCHER_METRICS_USERNAME` is set, behind
|
||||
Basic Auth. It has the Prometheus Go client's default metrics only (Go runtime,
|
||||
@@ -561,8 +573,9 @@ previous check's list is kept, or `null` when no earlier check saved one. A
|
||||
state file without it loads, and the first check after that saves it without a
|
||||
notification.
|
||||
|
||||
A port entry in the older format, with one `hostname` instead of the `hostnames`
|
||||
list, loads as a list of that one name.
|
||||
A port entry's `hostnames` lists every name that resolves to its address,
|
||||
domains included. A port entry in the older format, with one `hostname` instead
|
||||
of the `hostnames` list, loads as a list of that one name.
|
||||
|
||||
---
|
||||
|
||||
|
||||
@@ -19,6 +19,10 @@ trial run of the finished image: https://git.eeqj.de/sneak/dnswatcher/issues/149
|
||||
|
||||
# Completed Steps
|
||||
|
||||
- 2026-10-02: a domain that does not exist has no nameservers, not its parent
|
||||
zone's; no name gets a parent's when its servers did not answer (closes #222).
|
||||
- 2026-10-02: the dashboard's Ports table and `/api/v1/status` port entries list
|
||||
a port's domains apart from its hostnames (closes #245).
|
||||
- 2026-10-02: nameservers a referral names without addresses are looked up,
|
||||
three deep at most; `pool.ntp.org`'s nameservers resolve (closes #221).
|
||||
- 2026-10-02: an apex domain is not counted or listed as a hostname; its records
|
||||
|
||||
@@ -45,11 +45,14 @@ func newDashboardTemplate() *template.Template {
|
||||
|
||||
// dashboardData is the data passed to the dashboard template. Hostnames
|
||||
// and DomainRecords split the records in Snapshot.Hostnames, which also
|
||||
// holds the apex domains' own (see splitHostnames).
|
||||
// holds the apex domains' own (see splitHostnames). Ports holds
|
||||
// Snapshot.Ports with each port's names split into domains and
|
||||
// hostnames, as /api/v1/status gives them (see buildPorts).
|
||||
type dashboardData struct {
|
||||
Snapshot state.Snapshot
|
||||
Hostnames map[string]*state.HostnameState
|
||||
DomainRecords map[string]*state.HostnameState
|
||||
Ports map[string]*statusPortInfo
|
||||
Alerts []notify.AlertEntry
|
||||
StateAge string
|
||||
GeneratedAt string
|
||||
@@ -71,6 +74,7 @@ func (h *Handlers) HandleDashboard() http.HandlerFunc {
|
||||
Snapshot: snap,
|
||||
Hostnames: hostnames,
|
||||
DomainRecords: domainRecords,
|
||||
Ports: buildPorts(snap),
|
||||
Alerts: alerts,
|
||||
StateAge: relTime(snap.LastUpdated),
|
||||
GeneratedAt: time.Now().UTC().Format("2006-01-02 15:04:05"),
|
||||
|
||||
@@ -205,3 +205,51 @@ func TestDashboardShowsDomainRecordsUnderDomains(t *testing.T) {
|
||||
t.Errorf("summary bar does not say %q", summary)
|
||||
}
|
||||
}
|
||||
|
||||
// rowCells returns the text of each cell of a dashboard table row
|
||||
// whose cells start with tag, "<th" or "<td".
|
||||
func rowCells(row string, tag string) []string {
|
||||
tags := regexp.MustCompile(`<[^>]*>`)
|
||||
parts := strings.Split(row, tag)[1:]
|
||||
cells := make([]string, 0, len(parts))
|
||||
|
||||
for _, cell := range parts {
|
||||
text := tags.ReplaceAllString(tag+cell, " ")
|
||||
cells = append(cells, strings.Join(strings.Fields(text), " "))
|
||||
}
|
||||
|
||||
return cells
|
||||
}
|
||||
|
||||
// TestDashboardPortsTellDomainsFromHostnames checks that the Ports
|
||||
// table lists an apex domain under Domains and a hostname under
|
||||
// Hostnames when both resolve to the port's address.
|
||||
func TestDashboardPortsTellDomainsFromHostnames(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
page := get(t, newHandlersWithFailures(t).HandleDashboard())
|
||||
ports := dashboardSection(t, page, "Ports")
|
||||
|
||||
headings := rowCells(dashboardRow(t, ports, "Address</th>"), "<th")
|
||||
cells := rowCells(dashboardRow(t, ports, sharedPort), "<td")
|
||||
|
||||
if len(cells) != len(headings) {
|
||||
t.Fatalf("row of %s has cells %q under headings %q",
|
||||
sharedPort, cells, headings)
|
||||
}
|
||||
|
||||
under := make(map[string]string)
|
||||
for i, heading := range headings {
|
||||
under[heading] = cells[i]
|
||||
}
|
||||
|
||||
if under["Domains"] != testDomain {
|
||||
t.Errorf("row of %s lists %q under Domains, want %q",
|
||||
sharedPort, under["Domains"], testDomain)
|
||||
}
|
||||
|
||||
if under["Hostnames"] != testHostname {
|
||||
t.Errorf("row of %s lists %q under Hostnames, want %q",
|
||||
sharedPort, under["Hostnames"], testHostname)
|
||||
}
|
||||
}
|
||||
@@ -32,8 +32,11 @@ type statusHostnameInfo struct {
|
||||
}
|
||||
|
||||
// statusPortInfo holds status information for a monitored port.
|
||||
// Domains and Hostnames list the apex domains and the hostnames that
|
||||
// resolve to its address.
|
||||
type statusPortInfo struct {
|
||||
Open bool `json:"open"`
|
||||
Domains []string `json:"domains"`
|
||||
Hostnames []string `json:"hostnames"`
|
||||
LastChecked time.Time `json:"lastChecked"`
|
||||
}
|
||||
@@ -99,7 +102,6 @@ func buildStatusResponse(
|
||||
LastUpdated: snap.LastUpdated,
|
||||
Domains: make(map[string]*statusDomainInfo),
|
||||
Hostnames: make(map[string]*statusHostnameInfo),
|
||||
Ports: make(map[string]*statusPortInfo),
|
||||
Certificates: make(map[string]*statusCertificateInfo),
|
||||
}
|
||||
|
||||
@@ -107,7 +109,7 @@ func buildStatusResponse(
|
||||
|
||||
buildDomains(snap, domainRecords, resp)
|
||||
buildHostnames(hostnames, resp)
|
||||
buildPorts(snap, resp)
|
||||
resp.Ports = buildPorts(snap)
|
||||
buildCertificates(snap, resp)
|
||||
buildCounts(resp)
|
||||
|
||||
@@ -195,21 +197,36 @@ func nameserverInfo(
|
||||
return info
|
||||
}
|
||||
|
||||
func buildPorts(
|
||||
snap state.Snapshot,
|
||||
resp *statusResponse,
|
||||
) {
|
||||
// buildPorts returns the port entries saved in snap. A port entry
|
||||
// saves apex domains with its hostnames; they are told apart as in
|
||||
// splitHostnames, by a domain entry in snap.Domains.
|
||||
func buildPorts(snap state.Snapshot) map[string]*statusPortInfo {
|
||||
ports := make(map[string]*statusPortInfo, len(snap.Ports))
|
||||
|
||||
for key, ps := range snap.Ports {
|
||||
hostnames := make([]string, len(ps.Hostnames))
|
||||
copy(hostnames, ps.Hostnames)
|
||||
domains := []string{}
|
||||
hostnames := []string{}
|
||||
|
||||
for _, name := range ps.Hostnames {
|
||||
if _, isDomain := snap.Domains[name]; isDomain {
|
||||
domains = append(domains, name)
|
||||
} else {
|
||||
hostnames = append(hostnames, name)
|
||||
}
|
||||
}
|
||||
|
||||
sort.Strings(domains)
|
||||
sort.Strings(hostnames)
|
||||
|
||||
resp.Ports[key] = &statusPortInfo{
|
||||
ports[key] = &statusPortInfo{
|
||||
Open: ps.Open,
|
||||
Domains: domains,
|
||||
Hostnames: hostnames,
|
||||
LastChecked: ps.LastChecked,
|
||||
}
|
||||
}
|
||||
|
||||
return ports
|
||||
}
|
||||
|
||||
func buildCertificates(
|
||||
|
||||
@@ -21,7 +21,8 @@ import (
|
||||
// The state the handler tests serve: www.example.com has one nameserver
|
||||
// that answered and one whose query failed, and its certificate check
|
||||
// failed. example.net is an apex domain, whose own records are saved
|
||||
// with the hostnames' records, as the watcher saves them.
|
||||
// with the hostnames' records, as the watcher saves them. Both names
|
||||
// resolve to domainAddress, whose port 443 entry lists them.
|
||||
const (
|
||||
testHostname = "www.example.com"
|
||||
answeringNS = "ns1.example.com."
|
||||
@@ -32,6 +33,7 @@ const (
|
||||
testDomain = "example.net"
|
||||
domainNS = "a.iana-servers.net."
|
||||
domainAddress = "192.0.2.2"
|
||||
sharedPort = domainAddress + ":443"
|
||||
)
|
||||
|
||||
// newHandlersWithFailures builds real Handlers whose state holds the
|
||||
@@ -65,12 +67,31 @@ func newHandlersWithFailures(t *testing.T) *handlers.Handlers {
|
||||
t.Fatalf("state.New: %v", err)
|
||||
}
|
||||
|
||||
setTestState(st)
|
||||
|
||||
hnd, err := handlers.New(nil, handlers.Params{
|
||||
Logger: log,
|
||||
Globals: glob,
|
||||
State: st,
|
||||
Notify: notifier,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("handlers.New: %v", err)
|
||||
}
|
||||
|
||||
return hnd
|
||||
}
|
||||
|
||||
// setTestState sets the entries described above in st.
|
||||
func setTestState(st *state.State) {
|
||||
now := time.Now()
|
||||
|
||||
st.SetHostnameState(testHostname, &state.HostnameState{
|
||||
RecordsByNameserver: map[string]*state.NameserverRecordState{
|
||||
answeringNS: {
|
||||
Records: map[string][]string{"A": {"192.0.2.1"}},
|
||||
Records: map[string][]string{
|
||||
"A": {"192.0.2.1", domainAddress},
|
||||
},
|
||||
Status: "ok",
|
||||
LastChecked: now,
|
||||
},
|
||||
@@ -106,17 +127,11 @@ func newHandlersWithFailures(t *testing.T) *handlers.Handlers {
|
||||
LastChecked: now,
|
||||
})
|
||||
|
||||
hnd, err := handlers.New(nil, handlers.Params{
|
||||
Logger: log,
|
||||
Globals: glob,
|
||||
State: st,
|
||||
Notify: notifier,
|
||||
st.SetPortState(sharedPort, &state.PortState{
|
||||
Open: true,
|
||||
Hostnames: []string{testDomain, testHostname},
|
||||
LastChecked: now,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("handlers.New: %v", err)
|
||||
}
|
||||
|
||||
return hnd
|
||||
}
|
||||
|
||||
// get serves one GET request to handler and returns the response body.
|
||||
@@ -217,3 +232,36 @@ func TestStatusGivesDomainRecordsUnderTheDomain(t *testing.T) {
|
||||
testDomain, domainNS, records, domainAddress)
|
||||
}
|
||||
}
|
||||
|
||||
// TestStatusPortsTellDomainsFromHostnames checks that a port entry in
|
||||
// /api/v1/status lists an apex domain in domains and a hostname in
|
||||
// hostnames when both resolve to its address.
|
||||
func TestStatusPortsTellDomainsFromHostnames(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
body := get(t, newHandlersWithFailures(t).HandleStatus())
|
||||
|
||||
var resp struct {
|
||||
Ports map[string]struct {
|
||||
Domains []string `json:"domains"`
|
||||
Hostnames []string `json:"hostnames"`
|
||||
} `json:"ports"`
|
||||
}
|
||||
|
||||
err := json.Unmarshal([]byte(body), &resp)
|
||||
if err != nil {
|
||||
t.Fatalf("decoding response: %v", err)
|
||||
}
|
||||
|
||||
port := resp.Ports[sharedPort]
|
||||
|
||||
if !slices.Equal(port.Domains, []string{testDomain}) {
|
||||
t.Errorf("port %s domains = %v, want [%s]",
|
||||
sharedPort, port.Domains, testDomain)
|
||||
}
|
||||
|
||||
if !slices.Equal(port.Hostnames, []string{testHostname}) {
|
||||
t.Errorf("port %s hostnames = %v, want [%s]",
|
||||
sharedPort, port.Hostnames, testHostname)
|
||||
}
|
||||
}
|
||||
@@ -157,19 +157,20 @@
|
||||
>
|
||||
Ports
|
||||
</h2>
|
||||
{{ if .Snapshot.Ports }}
|
||||
{{ if .Ports }}
|
||||
<div class="overflow-x-auto">
|
||||
<table class="w-full text-left text-xs">
|
||||
<thead>
|
||||
<tr class="text-slate-500 uppercase tracking-wider">
|
||||
<th class="py-2 px-3">Address</th>
|
||||
<th class="py-2 px-3">State</th>
|
||||
<th class="py-2 px-3">Domains</th>
|
||||
<th class="py-2 px-3">Hostnames</th>
|
||||
<th class="py-2 px-3">Checked</th>
|
||||
</tr>
|
||||
</thead>
|
||||
<tbody class="divide-y divide-slate-800">
|
||||
{{ range $key, $ps := .Snapshot.Ports }}
|
||||
{{ range $key, $ps := .Ports }}
|
||||
<tr class="hover:bg-surface-800/50">
|
||||
<td class="py-2 px-3 text-slate-200 font-medium">
|
||||
{{ $key }}
|
||||
@@ -187,6 +188,9 @@
|
||||
>
|
||||
{{ end }}
|
||||
</td>
|
||||
<td class="py-2 px-3 text-slate-400 break-all">
|
||||
{{ joinStrings $ps.Domains ", " }}
|
||||
</td>
|
||||
<td class="py-2 px-3 text-slate-400 break-all">
|
||||
{{ joinStrings $ps.Hostnames ", " }}
|
||||
</td>
|
||||
|
||||
@@ -200,6 +200,11 @@ func glueIPs(nsNames []string, glue map[string][]net.IP) []string {
|
||||
return ips
|
||||
}
|
||||
|
||||
// followDelegation follows referrals from servers, the root servers, to
|
||||
// domain and returns the NS set of domain's delegation. When the servers
|
||||
// of the zone domain is in answer that it has no delegation of its own,
|
||||
// because it is not the zone's apex or does not exist, the set is empty
|
||||
// and there is no error. An error means that no such answer came.
|
||||
func (r *Resolver) followDelegation(
|
||||
ctx context.Context,
|
||||
domain string,
|
||||
@@ -230,10 +235,10 @@ func (r *Resolver) followDelegation(
|
||||
// An authoritative reply comes from the servers of the zone
|
||||
// domain is in; it is not a referral, even when its authority
|
||||
// section lists that zone's NS records. Without NS records in
|
||||
// the answer, domain is not the zone's apex and has no
|
||||
// nameservers of its own.
|
||||
// the answer, domain is not the zone's apex, or does not
|
||||
// exist, and has no nameservers of its own.
|
||||
if resp.Authoritative {
|
||||
return nil, ErrNoNameservers
|
||||
return []string{}, nil
|
||||
}
|
||||
|
||||
authNS := extractNSSet(resp.Ns)
|
||||
@@ -475,7 +480,8 @@ func (r *Resolver) resolveNSIPs(
|
||||
|
||||
// resolveNSIterative queries for NS records using iterative
|
||||
// resolution as a fallback when followDelegation finds no
|
||||
// authoritative answer in the delegation chain.
|
||||
// authoritative answer in the delegation chain. Its result means what
|
||||
// followDelegation's does.
|
||||
func (r *Resolver) resolveNSIterative(
|
||||
ctx context.Context,
|
||||
domain string,
|
||||
@@ -505,6 +511,12 @@ func (r *Resolver) resolveNSIterative(
|
||||
return nsNames, nil
|
||||
}
|
||||
|
||||
// As in followDelegation: domain has no nameservers of its
|
||||
// own.
|
||||
if resp.Authoritative {
|
||||
return []string{}, nil
|
||||
}
|
||||
|
||||
// Follow delegation.
|
||||
authNS := extractNSSet(resp.Ns)
|
||||
if len(authNS) == 0 {
|
||||
@@ -590,9 +602,10 @@ func (r *Resolver) resolveARecord(
|
||||
// FindAuthoritativeNameservers traces the delegation chain from
|
||||
// root servers to discover all authoritative nameservers for the
|
||||
// given domain, as the delegation from its parent zone's servers lists
|
||||
// them. For a name that is not a zone apex it tries each
|
||||
// parent name in turn, so it returns the nameservers of the zone the
|
||||
// name is in.
|
||||
// them. When the servers asked answer that the name has no delegation
|
||||
// of its own, it tries each parent name in turn, so it returns the
|
||||
// nameservers of the zone the name is in. When they do not answer, it
|
||||
// returns the error and tries no parent name.
|
||||
func (r *Resolver) FindAuthoritativeNameservers(
|
||||
ctx context.Context,
|
||||
domain string,
|
||||
@@ -614,16 +627,15 @@ func (r *Resolver) FindAuthoritativeNameservers(
|
||||
nsNames, err := r.followDelegation(
|
||||
ctx, candidate, rootServerList(),
|
||||
)
|
||||
if err == nil && len(nsNames) > 0 {
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if len(nsNames) > 0 {
|
||||
sort.Strings(nsNames)
|
||||
|
||||
return nsNames, nil
|
||||
}
|
||||
|
||||
// The root servers would refuse every parent name too.
|
||||
if errors.Is(err, ErrIntercepted) {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
|
||||
return nil, ErrNoNameservers
|
||||
@@ -784,9 +796,7 @@ func (r *Resolver) querySingleType(
|
||||
// A reply with no answer that lists other nameservers, from a server
|
||||
// that does not hold the name's zone, is a referral and says nothing
|
||||
// about the name's records. A server named in the delegation that
|
||||
// does not hold the zone may send one, as do a parent zone's servers
|
||||
// when FindAuthoritativeNameservers found no delegation for the
|
||||
// name's zone and moved on to a parent name.
|
||||
// does not hold the zone may send one.
|
||||
if !msg.Authoritative && len(msg.Answer) == 0 &&
|
||||
len(extractNSSet(msg.Ns)) > 0 {
|
||||
state.gotReferral = true
|
||||
@@ -941,12 +951,21 @@ func (r *Resolver) queryEachNS(
|
||||
return results, nil
|
||||
}
|
||||
|
||||
// LookupNS returns the NS record set for a domain.
|
||||
// LookupNS returns the NS record set of a domain, as the delegation from
|
||||
// its parent zone's servers lists it, and never a parent name's. When
|
||||
// they answer that the domain has no delegation of its own, as when it
|
||||
// does not exist, the set is empty and there is no error.
|
||||
func (r *Resolver) LookupNS(
|
||||
ctx context.Context,
|
||||
domain string,
|
||||
) ([]string, error) {
|
||||
return r.FindAuthoritativeNameservers(ctx, domain)
|
||||
if checkCtx(ctx) != nil {
|
||||
return nil, ErrContextCanceled
|
||||
}
|
||||
|
||||
return r.followDelegation(
|
||||
ctx, dns.Fqdn(strings.ToLower(domain)), rootServerList(),
|
||||
)
|
||||
}
|
||||
|
||||
// LookupAllRecords performs iterative resolution to find all DNS
|
||||
|
||||
@@ -187,8 +187,8 @@ func liveFindAuthoritative(
|
||||
return out
|
||||
}
|
||||
|
||||
// liveLookupNS is liveFindAuthoritative through the LookupNS entry
|
||||
// point, so that both entry points stay independently exercised.
|
||||
// liveLookupNS looks up the NS record set of domain, a domain that has
|
||||
// one, retrying until the delegation chain can be walked.
|
||||
func liveLookupNS(
|
||||
t *testing.T,
|
||||
r *resolver.Resolver,
|
||||
|
||||
@@ -87,6 +87,27 @@ func TestFindAuthoritativeNameservers_Subdomain(
|
||||
assert.Equal(t, fromZone, fromHost)
|
||||
}
|
||||
|
||||
// TestFindAuthoritativeNameservers_DelegatedSubdomain looks up the
|
||||
// nameservers of a name in compute-1.amazonaws.com, a zone that
|
||||
// amazonaws.com delegates to other servers. The servers of
|
||||
// compute-1.amazonaws.com answer that the name has no delegation of its
|
||||
// own, so it gets their names, not those of the amazonaws.com servers.
|
||||
func TestFindAuthoritativeNameservers_DelegatedSubdomain(
|
||||
t *testing.T,
|
||||
) {
|
||||
t.Parallel()
|
||||
|
||||
r := newTestResolver(t)
|
||||
fromHost := liveFindAuthoritative(
|
||||
t, r, "ec2-3-80-0-1.compute-1.amazonaws.com",
|
||||
)
|
||||
fromZone := liveLookupNS(t, r, "compute-1.amazonaws.com")
|
||||
fromParent := liveLookupNS(t, r, "amazonaws.com")
|
||||
|
||||
assert.Equal(t, fromZone, fromHost)
|
||||
assert.NotEqual(t, fromParent, fromHost)
|
||||
}
|
||||
|
||||
func TestFindAuthoritativeNameservers_ReturnsSorted(
|
||||
t *testing.T,
|
||||
) {
|
||||
@@ -806,8 +827,7 @@ func TestLookupNS_MatchesFindAuthoritative(t *testing.T) {
|
||||
// nameservers of g.ntpns.org. The org servers delegate its parent zone,
|
||||
// ntpns.org, without the addresses of its nameservers, so the walk has
|
||||
// to look them up to ask them. If it did not, the walk for g.ntpns.org
|
||||
// would fail and LookupNS would return the nameservers of ntpns.org,
|
||||
// which a.ntpns.org is not one of.
|
||||
// would fail.
|
||||
func TestLookupNS_ParentZoneDelegatedWithoutAddresses(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
@@ -817,6 +837,33 @@ func TestLookupNS_ParentZoneDelegatedWithoutAddresses(t *testing.T) {
|
||||
assert.Contains(t, nameservers, "a.ntpns.org.")
|
||||
}
|
||||
|
||||
// TestLookupNS_DomainThatDoesNotExist looks up the nameservers of a .com
|
||||
// domain that does not exist. The .com servers answer that it does not
|
||||
// exist, so it has none, and does not get theirs.
|
||||
func TestLookupNS_DomainThatDoesNotExist(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
const domain = "dnswatcher-test-does-not-exist.com"
|
||||
|
||||
r := newTestResolver(t)
|
||||
|
||||
var nameservers []string
|
||||
|
||||
livednstest.Retry(
|
||||
t,
|
||||
"LookupNS("+domain+")",
|
||||
func(ctx context.Context) error {
|
||||
var err error
|
||||
|
||||
nameservers, err = r.LookupNS(ctx, domain)
|
||||
|
||||
return err
|
||||
},
|
||||
)
|
||||
|
||||
assert.Empty(t, nameservers)
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------
|
||||
// ResolveIPAddresses tests
|
||||
// ----------------------------------------------------------------
|
||||
|
||||
@@ -11,7 +11,8 @@ import (
|
||||
|
||||
// DNSResolver performs iterative DNS resolution.
|
||||
type DNSResolver interface {
|
||||
// LookupNS discovers authoritative nameservers for a domain.
|
||||
// LookupNS returns a domain's NS record set, as its parent zone's
|
||||
// servers delegate it: empty when they answer that it has none.
|
||||
LookupNS(
|
||||
ctx context.Context,
|
||||
domain string,
|
||||
|
||||
Reference in new issue
Block a user