httputil

Documentation

Index

• Constants
• Variables
• func DumpBody(req *http.Request) ([]byte, error)
• func DumpHeader(req *http.Request) map[string]string
• func ErrorHandler(w http.ResponseWriter, r *http.Request, err error)
• func JSONWrite(w http.ResponseWriter, code int, obj interface{}) error
• func RapiDoc(opts RapiDocOpts) func(http.Handler) http.Handler
• type AuthError
  • func (e AuthError) Error() string
• type ErrorHandlerFunc
• type RapiDocOpts
  • func (r *RapiDocOpts) Defaults()
• type WriterProxy
  • func WrapWriter(w http.ResponseWriter) WriterProxy

Constants

const (
	// ErrUnauthorized represents failure when authenticating a request.
	ErrUnauthorized = AuthError("Unauthorized")

	// ErrForbidden represents failure when authorizing a request.
	ErrForbidden = AuthError("Forbidden")

	// ErrBasicAuthenticate is designed to trigger an HTTP Basic Auth challenge.
	ErrBasicAuthenticate = AuthError("ErrWWWAuthenticate")
)

const InternalErrorFormat = "Internal Server Error: %d"

InternalErrorFormat is the default error message returned for unhandled errors.

Variables

var (
	// ContentType header value.
	ContentType = "Content-Type"
	// ApplicationJSON content-type.
	ApplicationJSON = "application/json"
	// TextHTML content-type.
	TextHTML = "text/html"
)

var ErrUnsupported = fmt.Errorf("not implemented")

Functions

func DumpBody

func DumpBody(req *http.Request) ([]byte, error)

func DumpHeader

func DumpHeader(req *http.Request) map[string]string

func ErrorHandler

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

ErrorHandler provides some standard handling for errors in an http request flow.

Maps: json.SyntaxError to "BadRequest", body is the JSON string of the error message. validation.Errors to "BadRequest", body is the JSON of the error object (map of field name to list of errors). AuthError to "Forbidden" or "Unauthorized" as defined by the err instance. In addition ErrBasicAuthenticate issues a basic auth challenge using default realm of "Restricted". To override handle in your custom error handlers instead.

Unhandled errors are added to the ctx and return "Internal Server Error" with the request ID to aid with troubleshooting.

func JSONWrite

func JSONWrite(w http.ResponseWriter, code int, obj interface{}) error

JSONWrite is a simple helper utility to return the json encoded obj with appropriate content-type and code.

func RapiDoc

func RapiDoc(opts RapiDocOpts) func(http.Handler) http.Handler

Types

type AuthError

type AuthError string

AuthError encompasses Authentication and Authorization errors.

func (AuthError) Error

func (e AuthError) Error() string

type ErrorHandlerFunc

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

ErrorHandlerFunc is useful to standardize the exception management of requests.

type RapiDocOpts

type RapiDocOpts struct {
	// BasePath for the UI path, defaults to: /
	BasePath string
	// Path combines with BasePath for the full UI path, defaults to: docs
	Path string
	// SpecURL the url to find the spec for
	SpecURL string
	// RapiDocURL for the js that generates the rapidoc site, defaults to: https://unpkg.com/rapidoc/dist/rapidoc-min.js
	RapiDocURL string
	// Title for the documentation site, default to: API documentation
	Title string
}

RapiDocOpts configures the RapiDoc middlewares.

func (*RapiDocOpts) Defaults

func (r *RapiDocOpts) Defaults()

Defaults for all options.

type WriterProxy

type WriterProxy interface {
	http.ResponseWriter
	// Status returns the HTTP status of the request, or 0 if one has not
	// yet been sent.
	Status() int
	// BytesWritten returns the total number of bytes sent to the client.
	BytesWritten() int
	// Tee causes the response body to be written to the given io.Writer in
	// addition to proxying the writes through. Only one io.Writer can be
	// tee'd to at once: setting a second one will overwrite the first.
	// Writes will be sent to the proxy before being written to this
	// io.Writer. It is illegal for the tee'd writer to be modified
	// concurrently with writes.
	Tee(io.Writer)
	// Unwrap returns the original proxied target.
	Unwrap() http.ResponseWriter
}

WriterProxy is a proxy around an http.ResponseWriter that allows you to hook into various parts of the response process.

func WrapWriter

func WrapWriter(w http.ResponseWriter) WriterProxy

WrapWriter wraps an http.ResponseWriter, returning a proxy that allows you to hook into various parts of the response process.