GAE Chat Persistance des données dans Memcache

Question

Je suis en train d'écrire une fonction de discussion (comme celle de Faceboook.com) pour un site Google App Engine. J'ai besoin d'un moyen de garder une trace de ce que les utilisateurs ont de nouveaux messages. J'essaie d'utiliser actuellement Memcache:

class Message(): 
    def __init__(self, from_user_key, message_text) 
     self.from_user_key = from_user_key 
     self.message_text = message_text 

class NewMessages(): 
    def __init__(self): 
     self.messages = [] 
    def add_message(self, message): 
     self.messages.append(message) 
    def get_messages(self): 
     return self.messages 
    def messages_sent(self): 
     self.messages = [] #Clear all messages 

def ChatUserManager(): 
    def load(user_key): 
     manager = memcache.get("chat_user_%s" % user_key) 
     if manager is not None: 
      return manager 
     else: 
      manager = ChatUserManager(user_key) 
      memcache.set("chat_user_%s" % user_key, manager) 
      return manager 
    def save(self): 
     memcache.set("chat_user_%s" % user_key, self) 
    def __init__(self, user_key): 
     self.online = True 
     self.new_messages = NewMessages() 
     self.new_data = False 
     self.user_key = user_key 
    def recieve_message(self, message): 
     self.new_data = True 
     self.new_messages.add_message(Message(from_user_key, message_text)) 
    def send_message(self, message): 
     to_manager = ChatUserManager.load(message.from_user_key) 
     to_manager.recieve_message(message) 
    def client_receive_success(self): 
     self.new_data = False 
     self.new_messages.messages_sent() 

Cette discussion est un utilisateur à, comme Facebook ou d'une session de messagerie instantanée, pas le chat de groupe.

Chaque utilisateur interrogera une URL avec ajax pour obtenir de nouveaux messages toutes les x secondes. Le gestionnaire de chat sera chargé sur cette page (ChatUserManager.load (user_key)) et les nouveaux messages seront vérifiés. Lorsqu'ils sont envoyés, le gestionnaire sera informé que les messages ont été envoyés (manager.client_receive_success()), puis sauvegardé dans memcache (manager.save()).

Lorsqu'un utilisateur envoie un message dans le client javascript, il envoie une requête ajax à un URL. L'URL chargera le UserChatManager du client et appellera .send_message (Message (to_user_key, message_string))).

Je suis préoccupé par la praticité de ce modèle. Si tout est dans memcache, comment sera-t-il synchronisé sur différentes pages?

Y a-t-il une meilleure façon de procéder?

Je reconnais que je ne suis pas encore un python pro, donc le code n'est peut-être pas très pythonique, y a-t-il des bonnes pratiques qui me manquent?

Answer 1

Le problème n'est pas tellement de savoir comment partager des données entre "pages", mais comment sera l'impact sur l'utilisation du service en utilisant memcache.

Il n'y a aucune garantie associée à la persistance des données dans memcache: un moment est là, l'autre ne l'est pas.