B H/\j @sdZddlmZmZddlmZddlZddlZddl 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$d Z5d/d&d Z6d0d'd(Z7e fd)d Z8Gd*d d e9Z:d1d+dZ;Gd,dde&Z` method, calls it. This prevents a greenlet from being switched to for the first time after it's been killed but not yet executed. r F) exceptionblockN)deadhasattrr r"r&r'throw)rr9r.r.r/r s c@sReZdZdZdZddZddZddZeeeZ [[d d Z d d Z d dZ dS)r a_ 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. NcOslt|stdt|_|jjj|dd|_|j|j||_ ||_ ||_ |j dkrhddl m}||_ dS)Nz signal handler must be callable.F)r0r)Greenlet)r r!r"r+r&r r8start_starthandlerr)r*greenlet_classgeventr>)selfZ signalnumrAr)r*r>r.r.r/__init__s  zsignal.__init__cCs|jjS)N)r8r0)rDr.r.r/_get_refszsignal._get_refcCs ||j_dS)N)r8r0)rDvaluer.r.r/_set_refszsignal._set_refcCs|jdS)N)r8stop)rDr.r.r/cancelsz signal.cancelcCs>y||j}|Wn |jjdtYnXdS)N)N)rBhandler(r+ handle_errorsysZ _exc_info)rDrr.r.r/r@s   z signal._startcCs:y|j|j|jWn |jjdtYnXdS)N)N)rAr)r*r+rLrMexc_info)rDr.r.r/rK sz signal.handle) __name__ __module__ __qualname____doc__rBrErFrHpropertyr0rJr@rKr.r.r.r/r s cCsX|dkrtn|}|dkrdS|jx*|j|j|jfD]}t|dddq:WdS)a 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. NZ_on_forkcSsdS)Nr.r.r.r.r/Jszreinit..)_get_hubr&r _threadpool _resolverperiodic_monitoring_threadgetattr)r+objr.r.r/r s  c@s$eZdZdZeeefZeefZ dZ dZ dZ dZ dZd4ddZedd Zed d Zed d ZeddZddZddZddZeddZddZddZddZd5ddZd6d d!Zed"d#Z d$d%Z!d&d'Z"d(d)Z#ee!e"e#d*Z$ed+d,Z%d-d.Z&d/d0Z'd1d2Z(ee&e'e(d3Z)dS)7ra 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. NrcCst|ddt|_t|dr8|dk r0td||_nHtdk rLt|_n4|dkrb|jtkrbd}|dkrp|j }|j ||d|_d|_ d|_ t j|_tjd7_tj|_dS)NrunzUnexpected argument: defaultF)flagsdefault)rrEget_thread_ident thread_identr<r!r&rMAIN_THREAD_IDENTbackend loop_classrWrVr#format_contextr _hub_counterZ minimal_ident)rDr&r_r.r.r/rEs$   z Hub.__init__cCstS)N)r)rDr.r.r/ident_registryszHub.ident_registrycCstjS)N)r#r&)rDr.r.r/reszHub.loop_classcCstjS)N)r#Z libev_backend)rDr.r.r/rdsz Hub.backendcCs |jtkS)zW Is this the hub for the main thread? .. versionadded:: 1.3b1 )rbrc)rDr.r.r/main_hubsz Hub.main_hubc Cs|jdkrd}nFy|j}Wn6tk rT}zt|pBt|pBd}Wdd}~XYnXd|jj|jt||f}|j dk r|d|j 7}|j dk r|d|j 7}|dt |j f7}|dS)NZ destroyederrorz<%s %r at 0x%x %sz resolver=%rz threadpool=%rz thread_ident=%s>) r&Z_format Exceptionstrrepr __class__rOnameidrWrVhexrb)rDinfoexresultr.r.r/__repr__s" &  z Hub.__repr__cCsRt|tr||}t||js.||||||dksBt||jrN|||dS)aY 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) isinstancerm issubclass NOT_ERRORprint_exception SYSTEM_ERRORhandle_system_error)rDcontexttyperGtbr.r.r/rLs   zHub.handle_errorcCst}||ks"||jks"|jdkr2|j||nXd}y|j|j}Wntj|jdYnXz|j||Wd|dk r| XdS)z 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). N)file) rparentr&r=r'r( traceback print_excexception_streamrI)rDr~rGZcurrentcbr.r.r/r|szHub.handle_system_errorcCs&tr tjnd}t|jdkr"|j}|S)z The stream to which exceptions will be written. Defaults to ``sys.stderr`` unless assigned to. .. versionadded:: 1.2a1 NZFileObjectThread)rMstderrr~rOio)rDrr.r.r/rs zHub.exception_streamcCs|j}|sdS|dkr(|d|jntj||||d~y&|t||dk rZdndWn YnX|dk rt|tsy||}Wn"tj |jdt |}YnX|d|t |ddfdS)Nz%s )r  z%s failed with %s rOr9) rwriterOrrzrrwrmrfrrnrY)rDr}r~rGrZ errstreamr.r.r/rzs(  zHub.print_exceptioncCsp|tkstd|xP|j}||_z |Wdd|_Xg}t|drT|}|j t d||qWdS)a 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. zDo not call Hub.run() directlyNdebugz"This operation would block forever) rAssertionError start_periodic_monitoring_threadr&Z error_handlerr]r<rrr=r)rDr&rr.r.r/r]6s   zHub.runcCsb|jdkr\tjr\ddlm}ddlm}ddlm}|||_|jrN|j |||j|jS)Nr)PeriodicMonitoringThread)!PeriodicMonitorThreadStartedEvent)notify_and_call_entry_points) rXr#Zmonitor_threadZgevent._monitorrZ gevent.eventsrrriZinstall_monitor_memory_usage)rDrrrr.r.r/rRs      z$Hub.start_periodic_monitoring_threadcCst|jkstd|jrdSt|}|dk rL|jj|dd}||jdz&y | Wnt k rndSXWd|dk r| | XdS)anWait 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. z$only possible from the MAIN greenletTNF)r0) rrrr;rr&r2r?r(r1rrIclose)rDZtimeoutr4r.r.r/joinfs    zHub.joincCs|jdk r|jd|_|jdk r2|j|`|jdk rJ|j|`|dkr\|jj }|rt|jkrttd|j n t|jd|_t |krt ddS)z 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) rXr rWrrVr&r_rrdestroyrUr)rDZ destroy_loopr.r.r/rs&           z Hub.destroycCstjS)N)r#resolver)rDr.r.r/resolver_classszHub.resolver_classcCs|jdkr|j|d|_|jS)N)r+)rWr)rDr.r.r/ _get_resolvers zHub._get_resolvercCs ||_dS)N)rW)rDrGr.r.r/ _set_resolverszHub._set_resolvercCs d|_dS)N)rW)rDr.r.r/ _del_resolverszHub._del_resolverz The DNS resolver that the socket functions will use. .. seealso:: :doc:`/dns` cCstjS)N)r# threadpool)rDr.r.r/threadpool_classszHub.threadpool_classcCs"|jdkr|j|j|d|_|jS)N)r+)rVrthreadpool_size)rDr.r.r/_get_threadpools zHub._get_threadpoolcCs ||_dS)N)rV)rDrGr.r.r/_set_threadpoolszHub._set_threadpoolcCs d|_dS)N)rV)rDr.r.r/_del_threadpoolszHub._del_threadpoola 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. )NN)N)N)*rOrPrQrRKeyboardInterrupt SystemExit SystemErrorr{rryrrXrbrprgrErrhrSrerdrirvrLr|rrrzr]rrrrrrrrrrrrrr.r.r.r/rVsD         $  $   c@s$eZdZddgZddZddZdS) linkproxycallbackrZcCs||_||_dS)N)rrZ)rDrrZr.r.r/rEszlinkproxy.__init__cGs$|j}|j}d|_d|_||dS)N)rrZ)rDr)rrZr.r.r/__call__s zlinkproxy.__call__N)rOrPrQ __slots__rErr.r.r.r/rsr)rT)r)N)>rRZ __future__rr functoolsrr%rMrrr$rr__all__Zgevent._configrr#Zgevent._compatrZ gevent._utilrrrZ gevent._identrZgevent._hub_localr rrrrrUrr"rZgevent._greenlet_primitivesrZgevent._hub_primitivesrrCrZwait_on_objectsr3Ziwait_on_objectsZiwaitZgevent.exceptionsrZgevent._waiterr __import__ get_identrarcrr r6r objectr r rrr.r.r.r/sf                       7 (  @ D