8

更新 3/4：

我已经做了一些测试，并证明使用 checkout 事件处理程序来检查断开连接适用于 Elixir。开始认为我的问题与session.commit()从子进程调用有关？更新：我只是通过调用session.commit()一个子进程来反驳自己，下面更新了示例。我正在使用多处理模块来创建子进程。

这是显示它应该如何工作的代码（甚至不使用pool_recycle！）：

from sqlalchemy import exc
from sqlalchemy import event
from sqlalchemy.pool import Pool
from elixir import *
import multiprocessing as mp

class SubProcess(mp.Process):
    def run(self):
        a3 = TestModel(name="monkey")
        session.commit()

class TestModel(Entity):
    name = Field(String(255))

@event.listens_for(Pool, "checkout")
def ping_connection(dbapi_connection, connection_record, connection_proxy):
    cursor = dbapi_connection.cursor()
    try:
        cursor.execute("SELECT 1")
    except:
        # optional - dispose the whole pool
        # instead of invalidating one at a time
        # connection_proxy._pool.dispose()

        # raise DisconnectionError - pool will try
        # connecting again up to three times before raising.
        raise exc.DisconnectionError()
    cursor.close()

from sqlalchemy import create_engine
metadata.bind = create_engine("mysql://foo:bar@localhost/some_db", echo_pool=True)
setup_all(True)

subP = SubProcess()

a1 = TestModel(name='foo')
session.commit()

# pool size is now three.

print "Restart the server"
raw_input()

subP.start()

#a2 = TestModel(name='bar')
#session.commit()

更新 2：

我不得不寻找另一种解决方案，因为 MySQL-python 的 1.2.2 后版本放弃了对重新连接参数的支持。有人有解决方案吗？:\

更新 1（旧解决方案，不适用于 MySQL-python 版本 > 1.2.2）：

找到了解决方案：传递connect_args={'reconnect':True}给create_engine调用解决了问题，自动重新连接。甚至似乎不需要结帐事件处理程序。

因此，在问题的示例中：

metadata.bind = create_engine("mysql://foo:bar@localhost/db_name", pool_size=100, pool_recycle=3600, connect_args={'reconnect':True})

原始问题：

为这个问题做了相当多的谷歌搜索，似乎还没有找到特定于 Elixir 的解决方案 - 我正在尝试使用 SQLAlchemy 文档中的“断开连接处理 - 悲观”示例来处理 MySQL 断开连接。但是，当我对此进行测试时（通过重新启动 MySQL 服务器），在我的结帐事件处理程序之前引发了“MySQL 服务器已消失”错误。

这是我用来初始化 elixir 的代码：

##### Initialize elixir/SQLAlchemy
# Disconnect handling
from sqlalchemy import exc
from sqlalchemy import event
from sqlalchemy.pool import Pool

@event.listens_for(Pool, "checkout")
def ping_connection(dbapi_connection, connection_record, connection_proxy):
    logging.debug("***********ping_connection**************")
    cursor = dbapi_connection.cursor()
    try:
        cursor.execute("SELECT 1")
    except:
        logging.debug("######## DISCONNECTION ERROR #########")            
        # optional - dispose the whole pool
        # instead of invalidating one at a time
        # connection_proxy._pool.dispose()

        # raise DisconnectionError - pool will try
        # connecting again up to three times before raising.
        raise exc.DisconnectionError()
    cursor.close()

metadata.bind= create_engine("mysql://foo:bar@localhost/db_name", pool_size=100, pool_recycle=3600)

setup_all()

我创建了 elixir 实体对象并用 保存它们session.commit()，在此期间我看到从上面定义的事件生成的“ping_connection”消息。但是，当我重新启动 mysql 服务器并再次对其进行测试时，它会在 ping 连接事件之前出现 mysql 服务器已消失消息而失败。

