gzip

package module
v0.0.3 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 4, 2023 License: Apache-2.0 Imports: 15 Imported by: 31

README

gzip (This is a community driven project)

English | 中文

This is a middleware for hertz to enable gzip support.

Usage

Download and install it:

go get github.com/hertz-contrib/gzip

Import it in your code:

import "github.com/hertz-contrib/gzip"
For server

Canonical example:

package main

import (
	"context"
	"fmt"
	"net/http"
	"time"
	
	"github.com/cloudwego/hertz/pkg/app"
	"github.com/cloudwego/hertz/pkg/app/server"
	"github.com/hertz-contrib/gzip"
	
)

func main() {
	h := server.Default(server.WithHostPorts(":8080"))
	h.Use(gzip.Gzip(gzip.DefaultCompression))
	h.GET("/ping", func(ctx context.Context, c *app.RequestContext) {
		c.String(http.StatusOK, "pong "+fmt.Sprint(time.Now().Unix()))
	})
	h.Spin()
}

Customized Excluded Extensions

package main

import (
	"context"
	"fmt"
	"net/http"
	"time"
	
	"github.com/cloudwego/hertz/pkg/app"
	"github.com/cloudwego/hertz/pkg/app/server"
	"github.com/hertz-contrib/gzip"

)

func main() {
	h := server.Default(server.WithHostPorts(":8080"))
	h.Use(gzip.Gzip(gzip.DefaultCompression, gzip.WithExcludedExtensions([]string{".pdf", ".mp4"})))
	h.GET("/ping", func(ctx context.Context, c *app.RequestContext) {
		c.String(http.StatusOK, "pong "+fmt.Sprint(time.Now().Unix()))
	})
	h.Spin()
}

Customized Excluded Paths

package main

import (
	"context"
	"fmt"
	"net/http"
	"time"
	
	"github.com/cloudwego/hertz/pkg/app"
	"github.com/cloudwego/hertz/pkg/app/server"
	"github.com/hertz-contrib/gzip"

)

func main() {
	h := server.Default(server.WithHostPorts(":8080"))
	h.Use(gzip.Gzip(gzip.DefaultCompression,gzip.WithExcludedPaths([]string{"/api/"})))
	h.GET("/ping", func(ctx context.Context, c *app.RequestContext) {
		c.String(http.StatusOK, "pong "+fmt.Sprint(time.Now().Unix()))
	})
	h.Spin()
}

Customized Excluded Paths

package main

import (
	"context"
	"fmt"
	"net/http"
	"time"
	
	"github.com/cloudwego/hertz/pkg/app"
	"github.com/cloudwego/hertz/pkg/app/server"
	"github.com/hertz-contrib/gzip"

)

func main() {
	h := server.Default(server.WithHostPorts(":8080"))
	h.Use(gzip.Gzip(gzip.DefaultCompression, gzip.WithExcludedPathRegexes([]string{".*"})))
	h.GET("/ping", func(ctx context.Context, c *app.RequestContext) {
		c.String(http.StatusOK, "pong "+fmt.Sprint(time.Now().Unix()))
	})
	h.Spin()
}
For server-Stream compression

The server first compresses the data before streaming it out

Note: Using this middleware will hijack the response writer and may have an impact on other interfaces. Therefore, it is only necessary to use this middleware on interfaces with streaming gzip requirements.

Canonical example:

package main

import (
	"context"
	"fmt"
	"time"
	
	"github.com/cloudwego/hertz/pkg/app"
	"github.com/cloudwego/hertz/pkg/app/server"
	"github.com/hertz-contrib/gzip"
)

func main() {
	h := server.Default(server.WithHostPorts(":8081"))
	// Note: Using this middleware will hijack the response writer and may have an impact on other interfaces.
	// Therefore, it is only necessary to use this middleware on interfaces with streaming gzip requirements.
	h.GET("/ping", gzip.GzipStream(gzip.DefaultCompression), func(ctx context.Context, c *app.RequestContext) {
		for i := 0; i < 10; i++ {
			c.Write([]byte(fmt.Sprintf("chunk %d: %s\n", i, strings.Repeat("hi~", i)))) // nolint: errcheck
			c.Flush()                                                                   // nolint: errcheck
			time.Sleep(time.Second)
		}
	})
	h.Spin()
}
For client

Canonical example:

package main

import (
   "context"

   "github.com/cloudwego/hertz/pkg/app/client"
   "github.com/cloudwego/hertz/pkg/protocol"
   "github.com/hertz-contrib/gzip"
)

func main() {
   client, _ := client.NewClient()
   client.Use(gzip.GzipForClient(gzip.DefaultCompression))
   _, _, _ = client.Post(context.Background(),
      []byte{},
      "http://localhost:8080/ping",
      &protocol.Args{})
}

Customized Excluded Extensions

package main

import (
   "context"

   "github.com/cloudwego/hertz/pkg/app/client"
   "github.com/cloudwego/hertz/pkg/protocol"
   "github.com/hertz-contrib/gzip"
)

func main() {
   client, _ := client.NewClient()
   client.Use(gzip.GzipForClient(gzip.DefaultCompression,gzip.WithExcludedPathsForClient([]string{"/api/"})))
   _, _, _ = client.Post(context.Background(),
      []byte{},
      "http://localhost:8080/ping",
      &protocol.Args{})
}

Customized Excluded Paths

package main

import (
	"context"
	"fmt"

	"github.com/cloudwego/hertz/pkg/app/client"
	"github.com/cloudwego/hertz/pkg/protocol"
	"github.com/hertz-contrib/gzip"
)

