Le migliori pratiche per mantenere una sessione di MgO

Question

Attualmente sto usando un MongoDB con MgO lib per un'applicazione web, ma non sono sicuro se il modo in cui lo sto usando, è buona ..

package db 

import (
    "gopkg.in/mgo.v2" 
) 

const (
    MongoServerAddr = "192.168.0.104" 
    RedisServerAddr = "192.168.0.104" 
) 

var (
    MongoSession, err = mgo.Dial(MongoServerAddr) 

    MDB = MongoSession.DB("message") 
    MCol = MDB.C("new") 
    MSav = MDB.C("save") 

    UDB = MongoSession.DB("account") 
    UCol = UDB.C("user") 
) 

Iniziamo la sessione db e creo variabili che prendono il valore di raccolta e documento, così quando ho bisogno di interrogare una raccolta, io uso la variabile per renderla.

Come quella:

func UserExist(username string) bool { 
    user := Users{} 
    err := db.UCol.Find(bson.M{"username": username}).One(&user) 
    if err != nil { 
     return false 
    } else { 
     return true 
    } 
} 

è così c'è una buona pratica o questo va bene ..? Grazie

Answer 1

Suggerisco di non utilizzare una sessione globale come quella. Invece, è possibile creare un tipo responsabile di tutte le interazioni del database. Ad esempio:

type DataStore struct { 
    session *mgo.Session 
} 

func (ds *DataStore) ucol() *mgo.Collection { ... } 

func (ds *DataStore) UserExist(user string) bool { ... } 

Ci sono molti vantaggi a questo progetto. Un aspetto importante è che consente di avere più sessioni in volo contemporaneamente, quindi se si dispone di un gestore HTTP, ad esempio, è possibile creare una sessione locale supportata da una sessione indipendente solo per quella richiesta:

func (s *WebSite) dataStore() *DataStore { 
    return &DataStore{s.session.Copy()} 
}  

func (s *WebSite) HandleRequest(...) { 
    ds := s.dataStore() 
    defer ds.Close() 
    ... 
} 

Il driver mgo si comporta bene in questo caso, poiché le sessioni vengono memorizzate nella cache e riutilizzate/mantenute. Ogni sessione sarà inoltre supportata da un socket indipendente mentre è in uso e potrebbe avere impostazioni indipendenti configurate e avrà anche una gestione degli errori indipendente. Questi sono problemi che dovrai affrontare se stai utilizzando un'unica sessione globale.

Answer 2

Sebbene non risponda direttamente alla domanda, per quanto riguarda il controllo della sessione di mgo è necessario utilizzare il rinvio/recupero dal momento che il mico chiama (anche mgo.session.Ping) il panico. Per quanto posso dire non c'è altro modo per controllare lo stato della sessione di mgo (mgo godocs). Puoi utilizzare il suggerimento di Gustavo Niemeyer e aggiungere un metodo al tuo tipo DataStore.

func (d *DataStore) EnsureConnected() { 
    defer func() { 
     if r := recover(); r != nil { 
      //Your reconnect logic here. 
     } 
    }() 

    //Ping panics if session is closed. (see mgo.Session.Panic()) 
    d.Ping() 
} 

Answer 3

con Go 1.7, il modo più idiomatico di gestire sessione di Mongo su un server web è quello di utilizzare il nuovo pacchetto di libreria standard context per scrivere un middleware in grado di attaccare il defer session.Close() per ogni volta che il contesto di richiesta Done() viene chiamato . Quindi non è necessario ricordare per chiudere

AttachDeviceCollection = func(next http.Handler) http.Handler { 
     return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 
      db, err := infra.Cloner() 
      if err != nil { 
       http.Error(w, err.Error(), http.StatusInternalServerError) 
       return 
      } 
      collection, err := NewDeviceCollection(db) 

      if err != nil { 
       db.Session.Close() 
       http.Error(w, err.Error(), http.StatusInternalServerError) 
       return 
      } 
      ctx := context.WithValue(r.Context(), DeviceRepoKey, collection) 
      go func() { 
       select { 
       case <-ctx.Done(): 
        collection.Session.Close() 
       } 
      }() 

      next.ServeHTTP(w, r.WithContext(ctx)) 
     }) 
    }