1

我已经使用 Python 在 Google-App-Engine 上部署了一个网站。

由于 GAE 不保证“keep-alive”，我实现了一个无状态服务器：

  1. 每次内部变量发生变化时，它们都会立即存储到 GQL 数据库中。

  2. 每当流程启动时，所有内部变量都会从 GQL 数据库中加载。

我有一个很少引发异常的场景，但我无法追踪它：

  • 客户端发送一个同步的 AJAX POST 请求。

  • 服务器创建一个会话并在响应中发送一个唯一的会话 ID。

  • 客户端发送一个以会话 ID 作为参数的同步 AJAX GET 请求。

  • 服务器在响应中发送一些文本消息。

由于客户端请求是同步的，所以整个序列也是同步的。

这是我的服务器中的相关映射：

from webapp2 import WSGIApplication
from Handler import MyRequestHandler

app = WSGIApplication([
    ('/request1'    ,MyRequestHandler), # post request
    ('/request2(.*)',MyRequestHandler), # get request
])

这是我的服务器中的相关请求处理：

from webapp2 import RequestHandler
from Server  import MyServer

myServer = MyServer()

class MyRequestHandler(RequestHandler):
    def post(self):
        try:
            if self.request.path.startswith('/request1'):
                sessionId = myServer.GetNewSessionId()
                self.SendContent('text/plain',sessionId)
        except Exception,error:
            self.SendError(error)
    def get(self,sessionId):
        try:
            if self.request.path.startswith('/request2'):
                textMessage = myServer.GetMsg(sessionId)
                self.SendContent('text/plain',textMessage)
        except Exception,error:
            self.SendError(error)
    def SendContent(self,contentType,contentData):
        self.response.set_status(200)
        self.response.headers['content-type'] = contentType
        self.response.headers['cache-control'] = 'no-cache'
        self.response.write(contentData)
    def SendError(self,error):
        self.response.set_status(500)
        self.response.write(error.message)

这是我的服务器的内部实现：

class MyServer():
    def __init__(self):
        self.sessions = SessionsTable.ReadSessions()
    def GetNewSessionId(self):
        while True:
            sessionId = ... # a 16-digit random number
            if SessionsTable.ReserveSession(sessionId):
                self.sessions[sessionId] = ... # a text message
                SessionsTable.WriteSession(self.sessions,sessionId)
                return sessionId
    def GetMsg(self,sessionId):
        return self.sessions[sessionId]

最后，这是我服务器中的数据库维护：

from google.appengine.ext import db

class SessionsTable(db.Model):
    message = db.TextProperty()
    @staticmethod
    def ReadSessions():
        sessions = {}
        for session in SessionsTable.all():
            sessions[session.key().name()] = session.message
        return sessions
    @staticmethod
    @db.transactional
    def ReserveSession(sessionId):
        if not SessionsTable.get_by_key_name(sessionId):
            SessionsTable(key_name=sessionId,message='').put()
            return True
        return False
    @staticmethod
    def WriteSession(sessions,sessionId):
        SessionsTable(key_name=sessionId,message=sessions[sessionId]).put()
    @staticmethod
    def EraseSession(sessionId):
        SessionsTable.get_by_key_name(sessionId).delete()

异常本身表示使用密钥对sessions字典的非法访问。sessionId根据我的观察，只有在服务器“已经休眠”了相当长的一段时间（比如几天左右）之后启动本问题开头描述的客户端-服务器序列时才会发生这种情况。它可能会为这个问题的根源提供某种线索，尽管我看不到它。

我的问题：

  1. 我的设计有什么明显的问题吗？

  2. 有人在 GAE 上遇到过类似的问题吗？

  3. 有没有人看到一个明显的解决方案，甚至是可能有助于理解这个问题的调试方法？

谢谢

4

1 回答 1

3

您错误地假设所有请求都由同一个实例处理。情况并非如此：GAE 与大多数托管环境一样，不保证哪个服务器进程将处理任何请求。

您的实现正在使用模块级变量 ，myServer它是一个具有自己的实例变量的类实例。但是每个服务器进程都有自己的 myServer 实例，并且它们不会在进程之间共享：因此在一个请求中创建的字典条目不一定会在一秒钟内存在。

您需要研究跨实例持久保存这些数据的方法。确实，这就是数据存储的首要用途。如果您担心开销，您应该使用 memcache 进行调查。

于 2014-01-22T14:26:59.133 回答