A webtool kit for golang
The turbo
package provides enterprise grade http routing capabilities. The lightweight router works well
with all the necessary Use Cases and at the same time scales well.
Being a Lightweight HTTP Router, it comes with a simple usage as explained below, just import the package, and you are good to go.
func main() {
router := turbo.New()
router.Get("/api/v1/healthCheck", healthCheck) // healthCheck is the handler Function
router.Get("/api/v1/getData", getData) // getData is the handler Function
srv := &http.Server{
Handler: router,
Addr: ":8080",
ReadTimeout: 20 * time.Second,
WriteTimeout: 20 * time.Second,
}
if err := srv.ListenAndServe(); err != nil {
log.Fatalln(err)
}
}
- Router lets you register routes based on the common HTTP Methods such as
- GET
router.Get("/api/v1/getCustomers", getCustomers)
- POST
router.Post("/api/v1/getCustomers", getCustomers)
- PUT
router.Put("/api/v1/getCustomers", getCustomers)
- DELETE
router.Delete("/api/v1/getCustomers", getCustomers)
- GET
-
Router lets you register routes with multiple methods such as
("POST", "PUT")
for a single endpoint.With the help of
Add
function that can be achievedrouter.Add("/api/v1/addCustomers", getCustomers, "PUT", "POST")
This will register a route called
/api/v1/addCustomers
with two functions attached to a single route,PUT
andPOST
- Routes can be registered in the following ways
-
Registering Static Routes
router.Get("/api/v1/getCustomers", getCustomers)
-
Registering with Path Variables
The path variables can be registered with :<name_of_param>
router.Get("/api/v1/getCustomer/:id", getCustomer)
-
- Path Params can be fetched with the built-in wrapper provided by the framework
- The framework exposes a number of functions based on the type of variable that has been registered with the route
- To fetch string parameters
getPathParms(id string, r *http.Request) string {}
- To Fetch Int parameters
getIntPathParms(id string, r *http.Request) int {}
- To fetch Float parameters
getFloatPathParms(id string, r *http.Request) float64 {}
- To Fetch Boolean parameters
getBoolPathParms(id string, r *http.Request) bool {}
- To fetch string parameters
- The framework exposes a number of functions based on the type of variable that has been registered with the route
- Query Parameters can also be fetched with a built-in wrapper functions provided by the framework
- The Framework exposes a number of wrapper functions which lets you fetch the query params of specific data type
required
- To fetch string query params
GetQueryParams(id string, r *http.Request) string {}
- To Fetch Int query params
GetIntQueryParams(id string, r *http.Request) int {}
- To fetch Float64 query params
GetFloatQueryParams(id string, r *http.Request) float64 {}
- To Fetch Boolean query params
GetBoolQueryParams(id string, r *http.Request) bool {}
- To fetch string query params
- The Framework exposes a number of wrapper functions which lets you fetch the query params of specific data type
required
-
Filters are available to add your custom middlewares to the
route
.Keeping in mind that all these middlewares/filters can be added at the route level only, this way giving you more freedom on how each route should behave in a microservice.
turbo
provides two main Filter Functions which can be leveraged easily and make your microservice more flexible1. AddFilter(filters ...FilterFunc) 2. AddAuthenticator(filter FilterFunc)
-
AddFilter()
This Filter expects input of type
FilterFunc
i.e.func(http.Handler) http.Handler
. You can declare your own filters of type FilterFunc as explained before and Add them to the AddFilter() as explained belowfunc main() { turboRouter := turbo.NewRouter() turboRouter.Get("/api/v1", ResponseHandler).AddFilter(loggingFilter, dummyFilter) srv := &http.Server{ Handler: turboRouter, Addr: ":9292", } } func loggingFilter(next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { logger.Info("Filter Added") logger.Info(r.RequestURI) next.ServeHTTP(w, r) logger.Info("Filter Added again") }) } func dummyFilter(next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { logger.Info("Second Filter Added") next.ServeHTTP(w, r) logger.Info("Second Filter Added again") }) }
-
AddAuthenticator()
turbo is working on supporting all the major
Authentication
schemes in accordance with the OAS3 Specifications;| Authorization | Status | | :--- | :----: | | Basic Auth | WIP | | JWT | TBD | | OAuth | TBD | | LDAP | TBD |
An Authentication Filter can be implemented like below
func main() { turboRouter := turbo.NewRouter() var authenticator = auth.CreateBasicAuthAuthenticator() // provide the configuration to your authenticator filter struct, // with the relevant struct Objects that would be exposed // Once those input to your `authenticator` is fed, it can be used as the Filter easily turboRouter.Get("/api/v1", ResponseHandler).AddAuthenticator(authenticator) srv := &http.Server{ Handler: turboRouter, Addr: ":9292", } }
Working Understanding
The filters get executed in the order you add in the
AddFilter()
which states that if you add functions : f1, f2, f3 as filters and want to be executed before the actual handler executes. The Order of execution chain becomesf1 --> f2 --> f3 --> handlerFunction
If you add Authentication Filter i.e.
AddAuthenticator()
explicitly and then add other filters toAddFilter()
, then the order of execution of chain becomes,authFilterFunc --> f1 --> f2 --> f3 --> handlerFunction
Turbo gives the Authentication Filter precedence over any of the filter added to the chain. Rest all the chain order gets preserved in order they are added.
-
To be released soon