iris

package module
v12.2.10 Latest Latest
Warning

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

Go to latest
Published: Jan 18, 2024 License: BSD-3-Clause Imports: 46 Imported by: 2,460

README

Iris Web Framework

build status view examples chat donate

Iris is a fast, simple yet fully featured and very efficient web framework for Go.

It provides a beautifully expressive and easy to use foundation for your next website or API.

Learn what others saying about Iris and star this open-source project to support its potentials.

package main

import "github.com/kataras/iris/v12"

func main() {
  app := iris.New()
  app.Use(iris.Compression)

  app.Get("/", func(ctx iris.Context) {
    ctx.HTML("Hello <strong>%s</strong>!", "World")
  })

  app.Listen(":8080")
}

As one Go developer once said, Iris got you covered all-round and standing strong over the years.

Some of the features Iris offers:

  • HTTP/2 (Push, even Embedded data)
  • Middleware (Accesslog, Basicauth, CORS, gRPC, Anti-Bot hCaptcha, JWT, MethodOverride, ModRevision, Monitor, PPROF, Ratelimit, Anti-Bot reCaptcha, Recovery, RequestID, Rewrite)
  • API Versioning
  • Model-View-Controller
  • Websockets
  • gRPC
  • Auto-HTTPS
  • Builtin support for ngrok to put your app on the internet, the fastest way
  • Unique Router with dynamic path as parameter with standard types like :uuid, :string, :int... and the ability to create your own
  • Compression
  • View Engines (HTML, Django, Handlebars, Pug/Jade and more)
  • Create your own File Server and host your own WebDAV server
  • Cache
  • Localization (i18n, sitemap)
  • Sessions
  • Rich Responses (HTML, Text, Markdown, XML, YAML, Binary, JSON, JSONP, Protocol Buffers, MessagePack, Content Negotiation, Streaming, Server-Sent Events and more)
  • Response Compression (gzip, deflate, brotli, snappy, s2)
  • Rich Requests (Bind URL Query, Headers, Form, Text, XML, YAML, Binary, JSON, Validation, Protocol Buffers, MessagePack and more)
  • Dependency Injection (MVC, Handlers, API Routers)
  • Testing Suite
  • And the most important... you get fast answers and support from the 1st day until now - that's six full years!

👑 Supporters

With your help, we can improve Open Source web development for everyone!

getsentry github lensesio thepunterbot tstangenberg cuong48d rubyangxg draFWM gf3 trading-peter AlbinoGeek basilarchia sumjoe simpleittools xiaozhuai Remydeme celsosz linxcoder jnelle TechMaster janwebdev altafino jakoubek alekperos day0ng hengestone thomasfr CetinBasoz International Juanses SometimesMage ansrivas ekobayong lexrus li3p madhu72 se77en vincent-li sascha11110 clichi2002 derReineke Sirisap22 primadi agoncecelia antonio-pedrazzini chrisliang12 zyu hobysmith clacroix njeff3 ixalender mubariz-ahmed Cesar DavidShaw th31nitiate stgrosshh rodrigoghm Didainius DmarshalTU IwateKyle Little-YangYang Major2828 MatejLach amritpal042 andrefiorot boomhut coderperu cshum dtrifonov geordee guanting112 iantuan ichenhe angelaahhu anhxuanpham annieruci antoniejiao artman328 b2cbd baoch254 icibiri jewe11er jfloresremar jingtianfeng kilarusravankumar leandrobraga lfbos lpintes macropas marcmmx mark2b miguel-devs mihado mmckeen75 narven odas0r olaf-lexemo pitexplore pr123 rsousacode sankethpb saz59 shadowfiga siriushaha bastengao skurtz97 srinivasganti syrm tuhao1020 wahyuief xvalen xytis ElNovi IpastorSan KKP4 Lernakow ernestocolombo francisstephan pixelheresy rcapraro beytullahakyuz bjoroen blackHoleNgc1277 bunnycodego carlos-enginner soiestad thanasolykos ukitzmann DanielKirkwood aprinslo1 colinf kyoukhana spazzymoto victorgrey ArishSultan ehayun chrismalek civicwar cnzhangquan danlanxiaohei dfaugusto dkzhang dloprodu donam-givita dph0899 ec0629 edwindna2 ekofedriyanto eli-yip eljefedelrodeodeljefe fenriz07 ffelipelimao frenchmajesty gastropulgite geGao123 globalflea gloudx gnosthi goten002 guanzi008 kukaki oshirokazuhide t6tg 15189573255 AnatolyUA AwsIT BlackHole1 FernandoLangOFC Flammable-Duck Hongjian0619 JoeD Jude-X Kartoffelbot KevinZhouRafael KrishManohar Laotanling Longf99999 Lyansun MihaiPopescu1985 Mohammed8960 NA Neulhan NguyenPhuoc Oka00 PaddyFrenchman RainerGevers Ramblestsad SamuelNeves Scorpio69t Serissa4000 TianJIANG Ubun1 XinYoungCN YukinaMochizuki a112121788 acdias aeonsthorn agent3bood alessandromarotta algoflows hdezoscar93 hieungm hieunmg homerious CSRaghunandan hzxd iuliancarnaru iysaleh jackptoke jackysywk jeff2go jeremiahyan joelywz kamolcu kana99 kattaprasanth keeio GeorgeFourikis keymanye khasanovrs kkdaypenny knavels kohakuhubo korowiov kostasvk lafayetteDan leki75 L-M-Sherlock claudemuller edsongley lemuelroberto liheyuan lingyingtan linuxluigi lipatti maikelcoke marek-kuticka marman-hp mattbowen maxgozou mizzlespot mnievesco mo3lyana motogo mtrense mukunhao mulyawansentosa evan grassshrimp nasoma ngseiyu nikharsaxena nronzel onlysumitg ozfive paulxu21 pesquive petros9282 phil535 pitt134 qiepeipei qiuzhanghua rapita rbondi relaera remopavithran rfunix rhernandez-itemsoft rikoriswandha hazmi-e205 jtgoral ky2s lauweliam risallaw robivictor rubiagatra rxrw saleebm sbenimeli sebyno seun-otosho solohiroshi su1gen sukiejosh svirmi terjelafton thiennguyen93 unixedia vadgun valsorym vguhesan vpiduri vrocadev vuhoanglam walter-wang wixregiga xPoppa yesudeep ymonk yonson2 yusong-offx zhenggangpku SergeShin - BelmonduS Diewald cty4ka martinjanda martinlindhe mdamschen netbaalzovf oliverjosefzimmer talebisinan valkuere lfaynman ArturWierzbicki Supersherm5 aaxx crashCoder derekslenk dochoaj evillgenius75 gog200921 mauricedcastro mwiater sj671 statik supersherm5 thejones letmestudy mblandr midhubalan ndimorle rosales-stephanie shyyawn vcruzato wangbl11 wofka72 yoru74 xsokev oleang michalsz michaelsmanley Curtman SridarDhandapani opusmagna ShahramMebashar b4zz4r bobmcallan fangli galois-tnp geoshan juanxme nguyentamvinhlong pomland-94 tejzpr theantichris tuxaanand raphael-brand willypuzzle malcolm-white-dti HieuLsw carlosmoran092 yangxianglong

📖 Learning Iris

Installation

The only requirement is the Go Programming Language.

Create a new project
$ mkdir myapp
$ cd myapp
$ go mod init myapp
$ go get github.com/kataras/iris/v12@latest # or @v
Install on existing project
$ cd myapp
$ go get github.com/kataras/iris/v12@latest

Run

$ go mod tidy -compat=1.21 # -compat="1.21" for windows.
$ go run .

Iris contains extensive and thorough documentation making it easy to get started with the framework.

For a more detailed technical documentation you can head over to our godocs. And for executable code you can always visit the ./_examples repository's subdirectory.

Do you like to read while traveling?

Book cover

follow author on twitter

follow Iris web framework on twitter

follow Iris web framework on facebook

You can request a PDF and online access of the Iris E-Book (New Edition, future v12.2.0+) today and be participated in the development of Iris.

🙌 Contributing

We'd love to see your contribution to the Iris Web Framework! For more information about contributing to the Iris project please check the CONTRIBUTING.md file.

List of all Contributors

🛡 Security Vulnerabilities

If you discover a security vulnerability within Iris, please send an e-mail to iris-go@outlook.com. All security vulnerabilities will be promptly addressed.

📝 License

This project is licensed under the BSD 3-clause license, just like the Go project itself.

The project name "Iris" was inspired by the Greek mythology.

Documentation

Overview

Package iris implements the highest realistic performance, easy to learn Go web framework. Iris provides a beautifully expressive and easy to use foundation for your next website, API, or distributed app. Low-level handlers compatible with `net/http` and high-level fastest MVC implementation and handlers dependency injection. Easy to learn for new gophers and advanced features for experienced, it goes as far as you dive into it!

Source code and other details for the project are available at GitHub:

https://github.com/kataras/iris

Current Version

12.2.10

Installation

The only requirement is the Go Programming Language, at least version 1.21.

$ go get github.com/kataras/iris/v12@latest

Wiki:

https://www.iris-go.com/#ebookDonateForm

Examples:

https://github.com/kataras/iris/tree/main/_examples

Middleware:

https://github.com/kataras/iris/tree/main/middleware
https://github.com/iris-contrib/middleware

Home Page:

https://iris-go.com

Index

Constants

View Source
const (
	SameSiteDefaultMode = http.SameSiteDefaultMode
	SameSiteLaxMode     = http.SameSiteLaxMode
	SameSiteStrictMode  = http.SameSiteStrictMode
	SameSiteNoneMode    = http.SameSiteNoneMode
)

SameSite attributes.

View Source
const (
	// RouteOverride replaces an existing route with the new one, the default rule.
	RouteOverride = router.RouteOverride
	// RouteSkip keeps the original route and skips the new one.
	RouteSkip = router.RouteSkip
	// RouteError log when a route already exists, shown after the `Build` state,
	// server never starts.
	RouteError = router.RouteError
	// RouteOverlap will overlap the new route to the previous one.
	// If the route stopped and its response can be reset then the new route will be execute.
	RouteOverlap = router.RouteOverlap
)

Constants for input argument at `router.RouteRegisterRule`. See `Party#SetRegisterRule`.

View Source
const (
	ReferrerInvalid  = context.ReferrerInvalid
	ReferrerIndirect = context.ReferrerIndirect
	ReferrerDirect   = context.ReferrerDirect
	ReferrerEmail    = context.ReferrerEmail
	ReferrerSearch   = context.ReferrerSearch
	ReferrerSocial   = context.ReferrerSocial

	ReferrerNotGoogleSearch     = context.ReferrerNotGoogleSearch
	ReferrerGoogleOrganicSearch = context.ReferrerGoogleOrganicSearch
	ReferrerGoogleAdwords       = context.ReferrerGoogleAdwords
)

Contains the enum values of the `Context.GetReferrer()` method, shortcuts of the context subpackage.

View Source
const (
	MethodGet     = http.MethodGet
	MethodPost    = http.MethodPost
	MethodPut     = http.MethodPut
	MethodDelete  = http.MethodDelete
	MethodConnect = http.MethodConnect
	MethodHead    = http.MethodHead
	MethodPatch   = http.MethodPatch
	MethodOptions = http.MethodOptions
	MethodTrace   = http.MethodTrace
	// MethodNone is an iris-specific "virtual" method
	// to store the "offline" routes.
	MethodNone = router.MethodNone
)

HTTP Methods copied from `net/http`.

View Source
const (
	StatusContinue           = http.StatusContinue           // RFC 7231, 6.2.1
	StatusSwitchingProtocols = http.StatusSwitchingProtocols // RFC 7231, 6.2.2
	StatusProcessing         = http.StatusProcessing         // RFC 2518, 10.1
	StatusEarlyHints         = http.StatusEarlyHints         // RFC 8297

	StatusOK                   = http.StatusOK                   // RFC 7231, 6.3.1
	StatusCreated              = http.StatusCreated              // RFC 7231, 6.3.2
	StatusAccepted             = http.StatusAccepted             // RFC 7231, 6.3.3
	StatusNonAuthoritativeInfo = http.StatusNonAuthoritativeInfo // RFC 7231, 6.3.4
	StatusNoContent            = http.StatusNoContent            // RFC 7231, 6.3.5
	StatusResetContent         = http.StatusResetContent         // RFC 7231, 6.3.6
	StatusPartialContent       = http.StatusPartialContent       // RFC 7233, 4.1
	StatusMultiStatus          = http.StatusMultiStatus          // RFC 4918, 11.1
	StatusAlreadyReported      = http.StatusAlreadyReported      // RFC 5842, 7.1
	StatusIMUsed               = http.StatusIMUsed               // RFC 3229, 10.4.1

	StatusMultipleChoices  = http.StatusMultipleChoices  // RFC 7231, 6.4.1
	StatusMovedPermanently = http.StatusMovedPermanently // RFC 7231, 6.4.2
	StatusFound            = http.StatusFound            // RFC 7231, 6.4.3
	StatusSeeOther         = http.StatusSeeOther         // RFC 7231, 6.4.4
	StatusNotModified      = http.StatusNotModified      // RFC 7232, 4.1
	StatusUseProxy         = http.StatusUseProxy         // RFC 7231, 6.4.5

	StatusTemporaryRedirect = http.StatusTemporaryRedirect // RFC 7231, 6.4.7
	StatusPermanentRedirect = http.StatusPermanentRedirect // RFC 7538, 3

	StatusBadRequest                   = http.StatusBadRequest                   // RFC 7231, 6.5.1
	StatusUnauthorized                 = http.StatusUnauthorized                 // RFC 7235, 3.1
	StatusPaymentRequired              = http.StatusPaymentRequired              // RFC 7231, 6.5.2
	StatusForbidden                    = http.StatusForbidden                    // RFC 7231, 6.5.3
	StatusNotFound                     = http.StatusNotFound                     // RFC 7231, 6.5.4
	StatusMethodNotAllowed             = http.StatusMethodNotAllowed             // RFC 7231, 6.5.5
	StatusNotAcceptable                = http.StatusNotAcceptable                // RFC 7231, 6.5.6
	StatusProxyAuthRequired            = http.StatusProxyAuthRequired            // RFC 7235, 3.2
	StatusRequestTimeout               = http.StatusRequestTimeout               // RFC 7231, 6.5.7
	StatusConflict                     = http.StatusConflict                     // RFC 7231, 6.5.8
	StatusGone                         = http.StatusGone                         // RFC 7231, 6.5.9
	StatusLengthRequired               = http.StatusLengthRequired               // RFC 7231, 6.5.10
	StatusPreconditionFailed           = http.StatusPreconditionFailed           // RFC 7232, 4.2
	StatusRequestEntityTooLarge        = http.StatusRequestEntityTooLarge        // RFC 7231, 6.5.11
	StatusRequestURITooLong            = http.StatusRequestURITooLong            // RFC 7231, 6.5.12
	StatusUnsupportedMediaType         = http.StatusUnsupportedMediaType         // RFC 7231, 6.5.13
	StatusRequestedRangeNotSatisfiable = http.StatusRequestedRangeNotSatisfiable // RFC 7233, 4.4
	StatusExpectationFailed            = http.StatusExpectationFailed            // RFC 7231, 6.5.14
	StatusTeapot                       = http.StatusTeapot                       // RFC 7168, 2.3.3
	StatusMisdirectedRequest           = http.StatusMisdirectedRequest           // RFC 7540, 9.1.2
	StatusUnprocessableEntity          = http.StatusUnprocessableEntity          // RFC 4918, 11.2
	StatusLocked                       = http.StatusLocked                       // RFC 4918, 11.3
	StatusFailedDependency             = http.StatusFailedDependency             // RFC 4918, 11.4
	StatusTooEarly                     = http.StatusTooEarly                     // RFC 8470, 5.2.
	StatusUpgradeRequired              = http.StatusUpgradeRequired              // RFC 7231, 6.5.15
	StatusPreconditionRequired         = http.StatusPreconditionRequired         // RFC 6585, 3
	StatusTooManyRequests              = http.StatusTooManyRequests              // RFC 6585, 4
	StatusRequestHeaderFieldsTooLarge  = http.StatusRequestHeaderFieldsTooLarge  // RFC 6585, 5
	StatusUnavailableForLegalReasons   = http.StatusUnavailableForLegalReasons   // RFC 7725, 3
	// Unofficial Client Errors.
	StatusPageExpired                      = context.StatusPageExpired
	StatusBlockedByWindowsParentalControls = context.StatusBlockedByWindowsParentalControls
	StatusInvalidToken                     = context.StatusInvalidToken
	StatusTokenRequired                    = context.StatusTokenRequired
	//
	StatusInternalServerError           = http.StatusInternalServerError           // RFC 7231, 6.6.1
	StatusNotImplemented                = http.StatusNotImplemented                // RFC 7231, 6.6.2
	StatusBadGateway                    = http.StatusBadGateway                    // RFC 7231, 6.6.3
	StatusServiceUnavailable            = http.StatusServiceUnavailable            // RFC 7231, 6.6.4
	StatusGatewayTimeout                = http.StatusGatewayTimeout                // RFC 7231, 6.6.5
	StatusHTTPVersionNotSupported       = http.StatusHTTPVersionNotSupported       // RFC 7231, 6.6.6
	StatusVariantAlsoNegotiates         = http.StatusVariantAlsoNegotiates         // RFC 2295, 8.1
	StatusInsufficientStorage           = http.StatusInsufficientStorage           // RFC 4918, 11.5
	StatusLoopDetected                  = http.StatusLoopDetected                  // RFC 5842, 7.2
	StatusNotExtended                   = http.StatusNotExtended                   // RFC 2774, 7
	StatusNetworkAuthenticationRequired = http.StatusNetworkAuthenticationRequired // RFC 6585, 6
	// Unofficial Server Errors.
	StatusBandwidthLimitExceeded = context.StatusBandwidthLimitExceeded
	StatusInvalidSSLCertificate  = context.StatusInvalidSSLCertificate
	StatusSiteOverloaded         = context.StatusSiteOverloaded
	StatusSiteFrozen             = context.StatusSiteFrozen
	StatusNetworkReadTimeout     = context.StatusNetworkReadTimeout
)

