-
-[](https://travis-ci.org/gin-gonic/gin)
- [](https://codecov.io/gh/gin-gonic/gin)
- [](https://goreportcard.com/report/github.com/gin-gonic/gin)
- [](https://godoc.org/github.com/gin-gonic/gin)
- [](https://gitter.im/gin-gonic/gin?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
-
-Gin is a web framework written in Go (Golang). It features a martini-like API with much better performance, up to 40 times faster thanks to [httprouter](https://github.com/julienschmidt/httprouter). If you need performance and good productivity, you will love Gin.
-
-
-
-```sh
-$ cat test.go
-```
-
-```go
-package main
-
-import "github.com/gin-gonic/gin"
-
-func main() {
- r := gin.Default()
- r.GET("/ping", func(c *gin.Context) {
- c.JSON(200, gin.H{
- "message": "pong",
- })
- })
- r.Run() // listen and serve on 0.0.0.0:8080
-}
-```
-
-## Benchmarks
-
-Gin uses a custom version of [HttpRouter](https://github.com/julienschmidt/httprouter)
-
-[See all benchmarks](/BENCHMARKS.md)
-
-
-Benchmark name | (1) | (2) | (3) | (4)
---------------------------------|----------:|----------:|----------:|------:
-BenchmarkAce_GithubAll | 10000 | 109482 | 13792 | 167
-BenchmarkBear_GithubAll | 10000 | 287490 | 79952 | 943
-BenchmarkBeego_GithubAll | 3000 | 562184 | 146272 | 2092
-BenchmarkBone_GithubAll | 500 | 2578716 | 648016 | 8119
-BenchmarkDenco_GithubAll | 20000 | 94955 | 20224 | 167
-BenchmarkEcho_GithubAll | 30000 | 58705 | 0 | 0
-**BenchmarkGin_GithubAll** | **30000** | **50991** | **0** | **0**
-BenchmarkGocraftWeb_GithubAll | 5000 | 449648 | 133280 | 1889
-BenchmarkGoji_GithubAll | 2000 | 689748 | 56113 | 334
-BenchmarkGoJsonRest_GithubAll | 5000 | 537769 | 135995 | 2940
-BenchmarkGoRestful_GithubAll | 100 | 18410628 | 797236 | 7725
-BenchmarkGorillaMux_GithubAll | 200 | 8036360 | 153137 | 1791
-BenchmarkHttpRouter_GithubAll | 20000 | 63506 | 13792 | 167
-BenchmarkHttpTreeMux_GithubAll | 10000 | 165927 | 56112 | 334
-BenchmarkKocha_GithubAll | 10000 | 171362 | 23304 | 843
-BenchmarkMacaron_GithubAll | 2000 | 817008 | 224960 | 2315
-BenchmarkMartini_GithubAll | 100 | 12609209 | 237952 | 2686
-BenchmarkPat_GithubAll | 300 | 4830398 | 1504101 | 32222
-BenchmarkPossum_GithubAll | 10000 | 301716 | 97440 | 812
-BenchmarkR2router_GithubAll | 10000 | 270691 | 77328 | 1182
-BenchmarkRevel_GithubAll | 1000 | 1491919 | 345553 | 5918
-BenchmarkRivet_GithubAll | 10000 | 283860 | 84272 | 1079
-BenchmarkTango_GithubAll | 5000 | 473821 | 87078 | 2470
-BenchmarkTigerTonic_GithubAll | 2000 | 1120131 | 241088 | 6052
-BenchmarkTraffic_GithubAll | 200 | 8708979 | 2664762 | 22390
-BenchmarkVulcan_GithubAll | 5000 | 353392 | 19894 | 609
-BenchmarkZeus_GithubAll | 2000 | 944234 | 300688 | 2648
-
-(1): Total Repetitions
-(2): Single Repetition Duration (ns/op)
-(3): Heap Memory (B/op)
-(4): Average Allocations per Repetition (allocs/op)
-
-## Gin v1. stable
-
-- [x] Zero allocation router.
-- [x] Still the fastest http router and framework. From routing to writing.
-- [x] Complete suite of unit tests
-- [x] Battle tested
-- [x] API frozen, new releases will not break your code.
-
-
-## Start using it
-
-1. Download and install it:
-
-```sh
-$ go get github.com/gin-gonic/gin
-```
-
-2. Import it in your code:
-
-```go
-import "github.com/gin-gonic/gin"
-```
-
-3. (Optional) Import `net/http`. This is required for example if using constants such as `http.StatusOK`.
-
-```go
-import "net/http"
-```
-
-## API Examples
-
-### Using GET, POST, PUT, PATCH, DELETE and OPTIONS
-
-```go
-func main() {
- // Disable Console Color
- // gin.DisableConsoleColor()
-
- // Creates a gin router with default middleware:
- // logger and recovery (crash-free) middleware
- router := gin.Default()
-
- router.GET("/someGet", getting)
- router.POST("/somePost", posting)
- router.PUT("/somePut", putting)
- router.DELETE("/someDelete", deleting)
- router.PATCH("/somePatch", patching)
- router.HEAD("/someHead", head)
- router.OPTIONS("/someOptions", options)
-
- // By default it serves on :8080 unless a
- // PORT environment variable was defined.
- router.Run()
- // router.Run(":3000") for a hard coded port
-}
-```
-
-### Parameters in path
-
-```go
-func main() {
- router := gin.Default()
-
- // This handler will match /user/john but will not match neither /user/ or /user
- router.GET("/user/:name", func(c *gin.Context) {
- name := c.Param("name")
- c.String(http.StatusOK, "Hello %s", name)
- })
-
- // However, this one will match /user/john/ and also /user/john/send
- // If no other routers match /user/john, it will redirect to /user/john/
- router.GET("/user/:name/*action", func(c *gin.Context) {
- name := c.Param("name")
- action := c.Param("action")
- message := name + " is " + action
- c.String(http.StatusOK, message)
- })
-
- router.Run(":8080")
-}
-```
-
-### Querystring parameters
-
-```go
-func main() {
- router := gin.Default()
-
- // Query string parameters are parsed using the existing underlying request object.
- // The request responds to a url matching: /welcome?firstname=Jane&lastname=Doe
- router.GET("/welcome", func(c *gin.Context) {
- firstname := c.DefaultQuery("firstname", "Guest")
- lastname := c.Query("lastname") // shortcut for c.Request.URL.Query().Get("lastname")
-
- c.String(http.StatusOK, "Hello %s %s", firstname, lastname)
- })
- router.Run(":8080")
-}
-```
-
-### Multipart/Urlencoded Form
-
-```go
-func main() {
- router := gin.Default()
-
- router.POST("/form_post", func(c *gin.Context) {
- message := c.PostForm("message")
- nick := c.DefaultPostForm("nick", "anonymous")
-
- c.JSON(200, gin.H{
- "status": "posted",
- "message": message,
- "nick": nick,
- })
- })
- router.Run(":8080")
-}
-```
-
-### Another example: query + post form
-
-```
-POST /post?id=1234&page=1 HTTP/1.1
-Content-Type: application/x-www-form-urlencoded
-
-name=manu&message=this_is_great
-```
-
-```go
-func main() {
- router := gin.Default()
-
- router.POST("/post", func(c *gin.Context) {
-
- id := c.Query("id")
- page := c.DefaultQuery("page", "0")
- name := c.PostForm("name")
- message := c.PostForm("message")
-
- fmt.Printf("id: %s; page: %s; name: %s; message: %s", id, page, name, message)
- })
- router.Run(":8080")
-}
-```
-
-```
-id: 1234; page: 1; name: manu; message: this_is_great
-```
-
-### Upload files
-
-#### Single file
-
-References issue [#774](https://github.com/gin-gonic/gin/issues/774) and detail [example code](examples/upload-file/single).
-
-```go
-func main() {
- router := gin.Default()
- router.POST("/upload", func(c *gin.Context) {
- // single file
- file, _ := c.FormFile("file")
- log.Println(file.Filename)
-
- c.String(http.StatusOK, fmt.Printf("'%s' uploaded!", file.Filename))
- })
- router.Run(":8080")
-}
-```
-
-How to `curl`:
-
-```bash
-curl -X POST http://localhost:8080/upload \
- -F "file=@/Users/appleboy/test.zip" \
- -H "Content-Type: multipart/form-data"
-```
-
-#### Multiple files
-
-See the detail [example code](examples/upload-file/multiple).
-
-```go
-func main() {
- router := gin.Default()
- router.POST("/upload", func(c *gin.Context) {
- // Multipart form
- form, _ := c.MultipartForm()
- files := form.File["upload[]"]
-
- for _, file := range files {
- log.Println(file.Filename)
- }
- c.String(http.StatusOK, fmt.Printf("%d files uploaded!", len(files)))
- })
- router.Run(":8080")
-}
-```
-
-How to `curl`:
-
-```bash
-curl -X POST http://localhost:8080/upload \
- -F "upload[]=@/Users/appleboy/test1.zip" \
- -F "upload[]=@/Users/appleboy/test2.zip" \
- -H "Content-Type: multipart/form-data"
-```
-
-### Grouping routes
-
-```go
-func main() {
- router := gin.Default()
-
- // Simple group: v1
- v1 := router.Group("/v1")
- {
- v1.POST("/login", loginEndpoint)
- v1.POST("/submit", submitEndpoint)
- v1.POST("/read", readEndpoint)
- }
-
- // Simple group: v2
- v2 := router.Group("/v2")
- {
- v2.POST("/login", loginEndpoint)
- v2.POST("/submit", submitEndpoint)
- v2.POST("/read", readEndpoint)
- }
-
- router.Run(":8080")
-}
-```
-
-### Blank Gin without middleware by default
-
-Use
-
-```go
-r := gin.New()
-```
-
-instead of
-
-```go
-r := gin.Default()
-```
-
-
-### Using middleware
-```go
-func main() {
- // Creates a router without any middleware by default
- r := gin.New()
-
- // Global middleware
- r.Use(gin.Logger())
- r.Use(gin.Recovery())
-
- // Per route middleware, you can add as many as you desire.
- r.GET("/benchmark", MyBenchLogger(), benchEndpoint)
-
- // Authorization group
- // authorized := r.Group("/", AuthRequired())
- // exactly the same as:
- authorized := r.Group("/")
- // per group middleware! in this case we use the custom created
- // AuthRequired() middleware just in the "authorized" group.
- authorized.Use(AuthRequired())
- {
- authorized.POST("/login", loginEndpoint)
- authorized.POST("/submit", submitEndpoint)
- authorized.POST("/read", readEndpoint)
-
- // nested group
- testing := authorized.Group("testing")
- testing.GET("/analytics", analyticsEndpoint)
- }
-
- // Listen and serve on 0.0.0.0:8080
- r.Run(":8080")
-}
-```
-
-### Model binding and validation
-
-To bind a request body into a type, use model binding. We currently support binding of JSON, XML and standard form values (foo=bar&boo=baz).
-
-Note that you need to set the corresponding binding tag on all fields you want to bind. For example, when binding from JSON, set `json:"fieldname"`.
-
-When using the Bind-method, Gin tries to infer the binder depending on the Content-Type header. If you are sure what you are binding, you can use BindWith.
-
-You can also specify that specific fields are required. If a field is decorated with `binding:"required"` and has a empty value when binding, the current request will fail with an error.
-
-```go
-// Binding from JSON
-type Login struct {
- User string `form:"user" json:"user" binding:"required"`
- Password string `form:"password" json:"password" binding:"required"`
-}
-
-func main() {
- router := gin.Default()
-
- // Example for binding JSON ({"user": "manu", "password": "123"})
- router.POST("/loginJSON", func(c *gin.Context) {
- var json Login
- if c.BindJSON(&json) == nil {
- if json.User == "manu" && json.Password == "123" {
- c.JSON(http.StatusOK, gin.H{"status": "you are logged in"})
- } else {
- c.JSON(http.StatusUnauthorized, gin.H{"status": "unauthorized"})
- }
- }
- })
-
- // Example for binding a HTML form (user=manu&password=123)
- router.POST("/loginForm", func(c *gin.Context) {
- var form Login
- // This will infer what binder to use depending on the content-type header.
- if c.Bind(&form) == nil {
- if form.User == "manu" && form.Password == "123" {
- c.JSON(http.StatusOK, gin.H{"status": "you are logged in"})
- } else {
- c.JSON(http.StatusUnauthorized, gin.H{"status": "unauthorized"})
- }
- }
- })
-
- // Listen and serve on 0.0.0.0:8080
- router.Run(":8080")
-}
-```
-
-### Bind Query String
-
-See the [detail information](https://github.com/gin-gonic/gin/issues/742#issuecomment-264681292).
-
-```go
-package main
-
-import "log"
-import "github.com/gin-gonic/gin"
-
-type Person struct {
- Name string `form:"name"`
- Address string `form:"address"`
-}
-
-func main() {
- route := gin.Default()
- route.GET("/testing", startPage)
- route.Run(":8085")
-}
-
-func startPage(c *gin.Context) {
- var person Person
- // If `GET`, only `Form` binding engine (`query`) used.
- // If `POST`, first checks the `content-type` for `JSON` or `XML`, then uses `Form` (`form-data`).
- // See more at https://github.com/gin-gonic/gin/blob/develop/binding/binding.go#L45
- if c.Bind(&person) == nil {
- log.Println(person.Name)
- log.Println(person.Address)
- }
-
- c.String(200, "Success")
-}
-```
-
-### Multipart/Urlencoded binding
-
-```go
-package main
-
-import (
- "github.com/gin-gonic/gin"
-)
-
-type LoginForm struct {
- User string `form:"user" binding:"required"`
- Password string `form:"password" binding:"required"`
-}
-
-func main() {
- router := gin.Default()
- router.POST("/login", func(c *gin.Context) {
- // you can bind multipart form with explicit binding declaration:
- // c.MustBindWith(&form, binding.Form)
- // or you can simply use autobinding with Bind method:
- var form LoginForm
- // in this case proper binding will be automatically selected
- if c.Bind(&form) == nil {
- if form.User == "user" && form.Password == "password" {
- c.JSON(200, gin.H{"status": "you are logged in"})
- } else {
- c.JSON(401, gin.H{"status": "unauthorized"})
- }
- }
- })
- router.Run(":8080")
-}
-```
-
-Test it with:
-```sh
-$ curl -v --form user=user --form password=password http://localhost:8080/login
-```
-
-### XML, JSON and YAML rendering
-
-```go
-func main() {
- r := gin.Default()
-
- // gin.H is a shortcut for map[string]interface{}
- r.GET("/someJSON", func(c *gin.Context) {
- c.JSON(http.StatusOK, gin.H{"message": "hey", "status": http.StatusOK})
- })
-
- r.GET("/moreJSON", func(c *gin.Context) {
- // You also can use a struct
- var msg struct {
- Name string `json:"user"`
- Message string
- Number int
- }
- msg.Name = "Lena"
- msg.Message = "hey"
- msg.Number = 123
- // Note that msg.Name becomes "user" in the JSON
- // Will output : {"user": "Lena", "Message": "hey", "Number": 123}
- c.JSON(http.StatusOK, msg)
- })
-
- r.GET("/someXML", func(c *gin.Context) {
- c.XML(http.StatusOK, gin.H{"message": "hey", "status": http.StatusOK})
- })
-
- r.GET("/someYAML", func(c *gin.Context) {
- c.YAML(http.StatusOK, gin.H{"message": "hey", "status": http.StatusOK})
- })
-
- // Listen and serve on 0.0.0.0:8080
- r.Run(":8080")
-}
-```
-
-### Serving static files
-
-```go
-func main() {
- router := gin.Default()
- router.Static("/assets", "./assets")
- router.StaticFS("/more_static", http.Dir("my_file_system"))
- router.StaticFile("/favicon.ico", "./resources/favicon.ico")
-
- // Listen and serve on 0.0.0.0:8080
- router.Run(":8080")
-}
-```
-
-### HTML rendering
-
-Using LoadHTMLGlob() or LoadHTMLFiles()
-
-```go
-func main() {
- router := gin.Default()
- router.LoadHTMLGlob("templates/*")
- //router.LoadHTMLFiles("templates/template1.html", "templates/template2.html")
- router.GET("/index", func(c *gin.Context) {
- c.HTML(http.StatusOK, "index.tmpl", gin.H{
- "title": "Main website",
- })
- })
- router.Run(":8080")
-}
-```
-
-templates/index.tmpl
-
-```html
-
- Using posts/index.tmpl
- -{{ end }} -``` - -templates/users/index.tmpl - -```html -{{ define "users/index.tmpl" }} -Using users/index.tmpl
- -{{ end }} -``` - -You can also use your own html template render - -```go -import "html/template" - -func main() { - router := gin.Default() - html := template.Must(template.ParseFiles("file1", "file2")) - router.SetHTMLTemplate(html) - router.Run(":8080") -} -``` - -You may use custom delims - -```go - r := gin.Default() - r.Delims("{[{", "}]}") - r.LoadHTMLGlob("/path/to/templates")) -``` - -#### Add custom template funcs - -main.go - -```go - ... - - func formatAsDate(t time.Time) string { - year, month, day := t.Date() - return fmt.Sprintf("%d/%02d/%02d", year, month, day) - } - - ... - - router.SetFuncMap(template.FuncMap{ - "formatAsDate": formatAsDate, - }) - - ... - - router.GET("/raw", func(c *Context) { - c.HTML(http.StatusOK, "raw.tmpl", map[string]interface{}{ - "now": time.Date(2017, 07, 01, 0, 0, 0, 0, time.UTC), - }) - }) - - ... -``` - -raw.tmpl - -```html -Date: {[{.now | formatAsDate}]} -``` - -Result: -``` -Date: 2017/07/01 -``` - -### Multitemplate - -Gin allow by default use only one html.Template. Check [a multitemplate render](https://github.com/gin-contrib/multitemplate) for using features like go 1.6 `block template`. - -### Redirects - -Issuing a HTTP redirect is easy: - -```go -r.GET("/test", func(c *gin.Context) { - c.Redirect(http.StatusMovedPermanently, "http://www.google.com/") -}) -``` -Both internal and external locations are supported. - - -### Custom Middleware - -```go -func Logger() gin.HandlerFunc { - return func(c *gin.Context) { - t := time.Now() - - // Set example variable - c.Set("example", "12345") - - // before request - - c.Next() - - // after request - latency := time.Since(t) - log.Print(latency) - - // access the status we are sending - status := c.Writer.Status() - log.Println(status) - } -} - -func main() { - r := gin.New() - r.Use(Logger()) - - r.GET("/test", func(c *gin.Context) { - example := c.MustGet("example").(string) - - // it would print: "12345" - log.Println(example) - }) - - // Listen and serve on 0.0.0.0:8080 - r.Run(":8080") -} -``` - -### Using BasicAuth() middleware - -```go -// simulate some private data -var secrets = gin.H{ - "foo": gin.H{"email": "foo@bar.com", "phone": "123433"}, - "austin": gin.H{"email": "austin@example.com", "phone": "666"}, - "lena": gin.H{"email": "lena@guapa.com", "phone": "523443"}, -} - -func main() { - r := gin.Default() - - // Group using gin.BasicAuth() middleware - // gin.Accounts is a shortcut for map[string]string - authorized := r.Group("/admin", gin.BasicAuth(gin.Accounts{ - "foo": "bar", - "austin": "1234", - "lena": "hello2", - "manu": "4321", - })) - - // /admin/secrets endpoint - // hit "localhost:8080/admin/secrets - authorized.GET("/secrets", func(c *gin.Context) { - // get user, it was set by the BasicAuth middleware - user := c.MustGet(gin.AuthUserKey).(string) - if secret, ok := secrets[user]; ok { - c.JSON(http.StatusOK, gin.H{"user": user, "secret": secret}) - } else { - c.JSON(http.StatusOK, gin.H{"user": user, "secret": "NO SECRET :("}) - } - }) - - // Listen and serve on 0.0.0.0:8080 - r.Run(":8080") -} -``` - -### Goroutines inside a middleware - -When starting inside a middleware or handler, you **SHOULD NOT** use the original context inside it, you have to use a read-only copy. - -```go -func main() { - r := gin.Default() - - r.GET("/long_async", func(c *gin.Context) { - // create copy to be used inside the goroutine - cCp := c.Copy() - go func() { - // simulate a long task with time.Sleep(). 5 seconds - time.Sleep(5 * time.Second) - - // note that you are using the copied context "cCp", IMPORTANT - log.Println("Done! in path " + cCp.Request.URL.Path) - }() - }) - - r.GET("/long_sync", func(c *gin.Context) { - // simulate a long task with time.Sleep(). 5 seconds - time.Sleep(5 * time.Second) - - // since we are NOT using a goroutine, we do not have to copy the context - log.Println("Done! in path " + c.Request.URL.Path) - }) - - // Listen and serve on 0.0.0.0:8080 - r.Run(":8080") -} -``` - -### Custom HTTP configuration - -Use `http.ListenAndServe()` directly, like this: - -```go -func main() { - router := gin.Default() - http.ListenAndServe(":8080", router) -} -``` -or - -```go -func main() { - router := gin.Default() - - s := &http.Server{ - Addr: ":8080", - Handler: router, - ReadTimeout: 10 * time.Second, - WriteTimeout: 10 * time.Second, - MaxHeaderBytes: 1 << 20, - } - s.ListenAndServe() -} -``` - -### Support Let's Encrypt - -example for 1-line LetsEncrypt HTTPS servers. - -[embedmd]:# (examples/auto-tls/example1.go go) -```go -package main - -import ( - "log" - - "github.com/gin-gonic/autotls" - "github.com/gin-gonic/gin" -) - -func main() { - r := gin.Default() - - // Ping handler - r.GET("/ping", func(c *gin.Context) { - c.String(200, "pong") - }) - - log.Fatal(autotls.Run(r, "example1.com", "example2.com")) -} -``` - -example for custom autocert manager. - -[embedmd]:# (examples/auto-tls/example2.go go) -```go -package main - -import ( - "log" - - "github.com/gin-gonic/autotls" - "github.com/gin-gonic/gin" - "golang.org/x/crypto/acme/autocert" -) - -func main() { - r := gin.Default() - - // Ping handler - r.GET("/ping", func(c *gin.Context) { - c.String(200, "pong") - }) - - m := autocert.Manager{ - Prompt: autocert.AcceptTOS, - HostPolicy: autocert.HostWhitelist("example1.com", "example2.com"), - Cache: autocert.DirCache("/var/www/.cache"), - } - - log.Fatal(autotls.RunWithManager(r, m)) -} -``` - -### Graceful restart or stop - -Do you want to graceful restart or stop your web server? -There are some ways this can be done. - -We can use [fvbock/endless](https://github.com/fvbock/endless) to replace the default `ListenAndServe`. Refer issue [#296](https://github.com/gin-gonic/gin/issues/296) for more details. - -```go -router := gin.Default() -router.GET("/", handler) -// [...] -endless.ListenAndServe(":4242", router) -``` - -An alternative to endless: - -* [manners](https://github.com/braintree/manners): A polite Go HTTP server that shuts down gracefully. -* [graceful](https://github.com/tylerb/graceful): Graceful is a Go package enabling graceful shutdown of an http.Handler server. -* [grace](https://github.com/facebookgo/grace): Graceful restart & zero downtime deploy for Go servers. - -If you are using Go 1.8, you may not need to use this library! Consider using http.Server's built-in [Shutdown()](https://golang.org/pkg/net/http/#Server.Shutdown) method for graceful shutdowns. See the full [graceful-shutdown](./examples/graceful-shutdown) example with gin. - -[embedmd]:# (examples/graceful-shutdown/graceful-shutdown/server.go go) -```go -// +build go1.8 - -package main - -import ( - "context" - "log" - "net/http" - "os" - "os/signal" - "time" - - "github.com/gin-gonic/gin" -) - -func main() { - router := gin.Default() - router.GET("/", func(c *gin.Context) { - time.Sleep(5 * time.Second) - c.String(http.StatusOK, "Welcome Gin Server") - }) - - srv := &http.Server{ - Addr: ":8080", - Handler: router, - } - - go func() { - // service connections - if err := srv.ListenAndServe(); err != nil { - log.Printf("listen: %s\n", err) - } - }() - - // Wait for interrupt signal to gracefully shutdown the server with - // a timeout of 5 seconds. - quit := make(chan os.Signal) - signal.Notify(quit, os.Interrupt) - <-quit - log.Println("Shutdown Server ...") - - ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) - defer cancel() - if err := srv.Shutdown(ctx); err != nil { - log.Fatal("Server Shutdown:", err) - } - log.Println("Server exist") -} -``` - -## Contributing - -- With issues: - - Use the search tool before opening a new issue. - - Please provide source code and commit sha if you found a bug. - - Review existing issues and provide feedback or react to them. -- With pull requests: - - Open your pull request against develop - - Your pull request should have no more than two commits, if not you should squash them. - - It should pass all tests in the available continuous integrations systems such as TravisCI. - - You should add/modify tests to cover your proposed code changes. - - If your pull request contains a new feature, please document it on the README. - -## Users - -Awesome project lists using [Gin](https://github.com/gin-gonic/gin) web framework. - -* [drone](https://github.com/drone/drone): Drone is a Continuous Delivery platform built on Docker, written in Go -* [gorush](https://github.com/appleboy/gorush): A push notification server written in Go. diff --git a/vendor/github.com/gin-gonic/gin/auth.go b/vendor/github.com/gin-gonic/gin/auth.go deleted file mode 100644 index 125e659..0000000 --- a/vendor/github.com/gin-gonic/gin/auth.go +++ /dev/null @@ -1,92 +0,0 @@ -// Copyright 2014 Manu Martinez-Almeida. All rights reserved. -// Use of this source code is governed by a MIT style -// license that can be found in the LICENSE file. - -package gin - -import ( - "crypto/subtle" - "encoding/base64" - "strconv" -) - -const AuthUserKey = "user" - -type ( - Accounts map[string]string - authPair struct { - Value string - User string - } - authPairs []authPair -) - -func (a authPairs) searchCredential(authValue string) (string, bool) { - if len(authValue) == 0 { - return "", false - } - for _, pair := range a { - if pair.Value == authValue { - return pair.User, true - } - } - return "", false -} - -// BasicAuthForRealm returns a Basic HTTP Authorization middleware. It takes as arguments a map[string]string where -// the key is the user name and the value is the password, as well as the name of the Realm. -// If the realm is empty, "Authorization Required" will be used by default. -// (see http://tools.ietf.org/html/rfc2617#section-1.2) -func BasicAuthForRealm(accounts Accounts, realm string) HandlerFunc { - if realm == "" { - realm = "Authorization Required" - } - realm = "Basic realm=" + strconv.Quote(realm) - pairs := processAccounts(accounts) - return func(c *Context) { - // Search user in the slice of allowed credentials - user, found := pairs.searchCredential(c.Request.Header.Get("Authorization")) - if !found { - // Credentials doesn't match, we return 401 and abort handlers chain. - c.Header("WWW-Authenticate", realm) - c.AbortWithStatus(401) - } else { - // The user credentials was found, set user's id to key AuthUserKey in this context, the userId can be read later using - // c.MustGet(gin.AuthUserKey) - c.Set(AuthUserKey, user) - } - } -} - -// BasicAuth returns a Basic HTTP Authorization middleware. It takes as argument a map[string]string where -// the key is the user name and the value is the password. -func BasicAuth(accounts Accounts) HandlerFunc { - return BasicAuthForRealm(accounts, "") -} - -func processAccounts(accounts Accounts) authPairs { - assert1(len(accounts) > 0, "Empty list of authorized credentials") - pairs := make(authPairs, 0, len(accounts)) - for user, password := range accounts { - assert1(len(user) > 0, "User can not be empty") - value := authorizationHeader(user, password) - pairs = append(pairs, authPair{ - Value: value, - User: user, - }) - } - return pairs -} - -func authorizationHeader(user, password string) string { - base := user + ":" + password - return "Basic " + base64.StdEncoding.EncodeToString([]byte(base)) -} - -func secureCompare(given, actual string) bool { - if subtle.ConstantTimeEq(int32(len(given)), int32(len(actual))) == 1 { - return subtle.ConstantTimeCompare([]byte(given), []byte(actual)) == 1 - } - /* Securely compare actual to itself to keep constant time, but always return false */ - return subtle.ConstantTimeCompare([]byte(actual), []byte(actual)) == 1 && false -} diff --git a/vendor/github.com/gin-gonic/gin/auth_test.go b/vendor/github.com/gin-gonic/gin/auth_test.go deleted file mode 100644 index b22d9ce..0000000 --- a/vendor/github.com/gin-gonic/gin/auth_test.go +++ /dev/null @@ -1,146 +0,0 @@ -// Copyright 2014 Manu Martinez-Almeida. All rights reserved. -// Use of this source code is governed by a MIT style -// license that can be found in the LICENSE file. - -package gin - -import ( - "encoding/base64" - "net/http" - "net/http/httptest" - "testing" - - "github.com/stretchr/testify/assert" -) - -func TestBasicAuth(t *testing.T) { - pairs := processAccounts(Accounts{ - "admin": "password", - "foo": "bar", - "bar": "foo", - }) - - assert.Len(t, pairs, 3) - assert.Contains(t, pairs, authPair{ - User: "bar", - Value: "Basic YmFyOmZvbw==", - }) - assert.Contains(t, pairs, authPair{ - User: "foo", - Value: "Basic Zm9vOmJhcg==", - }) - assert.Contains(t, pairs, authPair{ - User: "admin", - Value: "Basic YWRtaW46cGFzc3dvcmQ=", - }) -} - -func TestBasicAuthFails(t *testing.T) { - assert.Panics(t, func() { processAccounts(nil) }) - assert.Panics(t, func() { - processAccounts(Accounts{ - "": "password", - "foo": "bar", - }) - }) -} - -func TestBasicAuthSearchCredential(t *testing.T) { - pairs := processAccounts(Accounts{ - "admin": "password", - "foo": "bar", - "bar": "foo", - }) - - user, found := pairs.searchCredential(authorizationHeader("admin", "password")) - assert.Equal(t, user, "admin") - assert.True(t, found) - - user, found = pairs.searchCredential(authorizationHeader("foo", "bar")) - assert.Equal(t, user, "foo") - assert.True(t, found) - - user, found = pairs.searchCredential(authorizationHeader("bar", "foo")) - assert.Equal(t, user, "bar") - assert.True(t, found) - - user, found = pairs.searchCredential(authorizationHeader("admins", "password")) - assert.Empty(t, user) - assert.False(t, found) - - user, found = pairs.searchCredential(authorizationHeader("foo", "bar ")) - assert.Empty(t, user) - assert.False(t, found) - - user, found = pairs.searchCredential("") - assert.Empty(t, user) - assert.False(t, found) -} - -func TestBasicAuthAuthorizationHeader(t *testing.T) { - assert.Equal(t, authorizationHeader("admin", "password"), "Basic YWRtaW46cGFzc3dvcmQ=") -} - -func TestBasicAuthSecureCompare(t *testing.T) { - assert.True(t, secureCompare("1234567890", "1234567890")) - assert.False(t, secureCompare("123456789", "1234567890")) - assert.False(t, secureCompare("12345678900", "1234567890")) - assert.False(t, secureCompare("1234567891", "1234567890")) -} - -func TestBasicAuthSucceed(t *testing.T) { - accounts := Accounts{"admin": "password"} - router := New() - router.Use(BasicAuth(accounts)) - router.GET("/login", func(c *Context) { - c.String(200, c.MustGet(AuthUserKey).(string)) - }) - - w := httptest.NewRecorder() - req, _ := http.NewRequest("GET", "/login", nil) - req.Header.Set("Authorization", authorizationHeader("admin", "password")) - router.ServeHTTP(w, req) - - assert.Equal(t, w.Code, 200) - assert.Equal(t, w.Body.String(), "admin") -} - -func TestBasicAuth401(t *testing.T) { - called := false - accounts := Accounts{"foo": "bar"} - router := New() - router.Use(BasicAuth(accounts)) - router.GET("/login", func(c *Context) { - called = true - c.String(200, c.MustGet(AuthUserKey).(string)) - }) - - w := httptest.NewRecorder() - req, _ := http.NewRequest("GET", "/login", nil) - req.Header.Set("Authorization", "Basic "+base64.StdEncoding.EncodeToString([]byte("admin:password"))) - router.ServeHTTP(w, req) - - assert.False(t, called) - assert.Equal(t, w.Code, 401) - assert.Equal(t, w.HeaderMap.Get("WWW-Authenticate"), "Basic realm=\"Authorization Required\"") -} - -func TestBasicAuth401WithCustomRealm(t *testing.T) { - called := false - accounts := Accounts{"foo": "bar"} - router := New() - router.Use(BasicAuthForRealm(accounts, "My Custom \"Realm\"")) - router.GET("/login", func(c *Context) { - called = true - c.String(200, c.MustGet(AuthUserKey).(string)) - }) - - w := httptest.NewRecorder() - req, _ := http.NewRequest("GET", "/login", nil) - req.Header.Set("Authorization", "Basic "+base64.StdEncoding.EncodeToString([]byte("admin:password"))) - router.ServeHTTP(w, req) - - assert.False(t, called) - assert.Equal(t, w.Code, 401) - assert.Equal(t, w.HeaderMap.Get("WWW-Authenticate"), "Basic realm=\"My Custom \\\"Realm\\\"\"") -} diff --git a/vendor/github.com/gin-gonic/gin/benchmarks_test.go b/vendor/github.com/gin-gonic/gin/benchmarks_test.go deleted file mode 100644 index a2c62ba..0000000 --- a/vendor/github.com/gin-gonic/gin/benchmarks_test.go +++ /dev/null @@ -1,162 +0,0 @@ -// Copyright 2017 Manu Martinez-Almeida. All rights reserved. -// Use of this source code is governed by a MIT style -// license that can be found in the LICENSE file. - -package gin - -import ( - "html/template" - "net/http" - "os" - "testing" -) - -func BenchmarkOneRoute(B *testing.B) { - router := New() - router.GET("/ping", func(c *Context) {}) - runRequest(B, router, "GET", "/ping") -} - -func BenchmarkRecoveryMiddleware(B *testing.B) { - router := New() - router.Use(Recovery()) - router.GET("/", func(c *Context) {}) - runRequest(B, router, "GET", "/") -} - -func BenchmarkLoggerMiddleware(B *testing.B) { - router := New() - router.Use(LoggerWithWriter(newMockWriter())) - router.GET("/", func(c *Context) {}) - runRequest(B, router, "GET", "/") -} - -func BenchmarkManyHandlers(B *testing.B) { - router := New() - router.Use(Recovery(), LoggerWithWriter(newMockWriter())) - router.Use(func(c *Context) {}) - router.Use(func(c *Context) {}) - router.GET("/ping", func(c *Context) {}) - runRequest(B, router, "GET", "/ping") -} - -func Benchmark5Params(B *testing.B) { - DefaultWriter = os.Stdout - router := New() - router.Use(func(c *Context) {}) - router.GET("/param/:param1/:params2/:param3/:param4/:param5", func(c *Context) {}) - runRequest(B, router, "GET", "/param/path/to/parameter/john/12345") -} - -func BenchmarkOneRouteJSON(B *testing.B) { - router := New() - data := struct { - Status string `json:"status"` - }{"ok"} - router.GET("/json", func(c *Context) { - c.JSON(200, data) - }) - runRequest(B, router, "GET", "/json") -} - -var htmlContentType = []string{"text/html; charset=utf-8"} - -func BenchmarkOneRouteHTML(B *testing.B) { - router := New() - t := template.Must(template.New("index").Parse(` -Server-sent events (SSE) is a technology where a browser receives automatic updates from a server via HTTP connection. It is not websockets. Learn more.
-The chat and the charts data is provided in realtime using the SSE implemention of Gin Framework.
-| Nick | -Message | -
|---|
- ◼︎ Users
- ◼︎ Inbound messages / sec
- ◼︎ Outbound messages / sec
-
-
- -
- ◼︎ Heap bytes
- ◼︎ Stack bytes
-
-
- -
- ◼︎ Mallocs / sec
- ◼︎ Frees / sec
-
func streamRoom(c *gin.Context) {
- roomid := c.ParamValue("roomid")
- listener := openListener(roomid)
- statsTicker := time.NewTicker(1 * time.Second)
- defer closeListener(roomid, listener)
- defer statsTicker.Stop()
-
- c.Stream(func(w io.Writer) bool {
- select {
- case msg := <-listener:
- c.SSEvent("message", msg)
- case <-statsTicker.C:
- c.SSEvent("stats", Stats())
- }
- return true
- })
-}function StartSSE(roomid) {
- var source = new EventSource('/stream/'+roomid);
- source.addEventListener('message', newChatMessage, false);
- source.addEventListener('stats', stats, false);
-}import "github.com/manucorporat/sse"
-
-func httpHandler(w http.ResponseWriter, req *http.Request) {
- // data can be a primitive like a string, an integer or a float
- sse.Encode(w, sse.Event{
- Event: "message",
- Data: "some data\nmore data",
- })
-
- // also a complex type, like a map, a struct or a slice
- sse.Encode(w, sse.Event{
- Id: "124",
- Event: "message",
- Data: map[string]interface{}{
- "user": "manu",
- "date": time.Now().Unix(),
- "content": "hi!",
- },
- })
-}event: message
-data: some data\\nmore data
-
-id: 124
-event: message
-data: {"content":"hi!","date":1431540810,"user":"manu"}
-