httpf

type Client ¶

type Client interface {
	Send(ctx context.Context, req *http.Request) (*http.Response, error)

	Get(ctx context.Context, url string) (*http.Response, error)
	Post(ctx context.Context, url string, body io.Reader) (*http.Response, error)
	PostForm(ctx context.Context, url string, form url.Values) (*http.Response, error)
	Put(ctx context.Context, url string, body io.Reader) (*http.Response, error)
	Delete(ctx context.Context, url string) (*http.Response, error)

	Close()
}

A Client is an HTTP client containing convenient API to send request with common HTTP methods. Send function is the fundamental implementation for the Client which provides a way to send request over HTTP and receive response.

type ClientOption ¶

type ClientOption func(*ClientOptions)

ClientOption defines single function to mutate options.

func WithCookies(cookieJar http.CookieJar) ClientOption

func WithRedirectHandler(handler func(req *http.Request, via []*http.Request) error) ClientOption

func WithTimeout(timeout time.Duration) ClientOption

func WithTransport(transport http.RoundTripper) ClientOption

type ClientOptions ¶

type ClientOptions struct {
	Transport     http.RoundTripper
	CheckRedirect func(req *http.Request, via []*http.Request) error
	Jar           http.CookieJar
	Timeout       time.Duration
}

ClientOptions defines http.Client constructor parameters which can be set on NewClient.

func NewClientOptions(opts ...ClientOption) ClientOptions

type ErrorHandler ¶

type ErrorHandler interface {
	Handle(w http.ResponseWriter, r *http.Request, err error)
}

A ErrorHandler handles error returned from Handler

Handle should write response to the ResponseWriter in common used format with proper mapped error.

type ErrorHandlerFunc ¶

type ErrorHandlerFunc func(w http.ResponseWriter, r *http.Request, err error)

The ErrorHandlerFunc type is an adapter to allow the use of ordinary functions as Error handlers. If h is a function with the appropriate signature, ErrorHandlerFunc(h) is a ErrorHandler that calls h.

func (h ErrorHandlerFunc) Handle(w http.ResponseWriter, r *http.Request, err error)

type Handler ¶

type Handler interface {
	ServeHTTP(w ResponseWriter, r *http.Request) error
}

A Handler responds to an HTTP request

ServeHTTP should write reply headers and data to the ResponseWriter and then return any occurring error. The error should be handler by Router which should finish request process.

func RateLimitMiddleware(h Handler, store rate.LimiterStore, keyFactory RateHttpKeyFactory) Handler

package main

import (
	"errors"
	"fmt"
	"net/http"
	"strconv"
	"sync"
	"time"

	"github.com/Prastiwar/Go-flow/httpf"
	"github.com/Prastiwar/Go-flow/rate"
	"github.com/Prastiwar/Go-flow/tests/mocks"
)

const hostPrefix = "localhost:"

var (
	port     = 8080
	serverMu = sync.Mutex{}
)

// runServer creates new server and listens in new goroutine on address that is returned from this function.
func runServer(router httpf.Router) string {
	serverMu.Lock()
	defer serverMu.Unlock()

	port++
	address := hostPrefix + strconv.Itoa(port)
	go func() {
		_ = httpf.NewServer(address, router).ListenAndServe()
	}()
	return "http://" + address
}

func main() {
	mux := httpf.NewServeMuxBuilder()

	mux.WithErrorHandler(httpf.ErrorHandlerFunc(func(w http.ResponseWriter, r *http.Request, err error) {
		if errors.Is(err, rate.ErrRateLimitExceeded) {
			w.WriteHeader(http.StatusTooManyRequests)
			return
		}
		panic(err)
	}))

	var (
		resetPeriod time.Duration = time.Second
		maxTokens   uint64        = 2
		tokens      uint64        = maxTokens
	)
	storeLimiter := mocks.LimiterStoreMock{
		OnLimit: func(key string) rate.Limiter {
			return mocks.LimiterMock{
				OnLimit:  func() uint64 { return maxTokens },
				OnTokens: func() uint64 { return tokens },
				OnTake: func() rate.Token {
					return mocks.TokenMock{
						OnUse: func() error {
							if tokens <= 0 {
								return rate.ErrRateLimitExceeded
							}
							tokens--
							go func() {
								time.Sleep(resetPeriod)
								tokens++
							}()
							return nil
						},
						OnResetsAt: func() time.Time { return time.Now().Add(resetPeriod) },
					}
				},
			}
		},
	}

	mux.Get("/api/test/", httpf.RateLimitMiddleware(httpf.HandlerFunc(func(w httpf.ResponseWriter, r *http.Request) error {
		return w.Response(http.StatusOK, nil)
	}), storeLimiter, httpf.PathRateKey()))

	serverAddress := runServer(mux.Build())

	callGet := func() {
		resp, err := http.Get(serverAddress + "/api/test/")
		if err != nil {
			panic(err)
		}
		defer resp.Body.Close()

		fmt.Println(resp.StatusCode)
	}

	for i := uint64(0); i <= maxTokens; i++ {
		callGet()
	}

	time.Sleep(resetPeriod)
	callGet()

}