HTTP status codes as registered with IANA. See: http://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml. Raw Copy from the future(tip) net/http std package in order to recude the import path of "net/http" for the users.

View Source
const (
	B = 1 << (10 * iota)
	KB
	MB
	GB
	TB
	PB
	EB
)

Byte unit helpers.

View Source
const NoLayout = view.NoLayout

NoLayout to disable layout for a particular template file A shortcut for the `view#NoLayout`.

View Source
const Version = "12.2.10"

Version is the current version of the Iris Web Framework.

Variables

View Source
var (
	// BuildRevision holds the vcs commit id information of the program's build.
	// To display the Iris' version please use the iris.Version constant instead.
	// Available at go version 1.18+
	BuildRevision = context.BuildRevision
	// BuildTime holds the vcs commit time information of the program's build.
	// Available at go version 1.18+
	BuildTime = context.BuildTime
)
View Source
var (
	// HTML view engine.
	// Shortcut of the view.HTML.
	HTML = view.HTML
	// Blocks view engine.
	// Can be used as a faster alternative of the HTML engine.
	// Shortcut of the view.Blocks.
	Blocks = view.Blocks
	// Django view engine.
	// Shortcut of the view.Django.
	Django = view.Django
	// Handlebars view engine.
	// Shortcut of the view.Handlebars.
	Handlebars = view.Handlebars
	// Pug view engine.
	// Shortcut of the view.Pug.
	Pug = view.Pug
	// Jet view engine.
	// Shortcut of the view.Jet.
	Jet = view.Jet
	// Ace view engine.
	// Shortcut of the view.Ace.
	Ace = view.Ace
)
View Source
var (
	// AllowQuerySemicolons returns a middleware that serves requests by converting any
	// unescaped semicolons(;) in the URL query to ampersands(&).
	//
	// This restores the pre-Go 1.17 behavior of splitting query parameters on both
	// semicolons and ampersands.
	// (See golang.org/issue/25192 and https://github.com/kataras/iris/issues/1875).
	// Note that this behavior doesn't match that of many proxies,
	// and the mismatch can lead to security issues.
	//
	// AllowQuerySemicolons should be invoked before any Context read query or
	// form methods are called.
	//
	// To skip HTTP Server logging for this type of warning:
	// app.Listen/Run(..., iris.WithoutServerError(iris.ErrURLQuerySemicolon)).
	AllowQuerySemicolons = func(ctx Context) {

		r := ctx.Request()
		if s := r.URL.RawQuery; strings.Contains(s, ";") {
			r2 := new(http.Request)
			*r2 = *r
			r2.URL = new(url.URL)
			*r2.URL = *r.URL
			r2.URL.RawQuery = strings.ReplaceAll(s, ";", "&")
			ctx.ResetRequest(r2)
		}

		ctx.Next()
	}

	// MatchImagesAssets is a simple regex expression
	// that can be passed to the DirOptions.Cache.CompressIgnore field
	// in order to skip compression on already-compressed file types
	// such as images and pdf.
	MatchImagesAssets = regexp.MustCompile("((.*).pdf|(.*).jpg|(.*).jpeg|(.*).gif|(.*).tif|(.*).tiff)$")
	// MatchCommonAssets is a simple regex expression which
	// can be used on `DirOptions.PushTargetsRegexp`.
	// It will match and Push
	// all available js, css, font and media files.
	// Ideal for Single Page Applications.
	MatchCommonAssets = regexp.MustCompile("((.*).js|(.*).css|(.*).ico|(.*).png|(.*).ttf|(.*).svg|(.*).webp|(.*).gif)$")
)
View Source
var (
	// RegisterOnInterrupt registers a global function to call when CTRL+C/CMD+C pressed or a unix kill command received.
	//
	// A shortcut for the `host#RegisterOnInterrupt`.
	RegisterOnInterrupt = host.RegisterOnInterrupt

	// LimitRequestBodySize is a middleware which sets a request body size limit
	// for all next handlers in the chain.
	//
	// A shortcut for the `context#LimitRequestBodySize`.
	LimitRequestBodySize = context.LimitRequestBodySize
	// NewConditionalHandler returns a single Handler which can be registered
	// as a middleware.
	// Filter is just a type of Handler which returns a boolean.
	// Handlers here should act like middleware, they should contain `ctx.Next` to proceed
	// to the next handler of the chain. Those "handlers" are registered to the per-request context.
	//
	//
	// It checks the "filter" and if passed then
	// it, correctly, executes the "handlers".
	//
	// If passed, this function makes sure that the Context's information
	// about its per-request handler chain based on the new "handlers" is always updated.
	//
	// If not passed, then simply the Next handler(if any) is executed and "handlers" are ignored.
	// Example can be found at: _examples/routing/conditional-chain.
	//
	// A shortcut for the `context#NewConditionalHandler`.
	NewConditionalHandler = context.NewConditionalHandler
	// FileServer returns a Handler which serves files from a specific system, phyisical, directory
	// or an embedded one.
	// The first parameter is the directory, relative to the executable program.
	// The second optional parameter is any optional settings that the caller can use.
	//
	// See `Party#HandleDir` too.
	// Examples can be found at: https://github.com/kataras/iris/tree/main/_examples/file-server
	// A shortcut for the `router.FileServer`.
	FileServer = router.FileServer
	// DirList is the default `DirOptions.DirList` field.
	// Read more at: `core/router.DirList`.
	DirList = router.DirList
	// DirListRich can be passed to `DirOptions.DirList` field
	// to override the default file listing appearance.
	// Read more at: `core/router.DirListRich`.
	DirListRich = router.DirListRich
	// StripPrefix returns a handler that serves HTTP requests
	// by removing the given prefix from the request URL's Path
	// and invoking the handler h. StripPrefix handles a
	// request for a path that doesn't begin with prefix by
	// replying with an HTTP 404 not found error.
	//
	// Usage:
	// fileserver := iris.FileServer("./static_files", DirOptions {...})
	// h := iris.StripPrefix("/static", fileserver)
	// app.Get("/static/{file:path}", h)
	// app.Head("/static/{file:path}", h)
	StripPrefix = router.StripPrefix
	// FromStd converts native http.Handler, http.HandlerFunc & func(w, r, next) to context.Handler.
	//
	// Supported form types:
	// 		 .FromStd(h http.Handler)
	// 		 .FromStd(func(w http.ResponseWriter, r *http.Request))
	// 		 .FromStd(func(w http.ResponseWriter, r *http.Request, next http.HandlerFunc))
	//
	// A shortcut for the `handlerconv#FromStd`.
	FromStd = handlerconv.FromStd
	// Cache is a middleware providing server-side cache functionalities
	// to the next handlers, can be used as: `app.Get("/", iris.Cache, aboutHandler)`.
	// It should be used after Static methods.
	// See `iris#Cache304` for an alternative, faster way.
	//
	// Examples can be found at: https://github.com/kataras/iris/tree/main/_examples/#caching
	Cache = cache.Handler
	// NoCache is a middleware which overrides the Cache-Control, Pragma and Expires headers
	// in order to disable the cache during the browser's back and forward feature.
	//
	// A good use of this middleware is on HTML routes; to refresh the page even on "back" and "forward" browser's arrow buttons.
	//
	// See `iris#StaticCache` for the opposite behavior.
	//
	// A shortcut of the `cache#NoCache`
	NoCache = cache.NoCache
	// StaticCache middleware for caching static files by sending the "Cache-Control" and "Expires" headers to the client.
	// It accepts a single input parameter, the "cacheDur", a time.Duration that it's used to calculate the expiration.
	//
	// If "cacheDur" <=0 then it returns the `NoCache` middleware instaed to disable the caching between browser's "back" and "forward" actions.
	//
	// Usage: `app.Use(iris.StaticCache(24 * time.Hour))` or `app.Use(iris.StaticCache(-1))`.
	// A middleware, which is a simple Handler can be called inside another handler as well, example:
	// cacheMiddleware := iris.StaticCache(...)
	// func(ctx iris.Context){
	//  cacheMiddleware(ctx)
	//  [...]
	// }
	//
	// A shortcut of the `cache#StaticCache`
	StaticCache = cache.StaticCache
	// Cache304 sends a `StatusNotModified` (304) whenever
	// the "If-Modified-Since" request header (time) is before the
	// time.Now() + expiresEvery (always compared to their UTC values).
	// Use this, which is a shortcut of the, `chache#Cache304` instead of the "github.com/kataras/iris/v12/cache" or iris.Cache
	// for better performance.
	// Clients that are compatible with the http RCF (all browsers are and tools like postman)
	// will handle the caching.
	// The only disadvantage of using that instead of server-side caching
	// is that this method will send a 304 status code instead of 200,
	// So, if you use it side by side with other micro services
	// you have to check for that status code as well for a valid response.
	//
	// Developers are free to extend this method's behavior
	// by watching system directories changes manually and use of the `ctx.WriteWithExpiration`
	// with a "modtime" based on the file modified date,
	// similar to the `HandleDir`(which sends status OK(200) and browser disk caching instead of 304).
	//
	// A shortcut of the `cache#Cache304`.
	Cache304 = cache.Cache304

	// CookieOverride is a CookieOption which overrides the cookie explicitly to the given "cookie".
	//
	// A shortcut for the `context#CookieOverride`.
	CookieOverride = context.CookieOverride
	// CookieDomain is a CookieOption which sets the cookie's Domain field.
	// If empty then the current domain is used.
	//
	// A shortcut for the `context#CookieDomain`.
	CookieDomain = context.CookieDomain
	// CookieAllowReclaim accepts the Context itself.
	// If set it will add the cookie to (on `CookieSet`, `CookieSetKV`, `CookieUpsert`)
	// or remove the cookie from (on `CookieRemove`) the Request object too.
	//
	// A shortcut for the `context#CookieAllowReclaim`.
	CookieAllowReclaim = context.CookieAllowReclaim
	// CookieAllowSubdomains set to the Cookie Options
	// in order to allow subdomains to have access to the cookies.
	// It sets the cookie's Domain field (if was empty) and
	// it also sets the cookie's SameSite to lax mode too.
	//
	// A shortcut for the `context#CookieAllowSubdomains`.
	CookieAllowSubdomains = context.CookieAllowSubdomains
	// CookieSameSite sets a same-site rule for cookies to set.
	// SameSite allows a server to define a cookie attribute making it impossible for
	// the browser to send this cookie along with cross-site requests. The main
	// goal is to mitigate the risk of cross-origin information leakage, and provide
	// some protection against cross-site request forgery attacks.
	//
	// See https://tools.ietf.org/html/draft-ietf-httpbis-cookie-same-site-00 for details.
	//
	// A shortcut for the `context#CookieSameSite`.
	CookieSameSite = context.CookieSameSite
	// CookieSecure sets the cookie's Secure option if the current request's
	// connection is using TLS. See `CookieHTTPOnly` too.
	//
	// A shortcut for the `context#CookieSecure`.
	CookieSecure = context.CookieSecure
	// CookieHTTPOnly is a `CookieOption`.
	// Use it to set the cookie's HttpOnly field to false or true.
	// HttpOnly field defaults to true for `RemoveCookie` and `SetCookieKV`.
	//
	// A shortcut for the `context#CookieHTTPOnly`.
	CookieHTTPOnly = context.CookieHTTPOnly
	// CookiePath is a `CookieOption`.
	// Use it to change the cookie's Path field.
	//
	// A shortcut for the `context#CookiePath`.
	CookiePath = context.CookiePath
	// CookieCleanPath is a `CookieOption`.
	// Use it to clear the cookie's Path field, exactly the same as `CookiePath("")`.
	//
	// A shortcut for the `context#CookieCleanPath`.
	CookieCleanPath = context.CookieCleanPath
	// CookieExpires is a `CookieOption`.
	// Use it to change the cookie's Expires and MaxAge fields by passing the lifetime of the cookie.
	//
	// A shortcut for the `context#CookieExpires`.
	CookieExpires = context.CookieExpires
	// CookieEncoding accepts a value which implements `Encode` and `Decode` methods.
	// It calls its `Encode` on `Context.SetCookie, UpsertCookie, and SetCookieKV` methods.
	// And on `Context.GetCookie` method it calls its `Decode`.
	//
	// A shortcut for the `context#CookieEncoding`.
	CookieEncoding = context.CookieEncoding

	// IsErrEmptyJSON reports whether the given "err" is caused by a
	// Context.ReadJSON call when the request body
	// didn't start with { or it was totally empty.
	IsErrEmptyJSON = context.IsErrEmptyJSON
	// IsErrPath can be used at `context#ReadForm` and `context#ReadQuery`.
	// It reports whether the incoming error is type of `schema.ErrPath`,
	// which can be ignored when server allows unknown post values to be sent by the client.
	//
	// A shortcut for the `context#IsErrPath`.
	IsErrPath = context.IsErrPath
	// IsErrCanceled reports whether the "err" is caused by a cancellation or timeout.
	//
	// A shortcut for the `context#IsErrCanceled`.
	IsErrCanceled = context.IsErrCanceled
	// ErrEmptyForm is the type error which API users can make use of
	// to check if a form was empty on `Context.ReadForm`.
	//
	// A shortcut for the `context#ErrEmptyForm`.
	ErrEmptyForm = context.ErrEmptyForm
	// ErrEmptyFormField reports whether if form value is empty.
	// An alias of `context.ErrEmptyFormField`.
	ErrEmptyFormField = context.ErrEmptyFormField
	// ErrNotFound reports whether a key was not found, useful
	// on post data, versioning feature and others.
	// An alias of `context.ErrNotFound`.
	ErrNotFound = context.ErrNotFound
	// NewProblem returns a new Problem.
	// Head over to the `Problem` type godoc for more.
	//
	// A shortcut for the `context#NewProblem`.
	NewProblem = context.NewProblem
	// XMLMap wraps a map[string]interface{} to compatible xml marshaler,
	// in order to be able to render maps as XML on the `Context.XML` method.
	//
	// Example: `Context.XML(XMLMap("Root", map[string]interface{}{...})`.
	//
	// A shortcut for the `context#XMLMap`.
	XMLMap = context.XMLMap
	// ErrStopExecution if returned from a hero middleware or a request-scope dependency
	// stops the handler's execution, see _examples/dependency-injection/basic/middleware.
	ErrStopExecution = hero.ErrStopExecution
	// ErrHijackNotSupported is returned by the Hijack method to
	// indicate that Hijack feature is not available.
	//
	// A shortcut for the `context#ErrHijackNotSupported`.
	ErrHijackNotSupported = context.ErrHijackNotSupported
	// ErrPushNotSupported is returned by the Push method to
	// indicate that HTTP/2 Push support is not available.
	//
	// A shortcut for the `context#ErrPushNotSupported`.
	ErrPushNotSupported = context.ErrPushNotSupported
	// PrivateError accepts an error and returns a wrapped private one.
	// A shortcut for the `context#PrivateError` function.
	PrivateError = context.PrivateError

	// TrimParamFilePart is a middleware which trims any last part after a dot (.) character
	// of the current route's dynamic path parameters.
	// A shortcut for the `context#TrimParamFilePart` function.
	TrimParamFilePart Handler = context.TrimParamFilePart
)
View Source
var (
	// StatusText returns a text for the HTTP status code. It returns the empty
	// string if the code is unknown.
	//
	// Shortcut for core/router#StatusText.
	StatusText = context.StatusText
	// RegisterMethods adds custom http methods to the "AllMethods" list.
	// Use it on initialization of your program.
	//
	// Shortcut for core/router#RegisterMethods.
	RegisterMethods = router.RegisterMethods

	// WebDAVMethods contains a list of WebDAV HTTP Verbs.
	// Register using RegiterMethods package-level function or
	// through HandleMany party-level method.
	WebDAVMethods = []string{
		MethodGet,
		MethodHead,
		MethodPatch,
		MethodPut,
		MethodPost,
		MethodDelete,
		MethodOptions,
		MethodConnect,
		MethodTrace,
		"MKCOL",
		"COPY",
		"MOVE",
		"LOCK",
		"UNLOCK",
		"PROPFIND",
		"PROPPATCH",
		"LINK",
		"UNLINK",
		"PURGE",
		"VIEW",
	}
)
View Source
var (
	// TLSNoRedirect is a `host.Configurator` which can be passed as last argument
	// to the `TLS` runner function. It disables the automatic
	// registration of redirection from "http://" to "https://" requests.
	// Applies only to the `TLS` runner.
	// See `AutoTLSNoRedirect` to register a custom fallback server for `AutoTLS` runner.
	TLSNoRedirect = func(su *host.Supervisor) { su.NoRedirect() }
	// AutoTLSNoRedirect is a `host.Configurator`.
	// It registers a fallback HTTP/1.1 server for the `AutoTLS` one.
	// The function accepts the letsencrypt wrapper and it
	// should return a valid instance of http.Server which its handler should be the result
	// of the "acmeHandler" wrapper.
	// Usage:
	//	 getServer := func(acme func(http.Handler) http.Handler) *http.Server {
	//	     srv := &http.Server{Handler: acme(yourCustomHandler), ...otherOptions}
	//	     go srv.ListenAndServe()
	//	     return srv
	//   }
	//   app.Run(iris.AutoTLS(":443", "example.com example2.com", "mail@example.com", getServer))
	//
	// Note that if Server.Handler is nil then the server is automatically ran
	// by the framework and the handler set to automatic redirection, it's still
	// a valid option when the caller wants just to customize the server's fields (except Addr).
	// With this host configurator the caller can customize the server
	// that letsencrypt relies to perform the challenge.
	// LetsEncrypt Certification Manager relies on http://example.com/.well-known/acme-challenge/<TOKEN>.
	AutoTLSNoRedirect = func(getFallbackServer func(acmeHandler func(fallback http.Handler) http.Handler) *http.Server) host.Configurator {
		return func(su *host.Supervisor) {
			su.NoRedirect()
			su.Fallback = getFallbackServer
		}
	}
)
View Source
var (
	// ErrServerClosed is logged by the standard net/http server when the server is terminated.
	// Ignore it by passing this error to the `iris.WithoutServerError` configurator
	// on `Application.Run/Listen` method.
	//
	// An alias of the `http#ErrServerClosed`.
	ErrServerClosed = http.ErrServerClosed

	// ErrURLQuerySemicolon is logged by the standard net/http server when
	// the request contains a semicolon (;) wihch, after go1.17 it's not used as a key-value separator character.
	//
	// Ignore it by passing this error to the `iris.WithoutServerError` configurator
	// on `Application.Run/Listen` method.
	//
	// An alias of the `http#ErrServerClosed`.
	ErrURLQuerySemicolon = errors.New("http: URL query contains semicolon, which is no longer a supported separator; parts of the query may be stripped when parsed; see golang.org/issue/25192")
)
View Source
var DefaultTimeoutMessage = `` /* 235-byte string literal not displayed */

