topology-map/main.go

128 lines
2.9 KiB
Go

package main
import (
"encoding/json"
"fmt"
"html/template"
"net/http"
"git.faercol.me/faercol/topology-map/internal/cache"
"git.faercol.me/faercol/topology-map/internal/config"
"git.faercol.me/faercol/topology-map/internal/mikrotik"
"git.faercol.me/faercol/topology-map/internal/models"
"git.faercol.me/faercol/topology-map/internal/netbox"
)
func main() {
config, err := config.New("build/config.json")
if err != nil {
panic(err)
}
fmt.Println("Initializing data")
dataCache := cache.NewDataCache()
netboxClt := netbox.NewClient(config.Netbox.BaseURL, config.Netbox.APIKey)
mikrotikClt := mikrotik.NewMikrotikClient(config.Mikrotik)
fmt.Println("Getting devices")
devices, err := netboxClt.GetDevices()
if err != nil {
panic(err)
}
for _, d := range devices {
dataCache.AddDevice(d)
}
fmt.Println("Getting VMs")
vms, err := netboxClt.GetVMs()
if err != nil {
panic(err)
}
for _, v := range vms {
dataCache.AddVM(v)
}
fmt.Println("Getting cables")
cables, err := netboxClt.GetCables()
if err != nil {
panic(err)
}
for _, c := range cables {
dataCache.AddCable(c)
}
fmt.Println("Getting interfaces")
interfaces, err := netboxClt.GetInterfaces()
if err != nil {
panic(err)
}
for _, i := range interfaces {
dataCache.AddInterface(i)
}
fmt.Println("Getting data from ARP cache")
arpCache, err := mikrotikClt.GetARPRecords()
if err != nil {
panic(err)
}
dataCache.AddARPRecords(arpCache)
fmt.Println("Reconciling data")
dataCache.ReconcileData()
fmt.Println("Done")
srv := http.NewServeMux()
srv.HandleFunc("/static/", func(w http.ResponseWriter, r *http.Request) {
fmt.Println("Serving static file")
fs := http.FileServer(http.Dir("./static"))
http.StripPrefix("/static", fs).ServeHTTP(w, r)
})
srv.HandleFunc("/api/data", func(w http.ResponseWriter, r *http.Request) {
fmt.Println("Serving API route")
resp := []models.Element{}
for _, d := range dataCache.GetDevices() {
resp = append(resp, d.Element())
}
for _, c := range dataCache.GetCables() {
resp = append(resp, c.Element())
}
for _, v := range dataCache.GetVMs() {
resp = append(resp, v.Elements()...)
}
for _, unm := range dataCache.GetUnmonitoredMachines() {
resp = append(resp, unm.Element())
}
respBody, err := json.Marshal(resp)
if err != nil {
fmt.Printf("Failed to serialize data: %s\n", err)
w.WriteHeader(500)
return
}
w.Header().Add("Content-Type", "application/json")
w.Write(respBody)
})
srv.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
fmt.Println("Serving main root")
tpl, err := template.New("index.html").ParseFiles("templates/index.html")
if err != nil {
fmt.Printf("Failed to read template: %s\n", err)
w.WriteHeader(500)
return
}
if err := tpl.Execute(w, nil); err != nil {
fmt.Printf("Failed to execute template: %s\n", err)
w.WriteHeader(500)
return
}
})
if err := http.ListenAndServe("0.0.0.0:5000", srv); err != nil {
panic(err)
}
}