Dylan/feature/v0.1 executor

conf/env.go

@@ -6,17 +6,21 @@ import (
  "strings"
 )
 
+const envKey = "Env"
+const ProdEnv = "prod"
+const DevEnv = "dev"
+
 type Env struct {
  Name string // env Name, like `prod`, `dev` and etc.,
  Debugger bool // whether to use debugger
 }
 
 func (env *Env) IsDevelopment() bool {
- return strings.EqualFold("dev", env.Name)
+ return strings.EqualFold(DevEnv, env.Name)
 }
 
 func (env *Env) IsProduction() bool {
- return strings.EqualFold("prod", env.Name)
+ return strings.EqualFold(ProdEnv, env.Name)
 }
 
 func (env *Env) GetEnvName() *string {
@@ -34,14 +38,14 @@ func getConfFilePath() *string {
 var Environment *Env
 
 func init() {
- envName := "prod"
- if len(os.Getenv("Env")) > 0 {
- envName = os.Getenv("Env")
+ envName := ProdEnv
+ if len(os.Getenv(envKey)) > 0 {
+ envName = os.Getenv(envKey)
  }
  Environment = &Env{
  Name: envName,
  Debugger: func() bool {
- return envName != "prod"
+ return envName != ProdEnv
  }(),
  }
 }

rpc_server/api/health.go

@@ -0,0 +1,27 @@
+package api
+
+import (
+ "AAStarCommunity/EthPaymaster_BackService/conf"
+ "AAStarCommunity/EthPaymaster_BackService/rpc_server/models"
+ "github.com/gin-gonic/gin"
+ "time"
+)
+
+// Healthz
+// @Tags Healthz
+// @Description Get Healthz
+// @Accept json
+// @Product json
+// @Param
+// @Router /api/health [post,get,put,delete]
+// @Success 200
+func Healthz(c *gin.Context) {
+ response := models.GetResponse()
+ response.WithDataSuccess(c, gin.H{
+ "hello": "Eth Paymaster",
+ "environment": conf.Environment.Name,
+ "time": time.Now(),
+ "version": "v1.0.0",
+ })
+ response.Success(c)
+}

rpc_server/middlewares/logger.go

@@ -0,0 +1,10 @@
+package middlewares
+
+import (
+ "github.com/gin-gonic/gin"
+)
+
+// LogHandler log handler
+func LogHandler() gin.HandlerFunc {
+ return gin.Logger()
+}

rpc_server/middlewares/rate_limit.go

@@ -15,8 +15,8 @@ const (
 
 var limiter map[string]*rate.Limiter
 
-// RateLimiterByApiKey represents the rate limit by each ApiKey for each api calling
-func RateLimiterByApiKey() gin.HandlerFunc {
+// RateLimiterByApiKeyHandler represents the rate limit by each ApiKey for each api calling
+func RateLimiterByApiKeyHandler() gin.HandlerFunc {
  return func(ctx *gin.Context) {
  if exists, current := utils.CurrentUser(ctx); exists {
 

rpc_server/middlewares/recovery.go

@@ -10,8 +10,8 @@ import (
  "strings"
 )
 
-// GenericRecovery represents the generic error(panic) process
-func GenericRecovery() gin.HandlerFunc {
+// GenericRecoveryHandler represents the generic error(panic) process
+func GenericRecoveryHandler() gin.HandlerFunc {
  DefaultErrorWriter := &PanicExceptionRecord{}
  return gin.RecoveryWithWriter(DefaultErrorWriter, func(c *gin.Context, err interface{}) {
  errStr := ""

rpc_server/routers/boot.go

@@ -16,37 +16,44 @@ import (
 func SetRouters() (routers *gin.Engine) {
  routers = gin.New()
 
- // middlewares
- handlers := make([]gin.HandlerFunc, 0)
- handlers = append(handlers, middlewares.GenericRecovery())
+ buildMod(routers)
+ buildRoute(routers)
+ routers.NoRoute(func(ctx *gin.Context) {
+ models.GetResponse().SetHttpCode(http.StatusNotFound).FailCode(ctx, http.StatusNotFound)
+ })
+
+ return
+}
+func buildRoute(routers *gin.Engine) {
+ // build http routers and middleware
+ routers.Use(middlewares.GenericRecoveryHandler())
  if conf.Environment.IsDevelopment() {
- handlers = append(handlers, gin.Logger())
+ routers.Use(middlewares.LogHandler())
  }
- handlers = append(handlers, middlewares.CorsHandler())
+ routers.Use(middlewares.CorsHandler())
+ //build the routers not need api access like auth or Traffic limit
+ buildRouters(routers, PublicRouterMaps)
+
+ routers.Use(middlewares.AuthHandler())
+ routers.Use(middlewares.RateLimiterByApiKeyHandler())
+ buildRouters(routers, PrivateRouterMaps)
+}
+
+func buildMod(routers *gin.Engine) {
 
  // prod mode
  if conf.Environment.IsProduction() {
  gin.SetMode(gin.ReleaseMode)
  gin.DefaultWriter = io.Discard // disable gin log
+ return
  }
 
  // dev mod
  if conf.Environment.IsDevelopment() {
  gin.SetMode(gin.DebugMode)
  buildSwagger(routers)
+ return
  }
-
- // use middlewares
- routers.Use(handlers...)
-
- // build http routers
- buildRouters(routers)
-
- routers.NoRoute(func(ctx *gin.Context) {
- models.GetResponse().SetHttpCode(http.StatusNotFound).FailCode(ctx, http.StatusNotFound)
- })
-
- return
 }
 
 // buildSwagger build swagger

rpc_server/routers/builder.go

@@ -1,32 +1,23 @@
 package routers
 
 import (
- "AAStarCommunity/EthPaymaster_BackService/rpc_server/api"
- "AAStarCommunity/EthPaymaster_BackService/rpc_server/middlewares"
  "github.com/gin-gonic/gin"
 )
 
 // buildRouters Build Routers
-func buildRouters(router *gin.Engine) {
-
- router.POST("api/auth", api.Auth)
-
- router.Use(middlewares.AuthHandler())
- {
- router.Use(middlewares.RateLimiterByApiKey())
-
- for _, routerMap := range RouterMaps {
- for _, method := range routerMap.Methods {
- if method == GET {
- router.GET(routerMap.Url, routerMap.Func)
- } else if method == PUT {
- router.PUT(routerMap.Url, routerMap.Func)
- } else if method == POST {
- router.POST(routerMap.Url, routerMap.Func)
- } else if method == DELETE {
- router.DELETE(routerMap.Url, routerMap.Func)
- } // ignore rest methods
- }
+func buildRouters(router *gin.Engine, routerMaps []RouterMap) {
+ for _, routerMap := range routerMaps {
+ for _, method := range routerMap.Methods {
+ if method == GET {
+ router.GET(routerMap.Url, routerMap.Func)
+ } else if method == PUT {
+ router.PUT(routerMap.Url, routerMap.Func)
+ } else if method == POST {
+ router.POST(routerMap.Url, routerMap.Func)
+ } else if method == DELETE {
+ router.DELETE(routerMap.Url, routerMap.Func)
+ } // ignore rest methods
  }
+
  }
 }

rpc_server/routers/method_map.go

@@ -0,0 +1,20 @@
+package routers
+
+import "github.com/gin-gonic/gin"
+
+type RestfulMethod string
+
+const (
+ PUT RestfulMethod = "PUT"
+ GET RestfulMethod = "GET"
+ DELETE RestfulMethod = "DELETE"
+ POST RestfulMethod = "POST"
+ HEAD RestfulMethod = "HEAD"
+ OPTIONS RestfulMethod = "OPTIONS"
+)
+
+type RouterMap struct {
+ Url string
+ Methods []RestfulMethod
+ Func func(ctx *gin.Context)
+}

rpc_server/routers/router_test.go

@@ -0,0 +1,8 @@
+package routers
+
+import "testing"
+
+func TestConst(t *testing.T) {
+
+ t.Logf("%s", string(TryPayUserOperation))
+}

rpc_server/routers/routers_map.go

@@ -0,0 +1,29 @@
+package routers
+
+import (
+ "AAStarCommunity/EthPaymaster_BackService/rpc_server/api"
+ v1 "AAStarCommunity/EthPaymaster_BackService/rpc_server/api/v1"
+)
+
+var PrivateRouterMaps []RouterMap
+var PublicRouterMaps []RouterMap
+
+func init() {
+ PrivateRouterMaps = make([]RouterMap, 0)
+
+ PrivateRouterMaps = append(PrivateRouterMaps, RouterMap{string(TryPayUserOperation), []RestfulMethod{POST}, v1.TryPayUserOperation})
+ PrivateRouterMaps = append(PrivateRouterMaps, RouterMap{string(GetSupportStrategy), []RestfulMethod{GET}, v1.GetSupportStrategy})
+ PrivateRouterMaps = append(PrivateRouterMaps, RouterMap{string(GetSupportEntrypoint), []RestfulMethod{GET}, v1.GetSupportEntrypoint})
+ PublicRouterMaps = append(PublicRouterMaps, RouterMap{string(Auth), []RestfulMethod{POST}, api.Auth})
+ PublicRouterMaps = append(PublicRouterMaps, RouterMap{string(Healthz), []RestfulMethod{GET, HEAD, OPTIONS}, api.Healthz})
+}
+
+type Path string
+
+const (
+ TryPayUserOperation Path = "api/v1/try-pay-user-operation"
+ GetSupportStrategy Path = "api/v1/get-support-strategy"
+ GetSupportEntrypoint Path = "api/v1/get-support-entrypoint"
+ Auth Path = "api/auth"
+ Healthz Path = "api/healthz"
+)