diff --git a/agent/main.go b/agent/main.go index 5a771bae4..84067dc6e 100644 --- a/agent/main.go +++ b/agent/main.go @@ -5,13 +5,24 @@ import ( "errors" "flag" "fmt" + "io/ioutil" "net/http" "os" "os/signal" + "strconv" + "strings" "syscall" "time" + "github.com/gin-contrib/static" + "github.com/gin-gonic/gin" + "github.com/up9inc/mizu/agent/pkg/elastic" + "github.com/up9inc/mizu/agent/pkg/middlewares" "github.com/up9inc/mizu/agent/pkg/models" + "github.com/up9inc/mizu/agent/pkg/oas" + "github.com/up9inc/mizu/agent/pkg/routes" + "github.com/up9inc/mizu/agent/pkg/servicemap" + "github.com/up9inc/mizu/agent/pkg/up9" "github.com/up9inc/mizu/agent/pkg/utils" "github.com/up9inc/mizu/agent/pkg/api" @@ -35,6 +46,7 @@ var apiServerAddress = flag.String("api-server-address", "", "Address of mizu AP var namespace = flag.String("namespace", "", "Resolve IPs if they belong to resources in this namespace (default is all)") var harsReaderMode = flag.Bool("hars-read", false, "Run in hars-read mode") var harsDir = flag.String("hars-dir", "", "Directory to read hars from") +var startTime int64 const ( socketConnectionRetries = 30 @@ -60,7 +72,7 @@ func main() { } else if *tapperMode { runInTapperMode() } else if *apiServerMode { - utils.StartServer(app.RunInApiServerMode(*namespace)) + utils.StartServer(runInApiServerMode(*namespace)) } else if *harsReaderMode { runInHarReaderMode() } @@ -72,6 +84,77 @@ func main() { logger.Log.Info("Exiting") } +func hostApi(socketHarOutputChannel chan<- *tapApi.OutputChannelItem) *gin.Engine { + app := gin.Default() + + app.GET("/echo", func(c *gin.Context) { + c.String(http.StatusOK, "Here is Mizu agent") + }) + + eventHandlers := api.RoutesEventHandlers{ + SocketOutChannel: socketHarOutputChannel, + } + + app.Use(disableRootStaticCache()) + + var staticFolder string + if config.Config.StandaloneMode { + staticFolder = "./site-standalone" + } else { + staticFolder = "./site" + } + + indexStaticFile := staticFolder + "/index.html" + if err := setUIFlags(indexStaticFile); err != nil { + logger.Log.Errorf("Error setting ui flags, err: %v", err) + } + + app.Use(static.ServeRoot("/", staticFolder)) + app.NoRoute(func(c *gin.Context) { + c.File(indexStaticFile) + }) + + app.Use(middlewares.CORSMiddleware()) // This has to be called after the static middleware, does not work if its called before + + api.WebSocketRoutes(app, &eventHandlers, startTime) + + if config.Config.StandaloneMode { + routes.ConfigRoutes(app) + routes.UserRoutes(app) + routes.InstallRoutes(app) + } + if config.Config.OAS { + routes.OASRoutes(app) + } + if config.Config.ServiceMap { + routes.ServiceMapRoutes(app) + } + + routes.QueryRoutes(app) + routes.EntriesRoutes(app) + routes.MetadataRoutes(app) + routes.StatusRoutes(app) + + return app +} + +func runInApiServerMode(namespace string) *gin.Engine { + app.ConfigureBasenineServer(shared.BasenineHost, shared.BaseninePort) + startTime = time.Now().UnixNano() / int64(time.Millisecond) + api.StartResolving(namespace) + + enableExpFeatureIfNeeded() + + syncEntriesConfig := getSyncEntriesConfig() + if syncEntriesConfig != nil { + if err := up9.SyncEntries(syncEntriesConfig); err != nil { + logger.Log.Error("Error syncing entries, err: %v", err) + } + } + + return hostApi(app.GetEntryInputChannel()) +} + func runInTapperMode() { logger.Log.Infof("Starting tapper, websocket address: %s", *apiServerAddress) if *apiServerAddress == "" { @@ -113,7 +196,7 @@ func runInStandaloneMode() { go app.FilterItems(outputItemsChannel, filteredOutputItemsChannel) go api.StartReadingEntries(filteredOutputItemsChannel, nil, app.ExtensionsMap) - ginApp := app.HostApi(nil) + ginApp := hostApi(nil) utils.StartServer(ginApp) } @@ -123,10 +206,63 @@ func runInHarReaderMode() { go app.FilterItems(outputItemsChannel, filteredHarChannel) go api.StartReadingEntries(filteredHarChannel, harsDir, app.ExtensionsMap) - ginApp := app.HostApi(nil) + ginApp := hostApi(nil) utils.StartServer(ginApp) } +func enableExpFeatureIfNeeded() { + if config.Config.OAS { + oas.GetOasGeneratorInstance().Start() + } + if config.Config.ServiceMap { + servicemap.GetInstance().SetConfig(config.Config) + } + elastic.GetInstance().Configure(config.Config.Elastic) +} + +func getSyncEntriesConfig() *shared.SyncEntriesConfig { + syncEntriesConfigJson := os.Getenv(shared.SyncEntriesConfigEnvVar) + if syncEntriesConfigJson == "" { + return nil + } + + var syncEntriesConfig = &shared.SyncEntriesConfig{} + err := json.Unmarshal([]byte(syncEntriesConfigJson), syncEntriesConfig) + if err != nil { + panic(fmt.Sprintf("env var %s's value of %s is invalid! json must match the shared.SyncEntriesConfig struct, err: %v", shared.SyncEntriesConfigEnvVar, syncEntriesConfigJson, err)) + } + + return syncEntriesConfig +} + +func disableRootStaticCache() gin.HandlerFunc { + return func(c *gin.Context) { + if c.Request.RequestURI == "/" { + // Disable cache only for the main static route + c.Writer.Header().Set("Cache-Control", "no-store") + } + + c.Next() + } +} + +func setUIFlags(uiIndexPath string) error { + read, err := ioutil.ReadFile(uiIndexPath) + if err != nil { + return err + } + + replacedContent := strings.Replace(string(read), "__IS_OAS_ENABLED__", strconv.FormatBool(config.Config.OAS), 1) + replacedContent = strings.Replace(replacedContent, "__IS_SERVICE_MAP_ENABLED__", strconv.FormatBool(config.Config.ServiceMap), 1) + + err = ioutil.WriteFile(uiIndexPath, []byte(replacedContent), 0) + if err != nil { + return err + } + + return nil +} + func parseEnvVar(env string) map[string][]v1.Pod { var mapOfList map[string][]v1.Pod diff --git a/agent/pkg/app/extensions.go b/agent/pkg/app/main.go similarity index 52% rename from agent/pkg/app/extensions.go rename to agent/pkg/app/main.go index 487493179..791f12e0b 100644 --- a/agent/pkg/app/extensions.go +++ b/agent/pkg/app/main.go @@ -1,12 +1,18 @@ package app import ( + "fmt" "sort" + "time" + "github.com/antelman107/net-wait-go/wait" + "github.com/op/go-logging" + basenine "github.com/up9inc/basenine/client/go" + "github.com/up9inc/mizu/agent/pkg/api" + "github.com/up9inc/mizu/agent/pkg/config" "github.com/up9inc/mizu/agent/pkg/controllers" "github.com/up9inc/mizu/shared/logger" tapApi "github.com/up9inc/mizu/tap/api" - amqpExt "github.com/up9inc/mizu/tap/extensions/amqp" httpExt "github.com/up9inc/mizu/tap/extensions/http" kafkaExt "github.com/up9inc/mizu/tap/extensions/kafka" @@ -60,3 +66,51 @@ func LoadExtensions() { controllers.InitExtensionsMap(ExtensionsMap) } + +func ConfigureBasenineServer(host string, port string) { + if !wait.New( + wait.WithProto("tcp"), + wait.WithWait(200*time.Millisecond), + wait.WithBreak(50*time.Millisecond), + wait.WithDeadline(5*time.Second), + wait.WithDebug(config.Config.LogLevel == logging.DEBUG), + ).Do([]string{fmt.Sprintf("%s:%s", host, port)}) { + logger.Log.Panicf("Basenine is not available!") + } + + // Limit the database size to default 200MB + err := basenine.Limit(host, port, config.Config.MaxDBSizeBytes) + if err != nil { + logger.Log.Panicf("Error while limiting database size: %v", err) + } + + // Define the macros + for _, extension := range Extensions { + macros := extension.Dissector.Macros() + for macro, expanded := range macros { + err = basenine.Macro(host, port, macro, expanded) + if err != nil { + logger.Log.Panicf("Error while adding a macro: %v", err) + } + } + } +} + +func GetEntryInputChannel() chan *tapApi.OutputChannelItem { + outputItemsChannel := make(chan *tapApi.OutputChannelItem) + filteredOutputItemsChannel := make(chan *tapApi.OutputChannelItem) + go FilterItems(outputItemsChannel, filteredOutputItemsChannel) + go api.StartReadingEntries(filteredOutputItemsChannel, nil, ExtensionsMap) + + return outputItemsChannel +} + +func FilterItems(inChannel <-chan *tapApi.OutputChannelItem, outChannel chan *tapApi.OutputChannelItem) { + for message := range inChannel { + if message.ConnectionInfo.IsOutgoing && api.CheckIsServiceIP(message.ConnectionInfo.ServerIP) { + continue + } + + outChannel <- message + } +} diff --git a/agent/pkg/app/server.go b/agent/pkg/app/server.go deleted file mode 100644 index ef4360e45..000000000 --- a/agent/pkg/app/server.go +++ /dev/null @@ -1,210 +0,0 @@ -package app - -import ( - "encoding/json" - "fmt" - "io/ioutil" - "net/http" - "os" - "strconv" - "strings" - "time" - - "github.com/antelman107/net-wait-go/wait" - "github.com/gin-contrib/static" - "github.com/gin-gonic/gin" - "github.com/op/go-logging" - basenine "github.com/up9inc/basenine/client/go" - "github.com/up9inc/mizu/agent/pkg/api" - "github.com/up9inc/mizu/agent/pkg/config" - "github.com/up9inc/mizu/agent/pkg/elastic" - "github.com/up9inc/mizu/agent/pkg/middlewares" - "github.com/up9inc/mizu/agent/pkg/oas" - "github.com/up9inc/mizu/agent/pkg/routes" - "github.com/up9inc/mizu/agent/pkg/servicemap" - "github.com/up9inc/mizu/agent/pkg/up9" - "github.com/up9inc/mizu/shared" - "github.com/up9inc/mizu/shared/logger" - tapApi "github.com/up9inc/mizu/tap/api" -) - -var ( - ConfigRoutes *gin.RouterGroup - UserRoutes *gin.RouterGroup - InstallRoutes *gin.RouterGroup - OASRoutes *gin.RouterGroup - ServiceMapRoutes *gin.RouterGroup - QueryRoutes *gin.RouterGroup - EntriesRoutes *gin.RouterGroup - MetadataRoutes *gin.RouterGroup - StatusRoutes *gin.RouterGroup - - startTime int64 -) - -func HostApi(socketHarOutputChannel chan<- *tapApi.OutputChannelItem) *gin.Engine { - app := gin.Default() - - app.GET("/echo", func(c *gin.Context) { - c.String(http.StatusOK, "Here is Mizu agent") - }) - - eventHandlers := api.RoutesEventHandlers{ - SocketOutChannel: socketHarOutputChannel, - } - - app.Use(disableRootStaticCache()) - - var staticFolder string - if config.Config.StandaloneMode { - staticFolder = "./site-standalone" - } else { - staticFolder = "./site" - } - - indexStaticFile := staticFolder + "/index.html" - if err := setUIFlags(indexStaticFile); err != nil { - logger.Log.Errorf("Error setting ui flags, err: %v", err) - } - - app.Use(static.ServeRoot("/", staticFolder)) - app.NoRoute(func(c *gin.Context) { - c.File(indexStaticFile) - }) - - app.Use(middlewares.CORSMiddleware()) // This has to be called after the static middleware, does not work if its called before - - api.WebSocketRoutes(app, &eventHandlers, startTime) - - if config.Config.StandaloneMode { - ConfigRoutes = routes.ConfigRoutes(app) - UserRoutes = routes.UserRoutes(app) - InstallRoutes = routes.InstallRoutes(app) - } - if config.Config.OAS { - OASRoutes = routes.OASRoutes(app) - } - if config.Config.ServiceMap { - ServiceMapRoutes = routes.ServiceMapRoutes(app) - } - - QueryRoutes = routes.QueryRoutes(app) - EntriesRoutes = routes.EntriesRoutes(app) - MetadataRoutes = routes.MetadataRoutes(app) - StatusRoutes = routes.StatusRoutes(app) - - return app -} - -func RunInApiServerMode(namespace string) *gin.Engine { - configureBasenineServer(shared.BasenineHost, shared.BaseninePort) - startTime = time.Now().UnixNano() / int64(time.Millisecond) - api.StartResolving(namespace) - - outputItemsChannel := make(chan *tapApi.OutputChannelItem) - filteredOutputItemsChannel := make(chan *tapApi.OutputChannelItem) - enableExpFeatureIfNeeded() - go FilterItems(outputItemsChannel, filteredOutputItemsChannel) - go api.StartReadingEntries(filteredOutputItemsChannel, nil, ExtensionsMap) - - syncEntriesConfig := getSyncEntriesConfig() - if syncEntriesConfig != nil { - if err := up9.SyncEntries(syncEntriesConfig); err != nil { - logger.Log.Error("Error syncing entries, err: %v", err) - } - } - - return HostApi(outputItemsChannel) -} - -func configureBasenineServer(host string, port string) { - if !wait.New( - wait.WithProto("tcp"), - wait.WithWait(200*time.Millisecond), - wait.WithBreak(50*time.Millisecond), - wait.WithDeadline(5*time.Second), - wait.WithDebug(config.Config.LogLevel == logging.DEBUG), - ).Do([]string{fmt.Sprintf("%s:%s", host, port)}) { - logger.Log.Panicf("Basenine is not available!") - } - - // Limit the database size to default 200MB - err := basenine.Limit(host, port, config.Config.MaxDBSizeBytes) - if err != nil { - logger.Log.Panicf("Error while limiting database size: %v", err) - } - - // Define the macros - for _, extension := range Extensions { - macros := extension.Dissector.Macros() - for macro, expanded := range macros { - err = basenine.Macro(host, port, macro, expanded) - if err != nil { - logger.Log.Panicf("Error while adding a macro: %v", err) - } - } - } -} - -func getSyncEntriesConfig() *shared.SyncEntriesConfig { - syncEntriesConfigJson := os.Getenv(shared.SyncEntriesConfigEnvVar) - if syncEntriesConfigJson == "" { - return nil - } - - var syncEntriesConfig = &shared.SyncEntriesConfig{} - err := json.Unmarshal([]byte(syncEntriesConfigJson), syncEntriesConfig) - if err != nil { - panic(fmt.Sprintf("env var %s's value of %s is invalid! json must match the shared.SyncEntriesConfig struct, err: %v", shared.SyncEntriesConfigEnvVar, syncEntriesConfigJson, err)) - } - - return syncEntriesConfig -} - -func FilterItems(inChannel <-chan *tapApi.OutputChannelItem, outChannel chan *tapApi.OutputChannelItem) { - for message := range inChannel { - if message.ConnectionInfo.IsOutgoing && api.CheckIsServiceIP(message.ConnectionInfo.ServerIP) { - continue - } - - outChannel <- message - } -} - -func enableExpFeatureIfNeeded() { - if config.Config.OAS { - oas.GetOasGeneratorInstance().Start() - } - if config.Config.ServiceMap { - servicemap.GetInstance().SetConfig(config.Config) - } - elastic.GetInstance().Configure(config.Config.Elastic) -} - -func disableRootStaticCache() gin.HandlerFunc { - return func(c *gin.Context) { - if c.Request.RequestURI == "/" { - // Disable cache only for the main static route - c.Writer.Header().Set("Cache-Control", "no-store") - } - - c.Next() - } -} - -func setUIFlags(uiIndexPath string) error { - read, err := ioutil.ReadFile(uiIndexPath) - if err != nil { - return err - } - - replacedContent := strings.Replace(string(read), "__IS_OAS_ENABLED__", strconv.FormatBool(config.Config.OAS), 1) - replacedContent = strings.Replace(replacedContent, "__IS_SERVICE_MAP_ENABLED__", strconv.FormatBool(config.Config.ServiceMap), 1) - - err = ioutil.WriteFile(uiIndexPath, []byte(replacedContent), 0) - if err != nil { - return err - } - - return nil -} diff --git a/agent/pkg/routes/config_routes.go b/agent/pkg/routes/config_routes.go index f44e02cde..fe3cf6426 100644 --- a/agent/pkg/routes/config_routes.go +++ b/agent/pkg/routes/config_routes.go @@ -7,17 +7,10 @@ import ( "github.com/gin-gonic/gin" ) -var ( - ConfigPostTapConfigHandler = controllers.PostTapConfig - ConfigGetTapConfigHandler = controllers.GetTapConfig -) - -func ConfigRoutes(ginApp *gin.Engine) *gin.RouterGroup { +func ConfigRoutes(ginApp *gin.Engine) { routeGroup := ginApp.Group("/config") routeGroup.Use(middlewares.RequiresAuth()) - routeGroup.POST("/tap", middlewares.RequiresAdmin(), func(c *gin.Context) { ConfigPostTapConfigHandler(c) }) - routeGroup.GET("/tap", func(c *gin.Context) { ConfigGetTapConfigHandler(c) }) - - return routeGroup + routeGroup.POST("/tap", middlewares.RequiresAdmin(), controllers.PostTapConfig) + routeGroup.GET("/tap", controllers.GetTapConfig) } diff --git a/agent/pkg/routes/entries_routes.go b/agent/pkg/routes/entries_routes.go index 644c00d67..5be3651ec 100644 --- a/agent/pkg/routes/entries_routes.go +++ b/agent/pkg/routes/entries_routes.go @@ -7,18 +7,11 @@ 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) *gin.RouterGroup { +func EntriesRoutes(ginApp *gin.Engine) { routeGroup := ginApp.Group("/entries") routeGroup.Use(middlewares.RequiresAuth()) - 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 + routeGroup.GET("/", controllers.GetEntries) // get entries (base/thin entries) and metadata + routeGroup.GET("/:id", controllers.GetEntry) // get single (full) entry } diff --git a/agent/pkg/routes/install_routes.go b/agent/pkg/routes/install_routes.go index 5ea0cab4a..bdf8b602b 100644 --- a/agent/pkg/routes/install_routes.go +++ b/agent/pkg/routes/install_routes.go @@ -6,16 +6,9 @@ import ( "github.com/gin-gonic/gin" ) -var ( - InstallGetIsNeededHandler = controllers.IsSetupNecessary - InstallPostAdminHandler = controllers.SetupAdminUser -) - -func InstallRoutes(ginApp *gin.Engine) *gin.RouterGroup { +func InstallRoutes(ginApp *gin.Engine) { routeGroup := ginApp.Group("/install") - routeGroup.GET("/isNeeded", func(c *gin.Context) { InstallGetIsNeededHandler(c) }) - routeGroup.POST("/admin", func(c *gin.Context) { InstallPostAdminHandler(c) }) - - return routeGroup + routeGroup.GET("/isNeeded", controllers.IsSetupNecessary) + routeGroup.POST("/admin", controllers.SetupAdminUser) } diff --git a/agent/pkg/routes/metadata_routes.go b/agent/pkg/routes/metadata_routes.go index 3f67e79ad..7428c5598 100644 --- a/agent/pkg/routes/metadata_routes.go +++ b/agent/pkg/routes/metadata_routes.go @@ -6,15 +6,9 @@ import ( "github.com/gin-gonic/gin" ) -var ( - MetadataGetVersionHandler = controllers.GetVersion -) - // MetadataRoutes defines the group of metadata routes. -func MetadataRoutes(app *gin.Engine) *gin.RouterGroup { +func MetadataRoutes(app *gin.Engine) { routeGroup := app.Group("/metadata") - routeGroup.GET("/version", func(c *gin.Context) { MetadataGetVersionHandler(c) }) - - return routeGroup + routeGroup.GET("/version", controllers.GetVersion) } diff --git a/agent/pkg/routes/oas_routes.go b/agent/pkg/routes/oas_routes.go index 26b18b808..34b988552 100644 --- a/agent/pkg/routes/oas_routes.go +++ b/agent/pkg/routes/oas_routes.go @@ -7,20 +7,12 @@ 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) *gin.RouterGroup { +func OASRoutes(ginApp *gin.Engine) { routeGroup := ginApp.Group("/oas") routeGroup.Use(middlewares.RequiresAuth()) - 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 + 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 } diff --git a/agent/pkg/routes/query_routes.go b/agent/pkg/routes/query_routes.go index 52cedda21..c64066a2c 100644 --- a/agent/pkg/routes/query_routes.go +++ b/agent/pkg/routes/query_routes.go @@ -7,15 +7,9 @@ import ( "github.com/gin-gonic/gin" ) -var ( - QueryPostValidateHandler = controllers.PostValidate -) - -func QueryRoutes(ginApp *gin.Engine) *gin.RouterGroup { +func QueryRoutes(ginApp *gin.Engine) { routeGroup := ginApp.Group("/query") routeGroup.Use(middlewares.RequiresAuth()) - routeGroup.POST("/validate", func(c *gin.Context) { QueryPostValidateHandler(c) }) - - return routeGroup + routeGroup.POST("/validate", controllers.PostValidate) } diff --git a/agent/pkg/routes/service_map_routes.go b/agent/pkg/routes/service_map_routes.go index 058a4a8b0..1fb831f5e 100644 --- a/agent/pkg/routes/service_map_routes.go +++ b/agent/pkg/routes/service_map_routes.go @@ -7,25 +7,13 @@ import ( "github.com/gin-gonic/gin" ) -var ( - ServiceMapGetStatus gin.HandlerFunc - ServiceMapGet gin.HandlerFunc - ServiceMapReset gin.HandlerFunc -) - -func ServiceMapRoutes(ginApp *gin.Engine) *gin.RouterGroup { +func ServiceMapRoutes(ginApp *gin.Engine) { routeGroup := ginApp.Group("/servicemap") routeGroup.Use(middlewares.RequiresAuth()) controller := controllers.NewServiceMapController() - 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 + routeGroup.GET("/status", controller.Status) + routeGroup.GET("/get", controller.Get) + routeGroup.GET("/reset", controller.Reset) } diff --git a/agent/pkg/routes/status_routes.go b/agent/pkg/routes/status_routes.go index 9dcce2bf8..f8a5c180b 100644 --- a/agent/pkg/routes/status_routes.go +++ b/agent/pkg/routes/status_routes.go @@ -7,39 +7,24 @@ import ( "github.com/gin-gonic/gin" ) -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 { +func StatusRoutes(ginApp *gin.Engine) { routeGroup := ginApp.Group("/status") routeGroup.Use(middlewares.RequiresAuth()) - routeGroup.GET("/health", func(c *gin.Context) { StatusGetHealthCheck(c) }) + routeGroup.GET("/health", controllers.HealthCheck) - 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.POST("/tappedPods", controllers.PostTappedPods) + routeGroup.POST("/tapperStatus", controllers.PostTapperStatus) + routeGroup.GET("/connectedTappersCount", controllers.GetConnectedTappersCount) + routeGroup.GET("/tap", controllers.GetTappingStatus) - routeGroup.GET("/auth", func(c *gin.Context) { StatusGetAuthStatus(c) }) + routeGroup.GET("/auth", controllers.GetAuthStatus) - routeGroup.GET("/analyze", func(c *gin.Context) { StatusGetAnalyzeInformation(c) }) + routeGroup.GET("/analyze", controllers.AnalyzeInformation) - routeGroup.GET("/general", func(c *gin.Context) { StatusGetGeneralStats(c) }) // get general stats about entries in DB + routeGroup.GET("/general", controllers.GetGeneralStats) // get general stats about entries in DB - routeGroup.GET("/recentTLSLinks", func(c *gin.Context) { StatusGetRecentTLSLinks(c) }) + routeGroup.GET("/recentTLSLinks", controllers.GetRecentTLSLinks) - routeGroup.GET("/resolving", func(c *gin.Context) { StatusGetCurrentResolvingInformation(c) }) - - return routeGroup + routeGroup.GET("/resolving", controllers.GetCurrentResolvingInformation) } diff --git a/agent/pkg/routes/user_routes.go b/agent/pkg/routes/user_routes.go index 7ee9f2476..bf6e562bd 100644 --- a/agent/pkg/routes/user_routes.go +++ b/agent/pkg/routes/user_routes.go @@ -6,18 +6,10 @@ import ( "github.com/gin-gonic/gin" ) -var ( - UserPostLogin = controllers.Login - UserPostLogout = controllers.Logout - UserPostRegister = controllers.Register -) - -func UserRoutes(ginApp *gin.Engine) *gin.RouterGroup { +func UserRoutes(ginApp *gin.Engine) { routeGroup := ginApp.Group("/user") - 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 + routeGroup.POST("/login", controllers.Login) + routeGroup.POST("/logout", controllers.Logout) + routeGroup.POST("/register", controllers.Register) }