iris

package module
v4.2.5+incompatible Latest Latest
Warning

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

 Go to latest Published: Sep 16, 2016 License: Apache-2.0, BSD-2-Clause, BSD-3-Clause, + 1 more Imports: 48 Imported by: 0

README


Build Status

Platforms

License

Built with GoLang


Releases

Examples

Practical Guide/Docs

Chat

The fastest backend web framework for Go.
Easy to learn, while it's highly customizable.
Ideally suited for both experienced and novice Developers.

Quick Look

package main

import "github.com/kataras/iris"

func main() {
	iris.Favicon("./favicon.ico")

	iris.Get("/", func(ctx *iris.Context) {
		ctx.Render("index.html")
	})

	iris.Get("/login", func(ctx *iris.Context) {
		ctx.Render("login.html", iris.Map{"Title": "Login Page"})
	})

	iris.Post("/login", func(ctx *iris.Context) {
		secret := ctx.PostValue("secret")
		ctx.Session().Set("secret", secret)

		ctx.Redirect("/user")
	})

	iris.Listen(":8080")
}

Installation

The only requirement is the Go Programming Language, at least v1.7.

$ go get -u github.com/kataras/iris/iris

If you have installation issues or you are connected to the Internet through China please, click here.

Docs & Community

If you'd like to discuss this package, or ask questions about it, feel free to

New website-docs & logo have been designed by the community*

Features

  • Focus on high performance
  • Robust routing, static, wildcard subdomains and routes.
  • Websocket API, Sessions support out of the box
  • Remote control through SSH
  • View system supporting 6+ template engines.*
  • Highly scalable response engines with pre-defined serializers
  • Live reload
  • Typescript integration + Online editor
  • OAuth, OAuth2 supporting 27+ API providers, JWT, BasicAuth
  • and many other surprises
Name Description Usage
JSON JSON Serializer (Default) example 1,example 2, book section
JSONP JSONP Serializer (Default) example 1,example 2, book section
XML XML Serializer (Default) example 1,example 2, book section
Markdown Markdown Serializer (Default) example 1,example 2, book section
Text Text Serializer (Default) example 1, book section
Binary Data Binary Data Serializer (Default) example 1, book section
HTML/Default Engine HTML Template Engine (Default) example , book section
Django Engine Django Template Engine example , book section
Pug/Jade Engine Pug Template Engine example , book section
Handlebars Engine Handlebars Template Engine example , book section
Amber Engine Amber Template Engine example , book section
Markdown Engine Markdown Template Engine example , book section
Basicauth Middleware HTTP Basic authentication example 1, example 2, book section
JWT Middleware JSON Web Tokens example , book section
Cors Middleware Cross Origin Resource Sharing W3 specification how to use
Secure Middleware Facilitates some quick security wins example
I18n Middleware Simple internationalization example, book section
Recovery Middleware Safety recover the station from panic example
Logger Middleware Logs every request example, book section
Editor Plugin Alm-tools, a typescript online IDE/Editor book section
Typescript Plugin Auto-compile client-side typescript files book section
OAuth,OAuth2 Plugin User Authentication was never be easier, supports >27 providers example, book section
Iris control Plugin Basic (browser-based) control over your Iris station example, book section

FAQ

Explore these questions or navigate to the community chat.

Philosophy

The Iris philosophy is to provide robust tooling for HTTP, making it a great solution for single page applications, web sites, hybrids, or public HTTP APIs.

Iris does not force you to use any specific ORM or template engine. With support for the most used template engines, you can quickly craft the perfect application.

Iris is built on top of fasthttp (http basic layer), net/http middleware will not work by default on Iris, but you can convert any net/http middleware to Iris, see middleware repository to see how.

If for any personal reasons you think that Iris+fasthttp is not suitable for you, but you don't want to miss the unique features that Iris provides, you can take a look at the HTTP2 Q web framework.

Benchmarks

This Benchmark test aims to compare the whole HTTP request processing between Go web frameworks.

Benchmark Wizzard July 21, 2016- Processing Time Horizontal Graph

The results have been updated on July 21, 2016

Testing

Community should write third-party or iris base tests to the iris-contrib/tests repository. I recommend writing your API tests using this new library, httpexpect which supports Iris and fasthttp now, after my request here.

Versioning

Current: v4.2.5

Iris is an active project

Read more about Semantic Versioning 2.0.0

Todo

  • Use of the standard log.Logger instead of the iris-contrib/logger(colorful logger), make these changes to all middleware, examples and plugins.
  • Implement, even, a better way to manage configuration/options, devs will be able to set their own custom options inside there. I'm thinking of something the last days, but it will have breaking changes.
  • Implement an internal updater, as requested here.

Iris is a Community-Driven Project, waiting for your suggestions and feature requests!

I, as the author of this package, am working full time on this package, no time to any other job, so if you're willing to donate and you can afford it please click here, thank you!

People

The big thanks goes to all people who help building this framework with feature-requests & bug reports!

The author of Iris is @kataras.

Contributing

If you are interested in contributing to the Iris project, please see the document CONTRIBUTING.

License

This project is licensed under the Apache License, Version 2.0.

License can be found here.

Documentation

Overview

Package iris the fastest go web framework in (this) Earth. /NOTE: When you see 'framework' or 'station' we mean the Iris web framework's main implementation.

Basic usage ----------------------------------------------------------------------

package main

import "github.com/kataras/iris" 

func main() {
    iris.Get("/hi_json", func(c *iris.Context) {
        c.JSON(200, iris.Map{
            "Name": "Iris",
            "Age":  2,
        })
    })
    iris.Listen(":8080")
}

----------------------------------------------------------------------

package main

import "github.com/kataras/iris" 

func main() {
	s1 := iris.New()
	s1.Get("/hi_json", func(c *iris.Context) {
		c.JSON(200, iris.Map{
			"Name": "Iris",
			"Age":  2,
		})
	})

	s2 := iris.New()
	s2.Get("/hi_raw_html", func(c *iris.Context) {
		c.HTML(iris.StatusOK, "<b> Iris </b> welcomes <h1>you!</h1>")
	})

	go s1.Listen(":8080")
	s2.Listen(":1993")
}

-----------------------------DOCUMENTATION---------------------------- ----------------------------_______________--------------------------- For middleware, template engines, response engines, sessions, websockets, mails, subdomains, dynamic subdomains, routes, party of subdomains & routes and much more visit https://www.gitbook.com/book/kataras/iris/details

Index

Constants

View Source 
const (
	DefaultDisablePathCorrection = false
	DefaultDisablePathEscape     = false
	DefaultCharset               = "UTF-8"
	DefaultLoggerPreffix         = "[IRIS] "
)

Default values for base Iris conf

View Source 
const (
	// DefaultCookieName the secret cookie's name for sessions
	DefaultCookieName = "irissessionid"
	// DefaultSessionGcDuration  is the default Session Manager's GCDuration , which is 2 hours
	DefaultSessionGcDuration = time.Duration(2) * time.Hour
	// DefaultCookieLength is the default Session Manager's CookieLength, which is 32
	DefaultCookieLength = 32
)
View Source 
const (
	// DefaultWriteTimeout 15 * time.Second
	DefaultWriteTimeout = 15 * time.Second
	// DefaultPongTimeout 60 * time.Second
	DefaultPongTimeout = 60 * time.Second
	// DefaultPingPeriod (DefaultPongTimeout * 9) / 10
	DefaultPingPeriod = (DefaultPongTimeout * 9) / 10
	// DefaultMaxMessageSize 1024
	DefaultMaxMessageSize = 1024
)
View Source 
const (
	// DefaultServerHostname returns the default hostname which is 0.0.0.0
	DefaultServerHostname = "0.0.0.0"
	// DefaultServerPort returns the default port which is 8080
	DefaultServerPort = 8080
	// DefaultMaxRequestBodySize is 8MB
	DefaultMaxRequestBodySize = 2 * fasthttp.DefaultMaxRequestBodySize

	// Per-connection buffer size for requests' reading.
	// This also limits the maximum header size.
	//
	// Increase this buffer if your clients send multi-KB RequestURIs
	// and/or multi-KB headers (for example, BIG cookies).
	//
	// Default buffer size is 8MB
	DefaultReadBufferSize = 8096

	// Per-connection buffer size for responses' writing.
	//
	// Default buffer size is 8MB
	DefaultWriteBufferSize = 8096

	// DefaultServerName the response header of the 'Server' value when writes to the client
	DefaultServerName = "iris"
)

Default values for base Server conf

View Source 
const (
	// MethodGet "GET"
	MethodGet = "GET"
	// MethodPost "POST"
	MethodPost = "POST"
	// MethodPut "PUT"
	MethodPut = "PUT"
	// MethodDelete "DELETE"
	MethodDelete = "DELETE"
	// MethodConnect "CONNECT"
	MethodConnect = "CONNECT"
	// MethodHead "HEAD"
	MethodHead = "HEAD"
	// MethodPatch "PATCH"
	MethodPatch = "PATCH"
	// MethodOptions "OPTIONS"
	MethodOptions = "OPTIONS"
	// MethodTrace "TRACE"
	MethodTrace = "TRACE"
)
View Source 
const (
	// StatusContinue http status '100'
	StatusContinue = 100
	// StatusSwitchingProtocols http status '101'
	StatusSwitchingProtocols = 101

	// StatusOK http status '200'
	StatusOK = 200
	// StatusCreated http status '201'
	StatusCreated = 201
	// StatusAccepted http status '202'
	StatusAccepted = 202
	// StatusNonAuthoritativeInfo http status '203'
	StatusNonAuthoritativeInfo = 203
	// StatusNoContent http status '204'
	StatusNoContent = 204
	// StatusResetContent http status '205'
	StatusResetContent = 205
	// StatusPartialContent http status '206'
	StatusPartialContent = 206

	// StatusMultipleChoices http status '300'
	StatusMultipleChoices = 300
	// StatusMovedPermanently http status '301'
	StatusMovedPermanently = 301
	// StatusFound http status '302'
	StatusFound = 302
	// StatusSeeOther http status '303'
	StatusSeeOther = 303
	// StatusNotModified http status '304'
	StatusNotModified = 304
	// StatusUseProxy http status '305'
	StatusUseProxy = 305
	// StatusTemporaryRedirect http status '307'
	StatusTemporaryRedirect = 307

	// StatusBadRequest http status '400'
	StatusBadRequest = 400
	// StatusUnauthorized http status '401'
	StatusUnauthorized = 401
	// StatusPaymentRequired http status '402'
	StatusPaymentRequired = 402
	// StatusForbidden http status '403'
	StatusForbidden = 403
	// StatusNotFound http status '404'
	StatusNotFound = 404
	// StatusMethodNotAllowed http status '405'
	StatusMethodNotAllowed = 405
	// StatusNotAcceptable http status '406'
	StatusNotAcceptable = 406
	// StatusProxyAuthRequired http status '407'
	StatusProxyAuthRequired = 407
	// StatusRequestTimeout http status '408'
	StatusRequestTimeout = 408
	// StatusConflict http status '409'
	StatusConflict = 409
	// StatusGone http status '410'
	StatusGone = 410
	// StatusLengthRequired http status '411'
	StatusLengthRequired = 411
	// StatusPreconditionFailed http status '412'
	StatusPreconditionFailed = 412
	// StatusRequestEntityTooLarge http status '413'
	StatusRequestEntityTooLarge = 413
	// StatusRequestURITooLong http status '414'
	StatusRequestURITooLong = 414
	// StatusUnsupportedMediaType http status '415'
	StatusUnsupportedMediaType = 415
	// StatusRequestedRangeNotSatisfiable http status '416'
	StatusRequestedRangeNotSatisfiable = 416
	// StatusExpectationFailed http status '417'
	StatusExpectationFailed = 417
	// StatusTeapot http status '418'
	StatusTeapot = 418
	// StatusPreconditionRequired http status '428'
	StatusPreconditionRequired = 428
	// StatusTooManyRequests http status '429'
	StatusTooManyRequests = 429
	// StatusRequestHeaderFieldsTooLarge http status '431'
	StatusRequestHeaderFieldsTooLarge = 431
	// StatusUnavailableForLegalReasons http status '451'
	StatusUnavailableForLegalReasons = 451

	// StatusInternalServerError http status '500'
	StatusInternalServerError = 500
	// StatusNotImplemented http status '501'
	StatusNotImplemented = 501
	// StatusBadGateway http status '502'
	StatusBadGateway = 502
	// StatusServiceUnavailable http status '503'
	StatusServiceUnavailable = 503
	// StatusGatewayTimeout http status '504'
	StatusGatewayTimeout = 504
	// StatusHTTPVersionNotSupported http status '505'
	StatusHTTPVersionNotSupported = 505
	// StatusNetworkAuthenticationRequired http status '511'
	StatusNetworkAuthenticationRequired = 511
)
View Source 
const (
	// NoLayout to disable layout for a particular template file
	NoLayout = template.NoLayout
	// TemplateLayoutContextKey is the name of the user values which can be used to set a template layout from a middleware and override the parent's
	TemplateLayoutContextKey = "templateLayout"
)
View Source 
const (
	// All is the string which the Emmiter use to send a message to all
	All = websocket.All
	// NotMe is the string which the Emmiter use to send a message to all except this websocket.Connection
	NotMe = websocket.NotMe
	// Broadcast is the string which the Emmiter use to send a message to all except this websocket.Connection, same as 'NotMe'
	Broadcast = websocket.Broadcast
)

conversionals

View Source 
const (
	// Version is the current version of the Iris web framework
	Version = "4.2.5"
)

