Add first iteration of YAML based router definitions

f0o · f0o · commit adfd38d35f73 · 2024-06-08T11:56:46.000Z
Add healthchecks
diff --git a/Dockerfile b/Dockerfile
@@ -15,13 +15,14 @@ RUN cd protobuf \
 
 FROM golang:alpine AS go-builder
 ENV CGO_ENABLED=0
+ENV VERSION=untracked
 WORKDIR /opt
 COPY server /opt/server
 COPY go.mod go.sum main.go /opt/.
 COPY --from=buf-builder /opt/protobuf /opt/protobuf
 COPY --from=node-builder /opt/dist /opt/dist
 RUN go mod tidy \
- && go build -o /opt/looking-glass
+ && go build -ldflags="-X gitlab.as203038.net/AS203038/looking-glass/server/utils.release=${VERSION}" -o /opt/looking-glass
 
 FROM scratch
 WORKDIR /
diff --git a/example.config.yaml b/example.config.yaml
@@ -11,6 +11,7 @@ devices:                                                                  # List
       vrf: "vrf1"                                                         #   VRF name, most platforms use 'default' if no VRF is used (required)
 
 grpc:                                                                     # gRPC Server Settings
+    enabled: true                                                         #   Enable or disable GRPC endpoints
     listen: ":8080"                                                       #   gRPC listener
     tls:                                                                  #   TLS Settings often required for h2c
         enabled: false                                                    #     Enable or disable TLS
@@ -23,6 +24,7 @@ web:                                                                      # WebU
     grpc_url: ""                                                          #   URI of the GRCP server; uses current host as viewed by the browser if not set (optional)
     theme: "skeleton"                                                     #   Theme, possible options are: skeleton, wintry, modern, rocket, seafoam, vintage, sahara, hamlindingo, gold-nouveau, crimson (ref https://www.skeleton.dev/docs/themes)
     title: "Example Web Page"                                             #   Freetext web page title (recommended)
+    rt_list_max: 4                                                        #   Maximum number of devices to display as list before grouping by location (optional, defaults to 4, use -1 to force grouping by location)
     header:                                                               #   Header navbar definitions (recommended)
         text: "Welcome to Example Website"                                #     Freetext header text, will be centered (recommended)
         logo: "/path/to/logo"                                             #     Header logo path (optional)
diff --git a/protobuf/lookingglass/v0/lookingglass.proto b/protobuf/lookingglass/v0/lookingglass.proto
@@ -3,6 +3,8 @@
 syntax = "proto3";
 
 package lookingglass.v0;
+import "google/protobuf/empty.proto";
+import "google/protobuf/timestamp.proto";
 
 option go_package = "gitlab.as203038.net/AS203038/looking-glass/protobuf/lookingglass/v0;lookingglass";
 option java_multiple_files = true;