DefaultTimeoutMessage is the default timeout message which is rendered on expired handlers when timeout handler is registered (see Timeout configuration field).

View Source
var WithDynamicHandler = func(app *Application) {
	app.config.EnableDynamicHandler = true
}

WithDynamicHandler enables for dynamic routing by setting the `EnableDynamicHandler` to true.

See `Configuration`.

View Source
var WithEasyJSON = func(app *Application) {
	app.config.EnableEasyJSON = true
}

WithEasyJSON enables the fast easy json marshaler on Context.JSON method.

See `Configuration` for more.

View Source
var WithEmptyFormError = func(app *Application) {
	app.config.FireEmptyFormError = true
}

WithEmptyFormError enables the setting `FireEmptyFormError`.

See `Configuration`.

View Source
var WithFireMethodNotAllowed = func(app *Application) {
	app.config.FireMethodNotAllowed = true
}

WithFireMethodNotAllowed enables the FireMethodNotAllowed setting.

See `Configuration`.

View Source
var WithGlobalConfiguration = func(app *Application) {
	app.Configure(WithConfiguration(YAML(globalConfigurationKeyword)))
}

WithGlobalConfiguration will load the global yaml configuration file from the home directory and it will set/override the whole app's configuration to that file's contents. The global configuration file can be modified by user and be used by multiple iris instances.

This is useful when we run multiple iris servers that share the same configuration, even with custom values at its "Other" field.

Usage: `app.Configure(iris.WithGlobalConfiguration)` or `app.Run(iris.Runner, iris.WithGlobalConfiguration)`.

View Source
var WithLowercaseRouting = func(app *Application) {
	app.config.ForceLowercaseRouting = true
}

WithLowercaseRouting enables for lowercase routing by setting the `ForceLowercaseRoutes` to true.

See `Configuration`.

View Source
var WithOptimizations = func(app *Application) {
	app.config.EnableOptimizations = true
}

WithOptimizations can force the application to optimize for the best performance where is possible.

See `Configuration`.

View Source
var WithPathEscape = func(app *Application) {
	app.config.EnablePathEscape = true
}

WithPathEscape sets the EnablePathEscape setting to true.

See `Configuration`.

View Source
var WithPathIntelligence = func(app *Application) {
	app.config.EnablePathIntelligence = true
}

WithPathIntelligence enables the EnablePathIntelligence setting.

See `Configuration`.

View Source
var WithProtoJSON = func(app *Application) {
	app.config.EnableProtoJSON = true
}

WithProtoJSON enables the proto marshaler on Context.JSON method.

See `Configuration` for more.

View Source
var WithResetOnFireErrorCode = func(app *Application) {
	app.config.ResetOnFireErrorCode = true
}

WithResetOnFireErrorCode sets the ResetOnFireErrorCode setting to true.

See `Configuration`.

View Source
var WithTunneling = func(app *Application) {
	conf := TunnelingConfiguration{
		Tunnels: []Tunnel{{}},
	}

	app.config.Tunneling = conf
}

WithTunneling is the `iris.Configurator` for the `iris.Configuration.Tunneling` field. It's used to enable http tunneling for an Iris Application, per registered host

Alternatively use the `iris.WithConfiguration(iris.Configuration{Tunneling: iris.TunnelingConfiguration{ ...}}}`.

View Source
var WithURLParamSeparator = func(sep string) Configurator {
	return func(app *Application) {
		app.config.URLParamSeparator = &sep
	}
}

WithURLParamSeparator sets the URLParamSeparator setting to "sep".

See `Configuration`.

View Source
var WithoutAutoFireStatusCode = func(app *Application) {
	app.config.DisableAutoFireStatusCode = true
}

WithoutAutoFireStatusCode sets the DisableAutoFireStatusCode setting to true.

See `Configuration`.

View Source
var WithoutBanner = WithoutStartupLog

WithoutBanner is a conversion for the `WithoutStartupLog` option.

Turns off the information send, once, to the terminal when the main server is open.

View Source
var WithoutBodyConsumptionOnUnmarshal = func(app *Application) {
	app.config.DisableBodyConsumptionOnUnmarshal = true
}

WithoutBodyConsumptionOnUnmarshal disables BodyConsumptionOnUnmarshal setting.

See `Configuration`.

View Source
var WithoutInterruptHandler = func(app *Application) {
	app.config.DisableInterruptHandler = true
}

WithoutInterruptHandler disables the automatic graceful server shutdown when control/cmd+C pressed.

View Source
var WithoutPathCorrection = func(app *Application) {
	app.config.DisablePathCorrection = true
}

WithoutPathCorrection disables the PathCorrection setting.

See `Configuration`.

View Source
var WithoutPathCorrectionRedirection = func(app *Application) {
	app.config.DisablePathCorrection = false
	app.config.DisablePathCorrectionRedirection = true
}

WithoutPathCorrectionRedirection disables the PathCorrectionRedirection setting.

See `Configuration`.

View Source
var WithoutStartupLog = func(app *Application) {
	app.config.DisableStartupLog = true
}

WithoutStartupLog turns off the information send, once, to the terminal when the main server is open.

Functions

func Compression added in v12.2.0

func Compression(ctx Context)

Compression is a middleware which enables writing and reading using the best offered compression. Usage: app.Use (for matched routes) app.UseRouter (for both matched and 404s or other HTTP errors).

func ConfigureMiddleware added in v12.2.0

func ConfigureMiddleware(handlers ...Handler) router.PartyConfigurator

ConfigureMiddleware is a PartyConfigurator which can be used as a shortcut to add middlewares on Party.PartyConfigure("/path", WithMiddleware(handler), new(example.API)).

func Minify added in v12.2.0

func Minify(ctx Context)

Minify is a middleware which minifies the responses based on the response content type. Note that minification might be slower, caching is advised. Customize the minifier through `Application.Minifier()`. Usage: app.Use(iris.Minify)

func PrefixDir added in v12.2.0

func PrefixDir(prefix string, fs http.FileSystem) http.FileSystem

PrefixDir returns a new FileSystem that opens files by adding the given "prefix" to the directory tree of "fs".

Useful when having templates and static files in the same bindata AssetFile method. This way you can select which one to serve as static files and what for templates. All view engines have a `RootDir` method for that reason too but alternatively, you can wrap the given file system with this `PrefixDir`.

Example: https://github.com/kataras/iris/blob/main/_examples/file-server/single-page-application/embedded-single-page-application/main.go

func PrefixFS added in v12.2.0

func PrefixFS(fileSystem fs.FS, dir string) (fs.FS, error)

PrefixFS same as "PrefixDir" but for `fs.FS` type.

func WithSocketSharding added in v12.2.0

func WithSocketSharding(app *Application)

WithSocketSharding sets the `Configuration.SocketSharding` field to true.

Types

type APIContainer added in v12.2.0

type APIContainer = router.APIContainer

APIContainer is a wrapper of a common `Party` featured by Dependency Injection. See `Party.ConfigureContainer` for more.

A shortcut for the `core/router#APIContainer`.

type Application

type Application struct {
	// routing embedded | exposing APIBuilder's and Router's public API.
	*router.APIBuilder
	*router.Router
	router.HTTPErrorHandler // if Router is Downgraded this is nil.
	ContextPool             *context.Pool

	// I18n contains localization and internationalization support.
	// Use the `Load` or `LoadAssets` to locale language files.
	//
	// See `Context#Tr` method for request-based translations.
	I18n *i18n.I18n

	// Validator is the request body validator, defaults to nil.
	Validator context.Validator

	// OnBuild is a single function which
	// is fired on the first `Build` method call.
	// If reports an error then the execution
	// is stopped and the error is logged.
	// It's nil by default except when `Switch` instead of `New` or `Default`
	// is used to initialize the Application.
	// Users can wrap it to accept more events.
	OnBuild func() error

	// Hosts contains a list of all servers (Host Supervisors) that this app is running on.
	//
	// Hosts may be empty only if application ran(`app.Run`) with `iris.Raw` option runner,
	// otherwise it contains a single host (`app.Hosts[0]`).
	//
	// Additional Host Supervisors can be added to that list by calling the `app.NewHost` manually.
	//
	// Hosts field is available after `Run` or `NewHost`.
	Hosts []*host.Supervisor
	// contains filtered or unexported fields
}

Application is responsible to manage the state of the application. It contains and handles all the necessary parts to create a fast web server.

func Default

func Default() *Application

Default returns a new Application. Default with "debug" Logger Level. Localization enabled on "./locales" directory and HTML templates on "./views" or "./templates" directory. CORS (allow all), Recovery and Request ID middleware already registered.

func New

func New() *Application

New creates and returns a fresh empty iris *Application instance.

func (*Application) Build

func (app *Application) Build() error

Build sets up, once, the framework. It builds the default router with its default macros and the template functions that are very-closed to iris.

If error occurred while building the Application, the returns type of error will be an *errgroup.Group which let the callers to inspect the errors and cause, usage:

import "github.com/kataras/iris/v12/core/errgroup"

errgroup.Walk(app.Build(), func(typ interface{}, err error) {
	app.Logger().Errorf("%s: %s", typ, err)
})

func (*Application) ConfigurationReadOnly

func (app *Application) ConfigurationReadOnly() context.ConfigurationReadOnly

ConfigurationReadOnly returns an object which doesn't allow field writing.

func (*Application) Configure

func (app *Application) Configure(configurators ...Configurator) *Application

Configure can called when modifications to the framework instance needed. It accepts the framework instance and returns an error which if it's not nil it's printed to the logger. See configuration.go for more.

Returns itself in order to be used like `app:= New().Configure(...)`

func (*Application) ConfigureHost

func (app *Application) ConfigureHost(configurators ...host.Configurator) *Application

ConfigureHost accepts one or more `host#Configuration`, these configurators functions can access the host created by `app.Run` or `app.Listen`, they're being executed when application is ready to being served to the public.

It's an alternative way to interact with a host that is automatically created by `app.Run`.

These "configurators" can work side-by-side with the `iris#Addr, iris#Server, iris#TLS, iris#AutoTLS, iris#Listener` final arguments("hostConfigs") too.

Note that these application's host "configurators" will be shared with the rest of the hosts that this app will may create (using `app.NewHost`), meaning that `app.NewHost` will execute these "configurators" everytime that is being called as well.

These "configurators" should be registered before the `app.Run` or `host.Serve/Listen` functions.

func (*Application) GetContextErrorHandler added in v12.2.0

func (app *Application) GetContextErrorHandler() context.ErrorHandler

GetContextErrorHandler returns the handler which handles errors on JSON write failures.

func (*Application) GetContextPool added in v12.2.0

func (app *Application) GetContextPool() *context.Pool

GetContextPool returns the Iris sync.Pool which holds the contexts values. Iris automatically releases the request context, so you don't have to use it. It's only useful to manually release the context on cases that connection is hijacked by a third-party middleware and the http handler return too fast.

func (*Application) I18nReadOnly added in v12.1.0

func (app *Application) I18nReadOnly() context.I18nReadOnly

I18nReadOnly returns the i18n's read-only features. See `I18n` method for more.

func (*Application) IsDebug added in v12.2.0

func (app *Application) IsDebug() bool

IsDebug reports whether the application is running under debug/development mode. It's just a shortcut of Logger().Level >= golog.DebugLevel. The same method existss as Context.IsDebug() too.

func (*Application) Listen added in v12.1.7

func (app *Application) Listen(hostPort string, withOrWithout ...Configurator) error

Listen builds the application and starts the server on the TCP network address "host:port" which handles requests on incoming connections.

Listen always returns a non-nil error except when NonBlocking option is being passed, so the error goes to the Wait method. Ignore specific errors by using an `iris.WithoutServerError(iris.ErrServerClosed)` as a second input argument.

Listen is a shortcut of `app.Run(iris.Addr(hostPort, withOrWithout...))`. See `Run` for details.

func (*Application) Logger

func (app *Application) Logger() *golog.Logger

Logger returns the golog logger instance(pointer) that is being used inside the "app".

Available levels: - "disable" - "fatal" - "error" - "warn" - "info" - "debug" Usage: app.Logger().SetLevel("error") Or set the level through Configurartion's LogLevel or WithLogLevel functional option. Defaults to "info" level.

Callers can use the application's logger which is the same `golog.Default.LastChild()` logger, to print custom logs too. Usage: app.Logger().Error/Errorf("...") app.Logger().Warn/Warnf("...") app.Logger().Info/Infof("...") app.Logger().Debug/Debugf("...")

Setting one or more outputs: app.Logger().SetOutput(io.Writer...) Adding one or more outputs : app.Logger().AddOutput(io.Writer...)

