migliori pratiche con le sessioni (Gorilla/sessioni)

Question

Prima di iniziare con le sessioni in golang ho bisogno di risposte ad alcune domande

sessione esempio

import "github.com/gorilla/sessions" 

var store = sessions.NewCookieStore([]byte("33446a9dcf9ea060a0a6532b166da32f304af0de")) 

func Handler(w http.ResponseWriter, r *http.Request){ 
    session, _ := store.Get(r, "session-name") 

    session.Values["foo"] = "bar" 
    session.Values[42] = 43 
    session.Save(r, w) 

    fmt.Fprint(w, "Hello world :)") 
} 

func main(){ 
    store.Options = &sessions.Options{ 
     Domain:  "localhost", 
     Path:  "/", 
     MaxAge:  60 * 15, 
     Secure:  false, 
     HttpOnly: true, 
    } 
} 

Q1:

E 'possibile aggiungere più sessioni nello stesso dominio con nomi diversi?

session1, _ := store.Get(r, "session-name-1") 
session2, _ := store.Get(r, "session-name-2") 

Quando sono necessarie più sessioni nello stesso dominio?

Q2:

Qual è la migliore pratica per ottenere le variabili della sessione? my_session_var = session.Values ​​[ "foo"]

Q3:

Come controllare se la sessione viene salvata in modo corretto? Se si accede allo stesso map sia per impostare che per ottenere le variabili?

aggiornamento

package main 

import (
    "github.com/gorilla/sessions" 
) 

var (
    store = sessions.NewCookieStore([]byte("33446a9dcf9ea060a0a6532b166da32f304af0de")) 
) 

type handler func(w http.ResponseWriter, r *http.Request, s *sessions.Session) 

func (h handler) ServeHTTP(w http.ResponseWriter, r *http.Request){ 
    session, _ := store.Get(r, "session-name") 

    h(w, r, session) 
} 

func Handler_404(w http.ResponseWriter, r *http.Request, s *sessions.Session){ 
    fmt.Fprint(w, "Oops, something went wrong!") 
} 

errore

# command-line-arguments 
.\mux.go:101: cannot convert Handler_404 (type func(http.ResponseWriter, *http.Request, *sessions.Session)) to type http.HandlerFunc 

Answer 1

L'articolo "BASIC EXTENSION OF GO’S HTTP HANDLERS" (Simon Whitehead) mostra un esempio di dove e quando per definire sessione.
Invece di farlo nello stesso Handler e dover duplicare un sacco di codice quando si definiscono altri gestori.

Con un named type, è possibile definire il Handler è necessario:

type handler func(w http.ResponseWriter, r *http.Request, db *mgo.Database) 

(nel tuo caso, sarebbe un sessioni gorilla invece di una sessione di MgO o database)

Il init() function può prendere cura della creazione della sessione (qui sessione mgo, ma l'idea è la stessa per altre sessioni quadro)

func init() { 
    session, err = mgo.Dial("localhost") 

    if err != nil { 
     log.Println(err) 
    } 
} 

E si può assicurarsi che questo tipo di funzione ('handler') non rispetta la funzione ServeHTTP(), curando:

• la gestione delle sessioni (clone/chiusura)

• chiamare il tuo gestore attuale (che può avere più parametri che solo w e r)

  func (h handler) ServeHTTP(w http.ResponseWriter, r *http.Request) { 
      s := session.Clone() 
      defer s.Close() 
  
      h(w, r, s.DB("example")) 
  } 
  

allora si può definire la vostra attuale Handler (ancora una volta, con m minerale di w e r):

func myHandler(w http.ResponseWriter, r *http.Request, db *mgo.Database) { 
    var users []user 

    db.C("users").Find(nil).All(&users) 

    for _, user := range users { 
     fmt.Fprintf(w, "%s is %d years old", user.Name, user.Age) 
    } 
} 

Ed è possibile utilizzare tale gestore nel server:

func main() { 
    mux := http.NewServeMux() 
    mux.Handle("/", handler(myHandler)) 
    http.ListenAndServe(":8080", mux) 
} 

L'idea è quella di limitare la "idraulico" in main() al minimo, pur avendo una Handler con più parametri (compresa la sessione).
che permette di utilizzare diversi Handlers con molto poco l'impianto idraulico, mantenendo main() solo per la dichiarazione del percorso diverso (e non per l'inizializzazione della sessione e gestori)