Back to godoc.org
github.com/nanmu42/gzip

Package gzip

v1.0.0
Latest Go to latest
Published: Apr 26, 2020 | License: MIT | Module: github.com/nanmu42/gzip

Overview

Package gzip implements gzip middleware for Gin and net/http.

* introduction: https://github.com/nanmu42/gzip

* examples: https://github.com/nanmu42/gzip/tree/master/examples

Index

Package Files

Constants

const (
	NoCompression      = gzip.NoCompression
	BestSpeed          = gzip.BestSpeed
	BestCompression    = gzip.BestCompression
	DefaultCompression = gzip.DefaultCompression
	HuffmanOnly        = gzip.HuffmanOnly
)

These constants are copied from the gzip package

type CommonRequestFilter

type CommonRequestFilter struct{}

CommonRequestFilter judge via common easy criteria like http method, accept-encoding header, etc.

func NewCommonRequestFilter

func NewCommonRequestFilter() *CommonRequestFilter

NewCommonRequestFilter ...

func (*CommonRequestFilter) ShouldCompress

func (c *CommonRequestFilter) ShouldCompress(req *http.Request) bool

ShouldCompress implements RequestFilter interface

type Config

type Config struct {
	// gzip compression level to use,
	// valid value: -2 ~ 9.
	//
	// see https://golang.org/pkg/compress/gzip/#NewWriterLevel
	CompressionLevel int
	// Minimum content length to trigger gzip,
	// the unit is in byte.
	//
	// When `Content-Length` is not available, handler may buffer your writes to
	// decide if its big enough to do a meaningful compression.
	// A high `MinContentLength` may bring memory overhead,
	// although the handler tries to be smart by reusing buffers
	// and testing if `len(data)` of the first
	// `http.ResponseWriter.Write(data []byte)` calling suffices or not.
	MinContentLength int64
	// Filters are applied in the sequence here
	RequestFilter []RequestFilter
	// Filters are applied in the sequence here
	ResponseHeaderFilter []ResponseHeaderFilter
}

Config is used in Handler initialization

type ContentTypeFilter

type ContentTypeFilter struct {
	Types      *acascii.Matcher
	AllowEmpty bool
}

ContentTypeFilter judge via the response content type

Omit this filter if you want to compress all content type.

func DefaultContentTypeFilter

func DefaultContentTypeFilter() *ContentTypeFilter

DefaultContentTypeFilter permits

func NewContentTypeFilter

func NewContentTypeFilter(types []string) *ContentTypeFilter

NewContentTypeFilter ...

func (*ContentTypeFilter) ShouldCompress

func (e *ContentTypeFilter) ShouldCompress(header http.Header) bool

ShouldCompress implements RequestFilter interface

type ExtensionFilter

type ExtensionFilter struct {
	Exts       *acascii.Matcher
	AllowEmpty bool
}

ExtensionFilter judge via the extension in path

Omit this filter if you want to compress all extension.

func DefaultExtensionFilter

func DefaultExtensionFilter() *ExtensionFilter

DefaultExtensionFilter permits

func NewExtensionFilter

func NewExtensionFilter(extensions []string) *ExtensionFilter

NewExtensionFilter returns a extension or panics

func (*ExtensionFilter) ShouldCompress

func (e *ExtensionFilter) ShouldCompress(req *http.Request) bool

ShouldCompress implements RequestFilter interface

type Handler

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

Handler implement gzip compression for gin and net/http

func DefaultHandler

func DefaultHandler() *Handler

DefaultHandler creates a gzip handler to take care of response compression, with meaningful preset.

func NewHandler

func NewHandler(config Config) *Handler

NewHandler initialized a costumed gzip handler to take care of response compression.

config must not be modified after calling on NewHandler()

func (*Handler) Gin

func (h *Handler) Gin(c *gin.Context)

Gin implement gin's middleware

func (*Handler) WrapHandler

func (h *Handler) WrapHandler(next http.Handler) http.Handler

WrapHandler wraps a http.Handler, returning its gzip-enabled version

type RequestFilter

type RequestFilter interface {
	// ShouldCompress decide whether or not to compress response,
	// judging by request
	ShouldCompress(req *http.Request) bool
}

RequestFilter decide whether or not to compress response judging by request

type ResponseHeaderFilter

type ResponseHeaderFilter interface {
	// ShouldCompress decide whether or not to compress response,
	// judging by response header
	ShouldCompress(header http.Header) bool
}

ResponseHeaderFilter decide whether or not to compress response judging by response header

type SkipCompressedFilter

type SkipCompressedFilter struct{}

SkipCompressedFilter judges whether content has been already compressed

func NewSkipCompressedFilter

func NewSkipCompressedFilter() *SkipCompressedFilter

NewSkipCompressedFilter ...

func (*SkipCompressedFilter) ShouldCompress

func (s *SkipCompressedFilter) ShouldCompress(header http.Header) bool

ShouldCompress implements ResponseHeaderFilter interface

Content-Encoding: https://tools.ietf.org/html/rfc2616#section-3.5

Documentation was rendered with GOOS=linux and GOARCH=amd64.

Jump to identifier

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to identifier