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 ReadHeaderTimeout = 10 * time.Second

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"`
	InjectMiddleware           *middlewares.Inject              `cfg:"inject"`
	HelloMiddleware            *middlewares.Hello               `cfg:"hello"`
	TemplateMiddleware         *middlewares.Template            `cfg:"template"`
	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"`
	PrintMiddleware            *middlewares.Print               `cfg:"print"`
	LoginMiddleware            *login.Login                     `cfg:"login"`
	SessionMiddleware          *session.Session                 `cfg:"session"`
	ViewMiddleware             *view.View                       `cfg:"view"`
	RequestMiddleware          *middlewares.Request             `cfg:"request"`
	RedirectionMiddleware      *middlewares.Redirection         `cfg:"redirection"`
	TryMiddleware              *middlewares.Try                 `cfg:"try"`
	SessionInfoMiddleware      *sessioninfo.Info                `cfg:"session_info"`
	OpenFgaMiddleware          *openfga.OpenFGA                 `cfg:"openfga"`
	OpenFgaCheckMiddleware     *openfgacheck.OpenFGACheck       `cfg:"openfga_check"`
	RoleCheckMiddleware        *rolecheck.RoleCheck             `cfg:"role_check"`
	RoleDataMiddleware         *roledata.RoleData               `cfg:"role_data"`
	TokenPassMiddleware        *middlewares.TokenPass           `cfg:"token_pass"`
	RedirectContinueMiddleware *middlewares.RedirectionContinue `cfg:"redirect_continue"`
	ForwardMiddleware          *middlewares.Forward             `cfg:"forward"`
}

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"`
}