Variables

View Source 
var (
	// OptionCheckForUpdates will try to search for newer version of Iris based on the https://github.com/kataras/iris/releases
	// If a newer version found then the app will ask the he dev/user if want to update the 'x' version
	// if 'y' is pressed then the updater will try to install the latest version
	// the updater, will notify the dev/user that the update is finished and should restart the App manually.
	// Notes:
	// 1. Experimental feature
	// 2. If setted to true, the app will have a little startup delay
	// 3. If you as developer edited the $GOPATH/src/github/kataras or any other Iris' Go dependencies at the past
	//    then the update process will fail.
	//
	// Usage: iris.Set(iris.OptionCheckForUpdates(true)) or
	//        iris.Config.CheckForUpdates = true or
	//        app := iris.New(iris.OptionCheckForUpdates(true))
	// Default is false
	OptionCheckForUpdates = func(val bool) OptionSet {
		return func(c *Configuration) {
			c.CheckForUpdates = val
		}

	}

	// OptionDisablePathCorrection corrects and redirects the requested path to the registed 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,
	// (permant)redirects the client to the correct path /home
	//
	// Default is false
	OptionDisablePathCorrection = func(val bool) OptionSet {
		return func(c *Configuration) {
			c.DisablePathCorrection = val
		}

	}

	// OptionDisablePathEscape when is false then its escapes the path, the named parameters (if any).
	OptionDisablePathEscape = func(val bool) OptionSet {
		return func(c *Configuration) {
			c.DisablePathEscape = val
		}
	}

	// OptionDisableBanner outputs the iris banner at startup
	//
	// Default is false
	OptionDisableBanner = func(val bool) OptionSet {
		return func(c *Configuration) {
			c.DisableBanner = val
		}
	}

	// OptionLoggerOut is the destination for output
	//
	// Default is os.Stdout
	OptionLoggerOut = func(val io.Writer) OptionSet {
		return func(c *Configuration) {
			c.LoggerOut = val
		}
	}

	// OptionLoggerPreffix is the logger's prefix to write at beginning of each line
	//
	// Default is [IRIS]
	OptionLoggerPreffix = func(val string) OptionSet {
		return func(c *Configuration) {
			c.LoggerPreffix = val
		}
	}

	// OptionProfilePath a the route path, set it to enable http pprof tool
	// Default is empty, if you set it to a $path, these routes will handled:
	OptionProfilePath = func(val string) OptionSet {
		return func(c *Configuration) {
			c.ProfilePath = val
		}
	}

	// OptionDisableTemplateEngines set to true to disable loading the default template engine (html/template) and disallow the use of iris.UseEngine
	// Default is false
	OptionDisableTemplateEngines = func(val bool) OptionSet {
		return func(c *Configuration) {
			c.DisableTemplateEngines = val
		}
	}

	// OptionIsDevelopment iris will act like a developer, for example
	// If true then re-builds the templates on each request
	// Default is false
	OptionIsDevelopment = func(val bool) OptionSet {
		return func(c *Configuration) {
			c.IsDevelopment = val
		}
	}

	// OptionTimeFormat time format for any kind of datetime parsing
	OptionTimeFormat = func(val string) OptionSet {
		return func(c *Configuration) {
			c.TimeFormat = val
		}
	}

	// OptionCharset character encoding for various rendering
	// used for templates and the rest of the responses
	// Default is "UTF-8"
	OptionCharset = func(val string) OptionSet {
		return func(c *Configuration) {
			c.Charset = val
		}
	}

	// OptionGzip enables gzip compression on your Render actions, this includes any type of render, templates and pure/raw content
	// If you don't want to enable it globaly, you could just use the third parameter on context.Render("myfileOrResponse", structBinding{}, iris.RenderOptions{"gzip": true})
	// Default is false
	OptionGzip = func(val bool) OptionSet {
		return func(c *Configuration) {
			c.Gzip = val
		}
	}

	// OptionOther are the custom, dynamic options, can be empty
	// this fill used only by you to set any app's options you want
	// for each of an Iris instance
	OptionOther = func(val ...options.Options) OptionSet {
		opts := options.Options{}
		for _, opt := range val {
			for k, v := range opt {
				opts[k] = v
			}
		}
		return func(c *Configuration) {
			c.Other = opts
		}
	}
)

All options starts with "Option" preffix in order to be easier to find what dev searching for

View Source 
var (
	// DefaultTimeFormat default time format for any kind of datetime parsing
	DefaultTimeFormat = "Mon, 02 Jan 2006 15:04:05 GMT"
	// StaticCacheDuration expiration duration for INACTIVE file handlers, it's a global configuration field to all iris instances
	StaticCacheDuration = 20 * time.Second
	// CompressedFileSuffix is the suffix to add to the name of
	// cached compressed file when using the .StaticFS function.
	//
	// Defaults to iris-fasthttp.gz
	CompressedFileSuffix = "iris-fasthttp.gz"
)
View Source 
var (
	// OptionSessionsCookie string, the session's client cookie name, for example: "qsessionid"
	OptionSessionsCookie = func(val string) OptionSet {
		return func(c *Configuration) {
			c.Sessions.Cookie = val
		}
	}

	// OptionSessionsDecodeCookie set it to true to decode the cookie key with base64 URLEncoding
	// Defaults to false
	OptionSessionsDecodeCookie = func(val bool) OptionSet {
		return func(c *Configuration) {
			c.Sessions.DecodeCookie = val
		}
	}

	// OptionSessionsExpires the duration of which the cookie must expires (created_time.Add(Expires)).
	// If you want to delete the cookie when the browser closes, set it to -1 but in this case, the server side's session duration is up to GcDuration
	//
	// Default infinitive/unlimited life duration(0)
	OptionSessionsExpires = func(val time.Duration) OptionSet {
		return func(c *Configuration) {
			c.Sessions.Expires = val
		}
	}

	// OptionSessionsCookieLength the length of the sessionid's cookie's value, let it to 0 if you don't want to change it
	// Defaults to 32
	OptionSessionsCookieLength = func(val int) OptionSet {
		return func(c *Configuration) {
			c.Sessions.CookieLength = val
		}
	}

	// OptionSessionsGcDuration every how much duration(GcDuration) the memory should be clear for unused cookies (GcDuration)
	// for example: time.Duration(2)*time.Hour. it will check every 2 hours if cookie hasn't be used for 2 hours,
	// deletes it from backend memory until the user comes back, then the session continue to work as it was
	//
	// Default 2 hours
	OptionSessionsGcDuration = func(val time.Duration) OptionSet {
		return func(c *Configuration) {
			c.Sessions.GcDuration = val
		}
	}

	// OptionSessionsDisableSubdomainPersistence set it to true in order dissallow your q subdomains to have access to the session cookie
	// defaults to false
	OptionSessionsDisableSubdomainPersistence = func(val bool) OptionSet {
		return func(c *Configuration) {
			c.Sessions.DisableSubdomainPersistence = val
		}
	}
)
View Source 
var (
	// OptionWebsocketWriteTimeout time allowed to write a message to the connection.
	// Default value is 15 * time.Second
	OptionWebsocketWriteTimeout = func(val time.Duration) OptionSet {
		return func(c *Configuration) {
			c.Websocket.WriteTimeout = val
		}
	}
	// OptionWebsocketPongTimeout allowed to read the next pong message from the connection
	// Default value is 60 * time.Second
	OptionWebsocketPongTimeout = func(val time.Duration) OptionSet {
		return func(c *Configuration) {
			c.Websocket.PongTimeout = val
		}
	}
	// OptionWebsocketPingPeriod send ping messages to the connection with this period. Must be less than PongTimeout
	// Default value is (PongTimeout * 9) / 10
	OptionWebsocketPingPeriod = func(val time.Duration) OptionSet {
		return func(c *Configuration) {
			c.Websocket.PingPeriod = val
		}
	}
	// OptionWebsocketMaxMessageSize max message size allowed from connection
	// Default value is 1024
	OptionWebsocketMaxMessageSize = func(val int64) OptionSet {
		return func(c *Configuration) {
			c.Websocket.MaxMessageSize = val
		}
	}
	// OptionWebsocketBinaryMessages set it to true in order to denotes binary data messages instead of utf-8 text
	// see https://github.com/kataras/iris/issues/387#issuecomment-243006022 for more
	// defaults to false
	OptionWebsocketBinaryMessages = func(val bool) OptionSet {
		return func(c *Configuration) {
			c.Websocket.BinaryMessages = val
		}
	}
	// OptionWebsocketEndpoint is the path which the websocket server will listen for clients/connections
	// Default value is empty string, if you don't set it the Websocket server is disabled.
	OptionWebsocketEndpoint = func(val string) OptionSet {
		return func(c *Configuration) {
			c.Websocket.Endpoint = val
		}
	}
	// OptionWebsocketReadBufferSize is the buffer size for the underline reader
	OptionWebsocketReadBufferSize = func(val int) OptionSet {
		return func(c *Configuration) {
			c.Websocket.ReadBufferSize = val
		}
	}
	// OptionWebsocketWriteBufferSize is the buffer size for the underline writer
	OptionWebsocketWriteBufferSize = func(val int) OptionSet {
		return func(c *Configuration) {
			c.Websocket.WriteBufferSize = val
		}
	}
)
View Source 
var (
	// OptionTesterListeningAddr is the virtual server's listening addr (host)
	// Default is "iris-go.com:1993"
	OptionTesterListeningAddr = func(val string) OptionSet {
		return func(c *Configuration) {
			c.Tester.ListeningAddr = val
		}
	}
	// OptionTesterExplicitURL If true then the url (should) be prepended manually, useful when want to test subdomains
	// Default is false
	OptionTesterExplicitURL = func(val bool) OptionSet {
		return func(c *Configuration) {
			c.Tester.ExplicitURL = val
		}
	}
	// OptionTesterDebug if true then debug messages from the httpexpect will be shown when a test runs
	// Default is false
	OptionTesterDebug = func(val bool) OptionSet {
		return func(c *Configuration) {
			c.Tester.Debug = val
		}
	}
)
View Source 
var (
	OptionServerListeningAddr = func(val string) OptionServerSet {
		return func(c *ServerConfiguration) {
			c.ListeningAddr = val
		}
	}

	OptionServerCertFile = func(val string) OptionServerSet {
		return func(c *ServerConfiguration) {
			c.CertFile = val
		}
	}

	OptionServerKeyFile = func(val string) OptionServerSet {
		return func(c *ServerConfiguration) {
			c.KeyFile = val
		}
	}

	// AutoTLS enable to get certifications from the Letsencrypt
	// when this configuration field is true, the CertFile & KeyFile are empty, no need to provide a key.
	//
	// example: https://github.com/iris-contrib/examples/blob/master/letsencyrpt/main.go
	OptionServerAutoTLS = func(val bool) OptionServerSet {
		return func(c *ServerConfiguration) {
			c.AutoTLS = val
		}
	}

	// Mode this is for unix only
	OptionServerMode = func(val os.FileMode) OptionServerSet {
		return func(c *ServerConfiguration) {
			c.Mode = val
		}
	}

	// OptionServerMaxRequestBodySize Maximum request body size.
	//
	// The server rejects requests with bodies exceeding this limit.
	//
	// By default request body size is 8MB.
	OptionServerMaxRequestBodySize = func(val int) OptionServerSet {
		return func(c *ServerConfiguration) {
			c.MaxRequestBodySize = val
		}
	}

	// Per-connection buffer size for requests' reading.
	// This also limits the maximum header size.
	//
	// Increase this buffer if your clients send multi-KB RequestURIs
	// and/or multi-KB headers (for example, BIG cookies).
	//
	// Default buffer size is used if not set.
	OptionServerReadBufferSize = func(val int) OptionServerSet {
		return func(c *ServerConfiguration) {
			c.ReadBufferSize = val
		}
	}

	// Per-connection buffer size for responses' writing.
	//
	// Default buffer size is used if not set.
	OptionServerWriteBufferSize = func(val int) OptionServerSet {
		return func(c *ServerConfiguration) {
			c.WriteBufferSize = val
		}
	}

	// Maximum duration for reading the full request (including body).
	//
	// This also limits the maximum duration for idle keep-alive
	// connections.
	//
	// By default request read timeout is unlimited.
	OptionServerReadTimeout = func(val time.Duration) OptionServerSet {
		return func(c *ServerConfiguration) {
			c.ReadTimeout = val
		}
	}

	// Maximum duration for writing the full response (including body).
	//
	// By default response write timeout is unlimited.
	OptionServerWriteTimeout = func(val time.Duration) OptionServerSet {
		return func(c *ServerConfiguration) {
			c.WriteTimeout = val
		}
	}

	// RedirectTo, defaults to empty, set it in order to override the station's handler and redirect all requests to this address which is of form(HOST:PORT or :PORT)
	//
	// NOTE: the http status is 'StatusMovedPermanently', means one-time-redirect(the browser remembers the new addr and goes to the new address without need to request something from this server
	// which means that if you want to change this address you have to clear your browser's cache in order this to be able to change to the new addr.
	//
	// example: https://github.com/iris-contrib/examples/tree/master/multiserver_listening2
	OptionServerRedirectTo = func(val string) OptionServerSet {
		return func(c *ServerConfiguration) {
			c.RedirectTo = val
		}
	}

	// OptionServerVirtual If this server is not really listens to a real host, it mostly used in order to achieve testing without system modifications
	OptionServerVirtual = func(val bool) OptionServerSet {
		return func(c *ServerConfiguration) {
			c.Virtual = val
		}
	}
	// OptionServerVListeningAddr, can be used for both virtual = true or false,
	// if it's setted to not empty, then the server's Host() will return this addr instead of the ListeningAddr.
	// server's Host() is used inside global template helper funcs
	// set it when you are sure you know what it does.
	//
	// Default is empty ""
	OptionServerVListeningAddr = func(val string) OptionServerSet {
		return func(c *ServerConfiguration) {
			c.VListeningAddr = val
		}
	}

	// OptionServerVScheme if setted to not empty value then all template's helper funcs prepends that as the url scheme instead of the real scheme
	// server's .Scheme returns VScheme if  not empty && differs from real scheme
	//
	// Default is empty ""
	OptionServerVScheme = func(val string) OptionServerSet {
		return func(c *ServerConfiguration) {
			c.VScheme = val
		}
	}

	// OptionServerName the server's name, defaults to "iris".
	// You're free to change it, but I will trust you to don't, this is the only setting whose somebody, like me, can see if iris web framework is used
	OptionServerName = func(val string) OptionServerSet {
		return func(c *ServerConfiguration) {
			c.ListeningAddr = val
		}
	}
)

