H/\c @@sndZddlmZmZddlmZddlZddlZddl m Z ddl m Z ddl m Z dd d d d d ddddg Z ddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlm Z!ddlm"Z"ddl#m$Z$dd l%m&Z&dd!l'm(Z(e(j)Z*e(j+Z,dd"l-m.Z.dd#l/m0Z0e1ej2Z3e3Z4d$Z5de6d%Z7dd&Z8e d'Z9d e:fd(YZ;e<d)Z=de&fd*YZ>e"e>d+e:fd,YZ?dS(-s Event-loop hub. i(tabsolute_importtprint_function(tpartialN(tgreenlet(t getcurrent(t GreenletExitRRt spawn_rawtsleeptkilltsignaltreinittget_hubtHubtWaiter(tconfig(tthread_mod_name(t readproperty(tLazy(tgmctime(t IdentRegistry(R (tget_loop(tset_hub(tset_loop(tget_hub_if_exists(tget_hub_noargs(tset_default_hub_class(tTrackedRawGreenlet(tWaitOperationsGreenlet(t_hub_primitives(tLoopExit(R cO@st|stdnt}tjr3tnt}|rvt|||}|||}|jj |j n%|||}|jj |j ||S(sG Create a new :class:`greenlet.greenlet` object and schedule it to run ``function(*args, **kwargs)``. This returns a raw :class:`~greenlet.greenlet` which does not have all the useful methods that :class:`gevent.Greenlet` has. Typically, applications should prefer :func:`~gevent.spawn`, but this method may occasionally be useful as an optimization if there are many greenlets involved. .. versionchanged:: 1.1a3 Verify that ``function`` is callable, raising a TypeError if not. Previously, the spawned greenlet would have failed the first time it was switched to. .. versionchanged:: 1.1b1 If *function* is not callable, immediately raise a :exc:`TypeError` instead of spawning a greenlet that will raise an uncaught TypeError. .. versionchanged:: 1.1rc2 Accept keyword arguments for ``function`` as previously (incorrectly) documented. Note that this may incur an additional expense. .. versionchanged:: 1.3a2 Populate the ``spawning_greenlet`` and ``spawn_tree_locals`` attributes of the returned greenlet. .. versionchanged:: 1.3b1 *Only* populate ``spawning_greenlet`` and ``spawn_tree_locals`` if ``GEVENT_TRACK_GREENLET_TREE`` is enabled (the default). If not enabled, those attributes will not be set. sfunction must be callable( tcallablet TypeErrort_get_hub_noargst GEVENT_CONFIGttrack_greenlet_treeRt RawGreenlett_functools_partialtloopt run_callbacktswitch(tfunctiontargstkwargsthubtfactorytg((s)lib/python2.7/site-packages/gevent/hub.pyRCs!  cC@st}|j}|dkrJt|}|j|jd|jn5|j|d|}|j|j |WdQXdS(s Put the current greenlet to sleep for at least *seconds*. *seconds* may be specified as an integer, or a float if fractional seconds are desired. .. tip:: In the current implementation, a value of 0 (the default) means to yield execution to any other runnable greenlets, but this greenlet may be scheduled again before the event loop cycles (in an extreme case, a greenlet that repeatedly sleeps with 0 can prevent greenlets that are ready to do I/O from being scheduled for some (small) period of time); a value greater than 0, on the other hand, will delay running this greenlet until the next iteration of the loop. If *ref* is False, the greenlet running ``sleep()`` will not prevent :func:`gevent.wait` from exiting. .. versionchanged:: 1.3a1 Sleeping with a value of 0 will now be bounded to approximately block the loop for no longer than :func:`gevent.getswitchinterval`. .. seealso:: :func:`idle` itrefN( R R%R R&R'tNonetgetttimert update_nowtwait(tsecondsR.R+R%twaitertt((s)lib/python2.7/site-packages/gevent/hub.pyRzs      cC@s;t}|jj}|r*||_n|j|dS(sO Cause the calling greenlet to wait until the event loop is idle. Idle is defined as having no other events of the same or higher *priority* pending. That is, as long as sockets, timeouts or even signals of the same or higher priority are being processed, the loop is not idle. .. seealso:: :func:`sleep` N(R R%tidletpriorityR3(R8R+twatcher((s)lib/python2.7/site-packages/gevent/hub.pyR7s  cC@sQ|jsMt|dr1|jd|dtqMtjj|j|ndS(s% Kill greenlet asynchronously. The current greenlet is not unscheduled. .. note:: The method :meth:`Greenlet.kill` method does the same and more (and the same caveats listed there apply here). However, the MAIN greenlet - the one that exists initially - does not have a ``kill()`` method, and neither do any created with :func:`spawn_raw`, so you have to use this function. .. caution:: Use care when killing greenlets. If they are not prepared for exceptions, this could result in corrupted state. .. versionchanged:: 1.1a2 If the ``greenlet`` has a :meth:`kill ` method, calls it. This prevents a greenlet from being switched to for the first time after it's been killed but not yet executed. Rt exceptiontblockN(tdeadthasattrRtFalseR R%R&tthrow(RR:((s)lib/python2.7/site-packages/gevent/hub.pyRs cB@s_eZdZdZdZdZdZeeeZ [[dZ dZ dZ RS(s_ Call the *handler* with the *args* and *kwargs* when the process receives the signal *signalnum*. The *handler* will be run in a new greenlet when the signal is delivered. This returns an object with the useful method ``cancel``, which, when called, will prevent future deliveries of *signalnum* from calling *handler*. .. note:: This may not operate correctly with SIGCHLD if libev child watchers are used (as they are by default with os.fork). .. versionchanged:: 1.2a1 The ``handler`` argument is required to be callable at construction time. cO@st|stdnt|_|jjj|dt|_|jj|j ||_ ||_ ||_ |j dkrddlm}||_ ndS(Ns signal handler must be callable.R.i(tGreenlet(RRR R+R%R R>R9tstartt_startthandlerR)R*tgreenlet_classR/tgeventR@(tselft signalnumRCR)R*R@((s)lib/python2.7/site-packages/gevent/hub.pyt__init__s     cC@s |jjS(N(R9R.(RF((s)lib/python2.7/site-packages/gevent/hub.pyt_get_refscC@s||j_dS(N(R9R.(RFtvalue((s)lib/python2.7/site-packages/gevent/hub.pyt_set_refscC@s|jjdS(N(R9tstop(RF((s)lib/python2.7/site-packages/gevent/hub.pytcancelscC@sGy |j|j}|jWn |jjdtjnXdS(N(RDthandleR'R+t handle_errorR/tsyst _exc_info(RFR((s)lib/python2.7/site-packages/gevent/hub.pyRBs cC@sAy|j|j|jWn |jjdtjnXdS(N(RCR)R*R+ROR/RPtexc_info(RF((s)lib/python2.7/site-packages/gevent/hub.pyRN sN( t__name__t __module__t__doc__R/RDRHRIRKtpropertyR.RMRBRN(((s)lib/python2.7/site-packages/gevent/hub.pyR s     cC@su|dkrtn|}|dkr+dS|jjx6|j|j|jfD]}t|ddqQWdS(s reinit() -> None Prepare the gevent hub to run in a new (forked) process. This should be called *immediately* after :func:`os.fork` in the child process. This is done automatically by :func:`gevent.os.fork` or if the :mod:`os` module has been monkey-patched. If this function is not called in a forked process, symptoms may include hanging of functions like :func:`socket.getaddrinfo`, and the hub's threadpool is unlikely to work. .. note:: Registered fork watchers may or may not run before this function (and thus ``gevent.os.fork``) return. If they have not run, they will run "soon", after an iteration of the event loop. You can force this by inserting a few small (but non-zero) calls to :func:`sleep` after fork returns. (As of gevent 1.1 and before, fork watchers will not have run, but this may change in the future.) .. note:: This function may be removed in a future major release if the fork process can be more smoothly managed. .. warning:: See remarks in :func:`gevent.os.fork` about greenlets and event loop watchers in the child process. Nt_on_forkcS@sdS(N(R/(((s)lib/python2.7/site-packages/gevent/hub.pytJs(R/t_get_hubR%R t _threadpoolt _resolvertperiodic_monitoring_threadtgetattr(R+tobj((s)lib/python2.7/site-packages/gevent/hub.pyR s   cB@smeZdZeeefZeefZdZ dZ dZ dZ dZdddZedZedZedZedZd Zd Zd Zed Zd ZdZdZddZddZedZ dZ!dZ"dZ#ee!e"e#dZ$edZ%dZ&dZ'dZ(ee&e'e(dZ)RS(s A greenlet that runs the event loop. It is created automatically by :func:`get_hub`. .. rubric:: Switching Every time this greenlet (i.e., the event loop) is switched *to*, if the current greenlet has a ``switch_out`` method, it will be called. This allows a greenlet to take some cleanup actions before yielding control. This method should not call any gevent blocking functions. i ticC@stj|ddt|_t|drU|dk rItdn||_nutdk rst|_nW|dkr|jt krt }n|dkr|j }n|j d|d||_d|_ d|_tj|_tjd7_tj|_dS(NtrunsUnexpected argument: defaulttflagstdefaulti(RRHR/tget_thread_identt thread_identR=RR%RtMAIN_THREAD_IDENTR>tbackendt loop_classR[RZR!tformat_contextR t _hub_countert minimal_ident(RFR%Rb((s)lib/python2.7/site-packages/gevent/hub.pyRHs$         cC@stS(N(R(RF((s)lib/python2.7/site-packages/gevent/hub.pytident_registryscC@stjS(N(R!R%(RF((s)lib/python2.7/site-packages/gevent/hub.pyRgscC@stjS(N(R!t libev_backend(RF((s)lib/python2.7/site-packages/gevent/hub.pyRfscC@s |jtkS(sW Is this the hub for the main thread? .. versionadded:: 1.3b1 (RdRe(RF((s)lib/python2.7/site-packages/gevent/hub.pytmain_hubscC@s|jdkrd}nGy|jj}Wn1tk r^}t|pXt|pXd}nXd|jj|jt ||f}|j dk r|d|j 7}n|j dk r|d|j 7}n|dt |j f7}|dS(Nt destroyedterrors<%s %r at 0x%x %ss resolver=%rs threadpool=%rs thread_ident=%st>(R%R/t_formatt Exceptiontstrtreprt __class__RStnametidR[RZthexRd(RFtinfotextresult((s)lib/python2.7/site-packages/gevent/hub.pyt__repr__s" "   cC@s~t|tr||}nt||jsI|j||||n|dksgt||jrz|j||ndS(sY Called by the event loop when an error occurs. The arguments type, value, and tb are the standard tuple returned by :func:`sys.exc_info`. Applications can set a property on the hub with this same signature to override the error handling provided by this class. Errors that are :attr:`system errors ` are passed to :meth:`handle_system_error`. :param context: If this is ``None``, indicates a system error that should generally result in exiting the loop and being thrown to the parent greenlet. N(t isinstanceRst issubclasst NOT_ERRORtprint_exceptionR/t SYSTEM_ERRORthandle_system_error(RFtcontextttypeRJttb((s)lib/python2.7/site-packages/gevent/hub.pyROs cC@st}||ks3||jks3|jdkrI|jj||npd}y|jj|j}Wntjd|j nXz|jj||Wd|dk r|j nXdS(s Called from `handle_error` when the exception type is determined to be a :attr:`system error `. System errors cause the exception to be raised in the main greenlet (the parent of this hub). tfileN( RtparentR%R/R?R&R't tracebackt print_exctexception_streamRL(RFRRJtcurrenttcb((s)lib/python2.7/site-packages/gevent/hub.pyRs * cC@s:trtjnd}t|jdkr6|j}n|S(s The stream to which exceptions will be written. Defaults to ``sys.stderr`` unless assigned to. .. versionadded:: 1.2a1 tFileObjectThreadN(RPtstderrR/RRStio(RFR((s)lib/python2.7/site-packages/gevent/hub.pyRs  cC@s|j}|sdS|dkr6|jd|jntj|||d|~y3|jt|j|dk r}dndWnnX|dk rt|tsy|j |}Wqtj d|jt |}qXn|jd|t |ddfndS(Ns%s Rt s s%s failed with %s RSR:( RR/twriteRSRRRR}RsRhRRtR](RFRRRJRt errstream((s)lib/python2.7/site-packages/gevent/hub.pyRs(  # cC@s|tkstd|jxq|j}||_z|jWdd|_Xg}t|dry|j}n|j j t d||q(WdS(s Entry-point to running the loop. This method is called automatically when the hub greenlet is scheduled; do not call it directly. :raises gevent.exceptions.LoopExit: If the loop finishes running. This means that there are no other scheduled greenlets, and no active watchers or servers. In some situations, this indicates a programming error. sDo not call Hub.run() directlyNtdebugs"This operation would block forever( RtAssertionErrort start_periodic_monitoring_threadR%t error_handlerR`R/R=RRR?R(RFR%R((s)lib/python2.7/site-packages/gevent/hub.pyR`6s     cC@s|jdkrtjrddlm}ddlm}ddlm}|||_|j rp|jj n|||jn|jS(Ni(tPeriodicMonitoringThread(t!PeriodicMonitorThreadStartedEvent(tnotify_and_call_entry_points( R\R/R!tmonitor_threadtgevent._monitorRt gevent.eventsRRRmtinstall_monitor_memory_usage(RFRRR((s)lib/python2.7/site-packages/gevent/hub.pyRRs cC@st|jkstd|jr+tSt|}|dk rq|jj|dt }|j |j dnz'y|j Wnt k rtSXWd|dk r|j|jnXt S(snWait for the event loop to finish. Exits only when there are no more spawned greenlets, started servers, active timeouts or watchers. If *timeout* is provided, wait no longer for the specified number of seconds. Returns True if exited because the loop finished execution. Returns False if exited because of timeout expired. s$only possible from the MAIN greenletR.N(RRRR<tTrueR R/R%R1R>RAR'R0RRLtclose(RFttimeoutR5((s)lib/python2.7/site-packages/gevent/hub.pytjoinfs        cC@s|jdk r(|jjd|_n|jdk rM|jj|`n|jdk rr|jj|`n|dkr|jj }n|rt|jkrt dn|jj n t |jd|_t |krt dndS(s Destroy this hub and clean up its resources. If you manually create hubs, you *should* call this method before disposing of the hub object reference. N( R\R/RR[RRZR%RbRRtdestroyRYR(RFt destroy_loop((s)lib/python2.7/site-packages/gevent/hub.pyRs&          cC@stjS(N(R!tresolver(RF((s)lib/python2.7/site-packages/gevent/hub.pytresolver_classscC@s.|jdkr'|jd||_n|jS(NR+(R[R/R(RF((s)lib/python2.7/site-packages/gevent/hub.pyt _get_resolverscC@s ||_dS(N(R[(RFRJ((s)lib/python2.7/site-packages/gevent/hub.pyt _set_resolverscC@s d|_dS(N(R/R[(RF((s)lib/python2.7/site-packages/gevent/hub.pyt _del_resolverss The DNS resolver that the socket functions will use. .. seealso:: :doc:`/dns` cC@stjS(N(R!t threadpool(RF((s)lib/python2.7/site-packages/gevent/hub.pytthreadpool_classscC@s4|jdkr-|j|jd||_n|jS(NR+(RZR/Rtthreadpool_size(RF((s)lib/python2.7/site-packages/gevent/hub.pyt_get_threadpoolscC@s ||_dS(N(RZ(RFRJ((s)lib/python2.7/site-packages/gevent/hub.pyt_set_threadpoolscC@s d|_dS(N(R/RZ(RF((s)lib/python2.7/site-packages/gevent/hub.pyt_del_threadpoolss The threadpool associated with this hub. Usually this is a :class:`gevent.threadpool.ThreadPool`, but you :attr:`can customize that `. Use this object to schedule blocking (non-cooperative) operations in a different thread to prevent them from halting the event loop. N(*RSRTRUtKeyboardInterruptt SystemExitt SystemErrorRRRRR/R\RdRvRiRHRRkRVRgRfRmR|RORRRRR`RRRRRRRRRRRRR(((s)lib/python2.7/site-packages/gevent/hub.pyR VsD       $    $         t linkproxycB@s&eZddgZdZdZRS(tcallbackR^cC@s||_||_dS(N(RR^(RFRR^((s)lib/python2.7/site-packages/gevent/hub.pyRHs cG@s2|j}|j}d|_d|_||dS(N(RR^R/(RFR)RR^((s)lib/python2.7/site-packages/gevent/hub.pyt__call__s     (RSRTt __slots__RHR(((s)lib/python2.7/site-packages/gevent/hub.pyRs  (@RUt __future__RRt functoolsRR$RPRRR#RRt__all__tgevent._configRR!tgevent._compatRt gevent._utilRRRt gevent._identRtgevent._hub_localR RRRRRYRR Rtgevent._greenlet_primitivesRtgevent._hub_primitivesRRERtwait_on_objectsR3tiwait_on_objectstiwaittgevent.exceptionsRtgevent._waiterR t __import__t get_identRcReRRRR7RtobjectR R/R R R(((s)lib/python2.7/site-packages/gevent/hub.pytsb       7(  @ D