Adding custom levels requires import of the `github.com/kataras/golog` package:

First we create our level to a golog.Level
in order to be used in the Log functions.
var SuccessLevel golog.Level = 6
Register our level, just three fields.
golog.Levels[SuccessLevel] = &golog.LevelMetadata{
	Name:    "success",
	RawText: "[SUCC]",
	// ColorfulText (Green Color[SUCC])
	ColorfulText: "\x1b[32m[SUCC]\x1b[0m",
}

Usage: app.Logger().SetLevel("success") app.Logger().Logf(SuccessLevel, "a custom leveled log message")

func (*Application) Minifier added in v12.2.0

func (app *Application) Minifier() *minify.M

Minifier returns the minifier instance. By default it can minifies: - text/html - text/css - image/svg+xml - application/text(javascript, ecmascript, json, xml). Use that instance to add custom Minifiers before server ran.

func (*Application) NewHost

func (app *Application) NewHost(srv *http.Server) *host.Supervisor

NewHost accepts a standard *http.Server object, completes the necessary missing parts of that "srv" and returns a new, ready-to-use, host (supervisor).

func (*Application) RegisterView

func (app *Application) RegisterView(viewEngine view.Engine)

RegisterView registers a view engine for the application. Children can register their own too. If no Party view Engine is registered then this one will be used to render the templates instead.

func (*Application) Run

func (app *Application) Run(serve Runner, withOrWithout ...Configurator) error

Run builds the framework and starts the desired `Runner` with or without configuration edits.

Run should be called only once per Application instance, it blocks like http.Server.

If more than one server needed to run on the same iris instance then create a new host and run it manually by `go NewHost(*http.Server).Serve/ListenAndServe` etc... or use an already created host: h := NewHost(*http.Server) Run(Raw(h.ListenAndServe), WithCharset("utf-8"), WithRemoteAddrHeader("CF-Connecting-IP"))

The Application can go online with any type of server or iris's host with the help of the following runners: `Listener`, `Server`, `Addr`, `TLS`, `AutoTLS` and `Raw`.

func (*Application) SetContextErrorHandler added in v12.2.0

func (app *Application) SetContextErrorHandler(errHandler context.ErrorHandler) *Application

SetContextErrorHandler can optionally register a handler to handle and fire a customized error body to the client on JSON write failures.

ExampleCode:

 type contextErrorHandler struct{}
 func (e *contextErrorHandler) HandleContextError(ctx iris.Context, err error) {
	 errors.HandleError(ctx, err)
 }
 ...
 app.SetContextErrorHandler(new(contextErrorHandler))

func (*Application) SetName added in v12.2.0

func (app *Application) SetName(appName string) *Application

SetName sets a unique name to this Iris Application. It sets a child prefix for the current Application's Logger. Look `String` method too.

It returns this Application.

func (*Application) Shutdown

func (app *Application) Shutdown(ctx stdContext.Context) error

Shutdown gracefully terminates all the application's server hosts and any tunnels. Returns an error on the first failure, otherwise nil.

func (*Application) String added in v12.2.0

func (app *Application) String() string

String completes the fmt.Stringer interface and it returns the application's name. If name was not set by `SetName` or `IRIS_APP_NAME` environment variable then this will return an empty string.

func (*Application) SubdomainRedirect

func (app *Application) SubdomainRedirect(from, to router.Party) router.Party

SubdomainRedirect registers a router wrapper which redirects(StatusMovedPermanently) a (sub)domain to another subdomain or to the root domain as fast as possible, before the router's try to execute route's handler(s).

It receives two arguments, they are the from and to/target locations, 'from' can be a wildcard subdomain as well (app.WildcardSubdomain()) 'to' is not allowed to be a wildcard for obvious reasons, 'from' can be the root domain(app) when the 'to' is not the root domain and visa-versa.

Usage: www := app.Subdomain("www") <- same as app.Party("www.") app.SubdomainRedirect(app, www) This will redirect all http(s)://mydomain.com/%anypath% to http(s)://www.mydomain.com/%anypath%.

One or more subdomain redirects can be used to the same app instance.

If you need more information about this implementation then you have to navigate through the `core/router#NewSubdomainRedirectWrapper` function instead.

Example: https://github.com/kataras/iris/tree/main/_examples/routing/subdomains/redirect

func (*Application) Validate added in v12.2.0

func (app *Application) Validate(v interface{}) error

Validate validates a value and returns nil if passed or the failure reason if does not.

func (*Application) View

func (app *Application) View(writer io.Writer, filename string, layout string, bindingData interface{}) error

View executes and writes the result of a template file to the writer.

First parameter is the writer to write the parsed template. Second parameter is the relative, to templates directory, template filename, including extension. Third parameter is the layout, can be empty string. Forth parameter is the bindable data to the template, can be nil.

Use context.View to render templates to the client instead. Returns an error on failure, otherwise nil.

func (*Application) WWW

func (app *Application) WWW() router.Party

WWW creates and returns a "www." subdomain. The difference from `app.Subdomain("www")` or `app.Party("www.")` is that the `app.WWW()` method wraps the router so all http(s)://mydomain.com will be redirect to http(s)://www.mydomain.com. Other subdomains can be registered using the app: `sub := app.Subdomain("mysubdomain")`, child subdomains can be registered using the www := app.WWW(); www.Subdomain("wwwchildSubdomain").

func (*Application) Wait added in v12.2.10

func (app *Application) Wait(ctx stdContext.Context) error

Wait blocks the main goroutine until the server application is up and running. Useful only when `Run` is called with `iris.NonBlocking()` option.

type ApplicationBuilder added in v12.2.5

type ApplicationBuilder interface {
	// Handle registers a simple route on specific method and (dynamic) path.
	// It simply calls the Iris Application's Handle method.
	// Use the "API" method instead to keep the app organized.
	Handle(method, path string, handlers ...Handler) ApplicationBuilder
	// API registers a router which is responsible to serve the /api group.
	API(pathPrefix string, c ...router.PartyConfigurator) ApplicationBuilder
	// Build builds the application with the prior configuration and returns the
	// Iris Application instance for further customizations.
	//
	// Use "Build" before "Listen" or "Run" to apply further modifications
	// to the framework before starting the server. Calling "Build" is optional.
	Build() *Application // optional call.
	// Listen calls the Application's Listen method which is a shortcut of Run(iris.Addr("hostPort")).
	// Use "Run" instead if you need to customize the HTTP/2 server itself.
	Listen(hostPort string, configurators ...Configurator) error // Listen OR Run.
	// Run calls the Application's Run method.
	// The 1st argument is a Runner (iris.Listener, iris.Server, iris.Addr, iris.TLS, iris.AutoTLS and iris.Raw).
	// The 2nd argument can be used to add custom configuration right before the server is up and running.
	Run(runner Runner, configurators ...Configurator) error
}

ApplicationBuilder is the final step of the Guide. It is used to register APIs controllers (PartyConfigurators) and its Build, Listen and Run methods configure and build the actual Iris application based on the previous steps.

type Attachments added in v12.2.0

type Attachments = router.Attachments

Attachments options for files to be downloaded and saved locally by the client. See `DirOptions`.

type CompressionGuide added in v12.2.5

type CompressionGuide interface {
	// Compression enables or disables the gzip (or any other client-preferred) compression algorithm
	// for response writes.
	Compression(b bool) HealthGuide
}

CompressionGuide is the 2nd step of the Guide. Compression (gzip or any other client requested) can be enabled or disabled.

type Configuration

