gen.go

//go:build ignore

package main

import (
	"bytes"
	"fmt"
	"go/format"
	"os"
	"path/filepath"
	"text/template"

	"github.com/semihalev/zlog/v2"
)

// middleware list order very important, handlers call via this order.
var middlewareList = []string{
	"recovery",
	"metrics",
	"dnstap",
	"accesslist",
	"ratelimit",
	"reflex",
	"edns",
	"accesslog",
	"chaos",
	"hostsfile",
	"views",
	"blocklist",
	// rpz sits after blocklist (blocklist wins on overlap; RPZ PASSTHRU
	// exempts from RPZ, not from the blocklist) and ahead of the cache, so
	// policy applies to every client query, hits included, and a reload
	// takes effect immediately.
	"rpz",
	"as112",
	"kubernetes",
	"dns64",
	"cache",
	"failover",
	"resolver",
	"forwarder",
}

const codeTemplate = `// Code generated by gen.go DO NOT EDIT.

// Package defaults holds SDNS's default middleware chain, in its default
// order.
//
// It is a package rather than an init in main so that everything which
// needs the real chain can ask for it: the binary, the benchmarks, a
// harness. When this lived in main it could not be imported, so each of
// those kept a list of its own — and they drifted, which is worse than
// duplication because a benchmark that quietly measures five handlers
// fewer than production still reports a number.
package defaults

import (
	"github.com/semihalev/sdns/config"
	"github.com/semihalev/sdns/middleware"
{{range .Imports}}
	"{{.}}"
{{- end}}
)

type entry struct {
	name string
	ctor middleware.Constructor
}

var chain = []entry{
{{range .Middleware}}	{"{{.}}", func(cfg *config.Config) middleware.Handler { return {{.}}.New(cfg) }},
{{end -}}
}

// Register registers the default chain, in order.
func Register() { RegisterUpTo("") }

// RegisterUpTo registers the chain up to but not including name; an empty
// name registers all of it.
//
// It exists for the harnesses that replace the tail — a benchmark
// standing a stub in for the resolver — so that what runs ahead of the
// stub is the real chain rather than a hand-kept approximation of it.
func RegisterUpTo(stop string) {
	for _, e := range chain {
		if e.name == stop {
			return
		}
		middleware.Register(e.name, e.ctor)
	}
}
`

func main() {
	if err := generate(); err != nil {
		zlog.Fatal("Generation failed", "error", err.Error())
	}
}

func generate() error {
	// Validate middleware directories
	var imports []string
	for _, name := range middlewareList {
		dir := filepath.Join(middlewareDir, name)
		stat, err := os.Stat(dir)
		if err != nil {
			return fmt.Errorf("checking middleware %s: %w", name, err)
		}
		if !stat.IsDir() {
			return fmt.Errorf("%s is not a directory", dir)
		}
		imports = append(imports, filepath.Join(prefixDir, middlewareDir, name))
	}

	// Generate code using template
	tmpl, err := template.New("code").Parse(codeTemplate)
	if err != nil {
		return fmt.Errorf("parsing template: %w", err)
	}

	var buf bytes.Buffer
	err = tmpl.Execute(&buf, struct {
		Imports    []string
		Middleware []string
	}{
		Imports:    imports,
		Middleware: middlewareList,
	})
	if err != nil {
		return fmt.Errorf("executing template: %w", err)
	}

	// Format the generated code
	formatted, err := format.Source(buf.Bytes())
	if err != nil {
		return fmt.Errorf("formatting code: %w", err)
	}

	// Write to file
	err = os.WriteFile(filename, formatted, 0644)
	if err != nil {
		return fmt.Errorf("writing file: %w", err)
	}

	fmt.Printf("Generated %s successfully\n", filename)
	return nil
}

const (
	filename      = "middleware/defaults/defaults.go"
	prefixDir     = "github.com/semihalev/sdns"
	middlewareDir = "middleware"
)