128 lines
2.9 KiB
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)
|
|
}
|
|
}
|