Add versioning, serve routes over an internal service

Taskfile.yml

@@ -4,7 +4,7 @@ vars:
   GIT_TAG: 
     sh: git tag --points-at HEAD
   GIT_COMMIT:
-    sh: git rev-parse HEAD
+    sh: git rev-parse --short HEAD
   GIT_DIRTY:
     sh: git status -s
   VERSION:
@@ -54,12 +54,15 @@ tasks:
       - task: builder
         vars:
           CLI_ARGS: /bin/sh -c 'cd ./proto/routerclientpb; protoc --proto_path=/go/bin:. --micro_out=paths=source_relative:. --go_out=paths=source_relative:. routerclientpb.proto'
+      - task: builder
+        vars:
+          CLI_ARGS: /bin/sh -c 'cd ./proto/routerserverpb; protoc --proto_path=/go/bin:. --micro_out=paths=source_relative:. --go_out=paths=source_relative:. routerserverpb.proto'
 
   build:podman:
     deps:
       - protoc
     cmds:
-      - podman build -v "$PWD:/code:rw" -v "{{.VOLUME_PATH}}:/go:rw" --build-arg CACHEBUST={{.DATE}} --build-arg=VERSION={{.VERSION}} -t docker.io/pcdummy/go-micro-router:latest -f ./docker/go-micro-router/Dockerfile .
+      - podman build -v "$PWD:/code:rw" -v "{{.VOLUME_PATH}}:/go:rw" --build-arg CACHEBUST={{.DATE}} --build-arg VERSION={{.VERSION}} -t docker.io/pcdummy/go-micro-router:latest -f ./docker/go-micro-router/Dockerfile .
     vars:
       DATE:
         sh: date +%s

cmd/microrouterd/main.go

@@ -1,17 +1,67 @@
 package main
 
 import (
+	"net/http"
+
 	"github.com/urfave/cli/v2"
 	"go-micro.dev/v4"
 	"go-micro.dev/v4/logger"
 
 	"github.com/gin-gonic/gin"
 	httpServer "github.com/go-micro/plugins/v4/server/http"
+	"github.com/go-micro/router"
 
 	"github.com/go-micro/router/config"
 	"github.com/go-micro/router/handler"
+	"github.com/go-micro/router/proto/routerclientpb"
+	"github.com/go-micro/router/proto/routerserverpb"
 )
 
