rj:>dZddlmZddlZddlZddlZddlmZddlm Z ddl m Z Gdd Z Gd d Z ejdd ZGd dZdZ ddZ ddZy)aDeterministic cancellation testing for the asyncio dialects. An asyncio task may be cancelled at any ``await``, and reproducing a specific one of those points by racing ``task.cancel()`` against real network traffic is unreliable. Here the choice is made exact. :func:`.greenlet_spawn` drives every await performed by an asyncio-driven SQLAlchemy operation, ``connect()`` included, so instrumenting the greenlet it switches into gives a stable enumeration of a scenario's IO points, and cancelling at point ``N`` is reproducible run to run. The cancellation is delivered to the task the application is running, which is not necessarily the task performing the await; SQLAlchemy runs some operations, such as the ``close()`` performed by an async context manager on exit, in a task of its own. Four things are asserted afterwards: * The cancellation reaches the application. The task ends cancelled, rather than raising some other exception in place of the ``CancelledError`` or returning normally; an application that treats an ordinary exception as something to retry would otherwise carry on past its own shutdown. * Every DBAPI connection the pool creates is eventually closed through ``Pool._close_connection()``. A connection that is never closed is leaked; for an asyncio driver the garbage collector cannot close it either, since closing requires the event loop. * Once the application's task has finished and garbage has been collected, no pool slot is still checked out. A slot still checked out at that point is lost: either nothing remains that could return it, or it is being returned by a task SQLAlchemy left running in the background, which the application has no way to wait for. In the latter case, an application that disposes of its engine at that point has the connection returned into the disposed pool afterwards, where nothing closes it. * The pool still works. The scenario is run once more against the same engine, un-cancelled, and has to succeed. A connection that was closed and nonetheless returned to the pool as though it were usable is neither leaked nor a lost slot; it is found only by the next thing to check it out. ) annotationsN)mock)exc) concurrencyc eZdZdZdZdZdZy)_InstrumentedAwaitablez6An awaitable that invokes ``hook`` when it is awaited. awaitablehookc ||_||_yNr )selfr r s j/var/www/html/python-recuperauto-other/env/lib/python3.12/site-packages/sqlalchemy/testing/cancellation.py__init__z_InstrumentedAwaitable.__init__Fs" cl|j|j|jjSr)r r __await__rs rrz _InstrumentedAwaitable.__await__Js% $..!~~''))rN)__name__ __module__ __qualname____doc__ __slots__rrrrr r As@%I*rr cDeZdZdZddZedZedZdZdZ y) AwaitPointsaqCounts await points, and cancels the running task at each of the ones given. ``cancel_at`` is a tuple of await point numbers; each one is a separate ``task.cancel()`` call. asyncio delivers a given cancellation exactly once, so a second number models a second, independent canceller reaching a task that is still cleaning up after the first. c<d|_||_g|_d|_yNr)_count _cancel_at _cancelled_at_task)r cancel_ats rrzAwaitPoints.__init__Zs # rc|jS)z*The number of await points counted so far.)r rs rcountzAwaitPoints.count`s{{rc,t|jS)zMDescriptions of the awaitables at which a cancellation was delivered.)tupler"rs r cancelled_atzAwaitPoints.cancelled_atfs T''((rcNtj||_|jS)zZRun ``coro`` in a new task, which is the task that cancellations are delivered to.)asyncio create_taskr#)rcoros rr,zAwaitPoints.create_taskms ((. zzrc H|xjdz c_|j|jvry|jjt |dt ||j |j ntj}|Jd|jy)NrzQcancellation can only be delivered to an operation running within an asyncio task) r r!r"appendgetattrreprr#r+ current_taskcancel)rr tasks r__call__zAwaitPoints.__call__ts q ;;doo -  !! I~tI ? "ZZ3tzz9M9M9O  %  rNr) rrrrrpropertyr&r)r,r6rrrrrOs>  )) rrc#Kt|tjj}|j|j fdfd}fd}t jj|d|5t jj|d|5ddddddy#1swYxYw#1swYyxYww)zlCount the await points performed within the block, cancelling the running task at each of ``cancel_at``.c8|jr|St|Sr)deadr )greenletresultpointss r instrumentz await_points..instruments ==M%ff55rc*||g|i|Srr)rargkwr? real_switchs rswitchzawait_points..switchs$ D =3 =" =>>rc$||g|Srr)rrAr? real_throws rthrowzawait_points..throws$ 4 6# 677rrDrGN) rr_concurrency_shim_AsyncIoGreenletrDrGrpatchobject)r$ greenlet_clsrDrGr?r>rCrFs @@@@r await_pointsrMs  #F00AAL%%K##J6?8 ,&9 ,7 s6A0C6"B:B.B:% C.B7 3B::C?CcteZdZdZdZej dZdZdddZ e dZ d Z d Z d Zd Zy )ConnectionAccountingaRecords which DBAPI connections a pool created and which it managed to close, how many of the pool's slots were lost, and whether the pool could still be used afterwards. Creation is observed at ``Pool._invoke_creator`` rather than through the ``connect`` pool event, because the ``connect`` event is itself where ``dialect.initialize()`` runs; a listener added there does not fire for precisely the connections that a failure in that event strands. c||_|j|_|j|_d|_d|_d|_t|_ t|_ yr) _pool_invoke_creator_real_invoke_creator_close_connection_real_close_connection _lost_slots_next_use_error_uncancelled_outcomeset_created_closed)rpools rrzConnectionAccounting.__init__sO $($8$8!&*&<&<##$(! u rc#<Ktjj|jd|j5tjj|jd|j 5|ddddddy#1swYxYw#1swYyxYww)z4Account for the pool's connections within the block.rRrTN)rrJrKrQrRrTrs rstartzConnectionAccounting.starts JJ   -t/C/C   JJ   /1G1G   J      s46B6B.B3B; BB BBBc^|j|}|jj||Sr)rSrZadd)rrecdbapi_connections rrRz$ConnectionAccounting._invoke_creators,44S9 *+rF terminatec  |j|||j j|y#tj$r?|r;|jjj r|j j|wxYw)Nrc)rUr+CancelledErrorrQ_dialect has_terminater[r`)rrbrds rrTz&ConnectionAccounting._close_connectionst   ' '(8I ' N )* %% TZZ00>>   !12   s 1ABc4|j|jz S)zr5otherss r run_scenarior;s& w9 99   F v &/* 6" " " ''- ) $ %%hv&67D   & &&tV-@-@A $$&((6::: .." " """$(<(<(>'?? ,,vq1 1 1 _/b 499Z<<>?G4 GG_ # **+    2 ; #""    2]//sG F?E1,F?F4E69E4:E6>A F?F F? F$ F"!F$%AF?+F=,F?-G 1F?4E66F FFFF  F?"F$$F:7F?9F::F??GG cZKgfddd{S7w)aCancel ``scenario`` at each of its await points in turn. With ``cancels=2``, each run that was cancelled at point ``N`` is then repeated with a second cancellation at each await point after ``N``, which is to say at each point of the cleanup the first cancellation set off. Returns a list of strings describing what went wrong, empty if every cancellation point was handled cleanly. The strings are meant to be read in an assertion failure:: eq_(await sweep(engine_factory, scenario), []) c Kt | d{\}}|j}|r|ddznd}t||dzD]}t ||fz d{\}}|Tdjd||fzD}dj|j} j d|d|d|d |t |dz ks ||fzd{y777 w) N)r$rrr/z, c32K|]}t|ywr)str).0is r z(sweep.._sweep..s#IqCF#Iszcancel at await point(s) r|z (z): )rr&rangerr)r0r})r$r>_totalr^indexfailureindexes awaitables_sweepcancelsrrreportedrxrs rrzsweep.._sweeps(&      %. " !A5%!), 3E$0#uh. %OFG"))#II4H#II!YYv':':; /yUGD"|3wi19~!G+Y%1222! 3 3s;C-C'AC- C)!A.C-C-C+ C-)C-+C-rNr)rrxrrrrrs`````@@rsweeprs1$H338 * Os +)+r7)rFF)FFr/)r __future__rr+rrrunittestrrutilrr rrrMrOrrrrrrrs~+Z#  * *;;| :DDN5AFGHVBC1r