http

Documentation

Index

• Variables
• func EchoNew() *echo.Echo
• type Certificate
• type HTTP
  • func (h *HTTP) Set(ctx context.Context, wg *sync.WaitGroup) error
• type HTTPMiddleware
  • func (h *HTTPMiddleware) Set(ctx context.Context, name string) error
• type Router
  • func (r *Router) Check() error
  • func (r *Router) Set(_ string, ruleRouter *RuleRouter) error
• type RuleRouter
  • func NewRuleRouter() *RuleRouter
  • func (s *RuleRouter) GetEcho(r RuleSelection) *echo.Echo
  • func (s RuleRouter) Serve(entrypoint string) http.Handler
  • func (s *RuleRouter) ServeHTTP(w http.ResponseWriter, r *http.Request)
  • func (s *RuleRouter) SetRule(selection RuleSelection)
• type RuleSelection
• type TLS

Variables

var PostMiddleware = func(next echo.HandlerFunc) echo.HandlerFunc {
	return func(c echo.Context) error {
		c.Response().WriteHeader(http.StatusNoContent)
		_, _ = c.Response().Writer.Write(nil)

		return nil
	}
}

var PreMiddleware = func(next echo.HandlerFunc) echo.HandlerFunc {
	return func(c echo.Context) error {
		c.Response().Header().Set("Server", ServerInfo)
		return next(c)
	}
}

var ServerInfo = "Turna"

Functions

func EchoNew

func EchoNew() *echo.Echo

Types

type Certificate

type Certificate struct {
	CertFile string `cfg:"cert_file"`
	KeyFile  string `cfg:"key_file"`
}

type HTTP

type HTTP struct {
	Routers     map[string]Router         `cfg:"routers"`
	Middlewares map[string]HTTPMiddleware `cfg:"middlewares"`
	TLS         TLS                       `cfg:"tls"`
}

func (*HTTP) Set

func (h *HTTP) Set(ctx context.Context, wg *sync.WaitGroup) error

type HTTPMiddleware

type HTTPMiddleware struct {
	AddPrefixMiddleware   *middlewares.AddPrefix   `cfg:"add_prefix"`
	AuthMiddleware        *middlewares.Auth        `cfg:"auth"`
	HelloMiddleware       *middlewares.Hello       `cfg:"hello"`
	InfoMiddleware        *middlewares.Info        `cfg:"info"`
	SetMiddleware         *middlewares.Set         `cfg:"set"`
	StripPrefixMiddleware *middlewares.StripPrefix `cfg:"strip_prefix"`
	RoleMiddleware        *middlewares.Role        `cfg:"role"`
	ScopeMiddleware       *middlewares.Scope       `cfg:"scope"`
	ServiceMiddleware     *middlewares.Service     `cfg:"service"`
	FolderMiddleware      *middlewares.Folder      `cfg:"folder"`
	BasicAuthMiddleware   *middlewares.BasicAuth   `cfg:"basic_auth"`
	CorsMiddleware        *middlewares.Cors        `cfg:"cors"`
	HeadersMiddleware     *middlewares.Headers     `cfg:"headers"`
	BlockMiddleware       *middlewares.Block       `cfg:"block"`
	RegexPathMiddleware   *middlewares.RegexPath   `cfg:"regex_path"`
	GzipMiddleware        *middlewares.Gzip        `cfg:"gzip"`
	DecompressMiddleware  *middlewares.Decompress  `cfg:"decompress"`
	LogMiddleware         *middlewares.Log         `cfg:"log"`
}

func (*HTTPMiddleware) Set

func (h *HTTPMiddleware) Set(ctx context.Context, name string) error

type Router

type Router struct {
	Host        string    `cfg:"host"`
	Path        string    `cfg:"path"`
	Middlewares []string  `cfg:"middlewares"`
	TLS         *struct{} `cfg:"tls"`
	EntryPoints []string  `cfg:"entrypoints"`
}

func (*Router) Check

func (r *Router) Check() error

func (*Router) Set

func (r *Router) Set(_ string, ruleRouter *RuleRouter) error

type RuleRouter

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

func NewRuleRouter

func NewRuleRouter() *RuleRouter

func (*RuleRouter) GetEcho

func (s *RuleRouter) GetEcho(r RuleSelection) *echo.Echo

func (RuleRouter) Serve

func (s RuleRouter) Serve(entrypoint string) http.Handler

Serve implements the http.Handler interface with changing entrypoint selection.

func (*RuleRouter) ServeHTTP

func (s *RuleRouter) ServeHTTP(w http.ResponseWriter, r *http.Request)

func (*RuleRouter) SetRule

func (s *RuleRouter) SetRule(selection RuleSelection)

type RuleSelection

type RuleSelection struct {
	Host       string
	Entrypoint string
}

type TLS

type TLS struct {
	Store map[string][]Certificate `cfg:"store"`
}