Documentation
¶
Overview ¶
Package apps is responsible to control many Iris Applications. This package directly imports the iris root package and cannot be used inside Iris' codebase itself. Only external packages/programs can make use of it.
Index ¶
- Constants
- Variables
- func Get(appName ...string) *iris.Application
- func GetAll() []*iris.Application
- func OnApplicationRegistered(listeners ...func(app *iris.Application))
- func Switch(provider SwitchProvider, options ...SwitchOption) *iris.Application
- type FriendlyNameProvider
- type Host
- type Hosts
- type Join
- type SwitchCase
- type SwitchOption
- type SwitchOptionFunc
- type SwitchOptions
- type SwitchProvider
Constants ¶
const AnyDomain = `` /* 183-byte string literal not displayed */
AnyDomain is a regexp that matches any domain. It can be used as the Pattern field of a Host.
Example:
apps.Switch(apps.Hosts{ { Pattern: "^id.*$", Target: identityApp, }, { Pattern: apps.AnyDomain, Target: app, }, }).Listen(":80")
Variables ¶
var HostsRedirectCode = iris.StatusMovedPermanently
HostsRedirectCode is the default status code is used to redirect a matching host to a url.
Functions ¶
func Get ¶
func Get(appName ...string) *iris.Application
Get returns an Iris Application based on its "appName". It returns nil when no application was found with the given exact name.
If "appName" parameter is missing then it returns the last registered one. When no application is registered yet then it creates a new on-fly with a "Default" name and returns that instead. The "Default" one can be used across multiple Go packages of the same Program too.
Applications of the same program are registered automatically.
To check if at least one application is registered or not use the `GetAll` function instead.
func GetAll ¶
func GetAll() []*iris.Application
GetAll returns a slice of all registered Iris Applications.
func OnApplicationRegistered ¶
func OnApplicationRegistered(listeners ...func(app *iris.Application))
OnApplicationRegistered adds a function which fires when a new application is registered.
func Switch ¶
func Switch(provider SwitchProvider, options ...SwitchOption) *iris.Application
Switch returns a new Application with the sole purpose of routing the matched Applications through the "provided cases".
The cases are filtered in order of their registration.
Example Code:
switcher := Switch(Hosts{ { Pattern: "mydomain.com", Target: app }, { Pattern: "test.mydomain.com", Target: testSubdomainApp }, { Pattern: "otherdomain.com", "Target: appName" }, }) switcher.Listen(":80")
Note that this is NOT an alternative for a load balancer. The filters are executed by registration order and a matched Application handles the request, that's all it does.
The returned Switch Iris Application can register routes that will run when neither of the registered Applications is responsible to handle the incoming request against the provided filters. The returned Switch Iris Application can also register custom error code handlers, e.g. to inject the 404 on not responsible Application was found. It can also be wrapped with its `WrapRouter` method, which is really useful for logging and statistics.
Wrap with the `Join` slice to pass more than one provider at the same time.
An alternative way for manually embedding an Iris Application to another one is:
app := iris.New() // root app. myOtherApp := api.NewServer(otherServerConfiguration) // embedded app. // myOtherApp.Logger().SetLevel("debug") if err := myOtherApp.Build(); err != nil { panic(err) } app.Any("/api/identity/{p:path}", func(ctx iris.Context) { apiPath := "/" + ctx.Params().Get("p") r := ctx.Request() r.URL.Path = apiPath r.URL.RawPath = apiPath ctx.Params().Remove("p") myOtherApp.ServeHTTPC(ctx) })
app.Listen(":80")
Types ¶
type FriendlyNameProvider ¶
type FriendlyNameProvider interface {
GetFriendlyName() string
}
FriendlyNameProvider can be optionally implemented by providers to customize the Switcher's Supervisor.FriendlyAddr field (Startup log).
type Host ¶
type Host struct { // Pattern is the incoming host matcher regexp or a literal. Pattern string // Target is the target Host that incoming requests will be redirected on pattern match // or an Application's Name that will handle the incoming request matched the Pattern. Target interface{} // It was a string in my initial design but let's do that interface{}, we may support more types here in the future, until generics are in, keep it interface{}. }
Host holds the pattern for the SwitchCase filter and the Target host or application.
type Hosts ¶
type Hosts []Host
Hosts is a switch provider. It can be used as input argument to the `Switch` function to map host to existing Iris Application instances, e.g. { "www.mydomain.com": "mydomainApp" } . It can accept regexp as a host too, e.g. { "^my.*$": "mydomainApp" } .
func (Hosts) GetFriendlyName ¶
GetFriendlyName implements the FriendlyNameProvider.
func (Hosts) GetSwitchCases ¶
func (hosts Hosts) GetSwitchCases() []SwitchCase
GetSwitchCases completes the SwitchProvider. It returns a slice of SwitchCase which if passed on `Switch` function, they act as a router between matched domains and subdomains between existing Iris Applications.
type Join ¶
type Join []SwitchProvider
Join returns a new slice which joins different type of switch cases.
func (Join) GetSwitchCases ¶
func (j Join) GetSwitchCases() (cases []SwitchCase)
GetSwitchCases completes the switch provider.
type SwitchCase ¶
type SwitchCase struct { Filter iris.Filter // Filter runs against the Switcher. App *iris.Application // App is the main target application responsible to handle the request. }
SwitchCase contains the filter and the matched Application instance.
func (SwitchCase) GetSwitchCases ¶
func (sc SwitchCase) GetSwitchCases() []SwitchCase
GetSwitchCases completes the SwitchProvider, it returns itself.
type SwitchOption ¶
type SwitchOption interface {
Apply(*SwitchOptions)
}
SwitchOption should be implemented by all options passed to the `Switch` package-level last variadic input argument.
type SwitchOptionFunc ¶
type SwitchOptionFunc func(*SwitchOptions)
SwitchOptionFunc provides a functional way to pass options to the `Switch` package-level function's last variadic input argument.
func SetHost ¶
func SetHost(hostField string) SwitchOptionFunc
SetHost is a SwitchOption. It force sets a Host field for the matched Application's request object. Extremely useful when used with Hosts SwitchProvider. Usecase: www. to root domain without redirection (SEO reasons) and keep the same internal request Host for both of them so the root app's handlers will always work with a single host no matter what the real request Host was.
func (SwitchOptionFunc) Apply ¶
func (f SwitchOptionFunc) Apply(opts *SwitchOptions)
Apply completes the `SwitchOption` interface.
type SwitchOptions ¶
type SwitchOptions struct { // RequestModifiers holds functions to run // if and only if at least one Filter passed. // They are used to modify the request object // of the matched Application, e.g. modify the host. // // See `SetHost` option too. RequestModifiers []func(*http.Request) }
SwitchOptions holds configuration for the switcher application.
func DefaultSwitchOptions ¶
func DefaultSwitchOptions() SwitchOptions
DefaultSwitchOptions returns a fresh SwitchOptions struct value with its fields set to their defaults.
func (SwitchOptions) Apply ¶
func (o SwitchOptions) Apply(opts *SwitchOptions)
Apply completes the `SwitchOption` interface. It does copies values from "o" to "opts" when necessary.
type SwitchProvider ¶
type SwitchProvider interface {
GetSwitchCases() []SwitchCase
}
A SwitchProvider should return the switch cases. It's an interface instead of a direct slice because we want to make available different type of structures without wrapping.