func main() {
	client, _ := client.NewClient()
	client.Use(gzip.GzipForClient(gzip.DefaultCompression, gzip.WithExcludedExtensionsForClient([]string{".pdf", ".mp4"})))
	statusCode, body, err := client.Post(context.Background(),
		[]byte{},
		"http://localhost:8080/ping",
		&protocol.Args{})
	fmt.Printf("%d, %s, %s", statusCode, body, err)
}

Customized Excluded Paths

package main

import (
   "context"
   "fmt"

   "github.com/cloudwego/hertz/pkg/app/client"
   "github.com/cloudwego/hertz/pkg/protocol"
   "github.com/hertz-contrib/gzip"
)

func main() {
   client, _ := client.NewClient()
   client.Use(gzip.GzipForClient(gzip.DefaultCompression, gzip.WithExcludedPathRegexesForClient([]string{".*"})))
   statusCode, body, err := client.Post(context.Background(),
      []byte{},
      "http://localhost:8080/ping",
      &protocol.Args{})
   fmt.Printf("%d, %s, %s", statusCode, body, err)
}

License

This project is under Apache License. See the LICENSE file for the full license text.

Documentation

Index

Constants

View Source 
const (
	BestCompression    = gzip.BestCompression
	BestSpeed          = gzip.BestSpeed
	DefaultCompression = gzip.DefaultCompression
	NoCompression      = gzip.NoCompression
)

Variables

View Source 
var (
	DefaultExcludedExtensions = NewExcludedExtensions([]string{
		".png", ".gif", ".jpeg", ".jpg",
	})
	DefaultOptions = &Options{
		ExcludedExtensions: DefaultExcludedExtensions,
	}
	DefaultClientExcludedExtensions = NewExcludedExtensions([]string{
		".png", ".gif", ".jpeg", ".jpg",
	})
	DefaultClientOptions = &ClientOptions{
		ExcludedExtensions: DefaultExcludedExtensions,
	}
)

Functions

func DefaultDecompressHandle 

func DefaultDecompressHandle(ctx context.Context, c *app.RequestContext)

func DefaultDecompressMiddlewareForClient added in v0.0.2 

func DefaultDecompressMiddlewareForClient(next client.Endpoint) client.Endpoint

func Gzip 

func Gzip(level int, options ...Option) app.HandlerFunc

func GzipForClient added in v0.0.2 

func GzipForClient(level int, options ...ClientOption) client.Middleware

func GzipStream added in v0.0.2 

func GzipStream(level int, options ...Option) app.HandlerFunc

Types

type ClientOption added in v0.0.2 

type ClientOption func(*ClientOptions)

func WithDecompressFnForClient added in v0.0.2 

func WithDecompressFnForClient(decompressFnForClient client.Middleware) ClientOption

func WithExcludedExtensionsForClient added in v0.0.2 

func WithExcludedExtensionsForClient(args []string) ClientOption

WithExcludedExtensionsForClient customize excluded extensions

func WithExcludedPathRegexesForClient added in v0.0.2 

func WithExcludedPathRegexesForClient(args []string) ClientOption

WithExcludedPathRegexesForClient customize paths' regexes

func WithExcludedPathsForClient added in v0.0.2 

func WithExcludedPathsForClient(args []string) ClientOption

type ClientOptions added in v0.0.2 

type ClientOptions struct {
	ExcludedExtensions    ExcludedExtensions
	ExcludedPaths         ExcludedPaths
	ExcludedPathRegexes   ExcludedPathRegexes
	DecompressFnForClient client.Middleware
}

type ExcludedExtensions 

type ExcludedExtensions map[string]bool

func NewExcludedExtensions 

func NewExcludedExtensions(extensions []string) ExcludedExtensions

func (ExcludedExtensions) Contains 

func (e ExcludedExtensions) Contains(target string) bool

type ExcludedPathRegexes 

type ExcludedPathRegexes []*regexp.Regexp

func NewExcludedPathRegexes 

func NewExcludedPathRegexes(regexes []string) ExcludedPathRegexes

func (ExcludedPathRegexes) Contains 

func (e ExcludedPathRegexes) Contains(requestURI string) bool

type ExcludedPaths 

type ExcludedPaths []string

func NewExcludedPaths 

func NewExcludedPaths(paths []string) ExcludedPaths

func (ExcludedPaths) Contains 

func (e ExcludedPaths) Contains(requestURI string) bool

type Option 

type Option func(*Options)

func WithDecompressFn 

func WithDecompressFn(decompressFn app.HandlerFunc) Option

func WithExcludedExtensions 

func WithExcludedExtensions(args []string) Option

WithExcludedExtensions customize excluded extensions

func WithExcludedPathRegexes 

func WithExcludedPathRegexes(args []string) Option

WithExcludedPathRegexes customize paths' regexes

func WithExcludedPaths 

func WithExcludedPaths(args []string) Option

func WithExcludedPathsRegexs added in v0.0.2 

func WithExcludedPathsRegexs(args []string) Option

WithExcludedPathsRegexs customize path's regexes NOTE: WithExcludedPathRegexs is exactly same as WithExcludedPathRegexes, this just for aligning with gin

type Options 

type Options struct {
	ExcludedExtensions  ExcludedExtensions
	ExcludedPaths       ExcludedPaths
	ExcludedPathRegexes ExcludedPathRegexes
	DecompressFn        app.HandlerFunc
}

Source Files

View all Source files

Directories

Path Synopsis
example
standard
stream

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.