turbo

Turbo

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.

• Quick Start Guide
• Features
  • Base Routing
  • Multiple HTTP Methods Registering
  • Routes Registering
  • Path Params Wrapper
  • Query Params Wrapper
  • Filters
• Benchmarking Results

Quick Start Guide

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)
    }
}

Features

Base Routing

• Router lets you register routes based on the common HTTP Methods such as
  1. GET

      router.Get("/api/v1/getCustomers", getCustomers) 
     

  2. POST

      router.Post("/api/v1/getCustomers", getCustomers) 
     

  3. PUT

      router.Put("/api/v1/getCustomers", getCustomers) 
     

  4. DELETE

     router.Delete("/api/v1/getCustomers", getCustomers) 
     

Multiple HTTP Methods Registering

• 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 achieved

   router.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 and POST

Routes Registering

• 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 Wrapper

• 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 {}
      

Query Params Wrapper

• 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 {}
      

Filters

• 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 flexible

  1. 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 below

    func 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 becomes

  f1 --> f2 --> f3 --> handlerFunction
  

  If you add Authentication Filter i.e. AddAuthenticator() explicitly and then add other filters to AddFilter(), 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.

Benchmarking Results

To be released soon