+func internalService(engine *gin.Engine) {
+	srv := micro.NewService()
+
+	routerHandler, err := handler.NewHandler(srv, engine)
+	if err != nil {
+		logger.Fatal(err)
+	}
+
+	opts := []micro.Option{
+		micro.Name(config.Name + "-internal"),
+		micro.Version(config.Version),
+		micro.Action(func(c *cli.Context) error {
+			if err := routerHandler.Start(); err != nil {
+				logger.Fatal(err)
+			}
+
+			routerserverpb.RegisterRouterServerServiceHandler(srv.Server(), routerHandler)
+
+			routerHandler := router.NewHandler(
+				config.GetServerConfig().RouterURI,
+				router.NewRoute(
+					router.RouteMethod(http.MethodGet),
+					router.RoutePath("/routes"),
+					router.RouteEndpoint(routerserverpb.RouterServerService.Routes),
+				),
+			)
+			routerclientpb.RegisterRouterClientServiceHandler(srv.Server(), routerHandler)
+
+			return nil
+		}),
+	}
+
+	srv.Init(opts...)
+
+	// Run server
+	if err := srv.Run(); err != nil {
+		logger.Fatal(err)
+	}
+
+	if err := routerHandler.Stop(); err != nil {
+		logger.Fatal(err)
+	}
+
+}
+
 func main() {
 	srv := micro.NewService(
 		micro.Server(httpServer.NewServer()),
@@ -25,24 +75,15 @@ func main() {
 		gin.SetMode(gin.ReleaseMode)
 	}
 
-	router := gin.New()
-	routerHandler, err := handler.NewHandler(srv, router)
-	if err != nil {
-		logger.Fatal(err)
-	}
-
+	r := gin.New()
 	opts := []micro.Option{
 		micro.Name(config.Name),
 		micro.Version(config.Version),
 		micro.Address(config.GetServerConfig().Address),
 		micro.Action(func(c *cli.Context) error {
-			router.Use(gin.Logger(), gin.Recovery())
-
-			if err := micro.RegisterHandler(srv.Server(), router); err != nil {
-				logger.Fatal(err)
-			}
+			r.Use(gin.Logger(), gin.Recovery())
 
-			if err := routerHandler.Start(); err != nil {
+			if err := micro.RegisterHandler(srv.Server(), r); err != nil {
 				logger.Fatal(err)
 			}
 
@@ -51,12 +92,10 @@ func main() {
 	}
 	srv.Init(opts...)
 
+	go internalService(r)
+
 	// Run server
 	if err := srv.Run(); err != nil {
 		logger.Fatal(err)
 	}
-
-	if err := routerHandler.Stop(); err != nil {
-		logger.Fatal(err)
-	}
 }

config/config.go

@@ -1,10 +1,12 @@
 package config
 
+var (
+	Version = "0.0.1-dev0"
+)
+
 const (
-	Name      = "go.micro.router"
-	Version   = "0.0.1-dev0"
-	RouterURI = "router"
-	PkgPath   = "github.com/go-micro/router"
+	Name    = "go.micro.router"
+	PkgPath = "github.com/go-micro/router"
 )
 
 const (
@@ -19,6 +21,7 @@ type Config struct {
 type ServerConfig struct {
 	Env            string
 	Address        string
+	RouterURI      string
 	RefreshSeconds int
 }
 

config/load.go

@@ -21,6 +21,7 @@ var _cfg *Config = &Config{
 	Server: ServerConfig{
 		Env:            EnvProd,
 		Address:        ":8080",
+		RouterURI:      "router",
 		RefreshSeconds: 10,
 	},
 }

docker/go-micro-router/Dockerfile

@@ -12,8 +12,8 @@ WORKDIR /code
 ENV GOPATH="/go"
 
 ARG CACHEBUST=1
-ARG VERSION=0.0.1-dev0
-RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -installsuffix cgo -ldflags='-w -s -X "github.com/go-micro/router/config.Version='$VERSION'"' -o /usr/local/bin/microrouterd github.com/go-micro/router/cmd/microrouterd
+ARG VERSION
+RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -installsuffix cgo -ldflags="-w -s -X 'github.com/go-micro/router/config.Version=$VERSION'" -o /usr/local/bin/microrouterd github.com/go-micro/router/cmd/microrouterd
 
 # STEP 2 build a small image
 # start from busybox

handler/handler.go

@@ -12,6 +12,7 @@ import (
 	"github.com/gin-gonic/gin"
 	"github.com/go-micro/router/config"
 	"github.com/go-micro/router/proto/routerclientpb"
+	"github.com/go-micro/router/proto/routerserverpb"
 	"github.com/go-micro/router/util"
 	"go-micro.dev/v4"
 	"go-micro.dev/v4/client"
@@ -42,20 +43,20 @@ func NewHandler(service micro.Service, engine *gin.Engine) (*Handler, error) {
 
 func (h *Handler) Start() error {
 	globalGroup := h.engine.Group("")
-	globalGroup.Handle("GET", fmt.Sprintf("/%s/routes", config.RouterURI), h.ginRoutes)
 
 	// Refresh routes for the proxy every 10 seconds
 	go func() {
 		ctx := context.Background()
 
 		for {
-			services, err := util.FindByEndpoint(h.service, "RouterClient.Routes")
+			services, err := util.FindByEndpoint(h.service, "RouterClientService.Routes")
 			if err != nil {
 				logger.Error(err)
 				continue
 			}
 
 			for _, s := range services {
+				logger.Debug("Found service ", s.Name)
 				client := routerclientpb.NewRouterClientService(s.Name, h.service.Client())
 				resp, err := client.Routes(ctx, &emptypb.Empty{})
 				if err != nil {
@@ -67,6 +68,7 @@ func (h *Handler) Start() error {
 				serviceGroup := globalGroup.Group(fmt.Sprintf("/%s", resp.GetRouterURI()))
 
 				for _, route := range resp.Routes {
+					logger.Debug("Found endpoint ", route.Endpoint)
 					var g *gin.RouterGroup = nil
 
 					if route.IsGlobal {
@@ -189,16 +191,15 @@ func (h *Handler) proxy(serviceName string, route *routerclientpb.RoutesReply_Ro
 	}
 }
 
-func (h *Handler) ginRoutes(c *gin.Context) {
+func (h *Handler) Routes(ctx context.Context, in *emptypb.Empty, out *routerserverpb.RoutesReply) error {
 	ginRoutes := h.engine.Routes()
-	rRoutes := []JSONRoute{}
+
 	for _, route := range ginRoutes {
-		rRoutes = append(rRoutes, JSONRoute{Method: route.Method, Path: route.Path})
+		out.Routes = append(out.Routes, &routerserverpb.RoutesReply_Route{
+			Method: route.Method,
+			Path:   route.Path,
+		})
 	}
 
-	c.JSON(http.StatusOK, gin.H{
-		"status":  200,
-		"message": "Dumping the routes",
-		"data":    rRoutes,
-	})
+	return nil
 }

proto/routerclientpb/routerclientpb.proto

@@ -6,7 +6,7 @@ option go_package = "github.com/go-micro/router/proto/routerclientpb;routerclien
 
 import "google/protobuf/empty.proto";
 
-service RouterClient {
+service RouterClientService {
     rpc Routes (google.protobuf.Empty) returns (RoutesReply) {}
 }
 

proto/routerserverpb/routerserverpb.proto

@@ -0,0 +1,20 @@
+syntax = "proto3";
+
+package routerserverpb;
+
+option go_package = "github.com/go-micro/router/proto/routerserverpb;routerserverpb";
+
+import "google/protobuf/empty.proto";
+
+service RouterServerService {
+    rpc Routes (google.protobuf.Empty) returns (RoutesReply) {}
+}
+
+message RoutesReply {
+    message Route {
+        string method = 1;
+        string path = 2;
+    }
+
+    repeated Route routes = 1;
+}