Update dependencies (#333)

2025-06-05 21:59:39 +02:00 · 2021-11-27 15:26:58 +01:00
parent ce22e03f9d
commit 182b4eea73
848 changed files with 377869 additions and 107280 deletions
--- a/vendor/github.com/gin-contrib/sessions/.travis.yml
+++ b/vendor/github.com/gin-contrib/sessions/.travis.yml
@ -1,44 +0,0 @@
-language: go
-sudo: false
-
-matrix:
-  fast_finish: true
-  include:
-  - go: 1.10.x
-  - go: 1.11.x
-    env: GO111MODULE=on
-  - go: 1.12.x
-    env: GO111MODULE=on
-  - go: 1.13.x
-  - go: master
-    env: GO111MODULE=on
-
-git:
-  depth: 10
-
-services:
-  - redis
-  - memcached
-  - mongodb
-
-before_install:
-  - go get github.com/campoy/embedmd
-
-install:
-  - if [[ "${GO111MODULE}" = "on" ]]; then go mod download; else go get -t -v .; fi
-  - if [[ "${GO111MODULE}" = "on" ]]; then export PATH="${GOPATH}/bin:${GOROOT}/bin:${PATH}"; fi
-
-script:
-  - embedmd -d *.md
-  - go test -v -covermode=atomic -coverprofile=coverage.out ./...
-
-after_success:
-  - bash <(curl -s https://codecov.io/bash)
-
-notifications:
-  webhooks:
-    urls:
-      - https://webhooks.gitter.im/e/acc2c57482e94b44f557
-    on_success: change
-    on_failure: always
-    on_start: false
--- a/vendor/github.com/gin-contrib/sessions/README.md
+++ b/vendor/github.com/gin-contrib/sessions/README.md
@ -1,6 +1,7 @@
 # sessions

-[![Build Status](https://travis-ci.org/gin-contrib/sessions.svg)](https://travis-ci.org/gin-contrib/sessions)
+[![Run CI Lint](https://github.com/gin-contrib/sessions/actions/workflows/lint.yml/badge.svg)](https://github.com/gin-contrib/sessions/actions/workflows/lint.yml)
+[![Run Testing](https://github.com/gin-contrib/sessions/actions/workflows/testing.yml/badge.svg)](https://github.com/gin-contrib/sessions/actions/workflows/testing.yml)
 [![codecov](https://codecov.io/gh/gin-contrib/sessions/branch/master/graph/badge.svg)](https://codecov.io/gh/gin-contrib/sessions)
 [![Go Report Card](https://goreportcard.com/badge/github.com/gin-contrib/sessions)](https://goreportcard.com/report/github.com/gin-contrib/sessions)
 [![GoDoc](https://godoc.org/github.com/gin-contrib/sessions?status.svg)](https://godoc.org/github.com/gin-contrib/sessions)
@ -13,6 +14,7 @@ Gin middleware for session management with multi-backend support:
 - [memcached](#memcached)
 - [MongoDB](#mongodb)
 - [memstore](#memstore)
+- [PostgreSQL](#postgresql)

 ## Usage

@ -21,7 +23,7 @@ Gin middleware for session management with multi-backend support:
 Download and install it:

 ```bash
-$ go get github.com/gin-contrib/sessions
+go get github.com/gin-contrib/sessions
 ```

 Import it in your code:
@ -38,27 +40,27 @@ import "github.com/gin-contrib/sessions"
 package main

 import (
-	"github.com/gin-contrib/sessions"
-	"github.com/gin-contrib/sessions/cookie"
-	"github.com/gin-gonic/gin"
+  "github.com/gin-contrib/sessions"
+  "github.com/gin-contrib/sessions/cookie"
+  "github.com/gin-gonic/gin"
 )

 func main() {
-	r := gin.Default()
-	store := cookie.NewStore([]byte("secret"))
-	r.Use(sessions.Sessions("mysession", store))
+  r := gin.Default()
+  store := cookie.NewStore([]byte("secret"))
+  r.Use(sessions.Sessions("mysession", store))

-	r.GET("/hello", func(c *gin.Context) {
-		session := sessions.Default(c)
+  r.GET("/hello", func(c *gin.Context) {
+    session := sessions.Default(c)

-		if session.Get("hello") != "world" {
-			session.Set("hello", "world")
-			session.Save()
-		}
+    if session.Get("hello") != "world" {
+      session.Set("hello", "world")
+      session.Save()
+    }

-		c.JSON(200, gin.H{"hello": session.Get("hello")})
-	})
-	r.Run(":8000")
+    c.JSON(200, gin.H{"hello": session.Get("hello")})
+  })
+  r.Run(":8000")
 }
 ```

@ -68,109 +70,107 @@ func main() {
 package main

 import (
-	"github.com/gin-contrib/sessions"
-	"github.com/gin-contrib/sessions/cookie"
-	"github.com/gin-gonic/gin"
+  "github.com/gin-contrib/sessions"
+  "github.com/gin-contrib/sessions/cookie"
+  "github.com/gin-gonic/gin"
 )

 func main() {
-	r := gin.Default()
-	store := cookie.NewStore([]byte("secret"))
-	sessionNames := []string{"a", "b"}
-	r.Use(sessions.SessionsMany(sessionNames, store))
+  r := gin.Default()
+  store := cookie.NewStore([]byte("secret"))
+  sessionNames := []string{"a", "b"}
+  r.Use(sessions.SessionsMany(sessionNames, store))

-	r.GET("/hello", func(c *gin.Context) {
-		sessionA := sessions.DefaultMany(c, "a")
-		sessionB := sessions.DefaultMany(c, "b")
+  r.GET("/hello", func(c *gin.Context) {
+    sessionA := sessions.DefaultMany(c, "a")
+    sessionB := sessions.DefaultMany(c, "b")

-		if sessionA.Get("hello") != "world!" {
-			sessionA.Set("hello", "world!")
-			sessionA.Save()
-		}
+    if sessionA.Get("hello") != "world!" {
+      sessionA.Set("hello", "world!")
+      sessionA.Save()
+    }

-		if sessionB.Get("hello") != "world?" {
-			sessionB.Set("hello", "world?")
-			sessionB.Save()
-		}
+    if sessionB.Get("hello") != "world?" {
+      sessionB.Set("hello", "world?")
+      sessionB.Save()
+    }

-		c.JSON(200, gin.H{
-			"a": sessionA.Get("hello"),
-			"b": sessionB.Get("hello"),
-		})
-	})
-	r.Run(":8000")
+    c.JSON(200, gin.H{
+      "a": sessionA.Get("hello"),
+      "b": sessionB.Get("hello"),
+    })
+  })
+  r.Run(":8000")
 }
 ```

-## Backend examples
+## Backend Examples

 ### cookie-based

-[embedmd]:# (example/cookie/main.go go)
 ```go
 package main

 import (
-	"github.com/gin-contrib/sessions"
-	"github.com/gin-contrib/sessions/cookie"
-	"github.com/gin-gonic/gin"
+  "github.com/gin-contrib/sessions"
+  "github.com/gin-contrib/sessions/cookie"
+  "github.com/gin-gonic/gin"
 )

 func main() {
-	r := gin.Default()
-	store := cookie.NewStore([]byte("secret"))
-	r.Use(sessions.Sessions("mysession", store))
+  r := gin.Default()
+  store := cookie.NewStore([]byte("secret"))
+  r.Use(sessions.Sessions("mysession", store))

-	r.GET("/incr", func(c *gin.Context) {
-		session := sessions.Default(c)
-		var count int
-		v := session.Get("count")
-		if v == nil {
-			count = 0
-		} else {
-			count = v.(int)
-			count++
-		}
-		session.Set("count", count)
-		session.Save()
-		c.JSON(200, gin.H{"count": count})
-	})
-	r.Run(":8000")
+  r.GET("/incr", func(c *gin.Context) {
+    session := sessions.Default(c)
+    var count int
+    v := session.Get("count")
+    if v == nil {
+      count = 0
+    } else {
+      count = v.(int)
+      count++
+    }
+    session.Set("count", count)
+    session.Save()
+    c.JSON(200, gin.H{"count": count})
+  })
+  r.Run(":8000")
 }
 ```

 ### Redis

-[embedmd]:# (example/redis/main.go go)
 ```go
 package main

 import (
-	"github.com/gin-contrib/sessions"
-	"github.com/gin-contrib/sessions/redis"
-	"github.com/gin-gonic/gin"
+  "github.com/gin-contrib/sessions"
+  "github.com/gin-contrib/sessions/redis"
+  "github.com/gin-gonic/gin"
 )

 func main() {
-	r := gin.Default()
-	store, _ := redis.NewStore(10, "tcp", "localhost:6379", "", []byte("secret"))
-	r.Use(sessions.Sessions("mysession", store))
+  r := gin.Default()
+  store, _ := redis.NewStore(10, "tcp", "localhost:6379", "", []byte("secret"))
+  r.Use(sessions.Sessions("mysession", store))

-	r.GET("/incr", func(c *gin.Context) {
-		session := sessions.Default(c)
-		var count int
-		v := session.Get("count")
-		if v == nil {
-			count = 0
-		} else {
-			count = v.(int)
-			count++
-		}
-		session.Set("count", count)
-		session.Save()
-		c.JSON(200, gin.H{"count": count})
-	})
-	r.Run(":8000")
+  r.GET("/incr", func(c *gin.Context) {
+    session := sessions.Default(c)
+    var count int
+    v := session.Get("count")
+    if v == nil {
+      count = 0
+    } else {
+      count = v.(int)
+      count++
+    }
+    session.Set("count", count)
+    session.Save()
+    c.JSON(200, gin.H{"count": count})
+  })
+  r.Run(":8000")
 }
 ```

@ -178,134 +178,174 @@ func main() {

 #### ASCII Protocol

-[embedmd]:# (example/memcached/ascii.go go)
 ```go
 package main

 import (
-	"github.com/bradfitz/gomemcache/memcache"
-	"github.com/gin-contrib/sessions"
-	"github.com/gin-contrib/sessions/memcached"
-	"github.com/gin-gonic/gin"
+  "github.com/bradfitz/gomemcache/memcache"
+  "github.com/gin-contrib/sessions"
+  "github.com/gin-contrib/sessions/memcached"
+  "github.com/gin-gonic/gin"
 )

 func main() {
-	r := gin.Default()
-	store := memcached.NewStore(memcache.New("localhost:11211"), "", []byte("secret"))
-	r.Use(sessions.Sessions("mysession", store))
+  r := gin.Default()
+  store := memcached.NewStore(memcache.New("localhost:11211"), "", []byte("secret"))
+  r.Use(sessions.Sessions("mysession", store))

-	r.GET("/incr", func(c *gin.Context) {
-		session := sessions.Default(c)
-		var count int
-		v := session.Get("count")
-		if v == nil {
-			count = 0
-		} else {
-			count = v.(int)
-			count++
-		}
-		session.Set("count", count)
-		session.Save()
-		c.JSON(200, gin.H{"count": count})
-	})
-	r.Run(":8000")
+  r.GET("/incr", func(c *gin.Context) {
+    session := sessions.Default(c)
+    var count int
+    v := session.Get("count")
+    if v == nil {
+      count = 0
+    } else {
+      count = v.(int)
+      count++
+    }
+    session.Set("count", count)
+    session.Save()
+    c.JSON(200, gin.H{"count": count})
+  })
+  r.Run(":8000")
 }
 ```

 #### Binary protocol (with optional SASL authentication)

-[embedmd]:# (example/memcached/binary.go go)
 ```go
 package main

 import (
-	"github.com/gin-contrib/sessions"
-	"github.com/gin-contrib/sessions/memcached"
-	"github.com/gin-gonic/gin"
-	"github.com/memcachier/mc"
+  "github.com/gin-contrib/sessions"
+  "github.com/gin-contrib/sessions/memcached"
+  "github.com/gin-gonic/gin"
+  "github.com/memcachier/mc"
 )

 func main() {
-	r := gin.Default()
-	client := mc.NewMC("localhost:11211", "username", "password")
-	store := memcached.NewMemcacheStore(client, "", []byte("secret"))
-	r.Use(sessions.Sessions("mysession", store))
+  r := gin.Default()
+  client := mc.NewMC("localhost:11211", "username", "password")
+  store := memcached.NewMemcacheStore(client, "", []byte("secret"))
+  r.Use(sessions.Sessions("mysession", store))

-	r.GET("/incr", func(c *gin.Context) {
-		session := sessions.Default(c)
-		var count int
-		v := session.Get("count")
-		if v == nil {
-			count = 0
-		} else {
-			count = v.(int)
-			count++
-		}
-		session.Set("count", count)
-		session.Save()
-		c.JSON(200, gin.H{"count": count})
-	})
-	r.Run(":8000")
+  r.GET("/incr", func(c *gin.Context) {
+    session := sessions.Default(c)
+    var count int
+    v := session.Get("count")
+    if v == nil {
+      count = 0
+    } else {
+      count = v.(int)
+      count++
+    }
+    session.Set("count", count)
+    session.Save()
+    c.JSON(200, gin.H{"count": count})
+  })
+  r.Run(":8000")
 }
 ```

 ### MongoDB

-[embedmd]:# (example/mongo/main.go go)
 ```go
 package main

 import (
-	"github.com/gin-contrib/sessions"
-	"github.com/gin-contrib/sessions/mongo"
-	"github.com/gin-gonic/gin"
-	"github.com/globalsign/mgo"
+  "github.com/gin-contrib/sessions"
+  "github.com/gin-contrib/sessions/mongo"
+  "github.com/gin-gonic/gin"
+  "github.com/globalsign/mgo"
 )

 func main() {
-	r := gin.Default()
-	session, err := mgo.Dial("localhost:27017/test")
-	if err != nil {
-		// handle err
-	}
+  r := gin.Default()
+  session, err := mgo.Dial("localhost:27017/test")
+  if err != nil {
+    // handle err
+  }

-	c := session.DB("").C("sessions")
-	store := mongo.NewStore(c, 3600, true, []byte("secret"))
-	r.Use(sessions.Sessions("mysession", store))
+  c := session.DB("").C("sessions")
+  store := mongo.NewStore(c, 3600, true, []byte("secret"))
+  r.Use(sessions.Sessions("mysession", store))

-	r.GET("/incr", func(c *gin.Context) {
-		session := sessions.Default(c)
-		var count int
-		v := session.Get("count")
-		if v == nil {
-			count = 0
-		} else {
-			count = v.(int)
-			count++
-		}
-		session.Set("count", count)
-		session.Save()
-		c.JSON(200, gin.H{"count": count})
-	})
-	r.Run(":8000")
+  r.GET("/incr", func(c *gin.Context) {
+    session := sessions.Default(c)
+    var count int
+    v := session.Get("count")
+    if v == nil {
+      count = 0
+    } else {
+      count = v.(int)
+      count++
+    }
+    session.Set("count", count)
+    session.Save()
+    c.JSON(200, gin.H{"count": count})
+  })
+  r.Run(":8000")
 }
 ```

 ### memstore

-[embedmd]:# (example/memstore/main.go go)
 ```go
 package main

 import (
+  "github.com/gin-contrib/sessions"
+  "github.com/gin-contrib/sessions/memstore"
+  "github.com/gin-gonic/gin"
+)
+
+func main() {
+  r := gin.Default()
+  store := memstore.NewStore([]byte("secret"))
+  r.Use(sessions.Sessions("mysession", store))
+
+  r.GET("/incr", func(c *gin.Context) {
+    session := sessions.Default(c)
+    var count int
+    v := session.Get("count")
+    if v == nil {
+      count = 0
+    } else {
+      count = v.(int)
+      count++
+    }
+    session.Set("count", count)
+    session.Save()
+    c.JSON(200, gin.H{"count": count})
+  })
+  r.Run(":8000")
+}
+```
+
+### PostgreSQL
+
+```go
+package main
+
+import (
+	"database/sql"
 	"github.com/gin-contrib/sessions"
-	"github.com/gin-contrib/sessions/memstore"
+	"github.com/gin-contrib/sessions/postgres"
 	"github.com/gin-gonic/gin"
 )

 func main() {
 	r := gin.Default()
-	store := memstore.NewStore([]byte("secret"))
+	db, err := sql.Open("postgres", "postgresql://username:password@localhost:5432/database")
+	if err != nil {
+		// handle err
+	}
+
+	store, err := postgres.NewStore(db, []byte("secret"))
+	if err != nil {
+		// handle err
+	}
+
 	r.Use(sessions.Sessions("mysession", store))

 	r.GET("/incr", func(c *gin.Context) {
@ -325,5 +365,3 @@ func main() {
 	r.Run(":8000")
 }
 ```
-
-
--- a/vendor/github.com/gin-contrib/sessions/sessions.go
+++ b/vendor/github.com/gin-contrib/sessions/sessions.go
@ -22,6 +22,8 @@ type Store interface {
 // Wraps thinly gorilla-session methods.
 // Session stores the values and optional configuration for a session.
 type Session interface {
+	// ID of the session, generated by stores. It should not be used for user data.
+	ID() string
 	// Get returns the session value associated to the given key.
 	Get(key interface{}) interface{}
 	// Set sets the session value associated to the given key.
@ -74,6 +76,10 @@ type session struct {
 	writer  http.ResponseWriter
 }

+func (s *session) ID() string {
+	return s.Session().ID
+}
+
 func (s *session) Get(key interface{}) interface{} {
 	return s.Session().Values[key]
 }