Ruffe

Golang HTTP handler

• Installing
• Router
  • Customization
• Interceptors
• Middlewares
  • Handler middleware
  • Router middleware
• Error Handling

Guide

Installing

go get -u github.com/8bitdogs/ruffe

Router

package main

import (
	"net/http"

	"github.com/8bitdogs/ruffe"
)

func main() {
	// Ruffe instance
	rr := ruffe.New()

	// add handler
	rr.HandleFunc("/", http.MethodGet, hello)

	// Start server
	http.ListenAndServe(":3030", rs)
}

// hello handler
func hello(ctx ruffe.Context) error {
	return ctx.Result(http.StatusOK, "hello world")
}

Customization

Using custom request router

package main

import (
	"net/http"

	"github.com/8bitdogs/ruffe"
	"github.com/gorilla/mux"
)

type Router struct {
	*mux.Router
}

// We have to override gorilla Handle and HandleFunc, because those two functions are returning gorilla Router instance

func (r *Router) Handle(pattern string, handler http.Handler) {
	r.Router.Handle(pattern, handler)
}

func (r *Router) HandleFunc(pattern string, handler func(http.ResponseWriter, *http.Request)) {
	r.Router.HandleFunc(pattern, handler)
}

type muxCreator struct{}

func (muxCreator) Create() ruffe.Mux {
	return &Router{
		Router: mux.NewRouter(),
	}
}

func main() {
	r := ruffe.NewMux(muxCreator{})
	r.HandleFunc("/foo/{id}", "GET", func(ctx ruffe.Context) error {
		// as you can see, gorilla mux features are available :) 
		return ctx.Result(http.StatusOK, "bar"+mux.Vars(ctx.Request())["id"])
	})
	http.ListenAndServe(":3030", r)
}

Interceptors

example with logging interceptor

rr := ruffe.New()

// adding interceptor
rr.AppendInterceptor(func(w http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
	log.Println(r.URL, r.Method, r.Header)
	next(w, r)
	log.Println("done")
})

// ... handlers registration

http.ListenAndServe(":3030", rr)

Middlewares

Handler middleware

// Initializing Ruffe Middleware
// Middleware implements ruffe.Handler interface
mw := ruffe.NewMiddlewareFunc(func(_ ruffe.Context) error {
	// Middleware logic
	return nil
})

// Add middleware handler before calling <ruffe handler> 
mwh := mw.Before(<ruffe handler>) // WrapFunc returns middleware

// Add middleware handler after calling <ruffe handler> 
mwh := mw.After(<ruffe handler>) // WrapAfterFunc returns middleware

Router middleware

rr := ruffe.New()

// applies handler which invokes before executing each registered handler
rr.Use(<ruffe handler>)

// applies handler which invokes after executing each registered handler
rr.UseAfter(<ruffe handler>)

Error handling

package main

import (
	"errors"
	"net/http"

	"github.com/8bitdogs/ruffe"
)

var Err = errors.New("error")

func main() {
	// Ruffe instance
	rr := ruffe.New()

	// Define error handler
	rr.OnError = func(_ ruffe.Context, err error) error {
		if err == Err {
			// Caught!
			return nil
		}
		return nil
	}

	// add handler
	rr.HandleFunc("/", http.MethodGet, hello)

	// Start server
	http.ListenAndServe(":3030", rs)
}

// hello handler
func hello(_ ruffe.Context) error {
	return Err
}