jpictl/cmd/jpictl/dns.go

package main

import (
	"context"
	"os"
	"time"

	"github.com/spf13/cobra"

	"git.jpi.io/amery/jpictl/pkg/cluster"
	"git.jpi.io/amery/jpictl/pkg/dns"
)

const (
	// DNSSyncTimeout specifies how long are we willing to wait for a DNS
	// synchronization
	DNSSyncTimeout = 10 * time.Second
)

func newDNSManager(m *cluster.Cluster, provider dns.Provider) (*dns.Manager, error) {
	domain := m.Domain
	if m.Name != "" {
		domain = m.Name + "." + domain
	}

	mgr, err := dns.NewManager(dns.WithDomain(domain), dns.WithLogger(log))
	if err != nil {
		return nil, err
	}

	if provider != nil {
		// set provider only  if specified
		err = dns.WithProvider(provider)(mgr)
		if err != nil {
			return nil, err
		}
	}

	if err := populateDNSManager(mgr, m); err != nil {
		return nil, err
	}

	return mgr, nil
}

func populateDNSManager(mgr *dns.Manager, m *cluster.Cluster) error {
	var err error

	ctx := context.TODO()

	m.ForEachZone(func(z *cluster.Zone) bool {
		z.ForEachMachine(func(p *cluster.Machine) bool {
			err = mgr.AddHost(ctx, z.Name, p.ID, true, p.PublicAddresses...)
			return err != nil
		})

		return err != nil
	})
	if err != nil {
		return err
	}

	m.ForEachRegion(func(r *cluster.Region) bool {
		r.ForEachZone(func(z *cluster.Zone) bool {
			err = mgr.AddRegion(ctx, r.Name, z.Name)
			return err != nil
		})

		return err != nil
	})

	return err
}

// Command
var dnsCmd = &cobra.Command{
	Use: "dns",
}

var dnsWriteCmd = &cobra.Command{
	Use:    "write",
	Short:  "dns write generates public DNS records",
	PreRun: setVerbosity,
	RunE: func(_ *cobra.Command, _ []string) error {
		m, err := cfg.LoadZones(true)
		if err != nil {
			return err
		}

		mgr, err := newDNSManager(m, nil)
		if err != nil {
			return err
		}

		_, err = mgr.WriteTo(os.Stdout)
		return err
	},
}

var dnsSyncCmd = &cobra.Command{
	Use:    "sync",
	Short:  "dns sync updates public DNS records",
	PreRun: setVerbosity,
	RunE: func(_ *cobra.Command, _ []string) error {
		cred, err := dns.DefaultDNSProvider()
		if err != nil {
			return err
		}

		m, err := cfg.LoadZones(true)
		if err != nil {
			return err
		}

		mgr, err := newDNSManager(m, cred)
		if err != nil {
			return err
		}

		ctx, cancel := context.WithTimeout(context.Background(), DNSSyncTimeout)
		defer cancel()

		return mgr.Sync(ctx)
	},
}

func init() {
	rootCmd.AddCommand(dnsCmd)

	dnsCmd.AddCommand(dnsWriteCmd)
	dnsCmd.AddCommand(dnsSyncCmd)
}