github.com/kataras/IRIS (go): Package iris provides a beautifully expressive and easy to use foundation for your next website, API, or distributed app.  Source code and other details for the project are available at GitHub:  8.5.9 Final  The only requirement is the Go Programming Language, at least version 1.8 but 1.9 is highly recommended.  Iris takes advantage of the vendor directory feature wisely: https://docs.google.com/document/d/1Bz5-UB7g2uPBdOx-rw5t9MxJwkfpx90cqG9AFL0JAYo. You get truly reproducible builds, as this method guards against upstream renames and deletes.  A simple copy-paste and `go get ./...` to resolve two dependencies: https://github.com/kataras/golog and the https://github.com/iris-contrib/httpexpect will work for ever even for older versions, the newest version can be retrieved by `go get` but this file contains documentation for an older version of Iris.  Follow the instructions below:  1. install the Go Programming Language: https://golang.org/dl 2. clear yours previously `$GOPATH/src/github.com/kataras/iris` folder or create new 3. download the Iris v8.5.9 (final): https://github.com/kataras/iris/archive/v8.zip 4. extract the contents of the `iris-v8` folder that's inside the downloaded zip file to your `$GOPATH/src/github.com/kataras/iris` 5. navigate to your `$GOPATH/src/github.com/kataras/iris` folder if you're not already there and open a terminal/command prompt, execute the command: `go get ./...` and you're ready to GO:)  Example code:  You can start the server(s) listening to any type of `net.Listener` or even `http.Server` instance. The method for initialization of the server should be passed at the end, via `Run` function.  Below you'll see some useful examples:  UNIX and BSD hosts can take advandage of the reuse port feature.  Example code:  That's all with listening, you have the full control when you need it.  Let's continue by learning how to catch CONTROL+C/COMMAND+C or unix kill command and shutdown the server gracefully.  In order to manually manage what to do when app is interrupted, we have to disable the default behavior with the option `WithoutInterruptHandler` and register a new interrupt handler (globally, across all possible hosts).  Example code:  Access to all hosts that serve your application can be provided by the `Application#Hosts` field, after the `Run` method.  But the most common scenario is that you may need access to the host before the `Run` method, there are two ways of gain access to the host supervisor, read below.  First way is to use the `app.NewHost` to create a new host and use one of its `Serve` or `Listen` functions to start the application via the `iris#Raw` Runner. Note that this way needs an extra import of the `net/http` package.  Example Code:  Second, and probably easier way is to use the `host.Configurator`.  Note that this method requires an extra import statement of "github.com/kataras/iris/core/host" when using go < 1.9, if you're targeting on go1.9 then you can use the `iris#Supervisor` and omit the extra host import.  All common `Runners` we saw earlier (`iris#Addr, iris#Listener, iris#Server, iris#TLS, iris#AutoTLS`) accept a variadic argument of `host.Configurator`, there are just `func(*host.Supervisor)`. Therefore the `Application` gives you the rights to modify the auto-created host supervisor through these.  Example Code:  Read more about listening and gracefully shutdown by navigating to:  All HTTP methods are supported, developers can also register handlers for same paths for different methods. The first parameter is the HTTP Method, second parameter is the request path of the route, third variadic parameter should contains one or more iris.Handler executed by the registered order when a user requests for that specific resouce path from the server.  Example code:  In order to make things easier for the user, iris provides functions for all HTTP Methods. The first parameter is the request path of the route, second variadic parameter should contains one or more iris.Handler executed by the registered order when a user requests for that specific resouce path from the server.  Example code:  A set of routes that are being groupped by path prefix can (optionally) share the same middleware handlers and template layout. A group can have a nested group too.  `.Party` is being used to group routes, developers can declare an unlimited number of (nested) groups.  Example code:  iris developers are able to register their own handlers for http statuses like 404 not found, 500 internal server error and so on.  Example code:  With the help of iris's expressionist router you can build any form of API you desire, with safety.  Example code:  Iris has first-class support for the MVC pattern, you'll not find these stuff anywhere else in the Go world.  Example Code:  Iris web framework supports Request data, Models, Persistence Data and Binding with the fastest possible execution.  Characteristics:  All HTTP Methods are supported, for example if want to serve `GET` then the controller should have a function named `Get()`, you can define more than one method function to serve in the same Controller struct.  Persistence data inside your Controller struct (share data between requests) via `iris:"persistence"` tag right to the field or Bind using `app.Controller("/" , new(myController), theBindValue)`.  Models inside your Controller struct (set-ed at the Method function and rendered by the View) via `iris:"model"` tag right to the field, i.e User UserModel `iris:"model" name:"user"` view will recognise it as `{{.user}}`. If `name` tag is missing then it takes the field's name, in this case the `"User"`.  Access to the request path and its parameters via the `Path and Params` fields.  Access to the template file that should be rendered via the `Tmpl` field.  Access to the template data that should be rendered inside the template file via `Data` field.  Access to the template layout via the `Layout` field.  Access to the low-level `iris.Context` via the `Ctx` field.  Get the relative request path by using the controller's name via `RelPath()`.  Get the relative template path directory by using the controller's name via `RelTmpl()`.  Flow as you used to, `Controllers` can be registered to any `Party`, including Subdomains, the Party's begin and done handlers work as expected.  Optional `BeginRequest(ctx)` function to perform any initialization before the method execution, useful to call middlewares or when many methods use the same collection of data.  Optional `EndRequest(ctx)` function to perform any finalization after any method executed.  Inheritance, recursively, see for example our `mvc.SessionController/iris.SessionController`, it has the `mvc.Controller/iris.Controller` as an embedded field and it adds its logic to its `BeginRequest`. Source file: https://github.com/kataras/iris/blob/v8/mvc/session_controller.go.  Read access to the current route  via the `Route` field.  Support for more than one input arguments (map to dynamic request path parameters).  Register one or more relative paths and able to get path parameters, i.e  Response via output arguments, optionally, i.e  Where `any` means everything, from custom structs to standard language's types-. `Result` is an interface which contains only that function: Dispatch(ctx iris.Context) and Get where HTTP Method function(Post, Put, Delete...).  Iris has a very powerful and blazing fast MVC support, you can return any value of any type from a method function and it will be sent to the client as expected.  * if `string` then it's the body. * if `string` is the second output argument then it's the content type. * if `int` then it's the status code. * if `bool` is false then it throws 404 not found http error by skipping everything else. * if `error` and not nil then (any type) response will be omitted and error's text with a 400 bad request will be rendered instead. * if `(int, error)` and error is not nil then the response result will be the error's text with the status code as `int`. * if  `custom struct` or `interface{}` or `slice` or `map` then it will be rendered as json, unless a `string` content type is following. * if `mvc.Result` then it executes its `Dispatch` function, so good design patters can be used to split the model's logic where needed.  The example below is not intended to be used in production but it's a good showcase of some of the return types we saw before;  Another good example with a typical folder structure, that many developers are used to work, can be found at: https://github.com/kataras/iris/tree/v8/_examples/mvc/overview.  By creating components that are independent of one another, developers are able to reuse components quickly and easily in other applications. The same (or similar) view for one application can be refactored for another application with different data because the view is simply handling how the data is being displayed to the user.  If you're new to back-end web development read about the MVC architectural pattern first, a good start is that wikipedia article: https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller.  Follow the examples at: https://github.com/kataras/iris/tree/v8/_examples/#mvc  At the previous example, we've seen static routes, group of routes, subdomains, wildcard subdomains, a small example of parameterized path with a single known parameter and custom http errors, now it's time to see wildcard parameters and macros.  iris, like net/http std package registers route's handlers by a Handler, the iris' type of handler is just a func(ctx iris.Context) where context comes from github.com/kataras/iris/context.  Iris has the easiest and the most powerful routing process you have ever meet.  At the same time, iris has its own interpeter(yes like a programming language) for route's path syntax and their dynamic path parameters parsing and evaluation, We call them "macros" for shortcut. How? It calculates its needs and if not any special regexp needed then it just registers the route with the low-level path syntax, otherwise it pre-compiles the regexp and adds the necessary middleware(s).  Standard macro types for parameters:  if type is missing then parameter's type is defaulted to string, so {param} == {param:string}.  If a function not found on that type then the "string"'s types functions are being used. i.e:  Besides the fact that iris provides the basic types and some default "macro funcs" you are able to register your own too!.  Register a named path parameter function:  at the func(argument ...) you can have any standard type, it will be validated before the server starts so don't care about performance here, the only thing it runs at serve time is the returning func(paramValue string) bool.  Example Code:  A path parameter name should contain only alphabetical letters, symbols, containing '_' and numbers are NOT allowed. If route failed to be registered, the app will panic without any warnings if you didn't catch the second return value(error) on .Handle/.Get....  Last, do not confuse ctx.Values() with ctx.Params(). Path parameter's values goes to ctx.Params() and context's local storage that can be used to communicate between handlers and middleware(s) goes to ctx.Values(), path parameters and the rest of any custom values are separated for your own good.  Run  Static Files  Example code:  More examples can be found here: https://github.com/kataras/iris/tree/v8/_examples/beginner/file-server  Middleware is just a concept of ordered chain of handlers. Middleware can be registered globally, per-party, per-subdomain and per-route.  Example code:  iris is able to wrap and convert any external, third-party Handler you used to use to your web application. Let's convert the https://github.com/rs/cors net/http external middleware which returns a `next form` handler.  Example code:  Iris supports 5 template engines out-of-the-box, developers can still use any external golang template engine, as `context/context#ResponseWriter()` is an `io.Writer`.  All of these five template engines have common features with common API, like Layout, Template Funcs, Party-specific layout, partial rendering and more.  Example code:  View engine supports bundled(https://github.com/jteeuwen/go-bindata) template files too. go-bindata gives you two functions, asset and assetNames, these can be setted to each of the template engines using the `.Binary` func.  Example code:  A real example can be found here: https://github.com/kataras/iris/tree/v8/_examples/view/embedding-templates-into-app.  Enable auto-reloading of templates on each request. Useful while developers are in dev mode as they no neeed to restart their app on every template edit.  Example code:  Note:  In case you're wondering, the code behind the view engines derives from the "github.com/kataras/iris/view" package, access to the engines' variables can be granded by "github.com/kataras/iris" package too.  Each one of these template engines has different options located here: https://github.com/kataras/iris/tree/v8/view .  This example will show how to store and access data from a session.  You don’t need any third-party library, but If you want you can use any session manager compatible or not.  In this example we will only allow authenticated users to view our secret message on the /secret page. To get access to it, the will first have to visit /login to get a valid session cookie, which logs him in. Additionally he can visit /logout to revoke his access to our secret message.  Example code:  Running the example:  Sessions persistence can be achieved using one (or more) `sessiondb`.  Example Code:  More examples:  In this example we will create a small chat between web sockets via browser.  Example Server Code:  Example Client(javascript) Code:  Running the example:  But you should have a basic idea of the framework by now, we just scratched the surface. If you enjoy what you just saw and want to learn more, please follow the below links:  Examples:  Middleware:  Home Page:
Keywords: basicauth|cors|dependency-injection|django|fastest-routes|go|golang|grpc-go|http2|iris|jwt|mvc|ngrok|performance|sessions|versioning|web-framework|websocket