web

Documentation

Index

• func GenerateBytesUUID() []byte
• func GenerateUUID() string
• func InstallViewHandler(l logger, sp view.ServiceProvider, d dispatcher)
• type Config
• type Dispatcher
  • func (rd *Dispatcher) HandleRequest(context *ReqContext) (response interface{}, statusCode int)
  • func (rd *Dispatcher) ParsePayload(bytes []byte) (interface{}, error)
  • func (rd *Dispatcher) WireViewCaller(vc ViewCaller)
• type HttpHandler
  • func NewHttpHandler(l logger) *HttpHandler
  • func (h *HttpHandler) RegisterURI(uri string, method string, rh RequestHandler)
  • func (h *HttpHandler) ServeHTTP(w http.ResponseWriter, req *http.Request)
• type Logger
• type Options
• type ReqContext
• type RequestHandler
• type ResponseErr
• type Server
  • func NewServer(o Options) *Server
  • func (s *Server) Addr() string
  • func (s *Server) HandlerChain(h http.Handler, secure bool) http.Handler
  • func (s *Server) RegisterHandler(pattern string, handler http.Handler, secure bool)
  • func (s *Server) Run(signals <-chan os.Signal, ready chan<- struct{}) error
  • func (s *Server) Start() error
  • func (s *Server) Stop() error
• type TLS
  • func (t TLS) Config() (*tls.Config, error)
• type ViewCaller

Functions

func GenerateBytesUUID

func GenerateBytesUUID() []byte

GenerateBytesUUID returns a UUID based on RFC 4122 returning the generated bytes

func GenerateUUID

func GenerateUUID() string

GenerateUUID returns a UUID based on RFC 4122

func InstallViewHandler

func InstallViewHandler(l logger, sp view.ServiceProvider, d dispatcher)

Types

type Config

type Config struct {
	MaxReqSize uint16
}

type Dispatcher

type Dispatcher struct {
	Logger  logger
	Handler *HttpHandler
	// contains filtered or unexported fields
}

func (*Dispatcher) HandleRequest

func (rd *Dispatcher) HandleRequest(context *ReqContext) (response interface{}, statusCode int)

func (*Dispatcher) ParsePayload

func (rd *Dispatcher) ParsePayload(bytes []byte) (interface{}, error)

func (*Dispatcher) WireViewCaller

func (rd *Dispatcher) WireViewCaller(vc ViewCaller)

type HttpHandler

type HttpHandler struct {
	Logger logger
	// contains filtered or unexported fields
}

func NewHttpHandler

func NewHttpHandler(l logger) *HttpHandler

func (*HttpHandler) RegisterURI

func (h *HttpHandler) RegisterURI(uri string, method string, rh RequestHandler)

func (*HttpHandler) ServeHTTP

func (h *HttpHandler) ServeHTTP(w http.ResponseWriter, req *http.Request)

type Logger

type Logger interface {
	Debugf(template string, args ...interface{})
	Warnf(template string, args ...interface{})
	Infof(template string, args ...interface{})
	Errorf(template string, args ...interface{})
	Warn(args ...interface{})
}

type Options

type Options struct {
	Logger        Logger
	ListenAddress string
	TLS           TLS
}

type ReqContext

type ReqContext struct {
	Req   *http.Request
	Vars  map[string]string
	Query interface{}
}

type RequestHandler

type RequestHandler interface {
	// HandleRequest dispatches the request in the backend by parsing the given request context
	// and returning a status code and a response back to the client.
	HandleRequest(*ReqContext) (response interface{}, statusCode int)

	// ParsePayload parses the payload to handler specific form or returns an error
	ParsePayload([]byte) (interface{}, error)
}

type ResponseErr

type ResponseErr struct {
	Reason string
}

type Server

type Server struct {
	// contains filtered or unexported fields
}

func NewServer

func NewServer(o Options) *Server

func (*Server) Addr

func (s *Server) Addr() string

func (*Server) HandlerChain

func (s *Server) HandlerChain(h http.Handler, secure bool) http.Handler

func (*Server) RegisterHandler

func (s *Server) RegisterHandler(pattern string, handler http.Handler, secure bool)

RegisterHandler registers into the ServeMux a handler chain that borrows its security properties from the fabhttp.Server. This method is thread safe because ServeMux.Handle() is thread safe, and options are immutable. This method can be called either before or after Server.Start(). If the pattern exists the method panics.

func (*Server) Run

func (s *Server) Run(signals <-chan os.Signal, ready chan<- struct{}) error

func (*Server) Start

func (s *Server) Start() error

func (*Server) Stop

func (s *Server) Stop() error

type TLS

type TLS struct {
	Enabled           bool
	CertFile          string
	KeyFile           string
	ClientCACertFiles []string
}

func (TLS) Config

func (t TLS) Config() (*tls.Config, error)

type ViewCaller

type ViewCaller interface {
	CallView(vid string, input []byte) (interface{}, error)
}