@@ -11,6 +13,7 @@ option java_package = "lookingglass.v0";
 
 // Data Streaming Service
 service LookingGlassService {
+  rpc GetInfo(google.protobuf.Empty) returns (GetInfoResponse) {}
   rpc GetRouters(GetRoutersRequest) returns (GetRoutersResponse) {}
   rpc Ping(PingRequest) returns (PingResponse) {}
   rpc Traceroute(TracerouteRequest) returns (TracerouteResponse) {}
@@ -20,6 +23,13 @@ service LookingGlassService {
   rpc BGPASPath(BGPASPathRequest) returns (BGPASPathResponse) {}
 }
 
+message RouterHealth {
+  // Time Checked
+  google.protobuf.Timestamp timestamp = 1;
+  // Status
+  bool healthy = 2;
+}
+
 // Router is a router.
 message Router {
   // The ID of the router.
@@ -28,6 +38,8 @@ message Router {
   string name = 2;
   // The Location of the router.
   string location = 4;
+  // Health of the router.
+  RouterHealth health = 5;
 }
 
 // BGPCommunity is a BGP community.g
@@ -38,6 +50,14 @@ message BGPCommunity {
   int32 value = 2;
 }
 
+// GetInfoResponse is the response message for GetInfo.
+message GetInfoResponse {
+  // The hostname of the service.
+  string hostname = 1;
+  // The version of the service.
+  string version = 2;
+}
+
 // GetRoutersRequest is the request message for GetRouters.
 message GetRoutersRequest {
   // The number of routers to return.
diff --git a/server/errs/router.go b/server/errs/router.go
@@ -7,4 +7,5 @@ import (
 var (
 	UnknownRouter     = errors.New("router unknown")
 	RouterUnavailable = errors.New("router unavailable")
+	OperationUnknown  = errors.New("operation unknown")
 )
diff --git a/server/http/grpc/grpc.go b/server/http/grpc/grpc.go
@@ -56,4 +56,31 @@ func Mux(ctx context.Context, mux *http.ServeMux, rts utils.RouterMap) {
 	interceptors := connect.WithInterceptors(NewLogInterceptor())
 	mux.Handle(lookingglassconnect.NewLookingGlassServiceHandler(NewLookingGlassService(ctx, rts), interceptors))
 	mux.Handle(grpchealth.NewHandler(Health))
+	Health.SetStatus(lookingglassconnect.LookingGlassServiceName, grpchealth.StatusServing)
+	go healthcheck(ctx, rts)
+}
+
+func healthcheck(ctx context.Context, rts utils.RouterMap) {
+	ticker := time.NewTicker(time.Minute)
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case <-ticker.C:
+			for _, r := range rts {
+				o := r.HealthCheck.Healthy
+				if err := r.Healthcheck(); err == nil {
+					if !o {
+						Health.SetStatus(lookingglassconnect.LookingGlassServiceName+"/"+r.Config.Name, grpchealth.StatusServing)
+						log.Printf("Router %s is healthy", r.Config.Name)
+					}
+				} else {
+					if o {
+						Health.SetStatus(lookingglassconnect.LookingGlassServiceName+"/"+r.Config.Name, grpchealth.StatusNotServing)
+						log.Printf("Router %s is unhealthy: %s", r.Config.Name, err)
+					}
+				}
+			}
+		}
+	}
 }
diff --git a/server/http/grpc/service.go b/server/http/grpc/service.go
@@ -2,6 +2,7 @@ package grpc
 
 import (
 	"context"
+	"os"
 	"strconv"
 	"strings"
 
@@ -10,6 +11,8 @@ import (
 	"gitlab.as203038.net/AS203038/looking-glass/protobuf/lookingglass/v0/lookingglassconnect"
 	"gitlab.as203038.net/AS203038/looking-glass/server/errs"
 	"gitlab.as203038.net/AS203038/looking-glass/server/utils"
+	emptypb "google.golang.org/protobuf/types/known/emptypb"
+	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
 )
 
 type LookingGlassService struct {
@@ -25,6 +28,17 @@ func NewLookingGlassService(ctx context.Context, rts utils.RouterMap) lookinggla
 	}
 }
 
+func (s *LookingGlassService) GetInfo(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[pb.GetInfoResponse], error) {
+	h, err := os.Hostname()
+	if err != nil {
+		h = "unknown"
+	}
+	return connect.NewResponse(&pb.GetInfoResponse{
+		Hostname: h,
+		Version:  utils.Version(),
+	}), nil
+}
+
 func (s *LookingGlassService) GetRouters(ctx context.Context, req *connect.Request[pb.GetRoutersRequest]) (*connect.Response[pb.GetRoutersResponse], error) {
 	var ret []*pb.Router
 	lim := req.Msg.GetLimit()
@@ -49,6 +63,13 @@ func (s *LookingGlassService) GetRouters(ctx context.Context, req *connect.Reque
 			Name:     v.Config.Name,
 			Location: v.Config.Location,
 			Id:       int64(k + 1),
+			Health: &pb.RouterHealth{
+				Healthy: v.HealthCheck.Healthy,
+				Timestamp: &timestamppb.Timestamp{
+					Seconds: v.HealthCheck.Checked.Unix(),
+					Nanos:   int32(v.HealthCheck.Checked.Nanosecond()),
+				},
+			},
 		})
 	}
 	var nextPage uint32
diff --git a/server/http/http.go b/server/http/http.go
@@ -77,7 +77,9 @@ func SecurityTxtInjector(cfg utils.SecurityTxtConfig) http.Handler {
 
 func ListenAndServe(ctx context.Context, cfg *utils.Config, rts utils.RouterMap, webfs fs.FS) error {
 	mux := http.NewServeMux()
-	grpc.Mux(ctx, mux, rts)
+	if cfg.Grpc.Enabled {
+		grpc.Mux(ctx, mux, rts)
+	}
 	if cfg.SecurityTxt.Enabled {
 		mux.Handle("/.well-known/security.txt", HTTPHandler(SecurityTxtInjector(cfg.SecurityTxt)))
 	}
diff --git a/server/http/webui/webui.go b/server/http/webui/webui.go
@@ -17,6 +17,8 @@ type EnvJS struct {
 	FooterLinks string `json:"PUBLIC_FOOTER_LINKS"`
 	FooterLogo  string `json:"PUBLIC_FOOTER_LOGO"`
 	GrpcURL     string `json:"PUBLIC_GRPC_URL"`
+	LGVersion   string `json:"PUBLIC_LG_VERSION"`
+	RtListMax   int    `json:"PUBLIC_RT_LIST_MAX"`
 }
 
 func ConfigInjector(cfg utils.WebConfig) http.Handler {
@@ -30,6 +32,8 @@ func ConfigInjector(cfg utils.WebConfig) http.Handler {
 		FooterLinks: cfg.Footer.LinksString(),
 		FooterLogo:  cfg.Footer.Logo,
 		GrpcURL:     cfg.GrpcURL,
+		LGVersion:   utils.Version(),
+		RtListMax:   cfg.RtListMax,
 	})
 	if err != nil {
 		panic(err)
diff --git a/server/routers/frrouting.yml b/server/routers/frrouting.yml
@@ -0,0 +1,28 @@
+name: frrouting
+
+ping: 
+    # any:
+    #     - ping -n -c5 {{.IP.IP}}
+    ipv4:
+        - ping -n -4 -c5 -I {{.Cfg.Source4.IP}} {{.IP.IP}}
+    ipv6:
+        - ping -n -6 -c5 -I {{.Cfg.Source6.IP}} {{.IP.IP}}
+
+traceroute:
+    # any:
+    #     - traceroute -w 1 -q1 -I --back --mtu -e {{.IP.IP}}
+    ipv4:
+        - traceroute -4 -w 1 -q1 -I --back --mtu -e -s {{.Cfg.Source4.IP}} {{.IP.IP}}
+    ipv6:
+        - traceroute -6 -w 1 -q1 -I --back --mtu -e -s {{.Cfg.Source6.IP}} {{.IP.IP}}
+
+bgp:
+    route: 
+        - vtysh -c 'show bgp vrf {{.Cfg.VRF}} {{.IP.Family}} unicast {{.IP.IP}}'
+    community:
+        - vtysh -c 'show bgp vrf {{.Cfg.VRF}} ipv4 unicast community {{.Community}}'
+        - vtysh -c 'show bgp vrf {{.Cfg.VRF}} ipv6 unicast community {{.Community}}'
+    aspath:
+        - vtysh -c 'show bgp vrf {{.Cfg.VRF}} ipv4 unicast regexp {{.ASPath}}'
+        - vtysh -c 'show bgp vrf {{.Cfg.VRF}} ipv6 unicast regexp {{.ASPath}}'
+
diff --git a/server/routers/routers.go b/server/routers/routers.go
@@ -33,10 +33,13 @@ func CreateRouterMap(cfg *utils.Config) utils.RouterMap {
 			log.Printf("Router Type %s not found (%s)\n", v.Type, v.Name)
 			continue
 		}
-		rm = append(rm, utils.RouterInstance{
-			Config: &v,
-			Router: Get(v.Type),
-		})
+		ri := &utils.RouterInstance{
+			Config:      &v,
+			Router:      Get(v.Type),
+			HealthCheck: &utils.HealthCheck{},
+		}
+		go ri.Healthcheck()
+		rm = append(rm, ri)
 	}
 	return rm
 }
diff --git a/server/routers/yaml.go b/server/routers/yaml.go
@@ -0,0 +1,131 @@
+package routers
+
+import (
+	"bytes"
+	"embed"
+	"fmt"
+	"text/template"
+
+	"gitlab.as203038.net/AS203038/looking-glass/server/errs"
+	"gitlab.as203038.net/AS203038/looking-glass/server/utils"
+	yaml "gopkg.in/yaml.v2"
+)
+
+type _tpl_data struct {
+	Cfg       *utils.RouterConfig
+	IP        *utils.IPNet
+	Community string
+	ASPath    string
+}
+
+type Yaml struct {
+	Path     string
+	Template struct {
+		Name string `yaml:"name"`
+		Ping struct {
+			Any  []string `yaml:"any"`
+			IPv4 []string `yaml:"ipv4"`
+			IPv6 []string `yaml:"ipv6"`
+		} `yaml:"ping"`
+		Traceroute struct {
+			Any  []string `yaml:"any"`
+			IPv4 []string `yaml:"ipv4"`
+			IPv6 []string `yaml:"ipv6"`
+		} `yaml:"traceroute"`
+		BGP struct {
+			Route     []string `yaml:"route"`
+			Community []string `yaml:"community"`
+			ASPath    []string `yaml:"aspath"`
+		} `yaml:"bgp"`
+	}
+}
+
+//go:embed all:*.yml
+var compiledRouters embed.FS
+
+func init() {
+	// Load all routers
+	files, err := compiledRouters.ReadDir(".")
+	if err != nil {
+		panic(err)
+	}
+	for _, file := range files {
+		y := &Yaml{}
+		y.Path = file.Name()
+		yamlFile, err := compiledRouters.ReadFile(y.Path)
+		if err != nil {
+			panic(err)
+		}
+		err = yaml.Unmarshal(yamlFile, &y.Template)
+		if err != nil {
+			panic(err)
+		}
+		register(y.Template.Name, y)
+		fmt.Printf("Router %s registered\n", y.Template.Name)
+	}
+}
+
+func (rt *Yaml) _tpl(name string, data _tpl_data) ([]string, error) {
+	var tpl []string
+	var ret []string
+	switch name {
+	case "ping":
+		if rt.Template.Ping.Any != nil {
+			tpl = rt.Template.Ping.Any
+		} else if data.IP.IsIPv4() {
+			tpl = rt.Template.Ping.IPv4
+		} else if data.IP.IsIPv6() {
+			tpl = rt.Template.Ping.IPv6
+		}
+	case "traceroute":
+		if rt.Template.Traceroute.Any != nil {
+			tpl = rt.Template.Traceroute.Any
+		} else if data.IP.IsIPv4() {
+			tpl = rt.Template.Traceroute.IPv4
+		} else if data.IP.IsIPv6() {
+			tpl = rt.Template.Traceroute.IPv6
+		}
+	case "bgp.route":
+		tpl = rt.Template.BGP.Route
+	case "bgp.community":
+		tpl = rt.Template.BGP.Community
+	case "bgp.aspath":
+		tpl = rt.Template.BGP.ASPath
+	}
+	if tpl == nil {
+		return nil, errs.OperationUnknown
+	}
+	for _, t := range tpl {
+		var buf bytes.Buffer
+		tt, err := template.New(t).Parse(t)
+		if err != nil {
+			return nil, err
+		}
+		err = tt.Execute(&buf, data)
+		if err != nil {
+			return nil, err
+		}
+		ret = append(ret, buf.String())
+	}
+	return ret, nil
+}
+
+func (rt *Yaml) Ping(cfg *utils.RouterConfig, ip *utils.IPNet) ([]string, error) {
+	return rt._tpl("ping", _tpl_data{Cfg: cfg, IP: ip})
+}
+
+func (rt *Yaml) Traceroute(cfg *utils.RouterConfig, ip *utils.IPNet) ([]string, error) {
+	return rt._tpl("traceroute", _tpl_data{Cfg: cfg, IP: ip})
+}
+
+func (rt *Yaml) BGPRoute(cfg *utils.RouterConfig, ip *utils.IPNet) ([]string, error) {
+	return rt._tpl("bgp.route", _tpl_data{Cfg: cfg, IP: ip})
+}
+
+func (rt *Yaml) BGPCommunity(cfg *utils.RouterConfig, community string) ([]string, error) {
+	return rt._tpl("bgp.community", _tpl_data{Cfg: cfg, Community: community})
+}
+
+func (rt *Yaml) BGPASPath(cfg *utils.RouterConfig, aspath string) ([]string, error) {
+	return rt._tpl("bgp.aspath", _tpl_data{Cfg: cfg, ASPath: aspath})
+}
diff --git a/server/utils/config.go b/server/utils/config.go
diff --git a/server/utils/interface.go b/server/utils/interface.go
diff --git a/webui/package-lock.json b/webui/package-lock.json
diff --git a/webui/src/lib/components/listRouters.svelte b/webui/src/lib/components/listRouters.svelte
diff --git a/webui/src/routes/+layout.svelte b/webui/src/routes/+layout.svelte

Original file line number	Diff line number	Diff line change
`@@ -7,4 +7,5 @@ import (`
`7`	`7`	`var (`
`8`	`8`	`UnknownRouter = errors.New("router unknown")`
`9`	`9`	`RouterUnavailable = errors.New("router unavailable")`
	`10`	`+ OperationUnknown = errors.New("operation unknown")`
`10`	`11`	`)`
Original file line number	Diff line number	Diff line change
`@@ -33,10 +33,13 @@ func CreateRouterMap(cfg *utils.Config) utils.RouterMap {`
`33`	`33`	`log.Printf("Router Type %s not found (%s)\n", v.Type, v.Name)`
`34`	`34`	`continue`
`35`	`35`	`}`
`36`		`- rm = append(rm, utils.RouterInstance{`
`37`		`- Config: &v,`
`38`		`- Router: Get(v.Type),`
`39`		`- })`
	`36`	`+ ri := &utils.RouterInstance{`
	`37`	`+ Config: &v,`
	`38`	`+ Router: Get(v.Type),`
	`39`	`+ HealthCheck: &utils.HealthCheck{},`
	`40`	`+ }`
	`41`	`+ go ri.Healthcheck()`
	`42`	`+ rm = append(rm, ri)`
`40`	`43`	`}`
`41`	`44`	`return rm`
`42`	`45`	`}`