TRA-4263 extensibility refactor (#770)

* Refactor routers

* refactor extension loading

* refactor server creation code

* Update main.go

agent/pkg/routes/config_routes.go

@@ -7,10 +7,17 @@ import (
 	"github.com/gin-gonic/gin"
 )
 
-func ConfigRoutes(ginApp *gin.Engine) {
+var (
+	ConfigPostTapConfigHandler = controllers.PostTapConfig
+	ConfigGetTapConfigHandler  = controllers.GetTapConfig
+)
+
+func ConfigRoutes(ginApp *gin.Engine) *gin.RouterGroup {
 	routeGroup := ginApp.Group("/config")
 	routeGroup.Use(middlewares.RequiresAuth())
 
-	routeGroup.POST("/tap", middlewares.RequiresAdmin(), controllers.PostTapConfig)
-	routeGroup.GET("/tap", controllers.GetTapConfig)
+	routeGroup.POST("/tap", middlewares.RequiresAdmin(), func(c *gin.Context) { ConfigPostTapConfigHandler(c) })
+	routeGroup.GET("/tap", func(c *gin.Context) { ConfigGetTapConfigHandler(c) })
+
+	return routeGroup
 }

agent/pkg/routes/entries_routes.go

@@ -7,11 +7,18 @@ import (
 	"github.com/gin-gonic/gin"
 )
 
+var (
+	EntriesGetHandler       = controllers.GetEntries
+	EntriesGetSingleHandler = controllers.GetEntry
+)
+
 // EntriesRoutes defines the group of har entries routes.
-func EntriesRoutes(ginApp *gin.Engine) {
+func EntriesRoutes(ginApp *gin.Engine) *gin.RouterGroup {
 	routeGroup := ginApp.Group("/entries")
 	routeGroup.Use(middlewares.RequiresAuth())
 
-	routeGroup.GET("/", controllers.GetEntries)  // get entries (base/thin entries) and metadata
-	routeGroup.GET("/:id", controllers.GetEntry) // get single (full) entry
+	routeGroup.GET("/", func(c *gin.Context) { EntriesGetHandler(c) })          // get entries (base/thin entries) and metadata
+	routeGroup.GET("/:id", func(c *gin.Context) { EntriesGetSingleHandler(c) }) // get single (full) entry
+
+	return routeGroup
 }

agent/pkg/routes/install_routes.go

@@ -6,9 +6,16 @@ import (
 	"github.com/gin-gonic/gin"
 )
 
-func InstallRoutes(ginApp *gin.Engine) {
+var (
+	InstallGetIsNeededHandler = controllers.IsSetupNecessary
+	InstallPostAdminHandler   = controllers.SetupAdminUser
+)
+
+func InstallRoutes(ginApp *gin.Engine) *gin.RouterGroup {
 	routeGroup := ginApp.Group("/install")
 
-	routeGroup.GET("/isNeeded", controllers.IsSetupNecessary)
-	routeGroup.POST("/admin", controllers.SetupAdminUser)
+	routeGroup.GET("/isNeeded", func(c *gin.Context) { InstallGetIsNeededHandler(c) })
+	routeGroup.POST("/admin", func(c *gin.Context) { InstallPostAdminHandler(c) })
+
+	return routeGroup
 }

agent/pkg/routes/metadata_routes.go

@@ -6,9 +6,15 @@ import (
 	"github.com/gin-gonic/gin"
 )
 
+var (
+	MetadataGetVersionHandler = controllers.GetVersion
+)
+
 // MetadataRoutes defines the group of metadata routes.
-func MetadataRoutes(app *gin.Engine) {
+func MetadataRoutes(app *gin.Engine) *gin.RouterGroup {
 	routeGroup := app.Group("/metadata")
 
-	routeGroup.GET("/version", controllers.GetVersion)
+	routeGroup.GET("/version", func(c *gin.Context) { MetadataGetVersionHandler(c) })
+
+	return routeGroup
 }

agent/pkg/routes/oas_routes.go

@@ -7,12 +7,20 @@ import (
 	"github.com/gin-gonic/gin"
 )
 
+var (
+	OASGetServersHandler    = controllers.GetOASServers
+	OASGetAllSpecsHandler   = controllers.GetOASAllSpecs
+	OASGetSingleSpecHandler = controllers.GetOASSpec
+)
+
 // OASRoutes methods to access OAS spec
-func OASRoutes(ginApp *gin.Engine) {
+func OASRoutes(ginApp *gin.Engine) *gin.RouterGroup {
 	routeGroup := ginApp.Group("/oas")
 	routeGroup.Use(middlewares.RequiresAuth())
 
-	routeGroup.GET("/", controllers.GetOASServers)     // list of servers in OAS map
-	routeGroup.GET("/all", controllers.GetOASAllSpecs) // list of servers in OAS map
-	routeGroup.GET("/:id", controllers.GetOASSpec)     // get OAS spec for given server
+	routeGroup.GET("/", func(c *gin.Context) { OASGetServersHandler(c) })       // list of servers in OAS map
+	routeGroup.GET("/all", func(c *gin.Context) { OASGetAllSpecsHandler(c) })   // list of servers in OAS map
+	routeGroup.GET("/:id", func(c *gin.Context) { OASGetSingleSpecHandler(c) }) // get OAS spec for given server
+
+	return routeGroup
 }

agent/pkg/routes/query_routes.go

@@ -7,9 +7,15 @@ import (
 	"github.com/gin-gonic/gin"
 )
 
-func QueryRoutes(ginApp *gin.Engine) {
+var (
+	QueryPostValidateHandler = controllers.PostValidate
+)
+
+func QueryRoutes(ginApp *gin.Engine) *gin.RouterGroup {
 	routeGroup := ginApp.Group("/query")
 	routeGroup.Use(middlewares.RequiresAuth())
 
-	routeGroup.POST("/validate", controllers.PostValidate)
+	routeGroup.POST("/validate", func(c *gin.Context) { QueryPostValidateHandler(c) })
+
+	return routeGroup
 }

agent/pkg/routes/service_map_routes.go

@@ -7,13 +7,25 @@ import (
 	"github.com/gin-gonic/gin"
 )
 
-func ServiceMapRoutes(ginApp *gin.Engine) {
+var (
+	ServiceMapGetStatus gin.HandlerFunc
+	ServiceMapGet       gin.HandlerFunc
+	ServiceMapReset     gin.HandlerFunc
+)
+
+func ServiceMapRoutes(ginApp *gin.Engine) *gin.RouterGroup {
 	routeGroup := ginApp.Group("/servicemap")
 	routeGroup.Use(middlewares.RequiresAuth())
 
 	controller := controllers.NewServiceMapController()
 
-	routeGroup.GET("/status", controller.Status)
-	routeGroup.GET("/get", controller.Get)
-	routeGroup.GET("/reset", controller.Reset)
+	ServiceMapGetStatus = controller.Status
+	ServiceMapGet = controller.Get
+	ServiceMapReset = controller.Reset
+
+	routeGroup.GET("/status", func(c *gin.Context) { ServiceMapGetStatus(c) })
+	routeGroup.GET("/get", func(c *gin.Context) { ServiceMapGet(c) })
+	routeGroup.GET("/reset", func(c *gin.Context) { ServiceMapReset(c) })
+
+	return routeGroup
 }

agent/pkg/routes/status_routes.go

@@ -7,24 +7,39 @@ import (
 	"github.com/gin-gonic/gin"
 )
 
-func StatusRoutes(ginApp *gin.Engine) {
+var (
+	StatusGetHealthCheck                 = controllers.HealthCheck
+	StatusPostTappedPods                 = controllers.PostTappedPods
+	StatusPostTapperStatus               = controllers.PostTapperStatus
+	StatusGetConnectedTappersCount       = controllers.GetConnectedTappersCount
+	StatusGetTappingStatus               = controllers.GetTappingStatus
+	StatusGetAuthStatus                  = controllers.GetAuthStatus
+	StatusGetAnalyzeInformation          = controllers.AnalyzeInformation
+	StatusGetGeneralStats                = controllers.GetGeneralStats
+	StatusGetRecentTLSLinks              = controllers.GetRecentTLSLinks
+	StatusGetCurrentResolvingInformation = controllers.GetCurrentResolvingInformation
+)
+
+func StatusRoutes(ginApp *gin.Engine) *gin.RouterGroup {
 	routeGroup := ginApp.Group("/status")
 	routeGroup.Use(middlewares.RequiresAuth())
 
-	routeGroup.GET("/health", controllers.HealthCheck)
+	routeGroup.GET("/health", func(c *gin.Context) { StatusGetHealthCheck(c) })
 
-	routeGroup.POST("/tappedPods", controllers.PostTappedPods)
-	routeGroup.POST("/tapperStatus", controllers.PostTapperStatus)
-	routeGroup.GET("/connectedTappersCount", controllers.GetConnectedTappersCount)
-	routeGroup.GET("/tap", controllers.GetTappingStatus)
+	routeGroup.POST("/tappedPods", func(c *gin.Context) { StatusPostTappedPods(c) })
+	routeGroup.POST("/tapperStatus", func(c *gin.Context) { StatusPostTapperStatus(c) })
+	routeGroup.GET("/connectedTappersCount", func(c *gin.Context) { StatusGetConnectedTappersCount(c) })
+	routeGroup.GET("/tap", func(c *gin.Context) { StatusGetTappingStatus(c) })
 
-	routeGroup.GET("/auth", controllers.GetAuthStatus)
+	routeGroup.GET("/auth", func(c *gin.Context) { StatusGetAuthStatus(c) })
 
-	routeGroup.GET("/analyze", controllers.AnalyzeInformation)
+	routeGroup.GET("/analyze", func(c *gin.Context) { StatusGetAnalyzeInformation(c) })
 
-	routeGroup.GET("/general", controllers.GetGeneralStats) // get general stats about entries in DB
+	routeGroup.GET("/general", func(c *gin.Context) { StatusGetGeneralStats(c) }) // get general stats about entries in DB
 
-	routeGroup.GET("/recentTLSLinks", controllers.GetRecentTLSLinks)
+	routeGroup.GET("/recentTLSLinks", func(c *gin.Context) { StatusGetRecentTLSLinks(c) })
 
-	routeGroup.GET("/resolving", controllers.GetCurrentResolvingInformation)
+	routeGroup.GET("/resolving", func(c *gin.Context) { StatusGetCurrentResolvingInformation(c) })
+
+	return routeGroup
 }

agent/pkg/routes/user_routes.go

@@ -6,10 +6,18 @@ import (
 	"github.com/gin-gonic/gin"
 )
 
-func UserRoutes(ginApp *gin.Engine) {
+var (
+	UserPostLogin    = controllers.Login
+	UserPostLogout   = controllers.Logout
+	UserPostRegister = controllers.Register
+)
+
+func UserRoutes(ginApp *gin.Engine) *gin.RouterGroup {
 	routeGroup := ginApp.Group("/user")
 
-	routeGroup.POST("/login", controllers.Login)
-	routeGroup.POST("/logout", controllers.Logout)
-	routeGroup.POST("/register", controllers.Register)
+	routeGroup.POST("/login", func(c *gin.Context) { UserPostLogin(c) })
+	routeGroup.POST("/logout", func(c *gin.Context) { UserPostLogout(c) })
+	routeGroup.POST("/register", func(c *gin.Context) { UserPostRegister(c) })
+
+	return routeGroup
 }