sessione GAAP webapp2: il processo corretto di creazione e controllo delle sessioni

Question

Ho provato ad implementare la sessione webapp2 di GAE, ma sembra che ci sia pochissima documentazione a riguardo. Secondo http://webapp-improved.appspot.com/api/webapp2_extras/sessions.html, i miei passi sono i seguenti:

1.Configure e aggiungere configurazione per l'applicazione principale:

config = {} 
config['webapp2_extras.sessions'] = { 
    'secret_key': 'my_secret_key', 
} 
app = webapp2.WSGIApplication([...], config=config) 

sessione 2.Creare nel gestore di login

# Delete existent session 
    --> not mention in the tutorial 
# member is found  
self.session_store = sessions.get_store(request=handler.request) 
self.session['account'] = member.account 

3.Verificare se esiste una sessione in varie posizioni nel mio programma

if self.session['account']: 
    # Session exists 

4.Delete sess ione quando l'utente si disconnette

--> not mentioned in the tutorial 

Le mie domande:

1. ho ricevuto il messaggio di errore "... oggetto non ha attributo 'session'" durante il processo di creazione della sessione (Fase 2)

2. Come si elimina una sessione nei passaggi 2 e 4?

3. Il processo generale di gestione delle sessioni è corretto?

Grazie.

Answer 1

Questa potrebbe non essere una risposta diretta alla domanda, ma è una soluzione che ho trovato usando le gaesessions invece della sessione webapp2 di GAE e vorrei condividere con sempre ybody. Ecco come fare:

1. Scarica gaesessions da https://github.com/dound/gae-sessions facendo clic sul pulsante "Download ZIP". Il file scaricato è "gae-sessions-master.zip".

2. Decomprimere il file (una directory "gae-sessioni-master" verrà creato), e copiare i "gaessions" directory alla directory principale della vostra applicazione (per esempio, dove "app.yaml" è)

3. Creare un file denominato "appengine_config".py" nella directory principale, con il seguente contenuto (modulo copiato https://github.com/dound/gae-sessions/tree/master/demo):

   from gaesessions import SessionMiddleware 
   
   # Original comments deleted ... 
   # Create a random string for COOKIE_KDY and the string has to 
   # be permanent. "os.urandom(64)" function may be used but do 
   # not use it *dynamically*. 
   # For me, I just randomly generate a string of length 64 
   # and paste it here, such as the following: 
   
   COOKIE_KEY = 'ppb52adekdhD25dqpbKu39dDKsd.....' 
   
   def webapp_add_wsgi_middleware(app): 
       from google.appengine.ext.appstats import recording 
       app = SessionMiddleware(app, cookie_key=COOKIE_KEY) 
       app = recording.appstats_wsgi_middleware(app) 
       return app 
   

4. Creare una sessione quando un utente accede a (variabile conto è l'account dell'utente):

   from gaesessions import get_current_session 
   session = get_current_session() 
   if session.is_active(): 
       session.terminate() 
   # start a session for the user (old one was terminated) 
   session['account'] = account 
   

5. Verificare se la sessione dell'utente esiste, se l'account di sì, dell'utente di ritorno:

   from gaesessions import get_current_session 
   def checkSession(): 
       session = get_current_session() 
       if session.is_active(): 
        return session['account'] 
       return False 
   

6. Eliminare la sessione quando l'utente si disconnette:

   def logout(): 
       session = get_current_session() 
       if session.is_active(): 
        session.terminate() 
   

7. Infine, è possibile creare un job cron per pulire periodicamente sessioni scadute:

cron.yaml:

- description: daily session cleanup 
    url: /clean_up_sessions 
    schedule: every day 3:00 
    timezone: ... (Your time zone) 

Funzione:

from gaesessions import delete_expired_sessions 
class clean_up_sessions(webapp2.RequestHandler): 
    def get(self): 
     while not delete_expired_sessions(): 
      pass 

Spero che questo aiuti.

Answer 2

Ecco un esempio del gestore e come utilizzare webapp2 sessioni in più

main.py con il BaseHandler e MainHandler

import webapp2 
from webapp2_extras import sessions 

class BaseHandler(webapp2.RequestHandler):    # taken from the webapp2 extrta session example 
    def dispatch(self):         # override dispatch 
     # Get a session store for this request. 
     self.session_store = sessions.get_store(request=self.request) 

     try: 
      # Dispatch the request. 
      webapp2.RequestHandler.dispatch(self)  # dispatch the main handler 
     finally: 
      # Save all sessions. 
      self.session_store.save_sessions(self.response) 

    @webapp2.cached_property 
    def session(self): 
     # Returns a session using the default cookie key. 
     return self.session_store.get_session() 

class YourMainHandler(BaseHandler): 

    def get(self): 

     .... 
     self.session['foo'] = 'bar' 


    def post(self): 


     foo = self.session.get('foo') 

E se hai un login.py separata:

Answer 3

Nella tua RequestHandler Override dispatch: da webapp2_extras sessioni di importazione

def dispatch(self): 

    self.session_store = sessions.get_store(request=self.request) 

    try: 
     webapp2.RequestHandler.dispatch(self) 
    finally: 
     self.session_store.save_sessions(self.response) 

e fare un webapp2.cached_property chiamato session:

@webapp2.cached_property 
def session(self): 
    return self.session_store.get_session(backend="<whatever you want here>") 

Quando si vuole accedere ai valori di sessione, si fa self.session[<key>]

Quando un utente effettua il login, è possibile chiamare uno:

self.auth.get_user_by_password(auth_id, password, remember=True, 
              save_session=True) 

, che si prenderà cura di sbarazzarsi della vecchia sessione e la creazione di uno nuovo per voi, o:

self.auth.set_session(self.auth.store.user_to_dict(self.user), remember=True) 

Per quanto riguarda la sessione, tutto cio che dovrete chiamare è:

self.auth.unset_session()