Options for ServerConfiguration

View Source 
var (
	Default   *Framework
	Config    *Configuration
	Logger    *log.Logger // if you want colors in your console then you should use this https://github.com/iris-contrib/logger instead.
	Plugins   PluginContainer
	Websocket *WebsocketServer
	// Look ssh.go for this field's configuration
	// example: https://github.com/iris-contrib/examples/blob/master/ssh/main.go
	SSH     *SSHServer
	Servers *ServerList
	// Available is a channel type of bool, fired to true when the server is opened and all plugins ran
	// never fires false, if the .Close called then the channel is re-allocating.
	// the channel is closed only when .ListenVirtual is used, otherwise it remains open until you close it.
	//
	// Note: it is a simple channel and decided to put it here and no inside HTTPServer, doesn't have statuses just true and false, simple as possible
	// Where to use that?
	// this is used on extreme cases when you don't know which .Listen/.ListenVirtual will be called
	// and you want to run/declare something external-not-Iris (all Iris functionality declared before .Listen/.ListenVirtual) AFTER the server is started and plugins finished.
	// see the server_test.go for an example
	Available chan bool
)

Default entry, use it with iris.$anyPublicFunc

View Source 
var (
	// AllMethods "GET", "POST", "PUT", "DELETE", "CONNECT", "HEAD", "PATCH", "OPTIONS", "TRACE"
	AllMethods = [...]string{MethodGet, MethodPost, MethodPut, MethodDelete, MethodConnect, MethodHead, MethodPatch, MethodOptions, MethodTrace}
)
View Source 
var (

	// CookieExpireNever the default cookie's life for sessions, unlimited (23 years)
	CookieExpireNever = time.Now().AddDate(23, 0, 0)
)
View Source 
var (
	// DefaultLoggerOut is the default logger's output
	DefaultLoggerOut = os.Stdout
)
View Source 
var DefaultSSHKeyPath = "iris_rsa"

DefaultSSHKeyPath used if SSH.KeyPath is empty. Defaults to: "iris_rsa". It can be changed.

View Source 
var (
	// DefaultServerAddr the default server addr which is: 0.0.0.0:8080
	DefaultServerAddr = DefaultServerHostname + ":" + strconv.Itoa(DefaultServerPort)
)
View Source 
var (
	// SSHBanner is the banner goes on top of the 'ssh help message'
	// it can be changed, defaults is the Iris's banner
	SSHBanner = banner
)

Functions

func API 

func API(path string, restAPI HandlerAPI, middleware ...HandlerFunc)

API converts & registers a custom struct to the router receives two parameters first is the request path (string) second is the custom struct (interface{}) which can be anything that has a *iris.Context as field. third is the common middlewares, it's optional

Note that API's routes have their default-name to the full registed path, no need to give a special name for it, because it's not supposed to be used inside your templates.

Recommend to use when you retrieve data from an external database, and the router-performance is not the (only) thing which slows the server's overall performance.

This is a slow method, if you care about router-performance use the Handle/HandleFunc/Get/Post/Put/Delete/Trace/Options... instead

func Any 

func Any(registedPath string, handlersFn ...HandlerFunc)

Any registers a route for ALL of the http methods (Get,Post,Put,Head,Patch,Options,Connect,Delete)

func CheckForUpdates 

func CheckForUpdates(force bool)

CheckForUpdates will try to search for newer version of Iris based on the https://github.com/kataras/iris/releases If a newer version found then the app will ask the he dev/user if want to update the 'x' version if 'y' is pressed then the updater will try to install the latest version the updater, will notify the dev/user that the update is finished and should restart the App manually.

func Close 

func Close() error

Close terminates all the registered servers and returns an error if any if you want to panic on this error use the iris.Must(iris.Close())

func DecodeFasthttpURL 

func DecodeFasthttpURL(path string) string

DecodeFasthttpURL returns the path decoded as url useful when you want to pass something to a database and be valid to retrieve it via context.Param use it only for special cases, when the default behavior doesn't suits you.

http://www.blooberry.com/indexdot/html/topics/urlencoding.htm 

Credits to Manish Singh @kryptodev for URLDecode by post issue share code

simple things, if DecodeURL doesn't gives you the results you waited, use this function I know it is not the best way to describe it, but I don't think you will ever need this, it is here for ANY CASE

func DecodeURL 

func DecodeURL(uri string) string

DecodeURL returns the uri parameter as url (string) useful when you want to pass something to a database and be valid to retrieve it via context.Param use it only for special cases, when the default behavior doesn't suits you.

http://www.blooberry.com/indexdot/html/topics/urlencoding.htm it uses just the url.QueryUnescape

func EmitError 

func EmitError(statusCode int, ctx *Context)

EmitError fires a custom http error handler to the client

if no custom error defined with this statuscode, then iris creates one, and once at runtime

func Go 

func Go() error

Go starts the iris station, listens to all registered servers, and prepare only if Virtual

func Listen 

func Listen(addr string)

Listen starts the standalone http server which listens to the addr parameter which as the form of host:port

It panics on error if you need a func to return an error, use the ListenTo

func ListenTLS 

func ListenTLS(addr string, certFile string, keyFile string)

ListenTLS Starts a https server with certificates, if you use this method the requests of the form of 'http://' will fail only https:// connections are allowed which listens to the addr parameter which as the form of host:port

It panics on error if you need a func to return an error, use the ListenTo ex: iris.ListenTLS(":8080","yourfile.cert","yourfile.key")

func ListenTLSAuto 

func ListenTLSAuto(addr string)

ListenTLSAuto starts a server listening at the specific nat address using key & certification taken from the letsencrypt.org 's servers it also starts a second 'http' server to redirect all 'http://$ADDR_HOSTNAME:80' to the' https://$ADDR'

Notes: if you don't want the last feature you should use this method: iris.ListenTo(iris.ServerConfiguration{ListeningAddr: "mydomain.com:443", AutoTLS: true}) it's a blocking function Limit : https://github.com/iris-contrib/letsencrypt/blob/master/lets.go#L142

example: https://github.com/iris-contrib/examples/blob/master/letsencyrpt/main.go

func ListenTo 

func ListenTo(setters ...OptionServerSettter) error

ListenTo listens to a server but accepts the full server's configuration returns an error, you're responsible to handle that ex: ris.ListenTo(iris.ServerConfiguration{ListeningAddr:":8080"}) ex2: err := iris.ListenTo(iris.OptionServerListeningAddr(":8080")) or use the iris.Must(iris.ListenTo(iris.ServerConfiguration{ListeningAddr:":8080"}))

it's a blocking func

func ListenUNIX 

func ListenUNIX(addr string, mode os.FileMode)

ListenUNIX starts the process of listening to the new requests using a 'socket file', this works only on unix

It panics on error if you need a func to return an error, use the ListenTo ex: iris.ListenUNIX(":8080", Mode: os.FileMode)

func Must 

func Must(err error)

Must panics on error, it panics on registed iris' logger

func NewTester 

func NewTester(api *Framework, t *testing.T) *httpexpect.Expect

NewTester Prepares and returns a new test framework based on the api is useful when you need to have more than one test framework for the same iris insttance, otherwise you can use the iris.Tester(t *testing.T)/variable.Tester(t *testing.T)

func OnError 

func OnError(statusCode int, handlerFn HandlerFunc)

OnError registers a custom http error handler

func Path 

func Path(routeName string, args ...interface{}) string

Path used to check arguments with the route's named parameters and return the correct url if parse failed returns empty string

func RouteConflicts 

func RouteConflicts(r *route, with string) bool

RouteConflicts checks for route's middleware conflicts

func SerializeToString 

func SerializeToString(keyOrContentType string, obj interface{}, options ...map[string]interface{}) string

SerializeToString returns the string of a serializer, does not render it to the client returns empty string on error

func ServerParseAddr 

func ServerParseAddr(listeningAddr string) string

ServerParseAddr parses the listening addr and returns this

func Set 

func Set(setters ...OptionSetter)

Set sets an option aka configuration field to the default iris instance

func StatusText 

func StatusText(code int) string

StatusText returns a text for the HTTP status code. It returns the empty string if the code is unknown.

func TemplateSourceString 

func TemplateSourceString(src string, pageContext interface{}) string

TemplateSourceString executes a template source(raw string contents) from the first template engines which supports raw parsing returns its result as string, 

useful when you want it for sending rich e-mails

returns empty string on error

func TemplateString 

func TemplateString(templateFile string, pageContext interface{}, options ...map[string]interface{}) string

TemplateString executes a template from the default template engine and returns its result as string, useful when you want it for sending rich e-mails returns empty string on error

func Tester 

func Tester(t *testing.T) *httpexpect.Expect

Tester returns the test framework for this default insance

func URL 

func URL(routeName string, args ...interface{}) (url string)

URL returns the subdomain+ host + Path(...optional named parameters if route is dynamic) returns an empty string if parse is failed

func Use 

func Use(handlers ...Handler)

Use registers Handler middleware

func UseFunc 

func UseFunc(handlersFn ...HandlerFunc)

UseFunc registers HandlerFunc middleware

func UseGlobal 

func UseGlobal(handlers ...Handler)

UseGlobal registers Handler middleware to the beginning, prepends them instead of append

Use it when you want to add a global middleware to all parties, to all routes in all subdomains It can be called after other, (but before .Listen of course)

func UseGlobalFunc 

func UseGlobalFunc(handlersFn ...HandlerFunc)

UseGlobalFunc registers HandlerFunc middleware to the beginning, prepends them instead of append

Use it when you want to add a global middleware to all parties, to all routes in all subdomains It can be called after other, (but before .Listen of course)

func UseSerializer 

func UseSerializer(forContentType string, e serializer.Serializer)

UseSerializer accepts a Serializer and the key or content type on which the developer wants to register this serializer the gzip and charset are automatically supported by Iris, by passing the iris.RenderOptions{} map on the context.Render context.Render renders this response or a template engine if no response engine with the 'key' found with these engines you can inject the context.JSON,Text,Data,JSONP,XML also to do that just register with UseSerializer(mySerializer,"application/json") and so on look at the https://github.com/kataras/go-serializer for examples

if more than one serializer with the same key/content type exists then the results will be appended to the final request's body this allows the developer to be able to create 'middleware' responses engines

Note: if you pass an engine which contains a dot('.') as key, then the engine will not be registered. you don't have to import and use github.com/iris-contrib/json, jsonp, xml, data, text, markdown because iris uses these by default if no other response engine is registered for these content types

func UseSessionDB 

func UseSessionDB(db sessions.Database)

UseSessionDB registers a session database, you can register more than one accepts a session database which implements a Load(sid string) map[string]interface{} and an Update(sid string, newValues map[string]interface{}) the only reason that a session database will be useful for you is when you want to keep the session's values/data after the app restart a session database doesn't have write access to the session, it doesn't accept the context, so forget 'cookie database' for sessions, I will never allow that, for your protection.

Note: Don't worry if no session database is registered, your context.Session will continue to work.

func UseTemplate 

func UseTemplate(e template.Engine) *template.Loader

UseTemplate adds a template engine to the iris view system it does not build/load them yet

Types

type Action 

type Action func(ssh.Channel)

Action the command's handler

type Command 

type Command struct {
	Name        string
	Description string
	Action      Action
}

Command contains the registered SSH commands contains a Name which is the payload string Description which is the description of the command shows to the admin/user Action is the particular command's handler

type Commands 

type Commands []Command

Commands the SSH Commands, it's just a type of []Command

func (*Commands) Add 

func (c *Commands) Add(cmd ...Command)

Add adds command(s) to the commands list

func (*Commands) ByName 

func (c *Commands) ByName(commandName string) (cmd Command, found bool)

ByName returns the command by its Name if not found returns a zero-value Command and false as the second output parameter.

type Configuration 

