No One Can Stop Me Now
This commit is contained in:
DigiJ
761
services/server-manager/internal/tui/view_dns.go
Normal file
761
services/server-manager/internal/tui/view_dns.go
Normal file
@@ -0,0 +1,761 @@
|
||||
package tui
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"os/exec"
|
||||
"strings"
|
||||
|
||||
"github.com/charmbracelet/bubbles/textinput"
|
||||
tea "github.com/charmbracelet/bubbletea"
|
||||
"github.com/charmbracelet/lipgloss"
|
||||
)
|
||||
|
||||
// ── Rendering ───────────────────────────────────────────────────────
|
||||
|
||||
func (a App) renderDNSMenu() string {
|
||||
var b strings.Builder
|
||||
|
||||
b.WriteString(styleTitle.Render("DNS SERVER"))
|
||||
b.WriteString("\n")
|
||||
b.WriteString(a.renderHR())
|
||||
b.WriteString("\n")
|
||||
|
||||
// Check DNS server status
|
||||
_, dnsRunning := getServiceStatus("autarch-dns")
|
||||
if dnsRunning {
|
||||
b.WriteString(" " + styleStatusOK.Render("● DNS Server is running"))
|
||||
} else {
|
||||
b.WriteString(" " + styleStatusBad.Render("○ DNS Server is stopped"))
|
||||
}
|
||||
b.WriteString("\n")
|
||||
|
||||
// Check if binary exists
|
||||
dir := findAutarchDir()
|
||||
binaryPath := dir + "/services/dns-server/autarch-dns"
|
||||
if fileExists(binaryPath) {
|
||||
b.WriteString(" " + styleSuccess.Render("✔ Binary found: ") + styleDim.Render(binaryPath))
|
||||
} else {
|
||||
b.WriteString(" " + styleWarning.Render("⚠ Binary not found — build required"))
|
||||
}
|
||||
b.WriteString("\n")
|
||||
|
||||
// Check if source exists
|
||||
sourcePath := dir + "/services/dns-server/main.go"
|
||||
if fileExists(sourcePath) {
|
||||
b.WriteString(" " + styleSuccess.Render("✔ Source code present"))
|
||||
} else {
|
||||
b.WriteString(" " + styleError.Render("✘ Source not found at " + dir + "/services/dns-server/"))
|
||||
}
|
||||
b.WriteString("\n\n")
|
||||
|
||||
b.WriteString(a.renderHR())
|
||||
b.WriteString("\n")
|
||||
b.WriteString(styleKey.Render(" [b]") + " Build DNS server from source\n")
|
||||
b.WriteString(styleKey.Render(" [s]") + " Start / Stop DNS server\n")
|
||||
b.WriteString(styleKey.Render(" [m]") + " Manage DNS (zones, records, hosts, blocklist)\n")
|
||||
b.WriteString(styleKey.Render(" [c]") + " Edit DNS config\n")
|
||||
b.WriteString(styleKey.Render(" [t]") + " Test DNS resolution\n")
|
||||
b.WriteString(styleKey.Render(" [l]") + " View DNS logs\n")
|
||||
b.WriteString(styleKey.Render(" [i]") + " Install systemd service unit\n")
|
||||
b.WriteString("\n")
|
||||
b.WriteString(styleDim.Render(" esc back"))
|
||||
b.WriteString("\n")
|
||||
|
||||
return b.String()
|
||||
}
|
||||
|
||||
func (a App) renderDNSManageMenu() string {
|
||||
var b strings.Builder
|
||||
|
||||
b.WriteString(styleTitle.Render("DNS MANAGEMENT"))
|
||||
b.WriteString("\n")
|
||||
b.WriteString(a.renderHR())
|
||||
b.WriteString("\n")
|
||||
|
||||
// Try to get status from API
|
||||
status := getDNSAPIStatus()
|
||||
if status != nil {
|
||||
b.WriteString(" " + styleKey.Render("Queries: ") +
|
||||
lipgloss.NewStyle().Foreground(colorWhite).Render(fmt.Sprintf("%v", status["total_queries"])))
|
||||
b.WriteString("\n")
|
||||
b.WriteString(" " + styleKey.Render("Cache: ") +
|
||||
lipgloss.NewStyle().Foreground(colorWhite).Render(fmt.Sprintf("hits=%v misses=%v", status["cache_hits"], status["cache_misses"])))
|
||||
b.WriteString("\n")
|
||||
b.WriteString(" " + styleKey.Render("Blocked: ") +
|
||||
lipgloss.NewStyle().Foreground(colorWhite).Render(fmt.Sprintf("%v", status["blocked_queries"])))
|
||||
b.WriteString("\n\n")
|
||||
} else {
|
||||
b.WriteString(styleWarning.Render(" ⚠ Cannot reach DNS API — is the server running?"))
|
||||
b.WriteString("\n\n")
|
||||
}
|
||||
|
||||
b.WriteString(a.renderHR())
|
||||
b.WriteString("\n")
|
||||
b.WriteString(styleKey.Render(" [z]") + " Manage zones\n")
|
||||
b.WriteString(styleKey.Render(" [h]") + " Manage hosts file\n")
|
||||
b.WriteString(styleKey.Render(" [b]") + " Manage blocklist\n")
|
||||
b.WriteString(styleKey.Render(" [f]") + " Manage forwarding rules\n")
|
||||
b.WriteString(styleKey.Render(" [c]") + " Flush cache\n")
|
||||
b.WriteString(styleKey.Render(" [q]") + " Query log\n")
|
||||
b.WriteString(styleKey.Render(" [t]") + " Top domains\n")
|
||||
b.WriteString(styleKey.Render(" [e]") + " Encryption settings (DoT/DoH)\n")
|
||||
b.WriteString(styleKey.Render(" [r]") + " Root server check\n")
|
||||
b.WriteString("\n")
|
||||
b.WriteString(styleDim.Render(" esc back"))
|
||||
b.WriteString("\n")
|
||||
|
||||
return b.String()
|
||||
}
|
||||
|
||||
func (a App) renderDNSZones() string {
|
||||
var b strings.Builder
|
||||
|
||||
b.WriteString(styleTitle.Render("DNS ZONES"))
|
||||
b.WriteString("\n")
|
||||
b.WriteString(a.renderHR())
|
||||
b.WriteString("\n")
|
||||
|
||||
if len(a.listItems) == 0 {
|
||||
b.WriteString(styleDim.Render(" No zones configured (or API unreachable)."))
|
||||
b.WriteString("\n\n")
|
||||
} else {
|
||||
for i, item := range a.listItems {
|
||||
cursor := " "
|
||||
if i == a.cursor {
|
||||
cursor = styleSelected.Render(" ▸") + " "
|
||||
}
|
||||
|
||||
b.WriteString(fmt.Sprintf("%s%s %s\n",
|
||||
cursor,
|
||||
lipgloss.NewStyle().Foreground(colorWhite).Bold(true).Render(item.Name),
|
||||
styleDim.Render(item.Status),
|
||||
))
|
||||
}
|
||||
b.WriteString("\n")
|
||||
}
|
||||
|
||||
b.WriteString(a.renderHR())
|
||||
b.WriteString(styleKey.Render(" [n]") + " New zone ")
|
||||
b.WriteString(styleKey.Render("[enter]") + " View records ")
|
||||
b.WriteString(styleKey.Render("[d]") + " Delete zone\n")
|
||||
b.WriteString(styleDim.Render(" esc back"))
|
||||
b.WriteString("\n")
|
||||
|
||||
return b.String()
|
||||
}
|
||||
|
||||
// ── Key Handling ────────────────────────────────────────────────────
|
||||
|
||||
func (a App) handleDNSMenu(key string) (tea.Model, tea.Cmd) {
|
||||
switch key {
|
||||
case "b":
|
||||
return a.buildDNSServer()
|
||||
case "s":
|
||||
return a.toggleDNSService()
|
||||
case "m":
|
||||
a.pushView(ViewDNSManage)
|
||||
return a, nil
|
||||
case "c":
|
||||
return a.editDNSConfig()
|
||||
case "t":
|
||||
return a.testDNSResolution()
|
||||
case "l":
|
||||
return a.viewDNSLogs()
|
||||
case "i":
|
||||
return a.installDNSUnit()
|
||||
}
|
||||
return a, nil
|
||||
}
|
||||
|
||||
func (a App) handleDNSManageMenu(key string) (tea.Model, tea.Cmd) {
|
||||
switch key {
|
||||
case "z":
|
||||
return a.loadDNSZones()
|
||||
case "h":
|
||||
return a.manageDNSHosts()
|
||||
case "b":
|
||||
return a.manageDNSBlocklist()
|
||||
case "f":
|
||||
return a.manageDNSForwarding()
|
||||
case "c":
|
||||
return a.flushDNSCache()
|
||||
case "q":
|
||||
return a.viewDNSQueryLog()
|
||||
case "t":
|
||||
return a.viewDNSTopDomains()
|
||||
case "e":
|
||||
return a.viewDNSEncryption()
|
||||
case "r":
|
||||
return a.dnsRootCheck()
|
||||
}
|
||||
return a, nil
|
||||
}
|
||||
|
||||
func (a App) handleDNSZonesMenu(key string) (tea.Model, tea.Cmd) {
|
||||
switch key {
|
||||
case "n":
|
||||
return a.openDNSZoneForm()
|
||||
case "enter":
|
||||
if a.cursor >= 0 && a.cursor < len(a.listItems) {
|
||||
return a.viewDNSZoneRecords(a.listItems[a.cursor].Name)
|
||||
}
|
||||
case "d":
|
||||
if a.cursor >= 0 && a.cursor < len(a.listItems) {
|
||||
zone := a.listItems[a.cursor].Name
|
||||
a.confirmPrompt = fmt.Sprintf("Delete zone '%s' and all its records?", zone)
|
||||
a.confirmAction = func() tea.Cmd {
|
||||
return func() tea.Msg {
|
||||
return dnsAPIDelete("/api/zones/" + zone)
|
||||
}
|
||||
}
|
||||
a.pushView(ViewConfirm)
|
||||
}
|
||||
}
|
||||
return a, nil
|
||||
}
|
||||
|
||||
// ── DNS Commands ────────────────────────────────────────────────────
|
||||
|
||||
func (a App) buildDNSServer() (App, tea.Cmd) {
|
||||
a.pushView(ViewDNSBuild)
|
||||
a.outputLines = nil
|
||||
a.outputDone = false
|
||||
a.progressStep = 0
|
||||
a.progressTotal = 0
|
||||
|
||||
ch := make(chan tea.Msg, 256)
|
||||
a.outputCh = ch
|
||||
|
||||
go func() {
|
||||
dir := findAutarchDir()
|
||||
dnsDir := dir + "/services/dns-server"
|
||||
|
||||
steps := []CmdStep{
|
||||
{Label: "Download Go dependencies", Args: []string{"go", "mod", "download"}, Dir: dnsDir},
|
||||
{Label: "Build DNS server binary", Args: []string{"go", "build", "-o", "autarch-dns", "."}, Dir: dnsDir},
|
||||
}
|
||||
|
||||
streamSteps(ch, steps)
|
||||
}()
|
||||
|
||||
return a, a.waitForOutput()
|
||||
}
|
||||
|
||||
func (a App) toggleDNSService() (App, tea.Cmd) {
|
||||
return a.toggleService(1) // Index 1 = autarch-dns
|
||||
}
|
||||
|
||||
func (a App) editDNSConfig() (App, tea.Cmd) {
|
||||
// Load DNS config as a settings section
|
||||
dir := findAutarchDir()
|
||||
configPath := dir + "/data/dns/config.json"
|
||||
|
||||
data, err := readFileBytes(configPath)
|
||||
if err != nil {
|
||||
return a, func() tea.Msg {
|
||||
return ResultMsg{
|
||||
Title: "DNS Config",
|
||||
Lines: []string{
|
||||
"No DNS config file found at: " + configPath,
|
||||
"",
|
||||
"Start the DNS server once to generate a default config,",
|
||||
"or build and run: ./autarch-dns --config " + configPath,
|
||||
},
|
||||
IsError: true,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
var cfg map[string]interface{}
|
||||
if err := json.Unmarshal(data, &cfg); err != nil {
|
||||
return a, func() tea.Msg {
|
||||
return ResultMsg{Title: "Error", Lines: []string{"Invalid JSON: " + err.Error()}, IsError: true}
|
||||
}
|
||||
}
|
||||
|
||||
// Flatten to key=value for editing
|
||||
var keys []string
|
||||
var vals []string
|
||||
for k, v := range cfg {
|
||||
keys = append(keys, k)
|
||||
vals = append(vals, fmt.Sprintf("%v", v))
|
||||
}
|
||||
|
||||
a.settingsSection = "dns-config"
|
||||
a.settingsKeys = keys
|
||||
a.settingsVals = vals
|
||||
a.pushView(ViewSettingsSection)
|
||||
return a, nil
|
||||
}
|
||||
|
||||
func (a App) testDNSResolution() (App, tea.Cmd) {
|
||||
return a, func() tea.Msg {
|
||||
domains := []string{"google.com", "github.com", "cloudflare.com"}
|
||||
var lines []string
|
||||
|
||||
for _, domain := range domains {
|
||||
out, err := exec.Command("dig", "@127.0.0.1", domain, "+short", "+time=2").Output()
|
||||
if err != nil {
|
||||
lines = append(lines, styleError.Render(fmt.Sprintf(" ✘ %s: %s", domain, err.Error())))
|
||||
} else {
|
||||
result := strings.TrimSpace(string(out))
|
||||
if result == "" {
|
||||
lines = append(lines, styleWarning.Render(fmt.Sprintf(" ⚠ %s: no answer", domain)))
|
||||
} else {
|
||||
lines = append(lines, styleSuccess.Render(fmt.Sprintf(" ✔ %s → %s", domain, result)))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return ResultMsg{Title: "DNS Resolution Test (@127.0.0.1)", Lines: lines}
|
||||
}
|
||||
}
|
||||
|
||||
func (a App) viewDNSLogs() (App, tea.Cmd) {
|
||||
return a, func() tea.Msg {
|
||||
out, _ := exec.Command("journalctl", "-u", "autarch-dns", "-n", "30", "--no-pager").Output()
|
||||
lines := strings.Split(strings.TrimSpace(string(out)), "\n")
|
||||
return ResultMsg{Title: "DNS Server Logs (last 30)", Lines: lines}
|
||||
}
|
||||
}
|
||||
|
||||
func (a App) installDNSUnit() (App, tea.Cmd) {
|
||||
// Delegate to the service installer for just the DNS unit
|
||||
return a, func() tea.Msg {
|
||||
dir := findAutarchDir()
|
||||
unit := fmt.Sprintf(`[Unit]
|
||||
Description=AUTARCH DNS Server
|
||||
After=network.target
|
||||
|
||||
[Service]
|
||||
Type=simple
|
||||
User=root
|
||||
WorkingDirectory=%s
|
||||
ExecStart=%s/services/dns-server/autarch-dns --config %s/data/dns/config.json
|
||||
Restart=on-failure
|
||||
RestartSec=5
|
||||
|
||||
[Install]
|
||||
WantedBy=multi-user.target
|
||||
`, dir, dir, dir)
|
||||
|
||||
path := "/etc/systemd/system/autarch-dns.service"
|
||||
if err := writeFileAtomic(path, []byte(unit)); err != nil {
|
||||
return ResultMsg{Title: "Error", Lines: []string{err.Error()}, IsError: true}
|
||||
}
|
||||
exec.Command("systemctl", "daemon-reload").Run()
|
||||
|
||||
return ResultMsg{
|
||||
Title: "DNS Service Unit Installed",
|
||||
Lines: []string{
|
||||
"Installed: " + path,
|
||||
"",
|
||||
"Start with: systemctl start autarch-dns",
|
||||
"Enable on boot: systemctl enable autarch-dns",
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ── DNS API Management Commands ─────────────────────────────────────
|
||||
|
||||
func (a App) loadDNSZones() (App, tea.Cmd) {
|
||||
a.pushView(ViewDNSZones)
|
||||
|
||||
return a, func() tea.Msg {
|
||||
zones := dnsAPIGet("/api/zones")
|
||||
if zones == nil {
|
||||
return dnsZonesMsg{items: nil}
|
||||
}
|
||||
|
||||
zoneList, ok := zones.([]interface{})
|
||||
if !ok {
|
||||
return dnsZonesMsg{items: nil}
|
||||
}
|
||||
|
||||
var items []ListItem
|
||||
for _, z := range zoneList {
|
||||
zMap, ok := z.(map[string]interface{})
|
||||
if !ok {
|
||||
continue
|
||||
}
|
||||
name := fmt.Sprintf("%v", zMap["domain"])
|
||||
recordCount := 0
|
||||
if records, ok := zMap["records"].([]interface{}); ok {
|
||||
recordCount = len(records)
|
||||
}
|
||||
items = append(items, ListItem{
|
||||
Name: name,
|
||||
Status: fmt.Sprintf("%d records", recordCount),
|
||||
})
|
||||
}
|
||||
return dnsZonesMsg{items: items}
|
||||
}
|
||||
}
|
||||
|
||||
type dnsZonesMsg struct{ items []ListItem }
|
||||
|
||||
func (a App) openDNSZoneForm() (App, tea.Cmd) {
|
||||
a.labels = []string{"Domain", "Primary NS", "Admin Email", "Default TTL"}
|
||||
a.inputs = make([]textinput.Model, 4)
|
||||
|
||||
defaults := []string{"", "ns1.example.com", "admin.example.com", "3600"}
|
||||
for i := range a.inputs {
|
||||
ti := textinput.New()
|
||||
ti.CharLimit = 256
|
||||
ti.Width = 40
|
||||
ti.SetValue(defaults[i])
|
||||
if i == 0 {
|
||||
ti.Focus()
|
||||
ti.SetValue("")
|
||||
}
|
||||
a.inputs[i] = ti
|
||||
}
|
||||
a.focusIdx = 0
|
||||
a.pushView(ViewDNSZoneEdit)
|
||||
return a, nil
|
||||
}
|
||||
|
||||
func (a App) submitDNSZone() (App, tea.Cmd) {
|
||||
domain := a.inputs[0].Value()
|
||||
ns := a.inputs[1].Value()
|
||||
admin := a.inputs[2].Value()
|
||||
ttl := a.inputs[3].Value()
|
||||
|
||||
if domain == "" {
|
||||
return a, func() tea.Msg {
|
||||
return ResultMsg{Title: "Error", Lines: []string{"Domain cannot be empty."}, IsError: true}
|
||||
}
|
||||
}
|
||||
|
||||
a.popView()
|
||||
|
||||
return a, func() tea.Msg {
|
||||
body := fmt.Sprintf(`{"domain":"%s","soa":{"primary_ns":"%s","admin_email":"%s","ttl":%s}}`,
|
||||
domain, ns, admin, ttl)
|
||||
return dnsAPIPost("/api/zones", body)
|
||||
}
|
||||
}
|
||||
|
||||
func (a App) viewDNSZoneRecords(zone string) (App, tea.Cmd) {
|
||||
return a, func() tea.Msg {
|
||||
data := dnsAPIGet("/api/zones/" + zone + "/records")
|
||||
if data == nil {
|
||||
return ResultMsg{Title: "Zone: " + zone, Lines: []string{"No records or API unreachable."}, IsError: true}
|
||||
}
|
||||
|
||||
records, ok := data.([]interface{})
|
||||
if !ok {
|
||||
return ResultMsg{Title: "Zone: " + zone, Lines: []string{"Unexpected response format."}, IsError: true}
|
||||
}
|
||||
|
||||
var lines []string
|
||||
lines = append(lines, fmt.Sprintf("Zone: %s — %d records", zone, len(records)))
|
||||
lines = append(lines, "")
|
||||
lines = append(lines, styleDim.Render(fmt.Sprintf(" %-8s %-30s %-6s %s", "TYPE", "NAME", "TTL", "VALUE")))
|
||||
lines = append(lines, styleDim.Render(" "+strings.Repeat("─", 70)))
|
||||
|
||||
for _, r := range records {
|
||||
rec, ok := r.(map[string]interface{})
|
||||
if !ok {
|
||||
continue
|
||||
}
|
||||
lines = append(lines, fmt.Sprintf(" %-8v %-30v %-6v %v",
|
||||
rec["type"], rec["name"], rec["ttl"], rec["value"]))
|
||||
}
|
||||
|
||||
return ResultMsg{Title: "Zone: " + zone, Lines: lines}
|
||||
}
|
||||
}
|
||||
|
||||
func (a App) manageDNSHosts() (App, tea.Cmd) {
|
||||
return a, func() tea.Msg {
|
||||
data := dnsAPIGet("/api/hosts")
|
||||
if data == nil {
|
||||
return ResultMsg{Title: "DNS Hosts", Lines: []string{"API unreachable."}, IsError: true}
|
||||
}
|
||||
|
||||
hosts, ok := data.([]interface{})
|
||||
if !ok {
|
||||
return ResultMsg{Title: "DNS Hosts", Lines: []string{"No hosts entries."}}
|
||||
}
|
||||
|
||||
var lines []string
|
||||
lines = append(lines, fmt.Sprintf("%d host entries", len(hosts)))
|
||||
lines = append(lines, "")
|
||||
for _, h := range hosts {
|
||||
hMap, _ := h.(map[string]interface{})
|
||||
lines = append(lines, fmt.Sprintf(" %-16v %v", hMap["ip"], hMap["hostname"]))
|
||||
}
|
||||
return ResultMsg{Title: "DNS Hosts", Lines: lines}
|
||||
}
|
||||
}
|
||||
|
||||
func (a App) manageDNSBlocklist() (App, tea.Cmd) {
|
||||
return a, func() tea.Msg {
|
||||
data := dnsAPIGet("/api/blocklist")
|
||||
if data == nil {
|
||||
return ResultMsg{Title: "DNS Blocklist", Lines: []string{"API unreachable."}, IsError: true}
|
||||
}
|
||||
|
||||
bl, ok := data.(map[string]interface{})
|
||||
if !ok {
|
||||
return ResultMsg{Title: "DNS Blocklist", Lines: []string{"Unexpected format."}}
|
||||
}
|
||||
|
||||
var lines []string
|
||||
if domains, ok := bl["domains"].([]interface{}); ok {
|
||||
lines = append(lines, fmt.Sprintf("%d blocked domains", len(domains)))
|
||||
lines = append(lines, "")
|
||||
max := 30
|
||||
if len(domains) < max {
|
||||
max = len(domains)
|
||||
}
|
||||
for _, d := range domains[:max] {
|
||||
lines = append(lines, " "+fmt.Sprintf("%v", d))
|
||||
}
|
||||
if len(domains) > 30 {
|
||||
lines = append(lines, styleDim.Render(fmt.Sprintf(" ... and %d more", len(domains)-30)))
|
||||
}
|
||||
} else {
|
||||
lines = append(lines, "Blocklist is empty.")
|
||||
}
|
||||
|
||||
return ResultMsg{Title: "DNS Blocklist", Lines: lines}
|
||||
}
|
||||
}
|
||||
|
||||
func (a App) manageDNSForwarding() (App, tea.Cmd) {
|
||||
return a, func() tea.Msg {
|
||||
data := dnsAPIGet("/api/forwarding")
|
||||
if data == nil {
|
||||
return ResultMsg{Title: "DNS Forwarding", Lines: []string{"API unreachable."}, IsError: true}
|
||||
}
|
||||
|
||||
rules, ok := data.([]interface{})
|
||||
if !ok {
|
||||
return ResultMsg{Title: "DNS Forwarding", Lines: []string{"No forwarding rules configured."}}
|
||||
}
|
||||
|
||||
var lines []string
|
||||
lines = append(lines, fmt.Sprintf("%d forwarding rules", len(rules)))
|
||||
lines = append(lines, "")
|
||||
for _, r := range rules {
|
||||
rMap, _ := r.(map[string]interface{})
|
||||
lines = append(lines, fmt.Sprintf(" %v → %v", rMap["zone"], rMap["upstream"]))
|
||||
}
|
||||
return ResultMsg{Title: "DNS Forwarding Rules", Lines: lines}
|
||||
}
|
||||
}
|
||||
|
||||
func (a App) flushDNSCache() (App, tea.Cmd) {
|
||||
return a, func() tea.Msg {
|
||||
return dnsAPIDelete("/api/cache")
|
||||
}
|
||||
}
|
||||
|
||||
func (a App) viewDNSQueryLog() (App, tea.Cmd) {
|
||||
return a, func() tea.Msg {
|
||||
data := dnsAPIGet("/api/querylog?limit=30")
|
||||
if data == nil {
|
||||
return ResultMsg{Title: "DNS Query Log", Lines: []string{"API unreachable."}, IsError: true}
|
||||
}
|
||||
|
||||
entries, ok := data.([]interface{})
|
||||
if !ok {
|
||||
return ResultMsg{Title: "DNS Query Log", Lines: []string{"No entries."}}
|
||||
}
|
||||
|
||||
var lines []string
|
||||
for _, e := range entries {
|
||||
eMap, _ := e.(map[string]interface{})
|
||||
lines = append(lines, fmt.Sprintf(" %-20v %-6v %-30v %v",
|
||||
eMap["time"], eMap["type"], eMap["name"], eMap["client"]))
|
||||
}
|
||||
return ResultMsg{Title: "DNS Query Log (last 30)", Lines: lines}
|
||||
}
|
||||
}
|
||||
|
||||
func (a App) viewDNSTopDomains() (App, tea.Cmd) {
|
||||
return a, func() tea.Msg {
|
||||
data := dnsAPIGet("/api/stats/top-domains?limit=20")
|
||||
if data == nil {
|
||||
return ResultMsg{Title: "Top Domains", Lines: []string{"API unreachable."}, IsError: true}
|
||||
}
|
||||
|
||||
domains, ok := data.([]interface{})
|
||||
if !ok {
|
||||
return ResultMsg{Title: "Top Domains", Lines: []string{"No data."}}
|
||||
}
|
||||
|
||||
var lines []string
|
||||
for i, d := range domains {
|
||||
dMap, _ := d.(map[string]interface{})
|
||||
lines = append(lines, fmt.Sprintf(" %2d. %-40v %v queries", i+1, dMap["domain"], dMap["count"]))
|
||||
}
|
||||
return ResultMsg{Title: "Top 20 Queried Domains", Lines: lines}
|
||||
}
|
||||
}
|
||||
|
||||
func (a App) viewDNSEncryption() (App, tea.Cmd) {
|
||||
return a, func() tea.Msg {
|
||||
data := dnsAPIGet("/api/encryption")
|
||||
if data == nil {
|
||||
return ResultMsg{Title: "DNS Encryption", Lines: []string{"API unreachable."}, IsError: true}
|
||||
}
|
||||
|
||||
enc, _ := data.(map[string]interface{})
|
||||
var lines []string
|
||||
for k, v := range enc {
|
||||
status := styleStatusBad.Render("disabled")
|
||||
if v == true {
|
||||
status = styleStatusOK.Render("enabled")
|
||||
}
|
||||
lines = append(lines, fmt.Sprintf(" %-20s %s", k, status))
|
||||
}
|
||||
return ResultMsg{Title: "DNS Encryption Status", Lines: lines}
|
||||
}
|
||||
}
|
||||
|
||||
func (a App) dnsRootCheck() (App, tea.Cmd) {
|
||||
return a, func() tea.Msg {
|
||||
body := dnsAPIPostRaw("/api/rootcheck", "")
|
||||
if body == nil {
|
||||
return ResultMsg{Title: "Root Check", Lines: []string{"API unreachable."}, IsError: true}
|
||||
}
|
||||
|
||||
results, ok := body.([]interface{})
|
||||
if !ok {
|
||||
return ResultMsg{Title: "Root Check", Lines: []string{"Unexpected format."}}
|
||||
}
|
||||
|
||||
var lines []string
|
||||
for _, r := range results {
|
||||
rMap, _ := r.(map[string]interface{})
|
||||
latency := fmt.Sprintf("%v", rMap["latency"])
|
||||
status := styleSuccess.Render("✔")
|
||||
if rMap["error"] != nil && rMap["error"] != "" {
|
||||
status = styleError.Render("✘")
|
||||
latency = fmt.Sprintf("%v", rMap["error"])
|
||||
}
|
||||
lines = append(lines, fmt.Sprintf(" %s %-20v %s", status, rMap["server"], latency))
|
||||
}
|
||||
return ResultMsg{Title: "Root Server Latency Check", Lines: lines}
|
||||
}
|
||||
}
|
||||
|
||||
// ── DNS API Helpers ─────────────────────────────────────────────────
|
||||
|
||||
func getDNSAPIBase() string {
|
||||
return "http://127.0.0.1:5380"
|
||||
}
|
||||
|
||||
func getDNSAPIToken() string {
|
||||
dir := findAutarchDir()
|
||||
configPath := dir + "/data/dns/config.json"
|
||||
data, err := readFileBytes(configPath)
|
||||
if err != nil {
|
||||
return ""
|
||||
}
|
||||
var cfg map[string]interface{}
|
||||
if err := json.Unmarshal(data, &cfg); err != nil {
|
||||
return ""
|
||||
}
|
||||
if token, ok := cfg["api_token"].(string); ok {
|
||||
return token
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func getDNSAPIStatus() map[string]interface{} {
|
||||
data := dnsAPIGet("/api/metrics")
|
||||
if data == nil {
|
||||
return nil
|
||||
}
|
||||
m, ok := data.(map[string]interface{})
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
return m
|
||||
}
|
||||
|
||||
func dnsAPIGet(path string) interface{} {
|
||||
url := getDNSAPIBase() + path
|
||||
token := getDNSAPIToken()
|
||||
|
||||
req, err := http.NewRequest("GET", url, nil)
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
if token != "" {
|
||||
req.Header.Set("Authorization", "Bearer "+token)
|
||||
}
|
||||
|
||||
client := &http.Client{}
|
||||
resp, err := client.Do(req)
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
var result interface{}
|
||||
json.NewDecoder(resp.Body).Decode(&result)
|
||||
return result
|
||||
}
|
||||
|
||||
func dnsAPIPost(path, body string) tea.Msg {
|
||||
result := dnsAPIPostRaw(path, body)
|
||||
if result == nil {
|
||||
return ResultMsg{Title: "Error", Lines: []string{"API request failed."}, IsError: true}
|
||||
}
|
||||
return ResultMsg{Title: "Success", Lines: []string{"Operation completed."}}
|
||||
}
|
||||
|
||||
func dnsAPIPostRaw(path, body string) interface{} {
|
||||
url := getDNSAPIBase() + path
|
||||
token := getDNSAPIToken()
|
||||
|
||||
req, err := http.NewRequest("POST", url, strings.NewReader(body))
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
if token != "" {
|
||||
req.Header.Set("Authorization", "Bearer "+token)
|
||||
}
|
||||
|
||||
client := &http.Client{}
|
||||
resp, err := client.Do(req)
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
var result interface{}
|
||||
json.NewDecoder(resp.Body).Decode(&result)
|
||||
return result
|
||||
}
|
||||
|
||||
func dnsAPIDelete(path string) tea.Msg {
|
||||
url := getDNSAPIBase() + path
|
||||
token := getDNSAPIToken()
|
||||
|
||||
req, err := http.NewRequest("DELETE", url, nil)
|
||||
if err != nil {
|
||||
return ResultMsg{Title: "Error", Lines: []string{err.Error()}, IsError: true}
|
||||
}
|
||||
if token != "" {
|
||||
req.Header.Set("Authorization", "Bearer "+token)
|
||||
}
|
||||
|
||||
client := &http.Client{}
|
||||
resp, err := client.Do(req)
|
||||
if err != nil {
|
||||
return ResultMsg{Title: "Error", Lines: []string{err.Error()}, IsError: true}
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
return ResultMsg{Title: "Success", Lines: []string{"Deleted."}}
|
||||
}
|
||||
Reference in New Issue
Block a user