type Configuration struct {
	// VHost lets you customize the trusted domain this server should run on.
	// Its value will be used as the return value of Context.Domain() too.
	// It can be retrieved by the context if needed (i.e router for subdomains)
	VHost string `ini:"v_host" json:"vHost" yaml:"VHost" toml:"VHost" env:"V_HOST"`

	// LogLevel is the log level the application should use to output messages.
	// Logger, by default, is mostly used on Build state but it is also possible
	// that debug error messages could be thrown when the app is running, e.g.
	// when malformed data structures try to be sent on Client (i.e Context.JSON/JSONP/XML...).
	//
	// Defaults to "info". Possible values are:
	// * "disable"
	// * "fatal"
	// * "error"
	// * "warn"
	// * "info"
	// * "debug"
	LogLevel string `ini:"log_level" json:"logLevel" yaml:"LogLevel" toml:"LogLevel" env:"LOG_LEVEL"`

	// SocketSharding enables SO_REUSEPORT (or SO_REUSEADDR for windows)
	// on all registered Hosts.
	// This option allows linear scaling server performance on multi-CPU servers.
	//
	// Please read the following:
	// 1. https://stackoverflow.com/a/14388707
	// 2. https://stackoverflow.com/a/59692868
	// 3. https://www.nginx.com/blog/socket-sharding-nginx-release-1-9-1/
	// 4. (BOOK) Learning HTTP/2: A Practical Guide for Beginners:
	//	  Page 37, To Shard or Not to Shard?
	//
	// Defaults to false.
	SocketSharding bool `ini:"socket_sharding" json:"socketSharding" yaml:"SocketSharding" toml:"SocketSharding" env:"SOCKET_SHARDING"`
	// KeepAlive sets the TCP connection's keep-alive duration.
	// If set to greater than zero then a tcp listener featured keep alive
	// will be used instead of the simple tcp one.
	//
	// Defaults to 0.
	KeepAlive time.Duration `ini:"keepalive" json:"keepAlive" yaml:"KeepAlive" toml:"KeepAlive" env:"KEEP_ALIVE"`
	// Timeout wraps the application's router with an http timeout handler
	// if the value is greater than zero.
	//
	// The underline response writer supports the Pusher interface but does not support
	// the Hijacker or Flusher interfaces when Timeout handler is registered.
	//
	// Read more at: https://pkg.go.dev/net/http#TimeoutHandler.
	Timeout time.Duration `ini:"timeout" json:"timeout" yaml:"Timeout" toml:"Timeout"`
	// TimeoutMessage specifies the HTML body when a handler hits its life time based
	// on the Timeout configuration field.
	TimeoutMessage string `ini:"timeout_message" json:"timeoutMessage" yaml:"TimeoutMessage" toml:"TimeoutMessage"`
	// NonBlocking, if set to true then the server will start listening for incoming connections
	// without blocking the main goroutine. Use the Application.Wait method to block and wait for the server to be up and running.
	NonBlocking bool `ini:"non_blocking" json:"nonBlocking" yaml:"NonBlocking" toml:"NonBlocking"`

	// Tunneling can be optionally set to enable ngrok http(s) tunneling for this Iris app instance.
	// See the `WithTunneling` Configurator too.
	Tunneling TunnelingConfiguration `ini:"tunneling" json:"tunneling,omitempty" yaml:"Tunneling" toml:"Tunneling"`
	// IgnoreServerErrors will cause to ignore the matched "errors"
	// from the main application's `Run` function.
	// This is a slice of string, not a slice of error
	// users can register these errors using yaml or toml configuration file
	// like the rest of the configuration fields.
	//
	// See `WithoutServerError(...)` function too.
	//
	// Example: https://github.com/kataras/iris/tree/main/_examples/http-server/listen-addr/omit-server-errors
	//
	// Defaults to an empty slice.
	IgnoreServerErrors []string `ini:"ignore_server_errors" json:"ignoreServerErrors,omitempty" yaml:"IgnoreServerErrors" toml:"IgnoreServerErrors"`

	// DisableStartupLog if set to true then it turns off the write banner on server startup.
	//
	// Defaults to false.
	DisableStartupLog bool `ini:"disable_startup_log" json:"disableStartupLog,omitempty" yaml:"DisableStartupLog" toml:"DisableStartupLog"`
	// DisableInterruptHandler if set to true then it disables the automatic graceful server shutdown
	// when control/cmd+C pressed.
	// Turn this to true if you're planning to handle this by your own via a custom host.Task.
	//
	// Defaults to false.
	DisableInterruptHandler bool `` /* 134-byte string literal not displayed */

	// DisablePathCorrection disables the correcting
	// and redirecting or executing directly the handler of
	// the requested path to the registered path
	// for example, if /home/ path is requested but no handler for this Route found,
	// then the Router checks if /home handler exists, if yes,
	// (permanent)redirects the client to the correct path /home.
	//
	// See `DisablePathCorrectionRedirection` to enable direct handler execution instead of redirection.
	//
	// Defaults to false.
	DisablePathCorrection bool `` /* 126-byte string literal not displayed */
	// DisablePathCorrectionRedirection works whenever configuration.DisablePathCorrection is set to false
	// and if DisablePathCorrectionRedirection set to true then it will fire the handler of the matching route without
	// the trailing slash ("/") instead of send a redirection status.
	//
	// Defaults to false.
	DisablePathCorrectionRedirection bool `` /* 171-byte string literal not displayed */
	// EnablePathIntelligence if set to true,
	// the router will redirect HTTP "GET" not found pages to the most closest one path(if any). For example
	// you register a route at "/contact" path -
	// a client tries to reach it by "/cont", the path will be automatic fixed
	// and the client will be redirected to the "/contact" path
	// instead of getting a 404 not found response back.
	//
	// Defaults to false.
	EnablePathIntelligence bool `` /* 130-byte string literal not displayed */
	// EnablePathEscape when is true then its escapes the path and the named parameters (if any).
	// When do you need to Disable(false) it:
	// accepts parameters with slash '/'
	// Request: http://localhost:8080/details/Project%2FDelta
	// ctx.Param("project") returns the raw named parameter: Project%2FDelta
	// which you can escape it manually with net/url:
	// projectName, _ := url.QueryUnescape(c.Param("project").
	//
	// Defaults to false.
	EnablePathEscape bool `ini:"enable_path_escape" json:"enablePathEscape,omitempty" yaml:"EnablePathEscape" toml:"EnablePathEscape"`
	// ForceLowercaseRouting if enabled, converts all registered routes paths to lowercase
	// and it does lowercase the request path too for matching.
	//
	// Defaults to false.
	ForceLowercaseRouting bool `` /* 126-byte string literal not displayed */
	// EnableOptimizations enables dynamic request handler.
	// It gives the router the feature to add routes while in serve-time,
	// when `RefreshRouter` is called.
	// If this setting is set to true, the request handler will use a mutex for data(trie routing) protection,
	// hence the performance cost.
	//
	// Defaults to false.
	EnableDynamicHandler bool `ini:"enable_dynamic_handler" json:"enableDynamicHandler,omitempty" yaml:"EnableDynamicHandler" toml:"EnableDynamicHandler"`
	// FireMethodNotAllowed if it's true router checks for StatusMethodNotAllowed(405) and
	//  fires the 405 error instead of 404
	// Defaults to false.
	FireMethodNotAllowed bool `ini:"fire_method_not_allowed" json:"fireMethodNotAllowed,omitempty" yaml:"FireMethodNotAllowed" toml:"FireMethodNotAllowed"`
	// DisableAutoFireStatusCode if true then it turns off the http error status code
	// handler automatic execution on error code from a `Context.StatusCode` call.
	// By-default a custom http error handler will be fired when "Context.StatusCode(errorCode)" called.
	//
	// Defaults to false.
	DisableAutoFireStatusCode bool `` /* 144-byte string literal not displayed */
	// ResetOnFireErrorCode if true then any previously response body or headers through
	// response recorder will be ignored and the router
	// will fire the registered (or default) HTTP error handler instead.
	// See `core/router/handler#FireErrorCode` and `Context.EndRequest` for more details.
	//
	// Read more at: https://github.com/kataras/iris/issues/1531
	//
	// Defaults to false.
	ResetOnFireErrorCode bool `ini:"reset_on_fire_error_code" json:"resetOnFireErrorCode,omitempty" yaml:"ResetOnFireErrorCode" toml:"ResetOnFireErrorCode"`

	// URLParamSeparator defines the character(s) separator for Context.URLParamSlice.
	// If empty or null then request url parameters with comma separated values will be retrieved as one.
	//
	// Defaults to comma ",".
	URLParamSeparator *string `ini:"url_param_separator" json:"urlParamSeparator,omitempty" yaml:"URLParamSeparator" toml:"URLParamSeparator"`
	// EnableOptimization when this field is true
	// then the application tries to optimize for the best performance where is possible.
	//
	// Defaults to false.
	// Deprecated. As of version 12.2.x this field does nothing.
	EnableOptimizations bool `ini:"enable_optimizations" json:"enableOptimizations,omitempty" yaml:"EnableOptimizations" toml:"EnableOptimizations"`
	// EnableProtoJSON when this field is true
	// enables the proto marshaler on given proto messages when calling the Context.JSON method.
	//
	// Defaults to false.
	EnableProtoJSON bool `ini:"enable_proto_json" json:"enableProtoJSON,omitempty" yaml:"EnableProtoJSON" toml:"EnableProtoJSON"`
	// EnableEasyJSON when this field is true
	// enables the fast easy json marshaler on compatible struct values when calling the Context.JSON method.
	//
	// Defaults to false.
	EnableEasyJSON bool `ini:"enable_easy_json" json:"enableEasyJSON,omitempty" yaml:"EnableEasyJSON" toml:"EnableEasyJSON"`

	// DisableBodyConsumptionOnUnmarshal manages the reading behavior of the context's body readers/binders.
	// If set to true then it
	// disables the body consumption by the `context.UnmarshalBody/ReadJSON/ReadXML`.
	//
	// By-default io.ReadAll` is used to read the body from the `context.Request.Body which is an `io.ReadCloser`,
	// if this field set to true then a new buffer will be created to read from and the request body.
	// The body will not be changed and existing data before the
	// context.UnmarshalBody/ReadJSON/ReadXML will be not consumed.
	//
	// See `Context.RecordRequestBody` method for the same feature, per-request.
	DisableBodyConsumptionOnUnmarshal bool `` /* 163-byte string literal not displayed */
	// FireEmptyFormError returns if set to tue true then the `context.ReadForm/ReadQuery/ReadBody`
	// will return an `iris.ErrEmptyForm` on empty request form data.
	FireEmptyFormError bool `ini:"fire_empty_form_error" json:"fireEmptyFormError,omitempty" yaml:"FireEmptyFormError" toml:"FireEmptyFormError"`

	// TimeFormat time format for any kind of datetime parsing
	// Defaults to  "Mon, 02 Jan 2006 15:04:05 GMT".
	TimeFormat string `ini:"time_format" json:"timeFormat,omitempty" yaml:"TimeFormat" toml:"TimeFormat"`

	// Charset character encoding for various rendering
	// used for templates and the rest of the responses
	// Defaults to "utf-8".
	Charset string `ini:"charset" json:"charset,omitempty" yaml:"Charset" toml:"Charset"`

	// PostMaxMemory sets the maximum post data size
	// that a client can send to the server, this differs
	// from the overall request body size which can be modified
	// by the `context#SetMaxRequestBodySize` or `iris#LimitRequestBodySize`.
	//
	// Defaults to 32MB or 32 << 20 if you prefer.
	PostMaxMemory int64 `ini:"post_max_memory" json:"postMaxMemory" yaml:"PostMaxMemory" toml:"PostMaxMemory"`

	// Context values' keys for various features.
	//
	// LocaleContextKey is used by i18n to get the current request's locale, which contains a translate function too.
	//
	// Defaults to "iris.locale".
	LocaleContextKey string `ini:"locale_context_key" json:"localeContextKey,omitempty" yaml:"LocaleContextKey" toml:"LocaleContextKey"`
	// LanguageContextKey is the context key which a language can be modified by a middleware.
	// It has the highest priority over the rest and if it is empty then it is ignored,
	// if it set to a static string of "default" or to the default language's code
	// then the rest of the language extractors will not be called at all and
	// the default language will be set instead.
	//
	// Use with `Context.SetLanguage("el-GR")`.
	//
	// See `i18n.ExtractFunc` for a more organised way of the same feature.
	// Defaults to "iris.locale.language".
	LanguageContextKey string `ini:"language_context_key" json:"languageContextKey,omitempty" yaml:"LanguageContextKey" toml:"LanguageContextKey"`
	// LanguageInputContextKey is the context key of a language that is given by the end-user.
	// It's the real user input of the language string, matched or not.
	//
	// Defaults to "iris.locale.language.input".
	LanguageInputContextKey string `` /* 135-byte string literal not displayed */
	// VersionContextKey is the context key which an API Version can be modified
	// via a middleware through `SetVersion` method, e.g. `versioning.SetVersion(ctx, ">=1.0.0 <2.0.0")`.
	// Defaults to "iris.api.version".
	VersionContextKey string `ini:"version_context_key" json:"versionContextKey" yaml:"VersionContextKey" toml:"VersionContextKey"`
	// VersionAliasesContextKey is the context key which the versioning feature
	// can look up for alternative values of a version and fallback to that.
	// Head over to the versioning package for more.
	// Defaults to "iris.api.version.aliases"
	VersionAliasesContextKey string `` /* 129-byte string literal not displayed */
	// ViewEngineContextKey is the context's values key
	// responsible to store and retrieve(view.Engine) the current view engine.
	// A middleware or a Party can modify its associated value to change
	// a view engine that `ctx.View` will render through.
	// If not an engine is registered by the end-developer
	// then its associated value is always nil,
	// meaning that the default value is nil.
	// See `Party.RegisterView` and `Context.ViewEngine` methods as well.
	//
	// Defaults to "iris.view.engine".
	ViewEngineContextKey string `ini:"view_engine_context_key" json:"viewEngineContextKey,omitempty" yaml:"ViewEngineContextKey" toml:"ViewEngineContextKey"`
	// ViewLayoutContextKey is the context's values key
	// responsible to store and retrieve(string) the current view layout.
	// A middleware can modify its associated value to change
	// the layout that `ctx.View` will use to render a template.
	//
	// Defaults to "iris.view.layout".
	ViewLayoutContextKey string `ini:"view_layout_context_key" json:"viewLayoutContextKey,omitempty" yaml:"ViewLayoutContextKey" toml:"ViewLayoutContextKey"`
	// ViewDataContextKey is the context's values key
	// responsible to store and retrieve(interface{}) the current view binding data.
	// A middleware can modify its associated value to change
	// the template's data on-fly.
	//
	// Defaults to "iris.view.data".
	ViewDataContextKey string `ini:"view_data_context_key" json:"viewDataContextKey,omitempty" yaml:"ViewDataContextKey" toml:"ViewDataContextKey"`
	// FallbackViewContextKey is the context's values key
	// responsible to store the view fallback information.
	//
	// Defaults to "iris.view.fallback".
	FallbackViewContextKey string `` /* 131-byte string literal not displayed */
	// RemoteAddrHeaders are the allowed request headers names
	// that can be valid to parse the client's IP based on.
	// By-default no "X-" header is consired safe to be used for retrieving the
	// client's IP address, because those headers can manually change by
	// the client. But sometimes are useful e.g. when behind a proxy
	// you want to enable the "X-Forwarded-For" or when cloudflare
	// you want to enable the "CF-Connecting-IP", indeed you
	// can allow the `ctx.RemoteAddr()` to use any header
	// that the client may sent.
	//
	// Defaults to an empty slice but an example usage is:
	// RemoteAddrHeaders {
	//    "X-Real-Ip",
	//    "X-Forwarded-For",
	//    "CF-Connecting-IP",
	//    "True-Client-Ip",
	//    "X-Appengine-Remote-Addr",
	//	}
	//
	// Look `context.RemoteAddr()` for more.
	RemoteAddrHeaders []string `ini:"remote_addr_headers" json:"remoteAddrHeaders,omitempty" yaml:"RemoteAddrHeaders" toml:"RemoteAddrHeaders"`
	// RemoteAddrHeadersForce forces the `Context.RemoteAddr()` method
	// to return the first entry of a request header as a fallback,
	// even if that IP is a part of the `RemoteAddrPrivateSubnets` list.
	// The default behavior, if a remote address is part of the `RemoteAddrPrivateSubnets`,
	// is to retrieve the IP from the `Request.RemoteAddr` field instead.
	RemoteAddrHeadersForce bool `` /* 131-byte string literal not displayed */
	// RemoteAddrPrivateSubnets defines the private sub-networks.
	// They are used to be compared against
	// IP Addresses fetched through `RemoteAddrHeaders` or `Context.Request.RemoteAddr`.
	// For details please navigate through: https://github.com/kataras/iris/issues/1453
	// Defaults to:
	// {
	// 	Start: "10.0.0.0",
	// 	End:   "10.255.255.255",
	// },
	// {
	// 	Start: "100.64.0.0",
	// 	End:   "100.127.255.255",
	// },
	// {
	// 	Start: "172.16.0.0",
	// 	End:   "172.31.255.255",
	// },
	// {
	// 	Start: "192.0.0.0",
	// 	End:   "192.0.0.255",
	// },
	// {
	// 	Start: "192.168.0.0",
	// 	End:   "192.168.255.255",
	// },
	// {
	// 	Start: "198.18.0.0",
	// 	End:   "198.19.255.255",
	// }
	//
	// Look `Context.RemoteAddr()` for more.
	RemoteAddrPrivateSubnets []netutil.IPRange `` /* 129-byte string literal not displayed */
	// SSLProxyHeaders defines the set of header key values
	// that would indicate a valid https Request (look `Context.IsSSL()`).
	// Example: `map[string]string{"X-Forwarded-Proto": "https"}`.
	//
	// Defaults to empty map.
	SSLProxyHeaders map[string]string `ini:"ssl_proxy_headers" json:"sslProxyHeaders" yaml:"SSLProxyHeaders" toml:"SSLProxyHeaders"`
	// HostProxyHeaders defines the set of headers that may hold a proxied hostname value for the clients.
	// Look `Context.Host()` for more.
	// Defaults to empty map.
	HostProxyHeaders map[string]bool `ini:"host_proxy_headers" json:"hostProxyHeaders" yaml:"HostProxyHeaders" toml:"HostProxyHeaders"`
	// Other are the custom, dynamic options, can be empty.
	// This field used only by you to set any app's options you want.
	//
	// Defaults to empty map.
	Other map[string]interface{} `ini:"other" json:"other,omitempty" yaml:"Other" toml:"Other"`
}

Configuration holds the necessary settings for an Iris Application instance. All fields are optionally, the default values will work for a common web application.

A Configuration value can be passed through `WithConfiguration` Configurator. Usage: conf := iris.Configuration{ ... } app := iris.New() app.Configure(iris.WithConfiguration(conf)) OR app.Run/Listen(..., iris.WithConfiguration(conf)).

func DefaultConfiguration

func DefaultConfiguration() Configuration

DefaultConfiguration returns the default configuration for an iris station, fills the main Configuration

func TOML

func TOML(filename string) Configuration

TOML reads Configuration from a toml-compatible document file. Read more about toml's implementation at: https://github.com/toml-lang/toml

Accepts the absolute path of the configuration file. An error will be shown to the user via panic with the error message. Error may occur when the file does not exist or is not formatted correctly.

Note: if the char '~' passed as "filename" then it tries to load and return the configuration from the $home_directory + iris.tml, see `WithGlobalConfiguration` for more information.

Usage: app.Configure(iris.WithConfiguration(iris.TOML("myconfig.tml"))) or app.Run(iris.Runner, iris.WithConfiguration(iris.TOML("myconfig.tml"))).

func YAML

func YAML(filename string) Configuration

YAML reads Configuration from a configuration.yml file.

Accepts the absolute path of the cfg.yml. An error will be shown to the user via panic with the error message. Error may occur when the cfg.yml does not exist or is not formatted correctly.

Note: if the char '~' passed as "filename" then it tries to load and return the configuration from the $home_directory + iris.yml, see `WithGlobalConfiguration` for more information.

Usage: app.Configure(iris.WithConfiguration(iris.YAML("myconfig.yml"))) or app.Run(iris.Runner, iris.WithConfiguration(iris.YAML("myconfig.yml"))).

func (*Configuration) GetCharset

func (c *Configuration) GetCharset() string

GetCharset returns the Charset field.

func (*Configuration) GetDisableAutoFireStatusCode

func (c *Configuration) GetDisableAutoFireStatusCode() bool

GetDisableAutoFireStatusCode returns the DisableAutoFireStatusCode field.

func (*Configuration) GetDisableBodyConsumptionOnUnmarshal

func (c *Configuration) GetDisableBodyConsumptionOnUnmarshal() bool

GetDisableBodyConsumptionOnUnmarshal returns the DisableBodyConsumptionOnUnmarshal field.

func (*Configuration) GetDisablePathCorrection

func (c *Configuration) GetDisablePathCorrection() bool

GetDisablePathCorrection returns the DisablePathCorrection field.

func (*Configuration) GetDisablePathCorrectionRedirection

func (c *Configuration) GetDisablePathCorrectionRedirection() bool

GetDisablePathCorrectionRedirection returns the DisablePathCorrectionRedirection field.

func (*Configuration) GetEnableDynamicHandler added in v12.2.4

func (c *Configuration) GetEnableDynamicHandler() bool

GetEnableDynamicHandler returns the EnableDynamicHandler field.

func (*Configuration) GetEnableEasyJSON added in v12.2.0

func (c *Configuration) GetEnableEasyJSON() bool

GetEnableEasyJSON returns the EnableEasyJSON field.

func (*Configuration) GetEnableOptimizations

func (c *Configuration) GetEnableOptimizations() bool

GetEnableOptimizations returns the EnableOptimizations.

func (*Configuration) GetEnablePathEscape

func (c *Configuration) GetEnablePathEscape() bool

GetEnablePathEscape returns the EnablePathEscape field.

func (*Configuration) GetEnablePathIntelligence added in v12.2.0

func (c *Configuration) GetEnablePathIntelligence() bool

GetEnablePathIntelligence returns the EnablePathIntelligence field.

func (*Configuration) GetEnableProtoJSON added in v12.2.0

func (c *Configuration) GetEnableProtoJSON() bool

GetEnableProtoJSON returns the EnableProtoJSON field.

func (*Configuration) GetFallbackViewContextKey added in v12.2.0

func (c *Configuration) GetFallbackViewContextKey() string

GetFallbackViewContextKey returns the FallbackViewContextKey field.

func (*Configuration) GetFireEmptyFormError added in v12.2.0

func (c *Configuration) GetFireEmptyFormError() bool

GetFireEmptyFormError returns the DisableBodyConsumptionOnUnmarshal field.

func (*Configuration) GetFireMethodNotAllowed

func (c *Configuration) GetFireMethodNotAllowed() bool

GetFireMethodNotAllowed returns the FireMethodNotAllowed field.

func (*Configuration) GetForceLowercaseRouting added in v12.2.0

func (c *Configuration) GetForceLowercaseRouting() bool

GetForceLowercaseRouting returns the ForceLowercaseRouting field.

func (*Configuration) GetHostProxyHeaders added in v12.2.0

func (c *Configuration) GetHostProxyHeaders() map[string]bool

GetHostProxyHeaders returns the HostProxyHeaders field.

func (*Configuration) GetKeepAlive added in v12.2.0

func (c *Configuration) GetKeepAlive() time.Duration

GetKeepAlive returns the KeepAlive field.

func (*Configuration) GetLanguageContextKey added in v12.2.0

func (c *Configuration) GetLanguageContextKey() string

GetLanguageContextKey returns the LanguageContextKey field.

func (*Configuration) GetLanguageInputContextKey added in v12.2.0

func (c *Configuration) GetLanguageInputContextKey() string

GetLanguageInputContextKey returns the LanguageInputContextKey field.

func (*Configuration) GetLocaleContextKey added in v12.1.0

func (c *Configuration) GetLocaleContextKey() string

GetLocaleContextKey returns the LocaleContextKey field.

func (*Configuration) GetLogLevel added in v12.2.0

func (c *Configuration) GetLogLevel() string

GetLogLevel returns the LogLevel field.

func (*Configuration) GetNonBlocking added in v12.2.10

func (c *Configuration) GetNonBlocking() bool

GetNonBlocking returns the NonBlocking field.

func (*Configuration) GetOther

func (c *Configuration) GetOther() map[string]interface{}

GetOther returns the Other field.

func (*Configuration) GetPostMaxMemory

func (c *Configuration) GetPostMaxMemory() int64

GetPostMaxMemory returns the PostMaxMemory field.

func (*Configuration) GetRemoteAddrHeaders

func (c *Configuration) GetRemoteAddrHeaders() []string

GetRemoteAddrHeaders returns the RemoteAddrHeaders field.

func (*Configuration) GetRemoteAddrHeadersForce added in v12.2.0

func (c *Configuration) GetRemoteAddrHeadersForce() bool

GetRemoteAddrHeadersForce returns RemoteAddrHeadersForce field.

func (*Configuration) GetRemoteAddrPrivateSubnets added in v12.2.0

func (c *Configuration) GetRemoteAddrPrivateSubnets() []netutil.IPRange

GetRemoteAddrPrivateSubnets returns the RemoteAddrPrivateSubnets field.

func (*Configuration) GetResetOnFireErrorCode added in v12.2.0

