long_param

Documentation

Index

• type Cache
• type Datastore
• type Formatter
• type Instrumentation
• type Logger
• type MyHandler
  • func NewMyHandler(logger Logger, stats Instrumentation, parser Parser, formatter Formatter, ...) *MyHandler
  • func (m *MyHandler) ServeHTTP(response http.ResponseWriter, request *http.Request)
• type Parser
• type RateLimiter

Types

type Cache

type Cache interface {
	Store(key string, data []byte)
	Get(key string) ([]byte, error)
}

Cache will store/retrieve data in a fast way

type Datastore

type Datastore interface {
	Load(ID int) ([]byte, error)
}

Datastore will store/retrieve data in a permanent

type Formatter

type Formatter interface {
	Format(resp http.ResponseWriter, data []byte) error
}

Formatter will build the output

type Instrumentation

type Instrumentation interface {
	Count(key string, value int)
	Duration(key string, start time.Time)
}

Instrumentation records the performances and events

type Logger

type Logger interface {
	Error(message string, args ...interface{})
	Warn(message string, args ...interface{})
	Info(message string, args ...interface{})
	Debug(message string, args ...interface{})
}

Logger logs stuff

type MyHandler

type MyHandler struct {
}

MyHandler does something fantastic

func NewMyHandler

func NewMyHandler(logger Logger, stats Instrumentation,
	parser Parser, formatter Formatter,
	limiter RateLimiter,
	cache Cache, db Datastore) *MyHandler

func (*MyHandler) ServeHTTP

func (m *MyHandler) ServeHTTP(response http.ResponseWriter, request *http.Request)

type Parser

type Parser interface {
	Extract(req *http.Request) (int, error)
}

Parse will extract details from the request

type RateLimiter

type RateLimiter interface {
	Acquire()
	Release()
}

RateLimiter limits how many concurrent requests we can make or process