isle/go/cmd/entrypoint/nebula.go

package main

import (
	"fmt"
	"isle/jsonutil"
	"isle/nebula"
	"os"
)

var subCmdNebulaShow = subCmd{
	name:  "show",
	descr: "Writes nebula network information to stdout in JSON format",
	do: func(subCmdCtx subCmdCtx) error {

		flags := subCmdCtx.flagSet(false)
		if err := flags.Parse(subCmdCtx.args); err != nil {
			return fmt.Errorf("parsing flags: %w", err)
		}

		hosts, err := subCmdCtx.getHosts()
		if err != nil {
			return fmt.Errorf("getting hosts: %w", err)
		}

		var caPublicCreds nebula.CAPublicCredentials
		err = subCmdCtx.daemonRCPClient.Call(
			subCmdCtx.ctx, &caPublicCreds, "GetNebulaCAPublicCredentials", nil,
		)
		if err != nil {
			return fmt.Errorf("calling GetNebulaCAPublicCredentials: %w", err)
		}

		caCert := caPublicCreds.Cert.Unwrap()
		caCertPEM, err := caCert.MarshalToPEM()
		if err != nil {
			return fmt.Errorf("marshaling CA cert to PEM: %w", err)
		}

		if len(caCert.Details.Subnets) != 1 {
			return fmt.Errorf(
				"malformed ca.crt, contains unexpected subnets %#v",
				caCert.Details.Subnets,
			)
		}

		subnet := caCert.Details.Subnets[0]

		type outLighthouse struct {
			PublicAddr string
			IP         string
		}

		out := struct {
			CACert      string
			SubnetCIDR  string
			Lighthouses []outLighthouse
		}{
			CACert:     string(caCertPEM),
			SubnetCIDR: subnet.String(),
		}

		for _, h := range hosts.Hosts {
			if h.Nebula.PublicAddr == "" {
				continue
			}

			out.Lighthouses = append(out.Lighthouses, outLighthouse{
				PublicAddr: h.Nebula.PublicAddr,
				IP:         h.IP().String(),
			})
		}

		if err := jsonutil.WriteIndented(os.Stdout, out); err != nil {
			return fmt.Errorf("encoding to stdout: %w", err)
		}

		return nil
	},
}

var subCmdNebula = subCmd{
	name:  "nebula",
	descr: "Sub-commands related to the nebula VPN",
	do: func(subCmdCtx subCmdCtx) error {
		return subCmdCtx.doSubCmd(
			subCmdNebulaShow,
		)
	},
}