func (c *Configuration) GetResetOnFireErrorCode() bool

GetResetOnFireErrorCode returns ResetOnFireErrorCode field.

func (*Configuration) GetSSLProxyHeaders added in v12.2.0

func (c *Configuration) GetSSLProxyHeaders() map[string]string

GetSSLProxyHeaders returns the SSLProxyHeaders field.

func (*Configuration) GetSocketSharding added in v12.2.0

func (c *Configuration) GetSocketSharding() bool

GetSocketSharding returns the SocketSharding field.

func (*Configuration) GetTimeFormat

func (c *Configuration) GetTimeFormat() string

GetTimeFormat returns the TimeFormat field.

func (*Configuration) GetTimeout added in v12.2.0

func (c *Configuration) GetTimeout() time.Duration

GetTimeout returns the Timeout field.

func (*Configuration) GetTimeoutMessage added in v12.2.0

func (c *Configuration) GetTimeoutMessage() string

GetTimeoutMessage returns the TimeoutMessage field.

func (*Configuration) GetURLParamSeparator added in v12.2.0

func (c *Configuration) GetURLParamSeparator() *string

GetURLParamSeparator returns URLParamSeparator field.

func (*Configuration) GetVHost

func (c *Configuration) GetVHost() string

GetVHost returns the VHost config field.

func (*Configuration) GetVersionAliasesContextKey added in v12.2.0

func (c *Configuration) GetVersionAliasesContextKey() string

GetVersionAliasesContextKey returns the VersionAliasesContextKey field.

func (*Configuration) GetVersionContextKey added in v12.2.0

func (c *Configuration) GetVersionContextKey() string

GetVersionContextKey returns the VersionContextKey field.

func (*Configuration) GetViewDataContextKey

func (c *Configuration) GetViewDataContextKey() string

GetViewDataContextKey returns the ViewDataContextKey field.

func (*Configuration) GetViewEngineContextKey added in v12.2.0

func (c *Configuration) GetViewEngineContextKey() string

GetViewEngineContextKey returns the ViewEngineContextKey field.

func (*Configuration) GetViewLayoutContextKey

func (c *Configuration) GetViewLayoutContextKey() string

GetViewLayoutContextKey returns the ViewLayoutContextKey field.

func (*Configuration) SetVHost added in v12.2.10

func (c *Configuration) SetVHost(s string)

SetVHost sets the VHost config field.

type Configurator

type Configurator func(*Application)

Configurator is just an interface which accepts the framework instance.

It can be used to register a custom configuration with `Configure` in order to modify the framework instance.

Currently Configurator is being used to describe the configuration's fields values.

func NonBlocking added in v12.2.10

func NonBlocking() Configurator

NonBlocking sets the `Configuration.NonBlocking` field to true.

func WithCharset

func WithCharset(charset string) Configurator

WithCharset sets the Charset setting.

See `Configuration`.

func WithConfiguration

func WithConfiguration(c Configuration) Configurator

WithConfiguration sets the "c" values to the framework's configurations.

Usage: app.Listen(":8080", iris.WithConfiguration(iris.Configuration{/* fields here */ })) or iris.WithConfiguration(iris.YAML("./cfg/iris.yml")) or iris.WithConfiguration(iris.TOML("./cfg/iris.tml"))

func WithHostProxyHeader added in v12.2.0

func WithHostProxyHeader(headers ...string) Configurator

WithHostProxyHeader sets a HostProxyHeaders key value pair. Example: WithHostProxyHeader("X-Host"). See `Context.Host` for more.

func WithKeepAlive added in v12.2.0

func WithKeepAlive(keepAliveDur time.Duration) Configurator

WithKeepAlive sets the `Configuration.KeepAlive` field to the given duration.

func WithLogLevel added in v12.2.0

func WithLogLevel(level string) Configurator

WithLogLevel sets the `Configuration.LogLevel` field.

func WithOtherValue

func WithOtherValue(key string, val interface{}) Configurator

WithOtherValue adds a value based on a key to the Other setting.

See `Configuration.Other`.

func WithPostMaxMemory

func WithPostMaxMemory(limit int64) Configurator

WithPostMaxMemory sets the maximum post data size that a client can send to the server, this differs from the overall request body size which can be modified by the `context#SetMaxRequestBodySize` or `iris#LimitRequestBodySize`.

Defaults to 32MB or 32 << 20 or 32*iris.MB if you prefer.

func WithRemoteAddrHeader

func WithRemoteAddrHeader(header ...string) Configurator

WithRemoteAddrHeader adds a new request header name that can be used to validate the client's real IP.

func WithRemoteAddrPrivateSubnet added in v12.2.0

func WithRemoteAddrPrivateSubnet(startIP, endIP string) Configurator

WithRemoteAddrPrivateSubnet adds a new private sub-net to be excluded from `context.RemoteAddr`. See `WithRemoteAddrHeader` too.

func WithSSLProxyHeader added in v12.2.0

func WithSSLProxyHeader(headerKey, headerValue string) Configurator

WithSSLProxyHeader sets a SSLProxyHeaders key value pair. Example: WithSSLProxyHeader("X-Forwarded-Proto", "https"). See `Context.IsSSL` for more.

func WithSitemap added in v12.1.0

func WithSitemap(startURL string) Configurator

WithSitemap enables the sitemap generator. Use the Route's `SetLastMod`, `SetChangeFreq` and `SetPriority` to modify the sitemap's URL child element properties. Excluded routes: - dynamic - subdomain - offline - ExcludeSitemap method called

It accepts a "startURL" input argument which is the prefix for the registered routes that will be included in the sitemap.

If more than 50,000 static routes are registered then sitemaps will be splitted and a sitemap index will be served in /sitemap.xml.

If `Application.I18n.Load/LoadAssets` is called then the sitemap will contain translated links for each static route.

If the result does not complete your needs you can take control and use the github.com/kataras/sitemap package to generate a customized one instead.

Example: https://github.com/kataras/iris/tree/main/_examples/sitemap.

func WithTimeFormat

func WithTimeFormat(timeformat string) Configurator

WithTimeFormat sets the TimeFormat setting.

See `Configuration`.

func WithTimeout added in v12.2.0

func WithTimeout(timeoutDur time.Duration, htmlBody ...string) Configurator

WithTimeout sets the `Configuration.Timeout` field to the given duration.

func WithoutRemoteAddrHeader

func WithoutRemoteAddrHeader(headerName string) Configurator

WithoutRemoteAddrHeader removes an existing request header name that can be used to validate and parse the client's real IP.

Look `context.RemoteAddr()` for more.

func WithoutServerError

func WithoutServerError(errors ...error) Configurator

WithoutServerError will cause to ignore the matched "errors" from the main application's `Run/Listen` function.

Usage: err := app.Listen(":8080", iris.WithoutServerError(iris.ErrServerClosed)) will return `nil` if the server's error was `http/iris#ErrServerClosed`.

See `Configuration#IgnoreServerErrors []string` too.

Example: https://github.com/kataras/iris/tree/main/_examples/http-server/listen-addr/omit-server-errors

type Context

type Context = *context.Context

Context is the middle-man server's "object" for the clients.

A New context is being acquired from a sync.Pool on each connection. The Context is the most important thing on the iris's http flow.

Developers send responses to the client's request through a Context. Developers get request information from the client's request by a Context.

type ContextPatches added in v12.2.0

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

ContextPatches contains the available global Iris context modifications.

func (*ContextPatches) GetDomain added in v12.2.0

func (cp *ContextPatches) GetDomain(patchFunc func(hostport string) string)

GetDomain modifies the way a domain is fetched from `Context#Domain` method, which is used on subdomain redirect feature, i18n's language cookie for subdomain sharing and the rewrite middleware.

func (*ContextPatches) ResolveFS added in v12.2.0

func (cp *ContextPatches) ResolveFS(patchFunc func(fsOrDir interface{}) fs.FS)

ResolveHTTPFS modifies the default way to resolve a filesystem by any type of value. It affects the view engine's filesystem resolver.

func (*ContextPatches) ResolveHTTPFS added in v12.2.0

func (cp *ContextPatches) ResolveHTTPFS(patchFunc func(fsOrDir interface{}) http.FileSystem)

ResolveHTTPFS modifies the default way to resolve a filesystem by any type of value. It affects the Application's API Builder's `HandleDir` method.

func (*ContextPatches) SetCookieKVExpiration added in v12.2.0

func (cp *ContextPatches) SetCookieKVExpiration(patch time.Duration)

SetCookieKVExpiration modifies the default cookie expiration time on `Context#SetCookieKV` method.

func (*ContextPatches) Writers added in v12.2.0

func (cp *ContextPatches) Writers() *ContextWriterPatches

Writers returns the available global Iris context modifications for REST writers.

type ContextPool added in v12.2.8

type ContextPool[T any] interface {
	// Acquire must return a new T from a pool.
	Acquire(ctx Context) T
	// Release must put the T back to the pool.
	Release(T)
}

ContextPool is a pool of T. It's used to acquire and release custom context. Use of custom implementation or `NewContextPool`.

See `NewContextWrapper` and `NewContextPool` for more.

func NewContextPool added in v12.2.8

func NewContextPool[T any, contextPtr ContextSetterPtr[T]]() ContextPool[contextPtr]

NewContextPool returns a new ContextPool default implementation which uses sync.Pool to implement its Acquire and Release methods. The contextPtr is acquired from the sync pool and released back to the sync pool after the handler's execution. The contextPtr is passed to the handler as an argument. ThecontextPtr is not shared between requests. The contextPtr must implement the `ContextSetter` interface. The T must be a struct. The contextPtr must be a pointer of T.

Example: w := iris.NewContextWrapper(iris.NewContextPool[myCustomContext, *myCustomContext]())

type ContextSetter added in v12.2.8

type ContextSetter interface {
	// SetContext sets the iris.Context to the struct.
	SetContext(Context)
}

ContextSetter is an interface which can be implemented by a struct to set the iris.Context to the struct. The receiver must be a pointer of the struct.

type ContextSetterPtr added in v12.2.8

type ContextSetterPtr[T any] interface {
	*T
	ContextSetter
}

ContextSetterPtr is a pointer of T which implements the `ContextSetter` interface. The T must be a struct.

type ContextWrapper added in v12.2.8

type ContextWrapper[T any] struct {
	// contains filtered or unexported fields
}

ContextWrapper is a wrapper for handlers which expect a T instead of iris.Context.

See the `NewContextWrapper` function for more.

func NewContextWrapper added in v12.2.8

func NewContextWrapper[T any](pool ContextPool[T]) *ContextWrapper[T]

NewContextWrapper returns a new ContextWrapper. If pool is nil, a default pool is used. The default pool's AcquireFunc returns a zero value of T. The default pool's ReleaseFunc does nothing. The default pool is used when the pool is nil. Use the `iris.NewContextPool[T, *T]()` to pass a simple context pool. Then, use the `Handler` method to wrap custom handlers to iris ones.

Example: https://github.com/kataras/iris/tree/main/_examples/routing/custom-context

func (*ContextWrapper[T]) FallbackViewFunc added in v12.2.8

func (w *ContextWrapper[T]) FallbackViewFunc(handler func(ctx T, err ErrViewNotExist) error) FallbackViewFunc

FallbackViewFunc same as `Handler` but it converts a handler to FallbackViewFunc.

func (*ContextWrapper[T]) Filter added in v12.2.8

func (w *ContextWrapper[T]) Filter(handler func(T) bool) Filter

Filter same as `Handler` but it converts a handler to Filter.

func (*ContextWrapper[T]) Handler added in v12.2.8

func (w *ContextWrapper[T]) Handler(handler func(T)) Handler

Handler wraps the handler with the pool's Acquire and Release methods. It returns a new handler which expects a T instead of iris.Context. The T is the type of the pool. The T is acquired from the pool and released back to the pool after the handler's execution. The T is passed to the handler as an argument. The T is not shared between requests.

func (*ContextWrapper[T]) HandlerReturnDuration added in v12.2.8

func (w *ContextWrapper[T]) HandlerReturnDuration(handler func(T) time.Duration) func(Context) time.Duration

HandlerReturnDuration same as `Handler` but it converts a handler which returns a time.Duration.

func (*ContextWrapper[T]) HandlerReturnError added in v12.2.8

func (w *ContextWrapper[T]) HandlerReturnError(handler func(T) error) func(Context) error

HandlerReturnError same as `Handler` but it converts a handler which returns an error.

func (*ContextWrapper[T]) Handlers added in v12.2.8

func (w *ContextWrapper[T]) Handlers(handlers ...func(T)) context.Handlers

Handlers wraps the handlers with the pool's Acquire and Release methods.

func (*ContextWrapper[T]) Pool added in v12.2.8

func (w *ContextWrapper[T]) Pool() ContextPool[T]

Pool returns the pool, useful when manually Acquire and Release of custom context is required.

type ContextWriterPatches added in v12.2.0

type ContextWriterPatches struct{}

ContextWriterPatches features the context's writers patches.

func (*ContextWriterPatches) JSON added in v12.2.0

func (cwp *ContextWriterPatches) JSON(patchFunc func(ctx Context, v interface{}, options *JSON) error)

JSON sets a custom function which runs and overrides the default behavior of the `Context#JSON` method.

func (*ContextWriterPatches) JSONP added in v12.2.0

func (cwp *ContextWriterPatches) JSONP(patchFunc func(ctx Context, v interface{}, options *JSONP) error)

JSONP sets a custom function which runs and overrides the default behavior of the `Context#JSONP` method.

func (*ContextWriterPatches) Markdown added in v12.2.0

func (cwp *ContextWriterPatches) Markdown(patchFunc func(ctx Context, v []byte, options *Markdown) error)

Markdown sets a custom function which runs and overrides the default behavior of the `Context#Markdown` method.

func (*ContextWriterPatches) XML added in v12.2.0

func (cwp *ContextWriterPatches) XML(patchFunc func(ctx Context, v interface{}, options *XML) error)

XML sets a custom function which runs and overrides the default behavior of the `Context#XML` method.

func (*ContextWriterPatches) YAML added in v12.2.0

func (cwp *ContextWriterPatches) YAML(patchFunc func(ctx Context, v interface{}, indentSpace int) error)

YAML sets a custom function which runs and overrides the default behavior of the `Context#YAML` method.

type Cookie = http.Cookie

Cookie is a type alias for the standard net/http Cookie struct type. See `Context.SetCookie`.

type CookieOption

type CookieOption = context.CookieOption

CookieOption is the type of function that is accepted on context's methods like `SetCookieKV`, `RemoveCookie` and `SetCookie` as their (last) variadic input argument to amend the end cookie's form.

Any custom or builtin `CookieOption` is valid, see `CookiePath`, `CookieCleanPath`, `CookieExpires` and `CookieHTTPOnly` for more.

An alias for the `context.CookieOption`.

type DecodeFunc added in v12.2.0

type DecodeFunc = context.DecodeFunc

DecodeFunc is a generic type of decoder function. When the returned error is not nil the decode operation is terminated and the error is received by the ReadJSONStream method, otherwise it continues to read the next available object. Look the `Context.ReadJSONStream` method.

Example: https://github.com/kataras/iris/blob/main/_examples/request-body/read-json-stream.

type Dir added in v12.2.0

type Dir = http.Dir

Dir implements FileSystem using the native file system restricted to a specific directory tree, can be passed to the `FileServer` function and `HandleDir` method. It's an alias of `http.Dir`.

type DirCacheOptions added in v12.2.0

type DirCacheOptions = router.DirCacheOptions

DirCacheOptions holds the options for the cached file system. See `DirOptions`.

type DirListRichOptions added in v12.2.0

type DirListRichOptions = router.DirListRichOptions

DirListRichOptions the options for the `DirListRich` helper function. A shortcut for the `router.DirListRichOptions`. Useful when `DirListRich` function is passed to `DirOptions.DirList` field.

type DirOptions

type DirOptions = router.DirOptions

DirOptions contains the optional settings that `FileServer` and `Party#HandleDir` can use to serve files and assets. A shortcut for the `router.DirOptions`, useful when `FileServer` or `HandleDir` is being used.

type ErrPrivate added in v12.2.0

type ErrPrivate = context.ErrPrivate

ErrPrivate if provided then the error saved in context should NOT be visible to the client no matter what. An alias for the `context.ErrPrivate`.

type ErrViewNotExist added in v12.2.0

type ErrViewNotExist = context.ErrViewNotExist

ErrViewNotExist reports whether a template was not found in the parsed templates tree.

type ExecutionOptions