type Configuration struct {
	// CheckForUpdates will try to search for newer version of Iris based on the https://github.com/kataras/iris/releases
	// If a newer version found then the app will ask the he dev/user if want to update the 'x' version
	// if 'y' is pressed then the updater will try to install the latest version
	// the updater, will notify the dev/user that the update is finished and should restart the App manually.
	// Notes:
	// 1. Experimental feature
	// 2. If setted to true, the app will have a little startup delay
	// 3. If you as developer edited the $GOPATH/src/github/kataras or any other Iris' Go dependencies at the past
	//    then the update process will fail.
	//
	// Usage: iris.Set(iris.OptionCheckForUpdates(true)) or
	//        iris.Config.CheckForUpdates = true or
	//        app := iris.New(iris.OptionCheckForUpdates(true))
	// Default is false
	CheckForUpdates bool

	// DisablePathCorrection corrects and redirects the requested path to the registed 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,
	// (permant)redirects the client to the correct path /home
	//
	// Default is false
	DisablePathCorrection bool

	// DisablePathEscape when is false then its escapes the path, the named parameters (if any).
	// Change to true it if you want something like this https://github.com/kataras/iris/issues/135 to work
	//
	// When do you need to Disable(true) 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").
	// Look here: https://github.com/kataras/iris/issues/135 for more
	//
	// Default is false
	DisablePathEscape bool

	// DisableBanner outputs the iris banner at startup
	//
	// Default is false
	DisableBanner bool

	// LoggerOut is the destination for output
	//
	// Default is os.Stdout
	LoggerOut io.Writer
	// LoggerPreffix is the logger's prefix to write at beginning of each line
	//
	// Default is [IRIS]
	LoggerPreffix string

	// ProfilePath a the route path, set it to enable http pprof tool
	// Default is empty, if you set it to a $path, these routes will handled:
	// $path/cmdline
	// $path/profile
	// $path/symbol
	// $path/goroutine
	// $path/heap
	// $path/threadcreate
	// $path/pprof/block
	// for example if '/debug/pprof'
	// http://yourdomain:PORT/debug/pprof/
	// http://yourdomain:PORT/debug/pprof/cmdline
	// http://yourdomain:PORT/debug/pprof/profile
	// http://yourdomain:PORT/debug/pprof/symbol
	// http://yourdomain:PORT/debug/pprof/goroutine
	// http://yourdomain:PORT/debug/pprof/heap
	// http://yourdomain:PORT/debug/pprof/threadcreate
	// http://yourdomain:PORT/debug/pprof/pprof/block
	// it can be a subdomain also, for example, if 'debug.'
	// http://debug.yourdomain:PORT/
	// http://debug.yourdomain:PORT/cmdline
	// http://debug.yourdomain:PORT/profile
	// http://debug.yourdomain:PORT/symbol
	// http://debug.yourdomain:PORT/goroutine
	// http://debug.yourdomain:PORT/heap
	// http://debug.yourdomain:PORT/threadcreate
	// http://debug.yourdomain:PORT/pprof/block
	ProfilePath string

	// DisableTemplateEngines set to true to disable loading the default template engine (html/template) and disallow the use of iris.UseEngine
	// default is false
	DisableTemplateEngines bool

	// IsDevelopment iris will act like a developer, for example
	// If true then re-builds the templates on each request
	// default is false
	IsDevelopment bool

	// TimeFormat time format for any kind of datetime parsing
	TimeFormat string

	// Charset character encoding for various rendering
	// used for templates and the rest of the responses
	// defaults to "UTF-8"
	Charset string

	// Gzip enables gzip compression on your Render actions, this includes any type of render, templates and pure/raw content
	// If you don't want to enable it globaly, you could just use the third parameter on context.Render("myfileOrResponse", structBinding{}, iris.RenderOptions{"gzip": true})
	// defaults to false
	Gzip bool

	// Sessions contains the configs for sessions
	Sessions SessionsConfiguration

	// Websocket contains the configs for Websocket's server integration
	Websocket WebsocketConfiguration

	// Tester contains the configs for the test framework, so far we have only one because all test framework's configs are setted by the iris itself
	// You can find example on the https://github.com/kataras/iris/glob/master/context_test.go
	Tester TesterConfiguration

	// Other are the custom, dynamic options, can be empty
	// this fill used only by you to set any app's options you want
	// for each of an Iris instance
	Other options.Options
}

Configuration the whole configuration for an iris instance ($instance.Config) or global iris instance (iris.Config) these can be passed via options also, look at the top of this file(configuration.go)

Configuration is also implements the OptionSet so it's a valid option itself, this is briliant enough

func DefaultConfiguration 

func DefaultConfiguration() Configuration

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

func (Configuration) Set 

func (c Configuration) Set(main *Configuration)

Set implements the OptionSetter

type Context 

type Context struct {
	*fasthttp.RequestCtx
	Params PathParameters
	// contains filtered or unexported fields
}

Context is resetting every time a request is coming to the server it is not good practice to use this object in goroutines, for these cases use the .Clone()

func (*Context) Data 

func (ctx *Context) Data(status int, v []byte) error

Data writes out the raw bytes as binary data.

func (*Context) Do 

func (ctx *Context) Do()

Do calls the first handler only, it's like Next with negative pos, used only on Router&MemoryRouter

func (*Context) EmitError 

func (ctx *Context) EmitError(statusCode int)

EmitError executes the custom error by the http status code passed to the function

func (*Context) FormValueString 

func (ctx *Context) FormValueString(name string) string

FormValueString returns a single value, as string, from post request's data

func (*Context) FormValues 

func (ctx *Context) FormValues(name string) []string

FormValues returns a slice of string from post request's data

func (*Context) Framework 

func (ctx *Context) Framework() *Framework

Framework returns the Iris instance, containing the configuration and all other fields

func (*Context) Get 

func (ctx *Context) Get(key string) interface{}

Get returns the user's value from a key if doesn't exists returns nil

func (*Context) GetCookie 

func (ctx *Context) GetCookie(name string) (val string)

GetCookie returns cookie's value by it's name returns empty string if nothing was found

func (*Context) GetFlash 

func (ctx *Context) GetFlash(key string) (string, error)

GetFlash get a flash message by it's key returns the value as string and an error

if the cookie doesn't exists the string is empty and the error is filled after the request's life the value is removed

func (*Context) GetFlashes 

func (ctx *Context) GetFlashes() map[string]string

GetFlashes returns all the flash messages for available for this request

func (*Context) GetFmt 

func (ctx *Context) GetFmt(key string) func(format string, args ...interface{}) string

GetFmt returns a value which has this format: func(format string, args ...interface{}) string if doesn't exists returns nil

func (*Context) GetHandlerName 

func (ctx *Context) GetHandlerName() string

GetHandlerName as requested returns the stack-name of the function which the Middleware is setted from

func (*Context) GetInt 

func (ctx *Context) GetInt(key string) int

GetInt same as Get but returns the value as int if nothing founds returns -1

func (*Context) GetRequestCtx 

func (ctx *Context) GetRequestCtx() *fasthttp.RequestCtx

GetRequestCtx returns the current fasthttp context

func (*Context) GetString 

func (ctx *Context) GetString(key string) string

GetString same as Get but returns the value as string if nothing founds returns empty string ""

func (*Context) Gzip 

func (ctx *Context) Gzip(b []byte, status int)

Gzip accepts bytes, which are compressed to gzip format and sent to the client

func (*Context) HTML 

func (ctx *Context) HTML(status int, htmlContents string)

HTML writes html string with a http status

func (*Context) HostString 

func (ctx *Context) HostString() string

HostString returns the Host of the request( the url as string )

func (*Context) IsAjax 

func (ctx *Context) IsAjax() bool

IsAjax returns true if this request is an 'ajax request'( XMLHttpRequest)

Read more at: http://www.w3schools.com/ajax/

func (*Context) IsStopped 

func (ctx *Context) IsStopped() bool

IsStopped checks and returns true if the current position of the Context is 255, means that the StopExecution has called

func (*Context) JSON 

func (ctx *Context) JSON(status int, v interface{}) error

JSON marshals the given interface object and writes the JSON response.

func (*Context) JSONP 

func (ctx *Context) JSONP(status int, callback string, v interface{}) error

JSONP marshals the given interface object and writes the JSON response.

func (*Context) Log 

func (ctx *Context) Log(format string, a ...interface{})

Log logs to the iris defined logger

func (*Context) Markdown 

func (ctx *Context) Markdown(status int, markdown string)

Markdown parses and renders to the client a particular (dynamic) markdown string accepts two parameters first is the http status code second is the markdown string

func (*Context) MarkdownString 

func (ctx *Context) MarkdownString(markdownText string) string

MarkdownString parses the (dynamic) markdown string and returns the converted html string

func (*Context) MethodString 

func (ctx *Context) MethodString() string

MethodString returns the HTTP Method

func (*Context) MustRender 

func (ctx *Context) MustRender(name string, binding interface{}, options ...map[string]interface{})

MustRender same as .Render but returns 500 internal server http status (error) if rendering fail builds up the response from the specified template or a serialize engine. Note: the options: "gzip" and "charset" are built'n support by Iris, so you can pass these on any template engine or serialize engine

func (*Context) Next 

func (ctx *Context) Next()

Next calls all the next handler from the middleware stack, it used inside a middleware

func (*Context) NotFound 

func (ctx *Context) NotFound()

NotFound emits an error 404 to the client, using the custom http errors if no custom errors provided then it sends the default error message

func (*Context) Panic 

func (ctx *Context) Panic()

Panic emits an error 500 to the client, using the custom http errors if no custom errors rpovided then it sends the default error message

func (*Context) Param 

func (ctx *Context) Param(key string) string

Param returns the string representation of the key's path named parameter's value

func (*Context) ParamInt 

func (ctx *Context) ParamInt(key string) (int, error)

ParamInt returns the int representation of the key's path named parameter's value

func (*Context) ParamInt64 

func (ctx *Context) ParamInt64(key string) (int64, error)

ParamInt64 returns the int64 representation of the key's path named parameter's value

func (*Context) PathString 

func (ctx *Context) PathString() string

PathString returns the full escaped path as string for unescaped use: ctx.RequestCtx.RequestURI() or RequestPath(escape bool)

func (*Context) PostValue 

func (ctx *Context) PostValue(name string) string

PostValue returns the post data value of a single key/name returns an empty string if nothing found

func (*Context) PostValues 

func (ctx *Context) PostValues(name string) []string

PostValues returns the post data values as []string of a single key/name

func (*Context) PostValuesAll 

func (ctx *Context) PostValuesAll() (valuesAll map[string][]string)

PostValuesAll returns all post data values with their keys multipart, form data, get & post query arguments

func (*Context) ReadForm 

func (ctx *Context) ReadForm(formObject interface{}) error

ReadForm binds the formObject with the form data it supports any kind of struct

func (*Context) ReadJSON 

func (ctx *Context) ReadJSON(jsonObject interface{}) error

ReadJSON reads JSON from request's body

func (*Context) ReadXML 

func (ctx *Context) ReadXML(xmlObject interface{}) error

ReadXML reads XML from request's body

func (*Context) Redirect 

func (ctx *Context) Redirect(urlToRedirect string, statusHeader ...int)

Redirect redirect sends a redirect response the client accepts 2 parameters string and an optional int first parameter is the url to redirect second parameter is the http status should send, default is 302 (StatusFound), you can set it to 301 (Permant redirect), if that's nessecery

func (*Context) RedirectTo 

func (ctx *Context) RedirectTo(routeName string, args ...interface{})

RedirectTo does the same thing as Redirect but instead of receiving a uri or path it receives a route name

func (*Context) RemoteAddr 

func (ctx *Context) RemoteAddr() string

RemoteAddr is like RequestIP but it checks for proxy servers also, tries to get the real client's request IP

func (*Context) RemoveCookie 

func (ctx *Context) RemoveCookie(name string)

RemoveCookie deletes a cookie by it's name/key

func (*Context) Render 

func (ctx *Context) Render(name string, binding interface{}, options ...map[string]interface{}) error

Render same as .RenderWithStatus but with status to iris.StatusOK (200) if no previous status exists builds up the response from the specified template or a serialize engine. Note: the options: "gzip" and "charset" are built'n support by Iris, so you can pass these on any template engine or serialize engine

func (*Context) RenderTemplateSource 

func (ctx *Context) RenderTemplateSource(status int, src string, binding interface{}, options ...map[string]interface{}) error

RenderTemplateSource serves a template source(raw string contents) from the first template engines which supports raw parsing returns its result as string

func (*Context) RenderWithStatus 

func (ctx *Context) RenderWithStatus(status int, name string, binding interface{}, options ...map[string]interface{}) (err error)

RenderWithStatus builds up the response from the specified template or a serialize engine. Note: the options: "gzip" and "charset" are built'n support by Iris, so you can pass these on any template engine or serialize engines

func (*Context) RequestHeader 

func (ctx *Context) RequestHeader(k string) string

RequestHeader returns the request header's value accepts one parameter, the key of the header (string) returns string

func (*Context) RequestIP 

func (ctx *Context) RequestIP() string

RequestIP gets just the Remote Address from the client.

func (*Context) RequestPath 

func (ctx *Context) RequestPath(escape bool) string

RequestPath returns the requested path

func (*Context) SendFile 

func (ctx *Context) SendFile(filename string, destinationName string)

SendFile sends file for force-download to the client

Use this instead of ServeFile to 'force-download' bigger files to the client

func (*Context) ServeContent 

func (ctx *Context) ServeContent(content io.ReadSeeker, filename string, modtime time.Time, gzipCompression bool) error

ServeContent serves content, headers are autoset receives three parameters, it's low-level function, instead you can use .ServeFile(string,bool)/SendFile(string,string)

You can define your own "Content-Type" header also, after this function call Doesn't implements resuming (by range), use ctx.SendFile instead

func (*Context) ServeFile 

func (ctx *Context) ServeFile(filename string, gzipCompression bool) error

ServeFile serves a view file, to send a file ( zip for example) to the client you should use the SendFile(serverfilename,clientfilename) receives two parameters filename/path (string) gzipCompression (bool)

