(MAINT) Add rate limit handler config. (#50)

(MAINT) Add rate limiting per handler.

Author: eoinmcq

pkg/service/README.md

@@ -38,12 +38,13 @@ type Config struct {
   ErrorHandler       *MiddlewareHandler       //Optional. If true a handler will be added to the end of the chain.
 }  
   
-//Handler will hold all the callback handlers to be registered. N.B. gin will be used.
+// Handler will hold all the callback handlers to be registered. N.B. gin will be used.
 type Handler struct {
-	Method  string               //HTTP method or service.AnyMethod to support all limits.
-	Path    string               //The path the endpoint runs on.
-	Group   string               //Optional - specify a group if this is to have it's own group. N.B. The point of the group is to allow middleware to run on some requests and not others(based on the group).
-	Handler func(c *gin.Context) //The handler to be used.
+	Method          string                  // HTTP method or service.AnyMethod to support all limits.
+	Path            string                  // The path the endpoint runs on.
+	Group           string                  // Optional - specify a group (used to control which middlewares will run)
+	Handler         func(c *gin.Context)    // The handler to be used.
+	RateLimitConfig *HandlerRateLimitConfig // Optional rate limiting config specifically for the handler.
 }
   
 //MiddlewareHandler will hold all the middleware and whether
@@ -71,6 +72,12 @@ type CorsConfig struct {
 	Enabled     bool         //Whether CORS is enabled or not.
 	OverrideCfg *cors.Config //Optional. This is only required if you do not want to use the default CORS configuration.
 } 
+
+// HandlerRateLimitConfig holds the rate limiting config fo a sepecific handler.
+type HandlerRateLimitConfig struct {
+	Limit  int // The number of requests allowed within the timeframe.
+	Within int // The timeframe(seconds) the requests are allowed in.
+}
   
 //Service will be the actual structure returned.  
 type Service struct {  
@@ -82,6 +89,7 @@ type Service struct {
 #### Notes
 - The cors config and the handlers are based on the gin framework : https://github.com/gin-gonic/gin.  
 - Rate limiting is done by the library github.com/cnjack/throttle.
+- Rate limiting can be added to a handler or on a per group basis. 
 - The group principle is based on Gin routergroups. The idea behind it is that not all middleware needs to run on 
 all requests so the middleware in a group will only run against an endpoint in that group. 
 This is applied to cors, rate limiting and any middleware in general.  

pkg/service/service.go

@@ -42,10 +42,11 @@ type Config struct {
 
 // Handler will hold all the callback handlers to be registered. N.B. gin will be used.
 type Handler struct {
-	Method  string               // HTTP method or service.AnyMethod to support all limits.
-	Path    string               // The path the endpoint runs on.
-	Group   string               // Optional - specify a group (used to control which middlewares will run)
-	Handler func(c *gin.Context) // The handler to be used.
+	Method          string                  // HTTP method or service.AnyMethod to support all limits.
+	Path            string                  // The path the endpoint runs on.
+	Group           string                  // Optional - specify a group (used to control which middlewares will run)
+	Handler         func(c *gin.Context)    // The handler to be used.
+	RateLimitConfig *HandlerRateLimitConfig // Optional rate limiting config specifically for the handler.
 }
 
 // MiddlewareHandler will hold a middleware handler and the groups on which it should be registered.
@@ -74,6 +75,12 @@ type CorsConfig struct {
 	OverrideCfg *cors.Config // Optional. Only required if you do not want to use the default CORS configuration.
 }
 
+// HandlerRateLimitConfig holds the rate limiting config fo a sepecific handler.
+type HandlerRateLimitConfig struct {
+	Limit  int // The number of requests allowed within the timeframe.
+	Within int // The timeframe(seconds) the requests are allowed in.
+}
+
 // Service will be the actual structure returned.
 type Service struct {
 	*http.Server         // Anonymous embedded struct to allow access to http server methods.
@@ -159,6 +166,10 @@ func setupRateLimiting(config *RateLimitConfig, engine *gin.Engine) {
 	}
 }
 
+func getRateLimitHandler(config *HandlerRateLimitConfig) gin.HandlerFunc {
+	return rateLimitHandler(config.Limit, config.Within)
+}
+
 func setupMiddleware(mwHandlers []MiddlewareHandler, engine *gin.Engine) {
 	// Add middleware first then the handlers
 	for _, handler := range mwHandlers {
@@ -199,6 +210,17 @@ func setupEndpoints(handlers []Handler, engine *gin.Engine) (err error) {
 
 	for _, handler := range handlers {
 		handlerGroup := getRouterGroup(engine, handler.Group)
+
+		// Create a new group on the fly with the rate limiter as the first entry point and copy the chain of handlers.
+		if handler.RateLimitConfig != nil {
+			newHandlerGroup := engine.Group("/")
+
+			newHandlerGroup.Handlers = append([]gin.HandlerFunc{getRateLimitHandler(handler.RateLimitConfig)},
+				handlerGroup.Handlers...)
+
+			handlerGroup = newHandlerGroup
+		}
+
 		switch method := handler.Method; method {
 		case http.MethodGet, http.MethodPost, http.MethodPatch, http.MethodDelete, http.MethodOptions:
 			handlerGroup.Handle(method, handler.Path, handler.Handler)