Add an inbuxa dns command to show the records the domain needs #56

Merged
jcoffey-dev merged 1 commits from feat/dns-records into main 2026-11-12 14:07:42 +00:00
3 changed files with 152 additions and 0 deletions

No files matched your search

+106
View File
@@ -61,6 +61,9 @@ const usage = `inbuxa -- install the inbuxa suite on this machine
inbuxa certs [--key KEY] the mail server's certificate: what its mail
ports present, and with an API key a new
order when it needs one
inbuxa dns the DNS records the domain needs: the saved
dns.zone, or --refresh --key - to re-read them
live from the server
inbuxa export [-o FILE] write a topology file from what is here
inbuxa relay install|status|uninstall
inbuxa Relay, on a machine of its own in front
@@ -125,6 +128,14 @@ certs flags:
default: postmaster@DOMAIN
--dry-run report, and say what it would do
dns flags:
--refresh read the records live from the server instead of
the saved dns.zone; needs an API key
--key KEY an API key made in the console, needed only with
--refresh; "-" reads it from standard input, and
INBUXA_API_KEY works too
--domain NAME the mail domain, if the install didn't record it
relay install flags:
--token TOKEN the join token the console shows when you add
the relay; "-" reads it from standard input, and
@@ -203,6 +214,8 @@ func main() {
os.Exit(uninstallCmd(os.Args[2:]))
case "certs":
os.Exit(certsCmd(os.Args[2:]))
case "dns":
os.Exit(dnsCmd(os.Args[2:]))
case "relay":
os.Exit(relayCmd(os.Args[2:]))
case "cluster":
@@ -1049,6 +1062,99 @@ func certsCmd(args []string) int {
return 0
}
// dnsCmd prints the DNS records the domain needs published. By default it
// reads the dns.zone the install wrote, which needs nothing; --refresh asks
// the running server for them live, with an API key, so a rotated DKIM key or
// a record that changed since the install shows up.
func dnsCmd(args []string) int {
fs := flag.NewFlagSet("dns", flag.ContinueOnError)
fs.Usage = func() { fmt.Print(usage) }
var (
refresh = fs.Bool("refresh", false, "")
key = fs.String("key", os.Getenv("INBUXA_API_KEY"), "")
domain = fs.String("domain", "", "")
)
if err := fs.Parse(args); err != nil {
return 2
}
ctx := context.Background()
st, err := state.Load()
if err != nil {
fmt.Fprintln(os.Stderr, err.Error())
return 1
}
if _, ok := st.Shapes["server"]; !ok || st.Removed() {
fmt.Println("The mail server isn't installed on this machine, so its DNS records are shown where it runs.")
return 0
}
if apply.LocalInstall(st) {
fmt.Println("This is a --local install: the mail ports are on loopback and no DNS is needed. A real")
fmt.Println("install for a domain that points here writes the records it needs to dns.zone.")
return 0
}
dom := *domain
if dom == "" {
dom = st.Domain
}
zoneFile := filepath.Join(st.Dir, "dns.zone")
// The saved file is the no-friction default: the install wrote it, it
// needs no key, and for most domains it never goes stale.
if !*refresh {
b, err := os.ReadFile(zoneFile)
if err == nil {
fmt.Printf("The records %s needs published, from %s:\n\n", dom, zoneFile)
os.Stdout.Write(b)
if len(b) > 0 && b[len(b)-1] != '\n' {
fmt.Println()
}
fmt.Println("\nTo re-read them live from the server (a rotated DKIM key, say):")
fmt.Println(" inbuxa dns --refresh --key -")
return 0
}
if !os.IsNotExist(err) {
fmt.Fprintln(os.Stderr, "reading "+zoneFile+": "+err.Error())
return 1
}
fmt.Printf("No saved records at %s. Reading them live from the server instead.\n\n", zoneFile)
}
if *key == "-" {
line, err := bufio.NewReader(os.Stdin).ReadString('\n')
if err != nil && line == "" {
fmt.Fprintln(os.Stderr, "reading the key from standard input: "+err.Error())
return 2
}
*key = strings.TrimSpace(line)
}
if *key == "" {
fmt.Println("Reading the records live needs an API key: make one in the console (your account, API")
fmt.Println("keys), then")
fmt.Println(" inbuxa dns --refresh --key -")
fmt.Println("and paste it, or set INBUXA_API_KEY. It isn't kept.")
return 1
}
zone, err := apply.FetchDNSZone(ctx, st, dom, *key)
if err != nil {
if errors.Is(err, apply.ErrKeyRefused) {
fmt.Fprintln(os.Stderr, "the server didn't take that API key")
return 1
}
fmt.Fprintln(os.Stderr, "stopped: "+err.Error())
return 1
}
fmt.Printf("The records %s needs published, read live from the server:\n\n", dom)
fmt.Print(zone)
if len(zone) > 0 && zone[len(zone)-1] != '\n' {
fmt.Println()
}
// Keep the saved copy in step with what the server now says.
if err := os.WriteFile(zoneFile, []byte(zone), 0o644); err == nil {
fmt.Printf("\n(also written to %s)\n", zoneFile)
}
return 0
}
// relayCmd is inbuxa Relay on this machine, which shares nothing with the
// suite's install but the way it is asked for.
func relayCmd(args []string) int {
+21
View File
@@ -34,3 +34,24 @@ func TestUpgradeTakesOptionsAfterComponents(t *testing.T) {
t.Errorf("an unknown component was accepted: %d", code)
}
}
// dns understands its flags: a bad one is a usage error, the good ones are
// not. With nothing installed it stops before touching the server, so what is
// checked is that the options parsed, not what they would have done.
func TestDNSTakesItsFlags(t *testing.T) {
if _, err := os.Stat(filepath.Join("/etc/inbuxa", "install.json")); err == nil {
t.Skip("an install is recorded on this machine")
}
for _, args := range [][]string{
nil,
{"--refresh", "--domain", "example.org"},
{"--refresh", "--key", ""},
} {
if code := dnsCmd(args); code == 2 {
t.Errorf("dns %v: taken as a usage error", args)
}
}
if code := dnsCmd([]string{"--bogus"}); code != 2 {
t.Errorf("an unknown option was accepted: %d", code)
}
}
+25
View File
@@ -286,6 +286,31 @@ func Renew(ctx context.Context, st *state.State, o CertsOptions, log Log) (*Serv
}
}
// FetchDNSZone asks the running server, on loopback, for the records the
// domain needs published right now -- the same zone fragment the install
// wrote to dns.zone, but re-read live, so it reflects the current DKIM key
// and any records that changed since. It needs an API key, as Renew does,
// because the server takes no password on its API once it is set up.
func FetchDNSZone(ctx context.Context, st *state.State, domain, key string) (string, error) {
if domain == "" {
return "", errors.New("no domain: this install didn't record one, so pass --domain")
}
srv := &jmap.Client{BaseURL: "http://" + hostFinalBind, Token: key}
domainID, err := srv.DomainID(ctx, domain)
if err != nil {
var he *jmap.HTTPError
if errors.As(err, &he) && (he.Status == 401 || he.Status == 403) {
return "", ErrKeyRefused
}
return "", fmt.Errorf("finding %s on the server: %w", domain, err)
}
zone, err := srv.DNSZone(ctx, domainID)
if err != nil {
return "", err
}
return zone, nil
}
// CertsLogHint is where the server says why an order failed.
func CertsLogHint(st *state.State) string {
if st.Shapes["server"] == "host" {