You can define your own "Content-Type" header also, after this function call This function doesn't implement resuming (by range), use ctx.SendFile/fasthttp.ServeFileUncompressed(ctx.RequestCtx,path)/fasthttpServeFile(ctx.RequestCtx,path) instead

Use it when you want to serve css/js/... files to the client, for bigger files and 'force-download' use the SendFile

func (*Context) Session 

func (ctx *Context) Session() sessions.Session

Session returns the current session

func (*Context) SessionDestroy 

func (ctx *Context) SessionDestroy()

SessionDestroy destroys the whole session, calls the provider's destroy and remove the cookie

func (*Context) Set 

func (ctx *Context) Set(key string, value interface{})

Set sets a value to a key in the values map

func (*Context) SetContentType 

func (ctx *Context) SetContentType(s string)

SetContentType sets the response writer's header key 'Content-Type' to a given value(s)

func (*Context) SetCookie 

func (ctx *Context) SetCookie(cookie *fasthttp.Cookie)

SetCookie adds a cookie

func (*Context) SetCookieKV 

func (ctx *Context) SetCookieKV(key, value string)

SetCookieKV adds a cookie, receives just a key(string) and a value(string)

func (*Context) SetFlash 

func (ctx *Context) SetFlash(key string, value string)

SetFlash sets a flash message, accepts 2 parameters the key(string) and the value(string) the value will be available on the NEXT request

func (*Context) SetHeader 

func (ctx *Context) SetHeader(k string, v string)

SetHeader write to the response writer's header to a given key the given value(s)

Note: If you want to send a multi-line string as header's value use: strings.TrimSpace first.

func (*Context) StopExecution 

func (ctx *Context) StopExecution()

StopExecution just sets the .pos to 255 in order to not move to the next middlewares(if any)

func (*Context) Stream 

func (ctx *Context) Stream(cb func(writer *bufio.Writer))

Stream same as StreamWriter

func (*Context) StreamReader 

func (ctx *Context) StreamReader(bodyStream io.Reader, bodySize int)

StreamReader sets response body stream and, optionally body size.

If bodySize is >= 0, then the bodyStream must provide exactly bodySize bytes before returning io.EOF.

If bodySize < 0, then bodyStream is read until io.EOF.

bodyStream.Close() is called after finishing reading all body data if it implements io.Closer.

See also StreamReader.

func (*Context) StreamWriter 

func (ctx *Context) StreamWriter(cb func(writer *bufio.Writer))

StreamWriter registers the given stream writer for populating response body.

This function may be used in the following cases:

  • if response body is too big (more than 10MB).
  • if response body is streamed from slow external sources.
  • if response body must be streamed to the client in chunks. (aka `http server push`).

func (*Context) Subdomain 

func (ctx *Context) Subdomain() (subdomain string)

Subdomain returns the subdomain (string) of this request, if any

func (*Context) TemplateString 

func (ctx *Context) TemplateString(name string, binding interface{}, options ...map[string]interface{}) string

TemplateString accepts a template filename, its context data and returns the result of the parsed template (string) if any error returns empty string

func (*Context) Text 

func (ctx *Context) Text(status int, v string) error

Text writes out a string as plain text.

func (*Context) URLParam 

func (ctx *Context) URLParam(key string) string

URLParam returns the get parameter from a request , if any

func (*Context) URLParamInt 

func (ctx *Context) URLParamInt(key string) (int, error)

URLParamInt returns the url query parameter as int value from a request , returns error on parse fail

func (*Context) URLParamInt64 

func (ctx *Context) URLParamInt64(key string) (int64, error)

URLParamInt64 returns the url query parameter as int64 value from a request , returns error on parse fail

func (*Context) URLParams 

func (ctx *Context) URLParams() map[string]string

URLParams returns a map of a list of each url(query) parameter

func (*Context) VirtualHostname 

func (ctx *Context) VirtualHostname() string

VirtualHostname returns the hostname that user registers, host path maybe differs from the real which is HostString, which taken from a net.listener

func (*Context) VisitAllCookies 

func (ctx *Context) VisitAllCookies(visitor func(key string, value string))

