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

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