type ExecutionOptions = router.ExecutionOptions

ExecutionOptions is a set of default behaviors that can be changed in order to customize the execution flow of the routes' handlers with ease.

See `ExecutionRules` and `core/router/Party#SetExecutionRules` for more.

type ExecutionRules

type ExecutionRules = router.ExecutionRules

ExecutionRules gives control to the execution of the route handlers outside of the handlers themselves. Usage:

Party#SetExecutionRules(ExecutionRules {
  Done: ExecutionOptions{Force: true},
})

See `core/router/Party#SetExecutionRules` for more. Example: https://github.com/kataras/iris/tree/main/_examples/mvc/middleware/without-ctx-next

type FallbackView added in v12.2.0

type FallbackView = context.FallbackView

FallbackView is a helper to register a single template filename as a fallback when the provided tempate filename was not found.

type FallbackViewFunc added in v12.2.0

type FallbackViewFunc = context.FallbackViewFunc

FallbackViewFunc is a function that can be registered to handle view fallbacks. It accepts the Context and a special error which contains information about the previous template error. It implements the FallbackViewProvider interface.

See `Context.View` method.

type FallbackViewLayout added in v12.2.0

type FallbackViewLayout = context.FallbackViewLayout

FallbackViewLayout is a helper to register a single template filename as a fallback layout when the provided layout filename was not found.

type Filter

type Filter = context.Filter

Filter is just a type of func(Context) bool which reports whether an action must be performed based on the incoming request.

See `NewConditionalHandler` for more. An alias for the `context/Filter`.

type GlobalPatches added in v12.2.0

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

GlobalPatches is a singleton features a uniform way to apply global/package-level modifications.

See the `Patches` package-level function.

func Patches added in v12.2.0

func Patches() *GlobalPatches

Patches returns the singleton of GlobalPatches, an easy way to modify global(package-level) configuration for Iris applications.

See its `Context` method.

Example: https://github.com/kataras/iris/blob/main/_examples/response-writer/json-third-party/main.go

func (*GlobalPatches) Context added in v12.2.0

func (p *GlobalPatches) Context() *ContextPatches

Context returns the available context patches.

type Guide added in v12.2.5

type Guide interface {
	// AllowOrigin defines the CORS allowed domains.
	// Many can be splitted by comma.
	// If "*" is provided then all origins are accepted (use it for public APIs).
	AllowOrigin(originLine string) CompressionGuide
}

Guide is the simplify API builder. It's a step-by-step builder which can be used to build an Iris Application with the most common features.

func NewGuide added in v12.2.0

func NewGuide() Guide

NewGuide returns a simple Iris API builder.

Example Code:

package main

import (
    "context"
    "database/sql"
    "time"

    "github.com/kataras/iris/v12"
    "github.com/kataras/iris/v12/x/errors"
)

func main() {
    iris.NewGuide().
        AllowOrigin("*").
        Compression(true).
        Health(true, "development", "kataras").
        Timeout(0, 20*time.Second, 20*time.Second).
        Middlewares().
        Services(
            // openDatabase(),
            // NewSQLRepoRegistry,
            NewMemRepoRegistry,
            NewTestService,
        ).
        API("/tests", new(TestAPI)).
        Listen(":80")
}

// Recommendation: move it to /api/tests/api.go file.
type TestAPI struct {
    TestService *TestService
}

func (api *TestAPI) Configure(r iris.Party) {
    r.Get("/", api.listTests)
}

func (api *TestAPI) listTests(ctx iris.Context) {
    tests, err := api.TestService.ListTests(ctx)
    if err != nil {
        errors.Internal.LogErr(ctx, err)
        return
    }

    ctx.JSON(tests)
}

// Recommendation: move it to /pkg/storage/sql/db.go file.
type DB struct {
    *sql.DB
}

func openDatabase( your database configuration... ) *DB {
    conn, err := sql.Open(...)
    // handle error.
    return &DB{DB: conn}
}

func (db *DB) Close() error {
    return nil
}

// Recommendation: move it to /pkg/repository/registry.go file.
type RepoRegistry interface {
    Tests() TestRepository

    InTransaction(ctx context.Context, fn func(RepoRegistry) error) error
}

// Recommendation: move it to /pkg/repository/registry/memory.go file.
type repoRegistryMem struct {
    tests TestRepository
}

func NewMemRepoRegistry() RepoRegistry {
    return &repoRegistryMem{
        tests: NewMemTestRepository(),
    }
}

func (r *repoRegistryMem) Tests() TestRepository {
    return r.tests
}

func (r *repoRegistryMem) InTransaction(ctx context.Context, fn func(RepoRegistry) error) error {
    return nil
}

// Recommendation: move it to /pkg/repository/registry/sql.go file.
type repoRegistrySQL struct {
    db *DB

    tests TestRepository
}

func NewSQLRepoRegistry(db *DB) RepoRegistry {
    return &repoRegistrySQL{
        db:    db,
        tests: NewSQLTestRepository(db),
    }
}

func (r *repoRegistrySQL) Tests() TestRepository {
    return r.tests
}

func (r *repoRegistrySQL) InTransaction(ctx context.Context, fn func(RepoRegistry) error) error {
    return nil

    // your own database transaction code, may look something like that:
    // tx, err := r.db.BeginTx(ctx, nil)
    // if err != nil {
    //     return err
    // }
    // defer tx.Rollback()
    // newRegistry := NewSQLRepoRegistry(tx)
    // if err := fn(newRegistry);err!=nil{
    // 	return err
    // }
    // return tx.Commit()
}

// Recommendation: move it to /pkg/test/test.go
type Test struct {
    Name string `db:"name"`
}

// Recommendation: move it to /pkg/test/repository.go
type TestRepository interface {
    ListTests(ctx context.Context) ([]Test, error)
}

type testRepositoryMem struct {
    tests []Test
}

func NewMemTestRepository() TestRepository {
    list := []Test{
        {Name: "test1"},
        {Name: "test2"},
        {Name: "test3"},
    }

    return &testRepositoryMem{
        tests: list,
    }
}

func (r *testRepositoryMem) ListTests(ctx context.Context) ([]Test, error) {
    return r.tests, nil
}

type testRepositorySQL struct {
    db *DB
}

func NewSQLTestRepository(db *DB) TestRepository {
    return &testRepositorySQL{db: db}
}

func (r *testRepositorySQL) ListTests(ctx context.Context) ([]Test, error) {
    query := `SELECT * FROM tests ORDER BY created_at;`

    rows, err := r.db.QueryContext(ctx, query)
    if err != nil {
        return nil, err
    }
    defer rows.Close()

    tests := make([]Test, 0)
    for rows.Next() {
        var t Test
        if err := rows.Scan(&t.Name); err != nil {
            return nil, err
        }
        tests = append(tests, t)
    }

    if err := rows.Err(); err != nil {
        return nil, err
    }

    return tests, nil
}

// Recommendation: move it to /pkg/service/test_service.go file.
type TestService struct {
    repos RepoRegistry
}

func NewTestService(registry RepoRegistry) *TestService {
    return &TestService{
        repos: registry,
    }
}

func (s *TestService) ListTests(ctx context.Context) ([]Test, error) {
    return s.repos.Tests().ListTests(ctx)
}

type Handler

type Handler = context.Handler

A Handler responds to an HTTP request. It writes reply headers and data to the Context.ResponseWriter() and then return. Returning signals that the request is finished; it is not valid to use the Context after or concurrently with the completion of the Handler call.

Depending on the HTTP client software, HTTP protocol version, and any intermediaries between the client and the iris server, it may not be possible to read from the Context.Request().Body after writing to the context.ResponseWriter(). Cautious handlers should read the Context.Request().Body first, and then reply.

Except for reading the body, handlers should not modify the provided Context.

If Handler panics, the server (the caller of Handler) assumes that the effect of the panic was isolated to the active request. It recovers the panic, logs a stack trace to the server error log, and hangs up the connection.

func Component added in v12.2.9

func Component(component context.Component) Handler

Component returns a new Handler which can be registered as a main handler for a route. It's a shortcut handler that renders the given component as HTML through Context.RenderComponent.

type HealthGuide added in v12.2.5

type HealthGuide interface {
	// Health enables the /health route.
	// If "env" and "developer" are given, these fields will be populated to the client
	// through headers and environment on health route.
	Health(b bool, env, developer string) TimeoutGuide
}

HealthGuide is the 3rd step of the Guide. Health enables the /health route.

type JSON

type JSON = context.JSON

JSON the optional settings for JSON renderer.

It is an alias of the `context#JSON` type.

type JSONP added in v12.2.0

type JSONP = context.JSONP

JSONP the optional settings for JSONP renderer.

It is an alias of the `context#JSONP` type.

type JSONReader added in v12.2.0

type JSONReader = context.JSONReader

JSONReader holds the JSON decode options of the `Context.ReadJSON, ReadBody` methods.

It is an alias of the `context#JSONReader` type.

type Locale added in v12.2.0

type Locale = context.Locale

Locale describes the i18n locale. An alias for the `context.Locale`.

type Map

type Map = context.Map

A Map is an alias of map[string]interface{}.

type Markdown added in v12.2.0

type Markdown = context.Markdown

Markdown the optional settings for Markdown renderer. See `Context.Markdown` for more.

It is an alias of the `context#Markdown` type.

type MiddlewareGuide added in v12.2.5

type MiddlewareGuide interface {
	// RouterMiddlewares registers one or more handlers to run before everything else.
	RouterMiddlewares(handlers ...Handler) MiddlewareGuide
	// Middlewares registers one or more handlers to run before the requested route's handler.
	Middlewares(handlers ...Handler) ServiceGuide
}

MiddlewareGuide is the 5th step of the Guide. It registers one or more handlers to run before everything else (RouterMiddlewares) or before registered routes (Middlewares).

type N

type N = context.N

N is a struct which can be passed on the `Context.Negotiate` method. It contains fields which should be filled based on the `Context.Negotiation()` server side values. If no matched mime then its "Other" field will be sent, which should be a string or []byte. It completes the `context/context.ContentSelector` interface.

An alias for the `context.N`.

type Party

type Party = router.Party

Party is just a group joiner of routes which have the same prefix and share same middleware(s) also. Party could also be named as 'Join' or 'Node' or 'Group' , Party chosen because it is fun.

Look the `core/router#APIBuilder` for its implementation.

A shortcut for the `core/router#Party`, useful when `PartyFunc` is being used.

type Problem

type Problem = context.Problem

Problem Details for HTTP APIs. Pass a Problem value to `context.Problem` to write an "application/problem+json" response.

Read more at: https://github.com/kataras/iris/blob/main/_examples/routing/http-errors.

It is an alias of the `context#Problem` type.

type ProblemOptions

type ProblemOptions = context.ProblemOptions

ProblemOptions the optional settings when server replies with a Problem. See `Context.Problem` method and `Problem` type for more details.

It is an alias of the `context#ProblemOptions` type.

type ProtoMarshalOptions added in v12.2.0

type ProtoMarshalOptions = context.ProtoMarshalOptions

ProtoMarshalOptions is a type alias for protojson.MarshalOptions.

type ProtoUnmarshalOptions added in v12.2.0

type ProtoUnmarshalOptions = context.ProtoUnmarshalOptions

ProtoUnmarshalOptions is a type alias for protojson.UnmarshalOptions.

type ResultHandler added in v12.2.0

type ResultHandler = hero.ResultHandler

ResultHandler describes the function type which should serve the "v" struct value. See `APIContainer.UseResultHandler`.

type Runner

type Runner func(*Application) error

Runner is just an interface which accepts the framework instance and returns an error.

It can be used to register a custom runner with `Run` in order to set the framework's server listen action.

Currently `Runner` is being used to declare the builtin server listeners.

See `Run` for more.

func Addr

func Addr(addr string, hostConfigs ...host.Configurator) Runner

Addr can be used as an argument for the `Run` method. It accepts a host address which is used to build a server and a listener which listens on that host and port.

Addr should have the form of host:port, i.e localhost:8080 or :8080.

Second argument is optional, it accepts one or more `func(*host.Configurator)` that are being executed on that specific host that this function will create to start the server. Via host configurators you can configure the back-end host supervisor, i.e to add events for shutdown, serve or error. An example of this use case can be found at: https://github.com/kataras/iris/blob/main/_examples/http-server/notify-on-shutdown/main.go Look at the `ConfigureHost` too.

See `Run` for more.

func AutoTLS

func AutoTLS(
	addr string,
	domain string, email string,
	hostConfigs ...host.Configurator,
) Runner

AutoTLS can be used as an argument for the `Run` method. It will start the Application's secure server using certifications created on the fly by the "autocert" golang/x package, so localhost may not be working, use it at "production" machine.

Addr should have the form of host:port, i.e mydomain.com:443.

The whitelisted domains are separated by whitespace in "domain" argument, i.e "iris-go.com", can be different than "addr". If empty, all hosts are currently allowed. This is not recommended, as it opens a potential attack where clients connect to a server by IP address and pretend to be asking for an incorrect host name. Manager will attempt to obtain a certificate for that host, incorrectly, eventually reaching the CA's rate limit for certificate requests and making it impossible to obtain actual certificates.

For an "e-mail" use a non-public one, letsencrypt needs that for your own security.

Note: `AutoTLS` will start a new server for you which will redirect all http versions to their https, including subdomains as well.

Last argument is optional, it accepts one or more `func(*host.Configurator)` that are being executed on that specific host that this function will create to start the server. Via host configurators you can configure the back-end host supervisor, i.e to add events for shutdown, serve or error. An example of this use case can be found at: https://github.com/kataras/iris/blob/main/_examples/http-server/notify-on-shutdown/main.go Look at the `ConfigureHost` too.

Usage: app.Run(iris.AutoTLS("iris-go.com:443", "iris-go.com www.iris-go.com", "mail@example.com"))

See `Run` and `core/host/Supervisor#ListenAndServeAutoTLS` for more.

func Listener

func Listener(l net.Listener, hostConfigs ...host.Configurator) Runner

Listener can be used as an argument for the `Run` method. It can start a server with a custom net.Listener via server's `Serve`.

Second argument is optional, it accepts one or more `func(*host.Configurator)` that are being executed on that specific host that this function will create to start the server. Via host configurators you can configure the back-end host supervisor, i.e to add events for shutdown, serve or error. An example of this use case can be found at: https://github.com/kataras/iris/blob/main/_examples/http-server/notify-on-shutdown/main.go Look at the `ConfigureHost` too.

See `Run` for more.

func Raw

func Raw(f func() error) Runner

Raw can be used as an argument for the `Run` method. It accepts any (listen) function that returns an error, this function should be block and return an error only when the server exited or a fatal error caused.

With this option you're not limited to the servers that iris can run by-default.

See `Run` for more.

func Server

func Server(srv *http.Server, hostConfigs ...host.Configurator) Runner

Server can be used as an argument for the `Run` method. It can start a server with a *http.Server.

Second argument is optional, it accepts one or more `func(*host.Configurator)` that are being executed on that specific host that this function will create to start the server. Via host configurators you can configure the back-end host supervisor, i.e to add events for shutdown, serve or error. An example of this use case can be found at: https://github.com/kataras/iris/blob/main/_examples/http-server/notify-on-shutdown/main.go Look at the `ConfigureHost` too.

See `Run` for more.

func TLS

func TLS(addr string, certFileOrContents, keyFileOrContents string, hostConfigs ...host.Configurator) Runner

TLS can be used as an argument for the `Run` method. It will start the Application's secure server.

Use it like you used to use the http.ListenAndServeTLS function.

Addr should have the form of host:port, i.e localhost:443 or :443. "certFileOrContents" & "keyFileOrContents" should be filenames with their extensions or raw contents of the certificate and the private key.

Last argument is optional, it accepts one or more `func(*host.Configurator)` that are being executed on that specific host that this function will create to start the server. Via host configurators you can configure the back-end host supervisor, i.e to add events for shutdown, serve or error. An example of this use case can be found at: https://github.com/kataras/iris/blob/main/_examples/http-server/notify-on-shutdown/main.go Look at the `ConfigureHost` too.

See `Run` for more.

type ServiceGuide added in v12.2.5

type ServiceGuide interface {
	// Deferrables registers one or more functions to be ran when the server is terminated.
	Deferrables(closers ...func()) ServiceGuide
	// Prefix sets the API Party prefix path.
	// Usage: WithPrefix("/api").
	WithPrefix(prefixPath string) ServiceGuide
	// WithoutPrefix disables the API Party prefix path.
	// Usage: WithoutPrefix(), same as WithPrefix("").
	WithoutPrefix() ServiceGuide
	// Services registers one or more dependencies that APIs can use.
	Services(deps ...interface{}) ApplicationBuilder
}