Output:
200
200
429
200

type HandlerFunc ¶

type HandlerFunc func(w ResponseWriter, r *http.Request) error

The HandlerFunc type is an adapter to allow the use of ordinary functions as HTTP handlers. If h is a function with the appropriate signature, HandlerFunc(h) is a Handler that calls h.

func (h HandlerFunc) ServeHTTP(w ResponseWriter, r *http.Request) error

type ParamsParser ¶

type ParamsParser interface {
	ParseParams(r *http.Request) map[string]string
}

ParamsParser is parser for request to retrieve path parameters. Implementation should decide how to retrieve params based on values in specified http request.

type ParamsParserFunc ¶

type ParamsParserFunc func(r *http.Request) map[string]string

The ParamsParserFunc type is an adapter to allow the use of ordinary functions as ParamsParser. If p is a function with the appropriate signature, ParamsParserFunc(p) is a ParamsParser that will return p.

func (p ParamsParserFunc) ParseParams(r *http.Request) map[string]string

type RateHttpKeyFactory ¶ added in v0.7.0

type RateHttpKeyFactory func(r *http.Request) string

RateHttpKeyFactory is factory func to create a string key based on http.Request.

func ComposeRateKeyFactories(factories ...RateHttpKeyFactory) RateHttpKeyFactory

func IPRateKey(headerNames ...string) RateHttpKeyFactory

func PathRateKey() RateHttpKeyFactory

type ResponseWriter ¶

type ResponseWriter interface {
	http.ResponseWriter

	Response(code int, data interface{}) error
}

A ResponseWriter interface is used by an HTTP handler to construct an HTTP response. It extends http.ResponseWriter with Response function which should be used to share common response format.

type RouteBuilder ¶

type RouteBuilder interface {
	Get(pattern string, handler Handler) RouteBuilder
	Post(pattern string, handler Handler) RouteBuilder
	Put(pattern string, handler Handler) RouteBuilder
	Delete(pattern string, handler Handler) RouteBuilder
	Patch(pattern string, handler Handler) RouteBuilder
	Options(pattern string, handler Handler) RouteBuilder

	WithErrorHandler(handler ErrorHandler) RouteBuilder
	WithWriterDecorator(decorator func(http.ResponseWriter) ResponseWriter) RouteBuilder
	WithParamsParser(parser ParamsParser) RouteBuilder

	Build() Router
}

A RouteBuilder is convenient builder for routing registration. It defines function for each HTTP Method. Pattern should be able to be registered with any method. It's also responsible to use ErrorHandler and WriterDecorator in mapping from Handler to http.Handler so errors can be handled gracefully and http.ResponseWriter would be decorated with Response function.

type Router ¶

type Router interface {
	http.Handler

	Handle(pattern string, handler http.Handler)
}

A Router is an HTTP request multiplexer. It should match the URL of each incoming request against a list of registered patterns and call the handler for the pattern that most closely matches the URL. Router also should take care of sanitizing the URL request path and the Host header, stripping the port number and redirecting any request containing . or .. elements or repeated slashes to an equivalent, cleaner URL.

type Server ¶

type Server interface {
	Close() error
	Shutdown(ctx context.Context) error
	RegisterOnShutdown(f func())

	ListenAndServe() error
	Serve(l net.Listener) error

	ListenAndServeTLS(certFile, keyFile string) error
	ServeTLS(l net.Listener, certFile, keyFile string) error
}

A Server defines functionality for running an HTTP server.