VisitAllCookies takes a visitor which loops on each (request's) cookie key and value

Note: the method ctx.Request.Header.VisitAllCookie by fasthttp, has a strange bug which I cannot solve at the moment. This is the reason which this function exists and should be used instead of fasthttp's built'n.

func (*Context) Write 

func (ctx *Context) Write(format string, a ...interface{})

Write writes a string to the client, something like fmt.Printf but for the web

func (*Context) XML 

func (ctx *Context) XML(status int, v interface{}) error

XML marshals the given interface object and writes the XML response.

type Framework 

type Framework struct {
	Config *Configuration

	// fields which are useful to the user/dev
	// the last  added server is the main server
	Servers *ServerList
	// configuration by instance.Logger.Config
	Logger    *log.Logger
	Plugins   PluginContainer
	Websocket *WebsocketServer
	SSH       *SSHServer
	Available chan bool
	// contains filtered or unexported fields
}

Framework is our God |\| Google.Search('Greek mythology Iris')

Implements the FrameworkAPI

func New 

func New(setters ...OptionSetter) *Framework

New creates and returns a new Iris instance.

Receives (optional) multi options, use iris.Option and your editor should show you the available options to set all options are inside ./configuration.go example 1: iris.New(iris.OptionIsDevelopment(true), iris.OptionCharset("UTF-8"), irisOptionSessionsCookie("mycookieid"),iris.OptionWebsocketEndpoint("my_endpoint")) example 2: iris.New(iris.Configuration{IsDevelopment:true, Charset: "UTF-8", Sessions: iris.SessionsConfiguration{Cookie:"mycookieid"}, Websocket: iris.WebsocketConfiguration{Endpoint:"/my_endpoint"}}) both ways are totally valid and equal

func (Framework) API 

func (api Framework) API(path string, restAPI HandlerAPI, middleware ...HandlerFunc)

API converts & registers a custom struct to the router receives two parameters first is the request path (string) second is the custom struct (interface{}) which can be anything that has a *iris.Context as field. third is the common middleware, it's optional

Note that API's routes have their default-name to the full registed path, no need to give a special name for it, because it's not supposed to be used inside your templates.

Recommend to use when you retrieve data from an external database, and the router-performance is not the (only) thing which slows the server's overall performance.

This is a slow method, if you care about router-performance use the Handle/HandleFunc/Get/Post/Put/Delete/Trace/Options... instead

func (*Framework) AddServer 

func (s *Framework) AddServer(setters ...OptionServerSettter) *Server

AddServer same as .Servers.Add(ServerConfiguration)

AddServer starts a server which listens to this station Note that the view engine's functions {{ url }} and {{ urlpath }} will return the last registered server's scheme (http/https)

this is useful mostly when you want to have two or more listening ports ( two or more servers ) for the same station

receives one parameter which is the ServerConfiguration for the new server returns the new standalone server( you can close this server by the returning reference)

If you need only one server you can use the blocking-funcs: .Listen/ListenTLS/ListenUNIX/ListenTo

this is a NOT A BLOCKING version, the main .Listen/ListenTLS/ListenUNIX/ListenTo should be always executed LAST, so this function goes before the main .Listen/ListenTLS/ListenUNIX/ListenTo

func (Framework) Any 

func (api Framework) Any(registedPath string, handlersFn ...HandlerFunc)

Any registers a route for ALL of the http methods (Get,Post,Put,Head,Patch,Options,Connect,Delete)

func (*Framework) CheckForUpdates 

func (s *Framework) CheckForUpdates(force bool)

CheckForUpdates will try to search for newer version of Iris based on the https://github.com/kataras/iris/releases If a newer version found then the app will ask the he dev/user if want to update the 'x' version if 'y' is pressed then the updater will try to install the latest version the updater, will notify the dev/user that the update is finished and should restart the App manually. Note: exported func CheckForUpdates exists because of the reason that an update can be executed while Iris is running

func (*Framework) Close 

func (s *Framework) Close() error

Close terminates all the registered servers and returns an error if any if you want to panic on this error use the iris.Must(iris.Close())

func (Framework) Connect 

func (api Framework) Connect(path string, handlersFn ...HandlerFunc) RouteNameFunc

Connect registers a route for the Connect http method

func (Framework) Delete 

func (api Framework) Delete(path string, handlersFn ...HandlerFunc) RouteNameFunc

Delete registers a route for the Delete http method

func (Framework) Done 

func (api Framework) Done(handlers ...Handler) MuxAPI

Done registers Handler 'middleware' the only difference from .Use is that it should be used BEFORE any party route registered or AFTER ALL party's routes have been registered.

returns itself

func (Framework) DoneFunc 

func (api Framework) DoneFunc(handlersFn ...HandlerFunc) MuxAPI

Done registers HandlerFunc 'middleware' the only difference from .Use is that it should be used BEFORE any party route registered or AFTER ALL party's routes have been registered.

returns itself

func (Framework) EmitError 

func (api Framework) EmitError(statusCode int, ctx *Context)

EmitError fires a custom http error handler to the client

if no custom error defined with this statuscode, then iris creates one, and once at runtime

func (Framework) Favicon 

func (api Framework) Favicon(favPath string, requestPath ...string) RouteNameFunc

Favicon serves static favicon accepts 2 parameters, second is optional favPath (string), declare the system directory path of the __.ico requestPath (string), it's the route's path, by default this is the "/favicon.ico" because some browsers tries to get this by default first, you can declare your own path if you have more than one favicon (desktop, mobile and so on)

this func will add a route for you which will static serve the /yuorpath/yourfile.ico to the /yourfile.ico (nothing special that you can't handle by yourself) Note that you have to call it on every favicon you have to serve automatically (dekstop, mobile and so on)

panics on error

func (Framework) Get 

func (api Framework) Get(path string, handlersFn ...HandlerFunc) RouteNameFunc

Get registers a route for the Get http method

func (*Framework) Go 

func (s *Framework) Go() error

Go starts the iris station, listens to all registered servers, and prepare only if Virtual

func (Framework) H_ 

func (api Framework) H_(method string, registedPath string, fn func(context.IContext)) func(string)

H_ is used to convert a context.IContext handler func to iris.HandlerFunc, is used only inside iris internal package to avoid import cycles

func (Framework) Handle 

func (api Framework) Handle(method string, registedPath string, handlers ...Handler) RouteNameFunc

Handle registers a route to the server's router if empty method is passed then registers handler(s) for all methods, same as .Any, but returns nil as result

func (Framework) HandleFunc 

func (api Framework) HandleFunc(method string, registedPath string, handlersFn ...HandlerFunc) RouteNameFunc

HandleFunc registers and returns a route with a method string, path string and a handler registedPath is the relative url path

func (Framework) Head 

func (api Framework) Head(path string, handlersFn ...HandlerFunc) RouteNameFunc

Head registers a route for the Head http method

func (Framework) Layout 

func (api Framework) Layout(tmplLayoutFile string) MuxAPI

Layout oerrides the parent template layout with a more specific layout for this Party returns this Party, to continue as normal example: my := iris.Party("/my").Layout("layouts/mylayout.html") 

{
	my.Get("/", func(ctx *iris.Context) {
		ctx.MustRender("page1.html", nil)
	})
}

func (*Framework) Listen 

func (s *Framework) Listen(addr string)

Listen starts the standalone http server which listens to the addr parameter which as the form of host:port

It panics on error if you need a func to return an error, use the ListenTo

func (*Framework) ListenTLS 

func (s *Framework) ListenTLS(addr string, certFile, keyFile string)

ListenTLS Starts a https server with certificates, if you use this method the requests of the form of 'http://' will fail only https:// connections are allowed which listens to the addr parameter which as the form of host:port

It panics on error if you need a func to return an error, use the ListenTo ex: iris.ListenTLS(":8080","yourfile.cert","yourfile.key")

func (*Framework) ListenTLSAuto 

func (s *Framework) ListenTLSAuto(addr string)

ListenTLSAuto starts a server listening at the specific nat address using key & certification taken from the letsencrypt.org 's servers it also starts a second 'http' server to redirect all 'http://$ADDR_HOSTNAME:80' to the' https://$ADDR'

Notes: if you don't want the last feature you should use this method: iris.ListenTo(iris.ServerConfiguration{ListeningAddr: "mydomain.com:443", AutoTLS: true}) it's a blocking function Limit : https://github.com/iris-contrib/letsencrypt/blob/master/lets.go#L142

example: https://github.com/iris-contrib/examples/blob/master/letsencyrpt/main.go

func (*Framework) ListenTo 

func (s *Framework) ListenTo(setters ...OptionServerSettter) (err error)

ListenTo listens to a server but acceots the full server's configuration returns an error, you're responsible to handle that ex: ris.ListenTo(iris.ServerConfiguration{ListeningAddr:":8080"}) ex2: err := iris.ListenTo(iris.OptionServerListeningAddr(":8080")) or use the iris.Must(iris.ListenTo(iris.ServerConfiguration{ListeningAddr:":8080"}))

it's a blocking func

func (*Framework) ListenUNIX 

func (s *Framework) ListenUNIX(addr string, mode os.FileMode)

ListenUNIX starts the process of listening to the new requests using a 'socket file', this works only on unix

It panics on error if you need a func to return an error, use the ListenTo ex: ris.ListenUNIX(":8080", Mode: os.FileMode)

func (*Framework) ListenVirtual 

func (s *Framework) ListenVirtual(optionalAddr ...string) *Server

ListenVirtual is useful only when you want to test Iris, it doesn't starts the server but it configures and returns it initializes the whole framework but server doesn't listens to a specific net.Listener it is not blocking the app

func (*Framework) Lookup 

func (s *Framework) Lookup(routeName string) Route

Lookup returns a registed route by its name

func (*Framework) Lookups 

func (s *Framework) Lookups() (routes []Route)

Lookups returns all registed routes

func (*Framework) Must 

func (s *Framework) Must(err error)

Must panics on error, it panics on registed iris' logger

func (Framework) OnError 

func (api Framework) OnError(statusCode int, handlerFn HandlerFunc)

OnError registers a custom http error handler

func (Framework) Options 

func (api Framework) Options(path string, handlersFn ...HandlerFunc) RouteNameFunc

Options registers a route for the Options http method

func (Framework) Party 

func (api Framework) Party(relativePath string, handlersFn ...HandlerFunc) MuxAPI

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

func (Framework) Patch 

func (api Framework) Patch(path string, handlersFn ...HandlerFunc) RouteNameFunc

Patch registers a route for the Patch http method

func (*Framework) Path 

func (s *Framework) Path(routeName string, args ...interface{}) string

Path used to check arguments with the route's named parameters and return the correct url if parse failed returns empty string

func (Framework) Post 

func (api Framework) Post(path string, handlersFn ...HandlerFunc) RouteNameFunc

Post registers a route for the Post http method

func (Framework) Put 

func (api Framework) Put(path string, handlersFn ...HandlerFunc) RouteNameFunc

Put registers a route for the Put http method

func (*Framework) SerializeToString 

func (s *Framework) SerializeToString(keyOrContentType string, obj interface{}, options ...map[string]interface{}) string

SerializeToString returns the string of a serializer, does not render it to the client returns empty string on error

func (*Framework) Set 

func (s *Framework) Set(setters ...OptionSetter)

Set sets an option aka configuration field to this iris instance

func (Framework) Static 

func (api Framework) Static(relative string, systemPath string, stripSlashes int) RouteNameFunc

Static registers a route which serves a system directory this doesn't generates an index page which list all files no compression is used also, for these features look at StaticFS func accepts three parameters first parameter is the request url path (string) second parameter is the system directory (string) third parameter is the level (int) of stripSlashes * stripSlashes = 0, original path: "/foo/bar", result: "/foo/bar" * stripSlashes = 1, original path: "/foo/bar", result: "/bar" * stripSlashes = 2, original path: "/foo/bar", result: ""

func (Framework) StaticContent 

func (api Framework) StaticContent(reqPath string, cType string, content []byte) RouteNameFunc

StaticContent serves bytes, memory cached, on the reqPath a good example of this is how the websocket server uses that to auto-register the /iris-ws.js

func (Framework) StaticFS 

func (api Framework) StaticFS(reqPath string, systemPath string, stripSlashes int) RouteNameFunc

StaticFS registers a route which serves a system directory this is the fastest method to serve static files generates an index page which list all files if you use this method it will generate compressed files also think this function as small fileserver with http accepts three parameters first parameter is the request url path (string) second parameter is the system directory (string) third parameter is the level (int) of stripSlashes * stripSlashes = 0, original path: "/foo/bar", result: "/foo/bar" * stripSlashes = 1, original path: "/foo/bar", result: "/bar" * stripSlashes = 2, original path: "/foo/bar", result: ""

func (Framework) StaticHandler 

func (api Framework) StaticHandler(systemPath string, stripSlashes int, compress bool, generateIndexPages bool, indexNames []string) HandlerFunc

StaticHandler returns a Handler to serve static system directory Accepts 5 parameters

first is the systemPath (string) Path to the root directory to serve files from.

second is the stripSlashes (int) level * stripSlashes = 0, original path: "/foo/bar", result: "/foo/bar" * stripSlashes = 1, original path: "/foo/bar", result: "/bar" * stripSlashes = 2, original path: "/foo/bar", result: ""

third is the compress (bool) Transparently compresses responses if set to true.

The server tries minimizing CPU usage by caching compressed files. It adds fasthttp.FSCompressedFileSuffix suffix to the original file name and tries saving the resulting compressed file under the new file name. So it is advisable to give the server write access to Root and to all inner folders in order to minimze CPU usage when serving compressed responses.

fourth is the generateIndexPages (bool) Index pages for directories without files matching IndexNames are automatically generated if set.

Directory index generation may be quite slow for directories with many files (more than 1K), so it is discouraged enabling index pages' generation for such directories.

fifth is the indexNames ([]string) List of index file names to try opening during directory access.

For example:

  • index.html
  • index.htm
  • my-super-index.xml

func (Framework) StaticServe 

func (api Framework) StaticServe(systemPath string, requestPath ...string) RouteNameFunc

StaticServe serves a directory as web resource it's the simpliest form of the Static* functions Almost same usage as StaticWeb accepts only one required parameter which is the systemPath ( the same path will be used to register the GET&HEAD routes) if second parameter is empty, otherwise the requestPath is the second parameter it uses gzip compression (compression on each request, no file cache)

func (Framework) StaticWeb 

func (api Framework) StaticWeb(reqPath string, systemPath string, stripSlashes int) RouteNameFunc

StaticWeb same as Static but if index.html exists and request uri is '/' then display the index.html's contents accepts three parameters first parameter is the request url path (string) second parameter is the system directory (string) third parameter is the level (int) of stripSlashes * stripSlashes = 0, original path: "/foo/bar", result: "/foo/bar" * stripSlashes = 1, original path: "/foo/bar", result: "/bar" * stripSlashes = 2, original path: "/foo/bar", result: "" * if you don't know what to put on stripSlashes just 1 example: https://github.com/iris-contrib/examples/tree/master/static_web

func (*Framework) TemplateSourceString 

func (s *Framework) TemplateSourceString(src string, pageContext interface{}) string

TemplateSourceString executes a template source(raw string contents) from the first template engines which supports raw parsing returns its result as string, 

useful when you want it for sending rich e-mails

returns empty string on error

func (*Framework) TemplateString 

func (s *Framework) TemplateString(templateFile string, pageContext interface{}, options ...map[string]interface{}) string

TemplateString executes a template from the default template engine and returns its result as string, useful when you want it for sending rich e-mails returns empty string on error

func (*Framework) Tester 

func (s *Framework) Tester(t *testing.T) *httpexpect.Expect

Tester returns the test framework for this iris insance

func (Framework) Trace 

func (api Framework) Trace(path string, handlersFn ...HandlerFunc) RouteNameFunc

Trace registers a route for the Trace http method

func (*Framework) URL 

func (s *Framework) URL(routeName string, args ...interface{}) (url string)

URL returns the subdomain+ host + Path(...optional named parameters if route is dynamic) returns an empty string if parse is failed

func (Framework) Use 

func (api Framework) Use(handlers ...Handler)

Use registers Handler middleware

func (Framework) UseFunc 

func (api Framework) UseFunc(handlersFn ...HandlerFunc)

UseFunc registers HandlerFunc middleware

func (*Framework) UseGlobal 

func (s *Framework) UseGlobal(handlers ...Handler)

UseGlobal registers Handler middleware to the beginning, prepends them instead of append

Use it when you want to add a global middleware to all parties, to all routes in all subdomains It can be called after other, (but before .Listen of course)

func (*Framework) UseGlobalFunc 

func (s *Framework) UseGlobalFunc(handlersFn ...HandlerFunc)

UseGlobalFunc registers HandlerFunc middleware to the beginning, prepends them instead of append

Use it when you want to add a global middleware to all parties, to all routes in all subdomains It can be called after other, (but before .Listen of course)

func (*Framework) UseSerializer 

func (s *Framework) UseSerializer(forContentType string, e serializer.Serializer)

UseSerializer accepts a Serializer and the key or content type on which the developer wants to register this serializer the gzip and charset are automatically supported by Iris, by passing the iris.RenderOptions{} map on the context.Render context.Render renders this response or a template engine if no response engine with the 'key' found with these engines you can inject the context.JSON,Text,Data,JSONP,XML also to do that just register with UseSerializer(mySerializer,"application/json") and so on look at the https://github.com/kataras/go-serializer for examples

if more than one serializer with the same key/content type exists then the results will be appended to the final request's body this allows the developer to be able to create 'middleware' responses engines

Note: if you pass an engine which contains a dot('.') as key, then the engine will not be registered. you don't have to import and use github.com/iris-contrib/json, jsonp, xml, data, text, markdown because iris uses these by default if no other response engine is registered for these content types

func (*Framework) UseSessionDB 

func (s *Framework) UseSessionDB(db sessions.Database)

UseSessionDB registers a session database, you can register more than one accepts a session database which implements a Load(sid string) map[string]interface{} and an Update(sid string, newValues map[string]interface{}) the only reason that a session database will be useful for you is when you want to keep the session's values/data after the app restart a session database doesn't have write access to the session, it doesn't accept the context, so forget 'cookie database' for sessions, I will never allow that, for your protection.

Note: Don't worry if no session database is registered, your context.Session will continue to work.

func (*Framework) UseTemplate 

func (s *Framework) UseTemplate(e template.Engine) *template.Loader

UseTemplate adds a template engine to the iris view system it does not build/load them yet

type FrameworkAPI 

type FrameworkAPI interface {
	MuxAPI
	Set(...OptionSetter)
	CheckForUpdates(bool)
	Must(error)
	AddServer(...OptionServerSettter) *Server
	ListenTo(...OptionServerSettter) error
	Listen(string)
	ListenTLS(string, string, string)
	ListenUNIX(string, os.FileMode)
	ListenVirtual(...string) *Server
	Go() error
	Close() error
	UseSessionDB(sessions.Database)
	UseSerializer(string, serializer.Serializer)
	UseTemplate(template.Engine) *template.Loader
	UseGlobal(...Handler)
	UseGlobalFunc(...HandlerFunc)
	Lookup(string) Route
	Lookups() []Route
	Path(string, ...interface{}) string
	URL(string, ...interface{}) string
	TemplateString(string, interface{}, ...map[string]interface{}) string
	TemplateSourceString(string, interface{}) string
	SerializeToString(string, interface{}, ...map[string]interface{}) string
	Tester(*testing.T) *httpexpect.Expect
}

FrameworkAPI contains the main Iris Public API

type Handler 

type Handler interface {
	Serve(ctx *Context)
}

Handler the main Iris Handler interface.

func ToHandler 

func ToHandler(handler interface{}) Handler

ToHandler converts an httapi.Handler or http.HandlerFunc to an iris.Handler

func ToHandlerFastHTTP 

func ToHandlerFastHTTP(h fasthttp.RequestHandler) Handler

ToHandlerFastHTTP converts an fasthttp.RequestHandler to an iris.Handler

type HandlerAPI 

type HandlerAPI interface{}

HandlerAPI empty interface used for .API

type HandlerFunc 

type HandlerFunc func(*Context)

HandlerFunc type is an adapter to allow the use of ordinary functions as HTTP handlers. If f is a function with the appropriate signature, HandlerFunc(f) is a Handler that calls f.

func NewLoggerHandler 

func NewLoggerHandler(writer io.Writer, calculateLatency ...bool) HandlerFunc

NewLoggerHandler is a basic Logger middleware/Handler (not an Entry Parser)

func StaticHandler 

func StaticHandler(systemPath string, stripSlashes int, compress bool, generateIndexPages bool, indexNames []string) HandlerFunc

StaticHandler returns a Handler to serve static system directory Accepts 5 parameters

first is the systemPath (string) Path to the root directory to serve files from.

second is the stripSlashes (int) level * stripSlashes = 0, original path: "/foo/bar", result: "/foo/bar" * stripSlashes = 1, original path: "/foo/bar", result: "/bar" * stripSlashes = 2, original path: "/foo/bar", result: ""

third is the compress (bool) Transparently compresses responses if set to true.

The server tries minimizing CPU usage by caching compressed files. It adds fasthttp.FSCompressedFileSuffix suffix to the original file name and tries saving the resulting compressed file under the new file name. So it is advisable to give the server write access to Root and to all inner folders in order to minimze CPU usage when serving compressed responses.

fourth is the generateIndexPages (bool) Index pages for directories without files matching IndexNames are automatically generated if set.

Directory index generation may be quite slow for directories with many files (more than 1K), so it is discouraged enabling index pages' generation for such directories.

fifth is the indexNames ([]string) List of index file names to try opening during directory access.

For example:

  • index.html
  • index.htm
  • my-super-index.xml

func ToHandlerFunc 

func ToHandlerFunc(handler interface{}) HandlerFunc

ToHandlerFunc converts an http.Handler or http.HandlerFunc to an iris.HandlerFunc

func (HandlerFunc) Serve 

func (h HandlerFunc) Serve(ctx *Context)

Serve implements the Handler, is like ServeHTTP but for Iris

type Map 

type Map map[string]interface{}

Map is just a conversion for a map[string]interface{} should not be used inside Render when PongoEngine is used.

type Middleware 

type Middleware []Handler

Middleware is just a slice of Handler []func(c *Context)

type MuxAPI 

type MuxAPI interface {
	Party(string, ...HandlerFunc) MuxAPI
	// middleware serial, appending
	Use(...Handler)
	UseFunc(...HandlerFunc)
	// returns itself, because at the most-cases used like .Layout, at the first-line party's declaration
	Done(...Handler) MuxAPI
	DoneFunc(...HandlerFunc) MuxAPI

	// main handlers
	Handle(string, string, ...Handler) RouteNameFunc
	HandleFunc(string, string, ...HandlerFunc) RouteNameFunc
	// H_ is used to convert a context.IContext handler func to iris.HandlerFunc, is used only inside iris internal package to avoid import cycles
	H_(string, string, func(context.IContext)) func(string)
	API(string, HandlerAPI, ...HandlerFunc)

	// http methods
	Get(string, ...HandlerFunc) RouteNameFunc
	Post(string, ...HandlerFunc) RouteNameFunc
	Put(string, ...HandlerFunc) RouteNameFunc
	Delete(string, ...HandlerFunc) RouteNameFunc
	Connect(string, ...HandlerFunc) RouteNameFunc
	Head(string, ...HandlerFunc) RouteNameFunc
	Options(string, ...HandlerFunc) RouteNameFunc
	Patch(string, ...HandlerFunc) RouteNameFunc
	Trace(string, ...HandlerFunc) RouteNameFunc
	Any(string, ...HandlerFunc)

	// static content
	StaticHandler(string, int, bool, bool, []string) HandlerFunc
	Static(string, string, int) RouteNameFunc
	StaticFS(string, string, int) RouteNameFunc
	StaticWeb(string, string, int) RouteNameFunc
	StaticServe(string, ...string) RouteNameFunc
	StaticContent(string, string, []byte) RouteNameFunc
	Favicon(string, ...string) RouteNameFunc

	// templates
	Layout(string) MuxAPI // returns itself

	// errors
	OnError(int, HandlerFunc)
	EmitError(int, *Context)
}

MuxAPI the visible api for the serveMux

func Done 

func Done(handlers ...Handler) MuxAPI

Done registers Handler 'middleware' the only difference from .Use is that it should be used BEFORE any party route registered or AFTER ALL party's routes have been registered.

returns itself

func DoneFunc 

func DoneFunc(handlersFn ...HandlerFunc) MuxAPI

DoneFunc registers HandlerFunc 'middleware' the only difference from .Use is that it should be used BEFORE any party route registered or AFTER ALL party's routes have been registered.

returns itself

func Party 

func Party(relativePath string, handlersFn ...HandlerFunc) MuxAPI

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

type OptionServerSet 

type OptionServerSet func(c *ServerConfiguration)

OptionServerSet is the func which implements the OptionServerSettter, this is used widely

func (OptionServerSet) Set 

func (o OptionServerSet) Set(c *ServerConfiguration)

Set is the func which makes OptionServerSet implements the OptionServerSettter

type OptionServerSettter 

type OptionServerSettter interface {
	Set(c *ServerConfiguration)
}

OptionServerSettter server configuration option setter

type OptionSet 

type OptionSet func(c *Configuration)

OptionSet implements the OptionSetter

func (OptionSet) Set 

func (o OptionSet) Set(c *Configuration)

Set is the func which makes the OptionSet an OptionSetter, this is used mostly

type OptionSetter 

type OptionSetter interface {
	// Set receives a pointer to the global Configuration type and does the job of filling it
	Set(c *Configuration)
}

OptionSetter sets a configuration field to the main configuration used to help developers to write less and configure only what they really want and nothing else example: iris.New(iris.Configuration{Sessions:iris.SessionConfiguration{Cookie:"mysessionid"}, Websocket: iris.WebsocketConfiguration{Endpoint:"/my_endpoint"}}) now can be done also by using iris.Option$FIELD: iris.New(irisOptionSessionsCookie("mycookieid"),iris.OptionWebsocketEndpoint("my_endpoint")) benefits: 1. user/dev have no worries what option to pass, he/she can just press iris.Option and all options should be shown to her/his editor's autocomplete-popup window 2. can be passed with any order 3. Can override previous configuration

type PathParameter 

type PathParameter struct {
	Key   string
	Value string
}

PathParameter is a struct which contains Key and Value, used for named path parameters

type PathParameters 

type PathParameters []PathParameter

PathParameters type for a slice of PathParameter Tt's a slice of PathParameter type, because it's faster than map

func ParseParams 

func ParseParams(str string) PathParameters

ParseParams receives a string and returns PathParameters (slice of PathParameter) received string must have this form: key1=value1,key2=value2...

func (PathParameters) Get 

func (params PathParameters) Get(key string) string

Get returns a value from a key inside this Parameters If no parameter with this key given then it returns an empty string

func (PathParameters) String 

func (params PathParameters) String() string

String returns a string implementation of all parameters that this PathParameters object keeps hasthe form of key1=value1,key2=value2...

type Plugin 

type Plugin interface {
}

Plugin just an empty base for plugins A Plugin can be added with: .Add(PreListenFunc(func(*Framework))) and so on... or .Add(myPlugin{},myPlugin2{}) which myPlugin is a struct with any of the methods below or .PostListen(func(*Framework)) and so on...

type PluginContainer 

type PluginContainer interface {
	Add(...Plugin) error
	Remove(string) error
	GetName(Plugin) string
	GetDescription(Plugin) string
	GetByName(string) Plugin
	Printf(string, ...interface{})
	PreLookup(PreLookupFunc)
	DoPreLookup(Route)
	PreListen(PreListenFunc)
	DoPreListen(*Framework)
	DoPreListenParallel(*Framework)
	PostListen(PostListenFunc)
	DoPostListen(*Framework)
	PreClose(PreCloseFunc)
	DoPreClose(*Framework)
	PreDownload(PreDownloadFunc)
	DoPreDownload(Plugin, string)
	//
	GetAll() []Plugin
	// GetDownloader is the only one module that is used and fire listeners at the same time in this file
	GetDownloader() PluginDownloadManager

} //Note: custom event callbacks, never used internaly by Iris, but if you need them use this: github.com/kataras/go-events

PluginContainer is the interface which the pluginContainer should implements

type PluginDownloadManager 

type PluginDownloadManager interface {
	DirectoryExists(string) bool
	DownloadZip(string, string) (string, error)
	Unzip(string, string) (string, error)
	Remove(string) error
	// install is just the flow of: downloadZip -> unzip -> removeFile(zippedFile)
	// accepts 2 parameters
	//
	// first parameter is the remote url file zip
	// second parameter is the target directory
	// returns a string(installedDirectory) and an error
	//
	// (string) installedDirectory is the directory which the zip file had, this is the real installation path, you don't need to know what it's because these things maybe change to the future let's keep it to return the correct path.
	// the installedDirectory is not empty when the installation is succed, the targetDirectory is not already exists and no error happens
	// the installedDirectory is empty when the installation is already done by previous time or an error happens
	Install(remoteFileZip string, targetDirectory string) (string, error)
}

PluginDownloadManager is the interface which the DownloadManager should implements

type PostListenFunc 

type PostListenFunc func(*Framework)

PostListenFunc implements the simple function listener for the PostListen(*Framework)

func (PostListenFunc) PostListen 

func (fn PostListenFunc) PostListen(station *Framework)

PostListen it's being called only one time, AFTER the Server is started (if .Listen called) parameter is the station

type PreCloseFunc 

type PreCloseFunc func(*Framework)

PreCloseFunc implements the simple function listener for the PreClose(*Framework)

func (PreCloseFunc) PreClose 

func (fn PreCloseFunc) PreClose(station *Framework)

PreClose it's being called only one time, BEFORE the Iris .Close method any plugin cleanup/clear memory happens here

The plugin is deactivated after this state

type PreDownloadFunc 

type PreDownloadFunc func(Plugin, string)

PreDownloadFunc implements the simple function listener for the PreDownload(plugin,string)

func (PreDownloadFunc) PreDownload 

func (fn PreDownloadFunc) PreDownload(pl Plugin, downloadURL string)

PreDownload it's being called every time a plugin tries to download something

first parameter is the plugin second parameter is the download url must return a boolean, if false then the plugin is not permmited to download this file

type PreListenFunc 

type PreListenFunc func(*Framework)

PreListenFunc implements the simple function listener for the PreListen(*Framework)

func (PreListenFunc) PreListen 

func (fn PreListenFunc) PreListen(station *Framework)

PreListen it's being called only one time, BEFORE the Server is started (if .Listen called) is used to do work at the time all other things are ready to go 

parameter is the station

type PreLookupFunc 

type PreLookupFunc func(Route)

PreLookupFunc implements the simple function listener for the PreLookup(Route)

func (PreLookupFunc) PreLookup 

func (fn PreLookupFunc) PreLookup(r Route)

PreLookup called before register a route

type RenderOptions 

type RenderOptions map[string]interface{}

RenderOptions is a helper type for the optional runtime options can be passed by user when Render an example of this is the "layout" or "gzip" option same as Map but more specific name

type Route 

type Route interface {
	// Name returns the name of the route
	Name() string
	// Subdomain returns the subdomain,if any
	Subdomain() string
	// Method returns the http method
	Method() string
	// Path returns the path
	Path() string
	// SetPath changes/sets the path for this route
	SetPath(string)
	// Middleware returns the slice of Handler([]Handler) registed to this route
	Middleware() Middleware
	// SetMiddleware changes/sets the middleware(handler(s)) for this route
	SetMiddleware(Middleware)
}

Route contains some useful information about a route

func Lookup 

func Lookup(routeName string) Route

Lookup returns a registed route by its name

func Lookups 

func Lookups() []Route

Lookups returns all registed routes

type RouteNameFunc 

type RouteNameFunc func(string)

RouteNameFunc the func returns from the MuxAPi's methods, optionally sets the name of the Route (*route)

func Connect 

func Connect(path string, handlersFn ...HandlerFunc) RouteNameFunc

Connect registers a route for the Connect http method

func Delete 

func Delete(path string, handlersFn ...HandlerFunc) RouteNameFunc

Delete registers a route for the Delete http method

func Favicon 

func Favicon(favPath string, requestPath ...string) RouteNameFunc

Favicon serves static favicon accepts 2 parameters, second is optional favPath (string), declare the system directory path of the __.ico requestPath (string), it's the route's path, by default this is the "/favicon.ico" because some browsers tries to get this by default first, you can declare your own path if you have more than one favicon (desktop, mobile and so on)

this func will add a route for you which will static serve the /yuorpath/yourfile.ico to the /yourfile.ico (nothing special that you can't handle by yourself) Note that you have to call it on every favicon you have to serve automatically (dekstop, mobile and so on)

panics on error

func Get 

func Get(path string, handlersFn ...HandlerFunc) RouteNameFunc

Get registers a route for the Get http method

func Handle 

func Handle(method string, registedPath string, handlers ...Handler) RouteNameFunc

Handle registers a route to the server's router if empty method is passed then registers handler(s) for all methods, same as .Any, but returns nil as result

func HandleFunc 

func HandleFunc(method string, registedPath string, handlersFn ...HandlerFunc) RouteNameFunc

HandleFunc registers and returns a route with a method string, path string and a handler registedPath is the relative url path 

func Head(path string, handlersFn ...HandlerFunc) RouteNameFunc

Head registers a route for the Head http method

func Options 

func Options(path string, handlersFn ...HandlerFunc) RouteNameFunc

Options registers a route for the Options http method

func Patch 

func Patch(path string, handlersFn ...HandlerFunc) RouteNameFunc

Patch registers a route for the Patch http method

func Post 

func Post(path string, handlersFn ...HandlerFunc) RouteNameFunc

Post registers a route for the Post http method

func Put 

func Put(path string, handlersFn ...HandlerFunc) RouteNameFunc

Put registers a route for the Put http method

func Static 

func Static(relative string, systemPath string, stripSlashes int) RouteNameFunc

Static registers a route which serves a system directory this doesn't generates an index page which list all files no compression is used also, for these features look at StaticFS func accepts three parameters first parameter is the request url path (string) second parameter is the system directory (string) third parameter is the level (int) of stripSlashes * stripSlashes = 0, original path: "/foo/bar", result: "/foo/bar" * stripSlashes = 1, original path: "/foo/bar", result: "/bar" * stripSlashes = 2, original path: "/foo/bar", result: ""

func StaticContent 

func StaticContent(reqPath string, contentType string, content []byte) RouteNameFunc

StaticContent serves bytes, memory cached, on the reqPath a good example of this is how the websocket server uses that to auto-register the /iris-ws.js

func StaticFS 

func StaticFS(reqPath string, systemPath string, stripSlashes int) RouteNameFunc

StaticFS registers a route which serves a system directory this is the fastest method to serve static files generates an index page which list all files if you use this method it will generate compressed files also think this function as small fileserver with http accepts three parameters first parameter is the request url path (string) second parameter is the system directory (string) third parameter is the level (int) of stripSlashes * stripSlashes = 0, original path: "/foo/bar", result: "/foo/bar" * stripSlashes = 1, original path: "/foo/bar", result: "/bar" * stripSlashes = 2, original path: "/foo/bar", result: ""

func StaticServe 

func StaticServe(systemPath string, requestPath ...string) RouteNameFunc

StaticServe serves a directory as web resource it's the simpliest form of the Static* functions Almost same usage as StaticWeb accepts only one required parameter which is the systemPath ( the same path will be used to register the GET&HEAD routes) if second parameter is empty, otherwise the requestPath is the second parameter it uses gzip compression (compression on each request, no file cache)

func StaticWeb 

func StaticWeb(reqPath string, systemPath string, stripSlashes int) RouteNameFunc

StaticWeb same as Static but if index.html exists and request uri is '/' then display the index.html's contents accepts three parameters first parameter is the request url path (string) second parameter is the system directory (string) third parameter is the level (int) of stripSlashes * stripSlashes = 0, original path: "/foo/bar", result: "/foo/bar" * stripSlashes = 1, original path: "/foo/bar", result: "/bar" * stripSlashes = 2, original path: "/foo/bar", result: "" * if you don't know what to put on stripSlashes just 1

func Trace 

func Trace(path string, handlersFn ...HandlerFunc) RouteNameFunc

Trace registers a route for the Trace http method

type SSHServer 

type SSHServer struct {
	Bin     string // windows: C:/Program Files/Git/usr/bin, it's the ssh[.exe] and ssh-keygen[.exe], we only need the ssh-keygen.
	KeyPath string // C:/Users/kataras/.ssh/iris_rsa
	Host    string // host:port

	Users    Users    // map[string][]byte]{ "username":[]byte("password"), "my_second_username" : []byte("my_second_password")}
	Commands Commands // Commands{Command{Name: "restart", Description:"restarts & rebuild the server", Action: func(ssh.Channel){}}}
	// note for Commands field:
	// the default  Iris's commands are defined at the end of this file, I tried to make this file as standalone as I can, because it will be used for Iris web framework also.
	Shell  bool        // Set it to true to enable execute terminal's commands(system commands) via ssh if no other command is found from the Commands field. Defaults to false for security reasons
	Logger *log.Logger // log.New(...)/ $qinstance.Logger, fill it when you want to receive debug and info/warnings messages
	// contains filtered or unexported fields
}

SSHServer : Simple SSH interface for Iris web framework, does not implements the most secure options and code, but its should works use it at your own risk.

func NewSSHServer 

func NewSSHServer() *SSHServer

NewSSHServer returns a new empty SSHServer

func (*SSHServer) Enabled 

func (s *SSHServer) Enabled() bool

Enabled returns true if SSH can be started, if Host != ""

func (*SSHServer) IsListening 

func (s *SSHServer) IsListening() bool

IsListening returns true if ssh server has been started

func (*SSHServer) Listen 

func (s *SSHServer) Listen() error

Listen starts the SSH Server

type Server 

type Server struct {
	*fasthttp.Server

	Config ServerConfiguration
	// contains filtered or unexported fields
}

Server the http server

func AddServer 

func AddServer(setters ...OptionServerSettter) *Server

AddServer same as .Servers.Add(ServerConfiguration)

AddServer starts a server which listens to this station Note that the view engine's functions {{ url }} and {{ urlpath }} will return the first's registered server's scheme (http/https)

this is useful mostly when you want to have two or more listening ports ( two or more servers ) for the same station

receives one parameter which is the ServerConfiguration for the new server returns the new standalone server( you can close this server by the returning reference)

If you need only one server you can use the blocking-funcs: .Listen/ListenTLS/ListenUNIX/ListenTo

this is a NOT A BLOCKING version, the main .Listen/ListenTLS/ListenUNIX/ListenTo should be always executed LAST, so this function goes before the main .Listen/ListenTLS/ListenUNIX/ListenTo

func ListenVirtual 

func ListenVirtual(optionalAddr ...string) *Server

ListenVirtual is useful only when you want to test Iris, it doesn't starts the server but it configures and returns it initializes the whole framework but server doesn't listens to a specific net.Listener it is not blocking the app

func (*Server) Close 

func (s *Server) Close() (err error)

Close terminates the server

func (*Server) FullHost 

func (s *Server) FullHost() string

FullHost returns the scheme+host

func (*Server) Host 

func (s *Server) Host() string

Host returns the registered host for the server

func (*Server) Hostname 

func (s *Server) Hostname() string

Hostname returns the hostname part of the host (host expect port)

func (*Server) IsListening 

func (s *Server) IsListening() bool

IsListening returns true if server is listening/started, otherwise false

func (*Server) IsOpened 

func (s *Server) IsOpened() bool

IsOpened checks if handler is not nil and returns true if not, otherwise false this is used to see if a server has opened, use IsListening if you want to see if the server is actually ready to serve connections

func (*Server) IsSecure 

func (s *Server) IsSecure() bool

IsSecure returns true if server uses TLS, otherwise false

func (*Server) Listener 

func (s *Server) Listener() net.Listener

Listener returns the net.Listener which this server (is) listening to

func (*Server) Open 

func (s *Server) Open(h fasthttp.RequestHandler) error

Open opens/starts/runs/listens (to) the server, listen tls if Cert && Key is registed, listenUNIX if Mode is registed, otherwise listen

func (*Server) Port 

func (s *Server) Port() int

Port returns the port which server listening for if no port given with the ListeningAddr, it returns 80

func (*Server) Scheme 

func (s *Server) Scheme() string

Scheme returns http:// or https:// if SSL is enabled

type ServerConfiguration 

type ServerConfiguration struct {
	// ListenningAddr the addr that server listens to
	ListeningAddr string
	CertFile      string
	KeyFile       string
	// AutoTLS enable to get certifications from the Letsencrypt
	// when this configuration field is true, the CertFile & KeyFile are empty, no need to provide a key.
	//
	// example: https://github.com/iris-contrib/examples/blob/master/letsencyrpt/main.go
	AutoTLS bool
	// Mode this is for unix only
	Mode os.FileMode
	// MaxRequestBodySize Maximum request body size.
	//
	// The server rejects requests with bodies exceeding this limit.
	//
	// By default request body size is 8MB.
	MaxRequestBodySize int

	// Per-connection buffer size for requests' reading.
	// This also limits the maximum header size.
	//
	// Increase this buffer if your clients send multi-KB RequestURIs
	// and/or multi-KB headers (for example, BIG cookies).
	//
	// Default buffer size is used if not set.
	ReadBufferSize int

	// Per-connection buffer size for responses' writing.
	//
	// Default buffer size is used if not set.
	WriteBufferSize int

	// Maximum duration for reading the full request (including body).
	//
	// This also limits the maximum duration for idle keep-alive
	// connections.
	//
	// By default request read timeout is unlimited.
	ReadTimeout time.Duration

	// Maximum duration for writing the full response (including body).
	//
	// By default response write timeout is unlimited.
	WriteTimeout time.Duration

	// RedirectTo, defaults to empty, set it in order to override the station's handler and redirect all requests to this address which is of form(HOST:PORT or :PORT)
	//
	// NOTE: the http status is 'StatusMovedPermanently', means one-time-redirect(the browser remembers the new addr and goes to the new address without need to request something from this server
	// which means that if you want to change this address you have to clear your browser's cache in order this to be able to change to the new addr.
	//
	// example: https://github.com/iris-contrib/examples/tree/master/multiserver_listening2
	RedirectTo string
	// Virtual If this server is not really listens to a real host, it mostly used in order to achieve testing without system modifications
	Virtual bool
	// VListeningAddr, can be used for both virtual = true or false,
	// if it's setted to not empty, then the server's Host() will return this addr instead of the ListeningAddr.
	// server's Host() is used inside global template helper funcs
	// set it when you are sure you know what it does.
	//
	// Default is empty ""
	VListeningAddr string
	// VScheme if setted to not empty value then all template's helper funcs prepends that as the url scheme instead of the real scheme
	// server's .Scheme returns VScheme if  not empty && differs from real scheme
	//
	// Default is empty ""
	VScheme string
	// Name the server's name, defaults to "iris".
	// You're free to change it, but I will trust you to don't, this is the only setting whose somebody, like me, can see if iris web framework is used
	Name string
}

ServerConfiguration is the configuration which is used inside iris' server(s) for listening to

func DefaultServerConfiguration 

func DefaultServerConfiguration() ServerConfiguration

DefaultServerConfiguration returns the default configs for the server

func (ServerConfiguration) Set 

func (c ServerConfiguration) Set(main *ServerConfiguration)

Set implements the OptionServerSettter to the ServerConfiguration

type ServerList 

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

ServerList contains the servers connected to the Iris station

func (*ServerList) Add 

func (s *ServerList) Add(setters ...OptionServerSettter) *Server

Add adds a server to the list by its config returns the new server

func (*ServerList) CloseAll 

func (s *ServerList) CloseAll() (err error)

CloseAll terminates all listening servers returns the first error, if erro happens it continues to closes the rest of the servers

func (*ServerList) Get 

func (s *ServerList) Get(addr string) (srv *Server)

Get returns the server by it's registered Address

func (*ServerList) GetAll 

func (s *ServerList) GetAll() []*Server

GetAll returns all registered servers

func (*ServerList) GetAllOpened 

func (s *ServerList) GetAllOpened() (servers []*Server)

GetAllOpened returns all opened/started servers

func (*ServerList) GetByIndex 

func (s *ServerList) GetByIndex(i int) *Server

GetByIndex returns a server from the list by it's index

func (*ServerList) Len 

func (s *ServerList) Len() int

Len returns the size of the server list

func (*ServerList) Main 

func (s *ServerList) Main() (srv *Server)

Main returns the main server, the last added server is the main server, even if's Virtual

func (*ServerList) OpenAll 

func (s *ServerList) OpenAll(reqHandler fasthttp.RequestHandler) error

OpenAll starts all servers returns the first error happens to one of these servers if one server gets error it closes the previous servers and exits from this process

func (*ServerList) Remove 

func (s *ServerList) Remove(addr string) bool

Remove deletes a server by it's registered Address returns true if something was removed, otherwise returns false

type SessionsConfiguration 

type SessionsConfiguration sessions.Config

SessionsConfiguration the configuration for sessions has 6 fields first is the cookieName, the session's name (string) ["mysessionsecretcookieid"] second enable if you want to decode the cookie's key also third is the time which the client's cookie expires forth is the cookie length (sessionid) int, defaults to 32, do not change if you don't have any reason to do fifth is the gcDuration (time.Duration) when this time passes it removes the unused sessions from the memory until the user come back sixth is the DisableSubdomainPersistence which you can set it to true in order dissallow your q subdomains to have access to the session cook

func DefaultSessionsConfiguration 

func DefaultSessionsConfiguration() SessionsConfiguration

DefaultSessionsConfiguration the default configs for Sessions

func (SessionsConfiguration) Set 

func (s SessionsConfiguration) Set(c *sessions.Config)

Set implements the OptionSetter of the sessions package

type TesterConfiguration 

type TesterConfiguration struct {
	// ListeningAddr is the virtual server's listening addr (host)
	// Default is "iris-go.com:1993"
	ListeningAddr string
	// ExplicitURL If true then the url (should) be prepended manually, useful when want to test subdomains
	// Default is false
	ExplicitURL bool
	// Debug if true then debug messages from the httpexpect will be shown when a test runs
	// Default is false
	Debug bool
}

TesterConfiguration configuration used inside main config field 'Tester'

func DefaultTesterConfiguration 

func DefaultTesterConfiguration() TesterConfiguration

DefaultTesterConfiguration returns the default configuration for a tester the ListeningAddr is used as virtual only when no running server is founded

type Users 

type Users map[string][]byte

Users SSH.Users field, it's just map[string][]byte (username:password)

type WebsocketConfiguration 

type WebsocketConfiguration struct {
	// WriteTimeout time allowed to write a message to the connection.
	// Default value is 15 * time.Second
	WriteTimeout time.Duration
	// PongTimeout allowed to read the next pong message from the connection
	// Default value is 60 * time.Second
	PongTimeout time.Duration
	// PingPeriod send ping messages to the connection with this period. Must be less than PongTimeout
	// Default value is (PongTimeout * 9) / 10
	PingPeriod time.Duration
	// MaxMessageSize max message size allowed from connection
	// Default value is 1024
	MaxMessageSize int64
	// BinaryMessages set it to true in order to denotes binary data messages instead of utf-8 text
	// see https://github.com/kataras/iris/issues/387#issuecomment-243006022 for more
	// defaults to false
	BinaryMessages bool
	// Endpoint is the path which the websocket server will listen for clients/connections
	// Default value is empty string, if you don't set it the Websocket server is disabled.
	Endpoint string
	// ReadBufferSize is the buffer size for the underline reader
	ReadBufferSize int
	// WriteBufferSize is the buffer size for the underline writer
	WriteBufferSize int
}

WebsocketConfiguration the config contains options for the Websocket main config field

func DefaultWebsocketConfiguration 

func DefaultWebsocketConfiguration() WebsocketConfiguration

DefaultWebsocketConfiguration returns the default config for iris-ws websocket package

type WebsocketConnection 

type WebsocketConnection interface {
	websocket.Connection
}

WebsocketConnection is the front-end API that you will use to communicate with the client side

type WebsocketServer 

type WebsocketServer struct {
	websocket.Server
	// contains filtered or unexported fields
}

WebsocketServer is the iris websocket server, expose the websocket.Server the below code is a wrapper and bridge between iris-contrib/websocket and kataras/go-websocket

func NewWebsocketServer 

func NewWebsocketServer() *WebsocketServer

NewWebsocketServer returns an empty WebsocketServer, nothing special here.

func (*WebsocketServer) Handler 

func (s *WebsocketServer) Handler(ctx *Context)

Handler is the iris Handler to upgrade the request used inside RegisterRoutes

func (*WebsocketServer) OnConnection 

func (s *WebsocketServer) OnConnection(connectionListener func(WebsocketConnection))

OnConnection this is the main event you, as developer, will work with each of the websocket connections

func (*WebsocketServer) RegisterTo 

func (s *WebsocketServer) RegisterTo(station *Framework, c WebsocketConfiguration)

RegisterTo creates the client side source route and the route path Endpoint with the correct Handler receives the websocket configuration and the iris station

func (*WebsocketServer) Upgrade 

func (s *WebsocketServer) Upgrade(ctx *Context) error

Upgrade upgrades the HTTP server connection to the WebSocket protocol.

The responseHeader is included in the response to the client's upgrade request. Use the responseHeader to specify cookies (Set-Cookie) and the application negotiated subprotocol (Sec-Websocket-Protocol).

If the upgrade fails, then Upgrade replies to the client with an HTTP error response.

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.