ServiceGuide is the 6th step of the Guide. It is used to register deferrable functions and, most importantly, dependencies that APIs can use.

type SimpleUser added in v12.2.0

type SimpleUser = context.SimpleUser

SimpleUser is a simple implementation of the User interface.

type Singleton added in v12.2.7

type Singleton struct{}

Singleton is a structure which can be used as an embedded field on struct/controllers that should be marked as singletons on `PartyConfigure` or `MVC` Applications.

func (Singleton) Singleton added in v12.2.7

func (c Singleton) Singleton() bool

Singleton returns true as this controller is a singleton.

type Supervisor

type Supervisor = host.Supervisor

Supervisor is a shortcut of the `host#Supervisor`. Used to add supervisor configurators on common Runners without the need of importing the `core/host` package.

type TimeoutGuide added in v12.2.5

type TimeoutGuide interface {
	// Timeout defines the http timeout, server read & write timeouts.
	Timeout(requestResponseLife, read time.Duration, write time.Duration) MiddlewareGuide
}

TimeoutGuide is the 4th step of the Guide. Timeout defines the http timeout, server read & write timeouts.

type Tunnel

type Tunnel = tunnel.Tunnel

Tunnel is the Tunnels field of the TunnelingConfiguration structure.

type TunnelingConfiguration

type TunnelingConfiguration = tunnel.Configuration

TunnelingConfiguration contains configuration for the optional tunneling through ngrok feature. Note that the ngrok should be already installed at the host machine.

type UnmarshalerFunc

type UnmarshalerFunc = context.UnmarshalerFunc

UnmarshalerFunc a shortcut, an alias for the `context#UnmarshalerFunc` type which implements the `context#Unmarshaler` interface for reading request's body via custom decoders, most of them already implement the `context#UnmarshalerFunc` like the json.Unmarshal, xml.Unmarshal, yaml.Unmarshal and every library which follows the best practises and is aligned with the Go standards.

See 'context#UnmarshalBody` for more.

Example: https://github.com/kataras/iris/blob/main/_examples/request-body/read-custom-via-unmarshaler/main.go

type User added in v12.2.0

type User = context.User

User is a generic view of an authorized client. See `Context.User` and `SetUser` methods for more. An alias for the `context/User` type.

type ViewEngine added in v12.2.0

type ViewEngine = context.ViewEngine

ViewEngine is an alias of `context.ViewEngine`. See HTML, Blocks, Django, Jet, Pug, Ace, Handlebars and e.t.c.

type XML

type XML = context.XML

XML the optional settings for XML renderer.

It is an alias of the `context#XML` type.

Directories

Path Synopsis
_benchmarks
_examples
auth/cors
Package main integrates the "rs/cors" net/http middleware into Iris.
Package main integrates the "rs/cors" net/http middleware into Iris.
file-server/embedding-files-into-app-bindata
Package main generated by go-bindata.// sources: assets/css/main.css assets/favicon.ico assets/js/main.js
Package main generated by go-bindata.// sources: assets/css/main.css assets/favicon.ico assets/js/main.js
file-server/embedding-gzipped-files-into-app-bindata
Package main generated by go-bindata.// sources: ../embedding-files-into-app-bindata/assets/css/main.css ../embedding-files-into-app-bindata/assets/favicon.ico ../embedding-files-into-app-bindata/assets/js/main.js
Package main generated by go-bindata.// sources: ../embedding-files-into-app-bindata/assets/css/main.css ../embedding-files-into-app-bindata/assets/favicon.ico ../embedding-files-into-app-bindata/assets/js/main.js
file-server/http2push-embedded
Package main generated by go-bindata.// sources: ../http2push/assets/app2/app2app3/css/main.css ../http2push/assets/app2/app2app3/dirs/dir1/text.txt ../http2push/assets/app2/app2app3/dirs/dir2/text.txt ../http2push/assets/app2/app2app3/dirs/text.txt ../http2push/assets/app2/app2app3/index.html ../http2push/assets/app2/index.html ../http2push/assets/app2/mydir/text.txt ../http2push/assets/css/main.css ../http2push/assets/favicon.ico ../http2push/assets/index.html ../http2push/assets/js/main.js
Package main generated by go-bindata.// sources: ../http2push/assets/app2/app2app3/css/main.css ../http2push/assets/app2/app2app3/dirs/dir1/text.txt ../http2push/assets/app2/app2app3/dirs/dir2/text.txt ../http2push/assets/app2/app2app3/dirs/text.txt ../http2push/assets/app2/app2app3/index.html ../http2push/assets/app2/index.html ../http2push/assets/app2/mydir/text.txt ../http2push/assets/css/main.css ../http2push/assets/favicon.ico ../http2push/assets/index.html ../http2push/assets/js/main.js
file-server/http2push-embedded-gzipped
Package main generated by go-bindata.// sources: ../http2push/assets/app2/app2app3/css/main.css ../http2push/assets/app2/app2app3/dirs/dir1/text.txt ../http2push/assets/app2/app2app3/dirs/dir2/text.txt ../http2push/assets/app2/app2app3/dirs/text.txt ../http2push/assets/app2/app2app3/index.html ../http2push/assets/app2/index.html ../http2push/assets/app2/mydir/text.txt ../http2push/assets/css/main.css ../http2push/assets/favicon.ico ../http2push/assets/index.html ../http2push/assets/js/main.js
Package main generated by go-bindata.// sources: ../http2push/assets/app2/app2app3/css/main.css ../http2push/assets/app2/app2app3/dirs/dir1/text.txt ../http2push/assets/app2/app2app3/dirs/dir2/text.txt ../http2push/assets/app2/app2app3/dirs/text.txt ../http2push/assets/app2/app2app3/index.html ../http2push/assets/app2/index.html ../http2push/assets/app2/mydir/text.txt ../http2push/assets/css/main.css ../http2push/assets/favicon.ico ../http2push/assets/index.html ../http2push/assets/js/main.js
file-server/single-page-application/embedded-single-page-application
Package main generated by go-bindata.// sources: data/public/app.js data/public/app2/index.html data/public/css/main.css data/views/index.html
Package main generated by go-bindata.// sources: data/public/app.js data/public/app2/index.html data/public/css/main.css data/views/index.html
file-server/single-page-application/embedded-single-page-application-with-other-routes
Package main generated by go-bindata.// sources: public/app.js public/css/main.css public/index.html
Package main generated by go-bindata.// sources: public/app.js public/css/main.css public/index.html
file-server/spa-vue-router
Package main simply shows how you can getting started with Iris and Vue Router.
Package main simply shows how you can getting started with Iris and Vue Router.
http-server/listen-letsencrypt
Package main provide one-line integration with letsencrypt.org
Package main provide one-line integration with letsencrypt.org
logging/request-logger/accesslog-formatter
Package main shows how to create a quite fast custom Log Formatter.
Package main shows how to create a quite fast custom Log Formatter.
logging/request-logger/accesslog-proxy
Package main is a proxy + accesslog example.
Package main is a proxy + accesslog example.
mvc/authenticated-controller
Package main shows how to use a dependency to check if a user is logged in using a special custom Go type `Authenticated`, which when, present on a controller's method or a field then it limits the visibility to "authenticated" users only.
Package main shows how to use a dependency to check if a user is logged in using a special custom Go type `Authenticated`, which when, present on a controller's method or a field then it limits the visibility to "authenticated" users only.
mvc/grpc-compatible/grpc-client
Package main implements a client for Greeter service.
Package main implements a client for Greeter service.
mvc/middleware
Package main shows how you can add middleware to an mvc Application, simply by using its `Router` which is a sub router(an iris.Party) of the main iris app.
Package main shows how you can add middleware to an mvc Application, simply by using its `Router` which is a sub router(an iris.Party) of the main iris app.
mvc/middleware/per-method
If you want to use it as middleware for the entire controller you can use its router which is just a sub router to add it as you normally do with standard API:
If you want to use it as middleware for the entire controller you can use its router which is just a sub router to add it as you normally do with standard API:
mvc/middleware/without-ctx-next
Package main shows how to add done handlers in an MVC application without the necessity of `ctx.Next()` inside the controller's methods.
Package main shows how to add done handlers in an MVC application without the necessity of `ctx.Next()` inside the controller's methods.
mvc/regexp
Package main shows how to match "/xxx.json" in MVC handler.
Package main shows how to match "/xxx.json" in MVC handler.
request-body/form-query-headers-params-decoder
package main contains an example on how to register a custom decoder for a custom type when using the `ReadQuery/ReadParams/ReadHeaders/ReadForm` methods.
package main contains an example on how to register a custom decoder for a custom type when using the `ReadQuery/ReadParams/ReadHeaders/ReadForm` methods.
request-body/read-form
package main contains an example on how to use the ReadForm, but with the same way you can do the ReadJSON & ReadJSON
package main contains an example on how to use the ReadForm, but with the same way you can do the ReadJSON & ReadJSON
request-body/read-headers
package main contains an example on how to use the ReadHeaders, same way you can do the ReadQuery, ReadJSON, ReadProtobuf and e.t.c.
package main contains an example on how to use the ReadHeaders, same way you can do the ReadQuery, ReadJSON, ReadProtobuf and e.t.c.
request-body/read-json-struct-validation
Package main shows the validator(latest, version 10) integration with Iris' Context methods of `ReadJSON`, `ReadXML`, `ReadMsgPack`, `ReadYAML`, `ReadForm`, `ReadQuery`, `ReadBody`.
Package main shows the validator(latest, version 10) integration with Iris' Context methods of `ReadJSON`, `ReadXML`, `ReadMsgPack`, `ReadYAML`, `ReadForm`, `ReadQuery`, `ReadBody`.
request-body/read-params
package main contains an example on how to use the ReadParams, same way you can do the ReadQuery, ReadJSON, ReadProtobuf and e.t.c.
package main contains an example on how to use the ReadParams, same way you can do the ReadQuery, ReadJSON, ReadProtobuf and e.t.c.
request-body/read-query
package main contains an example on how to use the ReadQuery, same way you can do the ReadJSON & ReadProtobuf and e.t.c.
package main contains an example on how to use the ReadQuery, same way you can do the ReadJSON & ReadProtobuf and e.t.c.
request-body/read-url
package main contains an example on how to use the ReadURL, same way you can do the ReadQuery, ReadParams, ReadJSON, ReadProtobuf and e.t.c.
package main contains an example on how to use the ReadURL, same way you can do the ReadQuery, ReadParams, ReadJSON, ReadProtobuf and e.t.c.
response-writer/cache/client-side
Package main shows how you can use the `WriteWithExpiration` based on the "modtime", if it's newer than the request header then it will refresh the contents, otherwise will let the client (99.9% the browser) to handle the cache mechanism, it's faster than iris.Cache because server-side has nothing to do and no need to store the responses in the memory.
Package main shows how you can use the `WriteWithExpiration` based on the "modtime", if it's newer than the request header then it will refresh the contents, otherwise will let the client (99.9% the browser) to handle the cache mechanism, it's faster than iris.Cache because server-side has nothing to do and no need to store the responses in the memory.
response-writer/content-negotiation
Package main contains three different ways to render content based on the client's accepted.
Package main contains three different ways to render content based on the client's accepted.
response-writer/http2push
Server push lets the server preemptively "push" website assets to the client without the user having explicitly asked for them.
Server push lets the server preemptively "push" website assets to the client without the user having explicitly asked for them.
response-writer/sse
Package main shows how to send continuous event messages to the clients through SSE via a broker.
Package main shows how to send continuous event messages to the clients through SSE via a broker.
routing/macros
Package main shows how you can register a custom parameter type and macro functions that belongs to it.
Package main shows how you can register a custom parameter type and macro functions that belongs to it.
routing/route-handlers-execution-rules
Package main is a simple example of the behavior change of the execution flow of the handlers, normally we need the `ctx.Next()` to call the next handler in a route's handler chain, but with the `ExecutionRules` we can change this default behavior.
Package main is a simple example of the behavior change of the execution flow of the handlers, normally we need the `ctx.Next()` to call the next handler in a route's handler chain, but with the `ExecutionRules` we can change this default behavior.
routing/subdomains/single
Package main register static subdomains, simple as parties, check ./hosts if you use windows
Package main register static subdomains, simple as parties, check ./hosts if you use windows
routing/subdomains/wildcard
Package main an example on how to catch dynamic subdomains - wildcard.
Package main an example on how to catch dynamic subdomains - wildcard.
routing/writing-a-middleware/share-funcs
Package main shows how you can share a function between handlers of the same chain.
Package main shows how you can share a function between handlers of the same chain.
url-shortener
Package main shows how you can create a simple URL Shortener.
Package main shows how you can create a simple URL Shortener.
view/embedding-templates-into-app-bindata
Package main generated by go-bindata.// sources: templates/layouts/layout.html templates/layouts/mylayout.html templates/page1.html templates/partials/page1_partial1.html
Package main generated by go-bindata.// sources: templates/layouts/layout.html templates/layouts/mylayout.html templates/page1.html templates/partials/page1_partial1.html
view/herotemplate/template
Code generated by hero.
Code generated by hero.
view/parse-template
Package main shows how to parse a template through custom byte slice content.
Package main shows how to parse a template through custom byte slice content.
view/template_blocks_1_embedded
Package main generated by go-bindata.// sources: ../template_blocks_0/views/500.html ../template_blocks_0/views/index.html ../template_blocks_0/views/layouts/error.html ../template_blocks_0/views/layouts/main.html ../template_blocks_0/views/partials/footer.html
Package main generated by go-bindata.// sources: ../template_blocks_0/views/500.html ../template_blocks_0/views/index.html ../template_blocks_0/views/layouts/error.html ../template_blocks_0/views/layouts/main.html ../template_blocks_0/views/partials/footer.html
view/template_html_3
Package main an example on how to naming your routes & use the custom 'url path' HTML Template Engine, same for other template engines.
Package main an example on how to naming your routes & use the custom 'url path' HTML Template Engine, same for other template engines.
view/template_html_4
Package main an example on how to naming your routes & use the custom 'url' HTML Template Engine, same for other template engines.
Package main an example on how to naming your routes & use the custom 'url' HTML Template Engine, same for other template engines.
view/template_jet_0
Package main shows how to use jet template parser with ease using the Iris built-in Jet view engine.
Package main shows how to use jet template parser with ease using the Iris built-in Jet view engine.
view/template_jet_1_embedded
Package main generated by go-bindata.// sources: views/includes/_partial.jet views/includes/blocks.jet views/index.jet views/layouts/application.jet
Package main generated by go-bindata.// sources: views/includes/_partial.jet views/includes/blocks.jet views/index.jet views/layouts/application.jet
view/template_jet_2
Package main an example on how to naming your routes & use the custom 'url path' Jet Template Engine.
Package main an example on how to naming your routes & use the custom 'url path' Jet Template Engine.
view/template_pug_0
Package main shows an example of pug actions based on https://github.com/Joker/jade/tree/master/example/actions
Package main shows an example of pug actions based on https://github.com/Joker/jade/tree/master/example/actions
view/template_pug_2_embedded
Package main generated by go-bindata.// sources: templates/index.pug templates/layout.pug
Package main generated by go-bindata.// sources: templates/index.pug templates/layout.pug
Package apps is responsible to control many Iris Applications.
Package apps is responsible to control many Iris Applications.
cfg
ruleset
Package ruleset provides the basics rules which are being extended by rules.
Package ruleset provides the basics rules which are being extended by rules.
uri
core
memstore
Package memstore contains a store which is just a collection of key-value entries with immutability capabilities.
Package memstore contains a store which is just a collection of key-value entries with immutability capabilities.
Package i18n provides internalization and localization features for Iris.
Package i18n provides internalization and localization features for Iris.
handler
Package handler is the highest level module of the macro package which makes use the rest of the macro package, it is mainly used, internally, by the router package.
Package handler is the highest level module of the macro package which makes use the rest of the macro package, it is mainly used, internally, by the router package.
middleware
jwt
logger
Package logger provides request logging via middleware.
Package logger provides request logging via middleware.
pprof
Package pprof provides native pprof support via middleware.
Package pprof provides native pprof support via middleware.
rate
Package rate implements rate limiter for Iris client requests.
Package rate implements rate limiter for Iris client requests.
recover
Package recover provides recovery for specific routes or for the whole app via middleware.
Package recover provides recovery for specific routes or for the whole app via middleware.
x

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL