caddy: github.com/mholt/caddy/caddyhttp/rewrite Index | Files

package rewrite

import "github.com/mholt/caddy/caddyhttp/rewrite"

Package rewrite is middleware for rewriting requests internally to a different path.

Index

Package Files

rewrite.go setup.go to.go

type ComplexRule Uses

type ComplexRule struct {
    // Path base. Request to this path and subpaths will be rewritten
    Base string

    // Path to rewrite to
    To  string

    // Extensions to filter by
    Exts []string

    // Request matcher
    httpserver.RequestMatcher

    Regexp *regexp.Regexp
}

ComplexRule is a rewrite rule based on a regular expression

func NewComplexRule Uses

func NewComplexRule(base, pattern, to string, ext []string, matcher httpserver.RequestMatcher) (ComplexRule, error)

NewComplexRule creates a new RegexpRule. It returns an error if regexp pattern (pattern) or extensions (ext) are invalid.

func (ComplexRule) BasePath Uses

func (r ComplexRule) BasePath() string

BasePath satisfies httpserver.Config

func (ComplexRule) Match Uses

func (r ComplexRule) Match(req *http.Request) bool

Match satisfies httpserver.Config.

Though ComplexRule embeds a RequestMatcher, additional checks are needed which requires a custom implementation.

func (ComplexRule) Rewrite Uses

func (r ComplexRule) Rewrite(fs http.FileSystem, req *http.Request) (re Result)

Rewrite rewrites the internal location of the current request.

type Result Uses

type Result int

Result is the result of a rewrite

const (
    // RewriteIgnored is returned when rewrite is not done on request.
    RewriteIgnored Result = iota
    // RewriteDone is returned when rewrite is done on request.
    RewriteDone
)

func To Uses

func To(fs http.FileSystem, r *http.Request, to string, replacer httpserver.Replacer) Result

To attempts rewrite. It attempts to rewrite to first valid path or the last path if none of the paths are valid.

type Rewrite Uses

type Rewrite struct {
    Next    httpserver.Handler
    FileSys http.FileSystem
    Rules   []httpserver.HandlerConfig
}

Rewrite is middleware to rewrite request locations internally before being handled.

func (Rewrite) ServeHTTP Uses

func (rw Rewrite) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error)

ServeHTTP implements the httpserver.Handler interface.

type Rule Uses

type Rule interface {
    httpserver.HandlerConfig
    // Rewrite rewrites the internal location of the current request.
    Rewrite(http.FileSystem, *http.Request) Result
}

Rule describes an internal location rewrite rule.

type SimpleRule Uses

type SimpleRule struct {
    Regexp *regexp.Regexp
    To     string
    Negate bool
}

SimpleRule is a simple rewrite rule.

func NewSimpleRule Uses

func NewSimpleRule(from, to string, negate bool) (*SimpleRule, error)

NewSimpleRule creates a new Simple Rule

func (SimpleRule) BasePath Uses

func (s SimpleRule) BasePath() string

BasePath satisfies httpserver.Config

func (*SimpleRule) Match Uses

func (s *SimpleRule) Match(r *http.Request) bool

Match satisfies httpserver.Config

func (*SimpleRule) Rewrite Uses

func (s *SimpleRule) Rewrite(fs http.FileSystem, r *http.Request) Result

Rewrite rewrites the internal location of the current request.

Package rewrite imports 10 packages (graph) and is imported by 107 packages. Updated 2019-07-03. Refresh now. Tools for package owners.