这是从相关行开始的堆栈跟踪：

  File "/usr/local/lib/python2.6/dist-packages/elixir/entity.py", line 1135, in get_by
    return cls.query.filter_by(*args, **kwargs).first()
  File "/usr/local/lib/python2.6/dist-packages/sqlalchemy/orm/query.py", line 1963, in first
    ret = list(self[0:1])
  File "/usr/local/lib/python2.6/dist-packages/sqlalchemy/orm/query.py", line 1857, in __getitem__
    return list(res)
  File "/usr/local/lib/python2.6/dist-packages/sqlalchemy/orm/query.py", line 2032, in __iter__
    return self._execute_and_instances(context)
  File "/usr/local/lib/python2.6/dist-packages/sqlalchemy/orm/query.py", line 2047, in _execute_and_instances
    result = conn.execute(querycontext.statement, self._params)
  File "/usr/local/lib/python2.6/dist-packages/sqlalchemy/engine/base.py", line 1399, in execute
    params)
  File "/usr/local/lib/python2.6/dist-packages/sqlalchemy/engine/base.py", line 1532, in _execute_clauseelement
    compiled_sql, distilled_params
  File "/usr/local/lib/python2.6/dist-packages/sqlalchemy/engine/base.py", line 1640, in _execute_context
    context)
  File "/usr/local/lib/python2.6/dist-packages/sqlalchemy/engine/base.py", line 1633, in _execute_context
    context)
  File "/usr/local/lib/python2.6/dist-packages/sqlalchemy/engine/default.py", line 330, in do_execute
    cursor.execute(statement, parameters)
  File "/usr/lib/pymodules/python2.6/MySQLdb/cursors.py", line 166, in execute
    self.errorhandler(self, exc, value)
  File "/usr/lib/pymodules/python2.6/MySQLdb/connections.py", line 35, in defaulterrorhandler
    raise errorclass, errorvalue
OperationalError: (OperationalError) (2006, 'MySQL server has gone away')
4

4 回答 4

2

最后的解决方法是session.remove()在操作和加载 elixir 实体之前调用方法的开头。它的作用是将连接返回到池，这样当它再次使用时，池的 checkout 事件将被触发，我们的处理程序将检测到断开连接。来自 SQLAlchemy 文档：

在请求结束时删除会话并不是绝对必要的 - 其他选项包括在结束时调用 Session.close()、Session.rollback()、Session.commit() 以便现有会话将其连接返回到池并删除任何现有的事务上下文。如果单个控制器方法负责确保在请求结束后没有事务保持打开状态，那么什么也不做也是一种选择。

非常重要的一小部分信息，我希望它在 elixir 文档中被提及。但是我猜它假设了 SQLAlchemy 的先验知识？

于 2011-11-02T06:48:50.377 回答
2

实际问题是每次调用 sessionmaker 工厂时 sqlalchemy 都会为您提供相同的会话。因此，只要您没有调用会话，就可能会使用更早打开的会话执行稍后的查询session.remove()。然而，每次请求会话时都必须记住调用remove()并不有趣，sqlalchemy 提供了一个更简单的东西：上下文“范围”会话。

要创建一个作用域会话，只需包装你的 sessionmaker：

from sqlalchemy.orm import scoped_session, sessionmaker
Session = scoped_session(sessionmaker())

session.remove()这样，您每次调用工厂时都会获得一个上下文绑定会话，这意味着一旦调用函数退出，sqlalchemy就会为您调用。请参见此处：sqlalchemy - 上下文会话的生命周期

于 2012-07-26T15:01:50.970 回答
0

您是否对两个（mysqld 重新启动之前和之后）操作使用相同的会话？如果是这样，则该"checkout"事件仅在新事务开始时发生。当您调用commit()新事务时（除非您使用自动提交模式）并签出连接。所以你在结帐后重新启动mysqld 。

在第二次操作之前（以及重新启动 mysqld 之后）使用commit()或调用的简单 hack应该可以解决您的问题。rollback()否则，每次在上次提交后等待很长时间时，请考虑使用新的新会话。

于 2011-10-27T10:27:22.570 回答
0

我不确定这是否与我遇到的问题相同，但这里是：

当我遇到时MySQL server has gone away，我使用它来解决它create_engine(..., pool_recycle=3600)，请参阅http://www.sqlalchemy.org/docs/dialects/mysql.html#connection-timeouts

于 2011-10-31T19:51:48.390 回答