myxce/src/frontend/apiserver/router/routers.go

package router

import (
	"apiserver/common"
	"apiserver/controllers"
	"apiserver/middleware"
	"apiserver/utils"
	logger "apiserver/utils"
	"path/filepath"

	"github.com/gin-gonic/gin"
	swaggerFiles "github.com/swaggo/files"
	ginSwagger "github.com/swaggo/gin-swagger"
	"go.uber.org/zap"
)

func Router() *gin.Engine {
	logger.Debug("Enter Router() function")
	r := gin.Default()

	// check access URL whitelist
	r.Use(middleware.WhitelistURLMiddleware())

	// check client IP whitelist
	whitelistConfig := utils.WhitelistYamlConfig
	logger.Debug("whitelistConfig", zap.Any("whitelistConfig", whitelistConfig))
	r.Use(middleware.WhitelistIPMiddleware(whitelistConfig.Whitelist))

	// Initialize rate limiter: 10 requests per second with a burst of 20
	rateLimitConfig := utils.RateLimitYamlConfig
	globalRL := middleware.NewRateLimiter(rateLimitConfig)
	r.Use(globalRL.Limit())
	r.Use(middleware.ValidateHandler()) //validate token

	// CORS
	corsOrigins := middleware.CORSOriginsFromConfig(
		utils.CORSYamlConfig != nil && utils.CORSYamlConfig.Enabled,
		func() []string {
			if utils.CORSYamlConfig != nil {
				return utils.CORSYamlConfig.AllowedOrigins
			}
			return nil
		}(),
	)
	r.Use(middleware.CORSMiddleware(corsOrigins))

	// load default rbac built-in roles
	rbacPath := filepath.Join(utils.Global_TopDir, "config", "rbac.yaml")
	if err := controllers.LoadRBACConfig(rbacPath); err != nil {
		logger.Error("Failed to load RBAC config: " + err.Error())
	}

	// ################ case: ping route
	r.GET("/ping", func(ctx *gin.Context) {
		logger.Debug("Get /ping successfully from ", zap.String("client_ip", ctx.ClientIP()))
		controllers.ReturnSuccess(ctx, common.SUCCESS_CODE, common.SUCCESS_MSG, "pong success")
	})

	// ################ case: swagger route
	r.GET("/swagger/*any", ginSwagger.WrapHandler(swaggerFiles.Handler))

	// ################ case: auth route
	auth := r.Group("/xce/v1/auth")
	{
		authHandler := &controllers.AuthController{}
		auth.POST("/logon", authHandler.Logon)
		auth.POST("/logout", authHandler.Logout)
	}

	// ################ case: permissions route
	permsApi := r.Group("/xce/v1/permissions")
	{
		permHandler := &controllers.PermController{}
		permsApi.GET("", controllers.RequirePermission("rbac:view"), permHandler.GetPermsInfo)
	}
	// ################ case: roles route
	rolesApi := r.Group("/xce/v1/roles")
	{
		roleHandler := &controllers.RoleController{}
		rolesApi.GET("", controllers.RequirePermission("rbac:view"), roleHandler.GetRolesInfo)
		rolesApi.GET("/:rolename", controllers.RequirePermission("rbac:view"), roleHandler.GetRoleByRolename)
		rolesApi.POST("/create", controllers.RequirePermission("rbac:control"), roleHandler.CreateRole)
		rolesApi.POST("/:roleid/permissions", controllers.RequirePermission("rbac:control"), roleHandler.AddPermissionsForRole)
		// update role_permission table
		rolesApi.DELETE("/:rolename", controllers.RequirePermission("rbac:control"), roleHandler.DeleteRoleAndPermissions)
	}
	// ################ case: users route
	usersApi := r.Group("/xce/v1/users")
	{
		userHandler := &controllers.UserController{}
		usersApi.GET("", controllers.RequirePermission("rbac:view"), userHandler.GetUserRolesInfo)
		usersApi.GET("/current", controllers.RequirePermission("rbac:view"), userHandler.GetCurrentUserInfo)
		usersApi.GET("/:username/permissions", controllers.RequirePermission("rbac:view"), userHandler.GetUserPermInfo)
		usersApi.POST("/:username/roles", controllers.RequirePermission("rbac:control"), userHandler.AddRolesForUser)
		// update user_role table
		usersApi.DELETE("/:username/:rolename", controllers.RequirePermission("rbac:control"), userHandler.DeleteRolesForUser)
	}
	// ################ case: clusters route
	clusterApi := r.Group("/xce/v1/clusters")
	{
		clusterHandler := &controllers.ClusterController{}
		clusterApi.GET("", controllers.RequirePermission("cluster:view"), clusterHandler.GetClustersInfo)
	}
	// ################ case: hosts route
	hostsApi := r.Group("xce/v1/hosts")
	{
		hostHandler := &controllers.HostHandler{}
		hostsApi.GET("", controllers.RequirePermission("host:view"), hostHandler.GetHostsInfo)
		hostsApi.GET("/:hostname", controllers.RequirePermission("host:view"), hostHandler.GetHostByHostname)
		// for select res_req contains &&, ||, >,<, !, == charactars, so use POST method.
		hostsApi.POST("/select", controllers.RequirePermission("host:view"), hostHandler.FilterHostByResReqSelect)
		hostsApi.POST("/control", controllers.RequirePermission("host:control"), hostHandler.ControlHost)
	}

	// ################ case: queues route
	queueApi := r.Group("/xce/v1/queues")
	{
		queueHandler := &controllers.QueueController{}
		queueApi.GET("", controllers.RequirePermission("queue:view"), queueHandler.GetQueuesInfo)
		queueApi.GET("/:queuename", controllers.RequirePermission("queue:view"), queueHandler.GetQueueByName)
		queueApi.POST("/control", controllers.RequirePermission("queue:control"), queueHandler.ControlQueue)
	}

	// ################ case: jobs route
	jobsApi := r.Group("/xce/v1/jobs")
	{
		jobHandler := &controllers.JobController{}
		jobsApi.GET("", controllers.RequirePermission("job:view"), jobHandler.GetJobsInfo)
		jobsApi.GET("/:jobids", controllers.RequirePermission("job:view"), jobHandler.GetJobByIDs)
		jobsApi.POST("/create", controllers.RequirePermission("queue:submit"), jobHandler.CreateJob)
		jobsApi.POST("/:jobids/control", controllers.RequirePermission("job:control"), jobHandler.ControlJobByID)
		jobsApi.POST("/control", controllers.RequirePermission("job:control"), jobHandler.ControlJob)
		jobsApi.POST("/:jobids/restart", controllers.RequirePermission("queue:submit"), jobHandler.RestartJobByID)
	}

	// ################ case: resources route
	resApi := r.Group("/xce/v1/resources")
	{
		resHandler := &controllers.ResourceController{}
		resApi.GET("/distribution", controllers.RequirePermission("resource:view"), resHandler.GetResourcesDistributionInfo)
		resApi.GET("/definition", controllers.RequirePermission("resource:view"), resHandler.GetResourcesDefinitionInfo)
	}
	// ################ case: files route
	filesApi := r.Group("/xce/v1/files")
	{
		filesHandler := &controllers.FilesController{}
		filesApi.POST("/upload", controllers.RequirePermission("file:control"), filesHandler.UploadFiles) //upload one or more files
		//filesApi.DELETE("", filesHandler.DeleteFiles) //delete
		filesApi.GET("/:uuid/:filename", controllers.RequirePermission("file:view"), filesHandler.DownloadFile) //download
		filesApi.GET("", controllers.RequirePermission("file:view"), filesHandler.GetFileLists)                 //query
	}

	return r
}