o )ªZh 1ã@sdZddlZddlZddlZddlZddlZddlZddlZddlm Z ddl m Z m Z m Z ddlmZddlmZddlmZddlZddlmZmZmZejrWdd lmZejZd efd d „Zdd d„Zda ddeedeed efdd„Zd eefdd„Z Gdd„de!ƒZ"dS)z„Utilities for working with multiple processes, including both forking the server into multiple processes and managing subprocesses. éN)Úhexlify)ÚFutureÚ"future_set_result_unless_cancelledÚ%future_set_exception_unless_cancelled)Úioloop)Ú PipeIOStream)Úgen_log)ÚOptionalÚAnyÚCallable)ÚListÚreturnc Cs\tdurdSzt ¡WStyYnwzt d¡WSttfy&Ynwt d¡dS)z1Returns the number of processors on this machine.NéÚSC_NPROCESSORS_CONFz1Could not detect number of processors; assuming 1) ÚmultiprocessingÚ cpu_countÚNotImplementedErrorÚosÚsysconfÚAttributeErrorÚ ValueErrorrÚerror©rrúF/var/www/html/lang_env/lib/python3.10/site-packages/tornado/process.pyr1s  ÿ ÿ rcCshdtjvrdSddl}z ttt d¡ƒdƒ}Wnty,tt ¡dƒt  ¡A}Ynw|  |¡dS)NÚrandomréiè) ÚsysÚmodulesrÚintrrÚurandomrÚtimeÚgetpidÚseed)rr"rrrÚ_reseed_randomAs  ÿr#Ú num_processesÚ max_restartsc sNtjdkr tdƒ‚|durd}tdusJ‚|dus|dkr tƒ}t d|¡i‰dtdttf‡fd d „ }t |ƒD]}||ƒ}|durG|Sq9d}ˆr t   ¡\}}|ˆvrWqJˆ  |¡}t   |¡rmt d ||t  |¡¡nt  |¡dkr€t d ||t  |¡¡nt d ||¡qJ|d7}||kr”tdƒ‚||ƒ}|durž|SˆsLt d¡dS)aqStarts multiple worker processes. If ``num_processes`` is None or <= 0, we detect the number of cores available on this machine and fork that number of child processes. If ``num_processes`` is given and > 0, we fork that specific number of sub-processes. Since we use processes and not threads, there is no shared memory between any server code. Note that multiple processes are not compatible with the autoreload module (or the ``autoreload=True`` option to `tornado.web.Application` which defaults to True when ``debug=True``). When using multiple processes, no IOLoops can be created or referenced until after the call to ``fork_processes``. In each child process, ``fork_processes`` returns its *task id*, a number between 0 and ``num_processes``. Processes that exit abnormally (due to a signal or non-zero exit status) are restarted with the same id (up to ``max_restarts`` times). In the parent process, ``fork_processes`` calls ``sys.exit(0)`` after all child processes have exited normally. max_restarts defaults to 100. Availability: Unix Úwin32zfork not available on windowsNédrzStarting %d processesÚir cs*t ¡}|dkrtƒ|a|S|ˆ|<dS©Nr)rÚforkr#Ú_task_id)r(Úpid©ÚchildrenrrÚ start_childsz#fork_processes..start_childz1child %d (pid %d) killed by signal %d, restartingz3child %d (pid %d) exited with status %d, restartingz!child %d (pid %d) exited normallyrz"Too many child restarts, giving up)rÚplatformÚ Exceptionr+rrÚinforr ÚrangerÚwaitÚpopÚ WIFSIGNALEDÚwarningÚWTERMSIGÚ WEXITSTATUSÚ RuntimeErrorÚexit) r$r%r/r(ÚidZ num_restartsr,ÚstatusZnew_idrr-rÚfork_processesSsZ    ÿ   üüå r>cCstS)zpReturns the current task id, if any. Returns None if this process was not created by `fork_processes`. )r+rrrrÚtask_id³sr?c@s¶eZdZdZeƒZdZiZdededdfdd„Z d e e gdfddfd d „Z dd e ddfdd„Zeddd„ƒZeddd„ƒZeddd„ƒZede ddfdd„ƒZde ddfdd„ZdS)Ú Subprocessa Wraps ``subprocess.Popen`` with IOStream support. The constructor is the same as ``subprocess.Popen`` with the following additions: * ``stdin``, ``stdout``, and ``stderr`` may have the value ``tornado.process.Subprocess.STREAM``, which will make the corresponding attribute of the resulting Subprocess a `.PipeIOStream`. If this option is used, the caller is responsible for closing the streams when done with them. The ``Subprocess.STREAM`` option and the ``set_exit_callback`` and ``wait_for_exit`` methods do not work on Windows. There is therefore no reason to use this class instead of ``subprocess.Popen`` on that platform. .. versionchanged:: 5.0 The ``io_loop`` argument (deprecated since version 4.1) has been removed. FÚargsÚkwargsr Nc Osptj ¡|_g}g}| d¡tjur-t ¡\}}||d<|  ||f¡|  |¡t |ƒ|_ | d¡tjurPt ¡\}}||d<|  ||f¡|  |¡t |ƒ|_ | d¡tjurst ¡\} } | |d<|  | | f¡|  | ¡t | ƒ|_z tj|i|¤Ž|_Wn|D]} t | ¡q„‚|D]} t | ¡q|jj|_dD]} t|| ƒs¯t|| t|j| ƒƒqžd|_d|_dS)NÚstdinÚstdoutÚstderr)rCrDrE)rZIOLoopÚcurrentÚio_loopÚgetr@ÚSTREAMrÚpipeÚextendÚappendrrCrDrEÚ subprocessÚPopenÚprocÚcloser,ÚhasattrÚsetattrÚgetattrÚ_exit_callbackÚ returncode) ÚselfrArBZpipe_fdsÚto_closeZin_rZin_wZout_rZout_wZerr_rZerr_wÚfdÚattrrrrÚ__init__×sH              € zSubprocess.__init__ÚcallbackcCs*||_t ¡|tj|j<t |j¡dS)a¦Runs ``callback`` when this process exits. The callback takes one argument, the return code of the process. This method uses a ``SIGCHLD`` handler, which is a global setting and may conflict if you have other libraries trying to handle the same signal. If you are using more than one ``IOLoop`` it may be necessary to call `Subprocess.initialize` first to designate one ``IOLoop`` to run the signal handlers. In many cases a close callback on the stdout or stderr streams can be used as an alternative to an exit callback if the signal handler is causing a problem. Availability: Unix N)rTr@Ú initializeÚ_waitingr,Ú_try_cleanup_process)rVr[rrrÚset_exit_callbackþs zSubprocess.set_exit_callbackTÚ raise_errorz Future[int]cs,tƒ‰dtddf‡‡fdd„ }| |¡ˆS)a2Returns a `.Future` which resolves when the process exits. Usage:: ret = yield proc.wait_for_exit() This is a coroutine-friendly alternative to `set_exit_callback` (and a replacement for the blocking `subprocess.Popen.wait`). By default, raises `subprocess.CalledProcessError` if the process has a non-zero exit status. Use ``wait_for_exit(raise_error=False)`` to suppress this behavior and return the exit status without raising. .. versionadded:: 4.2 Availability: Unix Úretr Ncs.|dkrˆrtˆt|dƒƒdStˆ|ƒdS)NrÚunknown)rÚCalledProcessErrorr)ra©Úfuturer`rrr[(s  ÿz*Subprocess.wait_for_exit..callback)rrr_)rVr`r[rrdrÚ wait_for_exits zSubprocess.wait_for_exitcCs,|jrdSt ¡}| tj|j¡d|_dS)aáInitializes the ``SIGCHLD`` handler. The signal handler is run on an `.IOLoop` to avoid locking issues. Note that the `.IOLoop` used for signal handling need not be the same one used by individual Subprocess objects (as long as the ``IOLoops`` are each running in separate threads). .. versionchanged:: 5.0 The ``io_loop`` argument (deprecated since version 4.1) has been removed. Availability: Unix NT)Ú _initializedÚasyncioÚget_event_loopZadd_signal_handlerÚsignalÚSIGCHLDÚ_cleanup©ÚclsÚlooprrrr\4s  zSubprocess.initializecCs(|jsdSt ¡}| tj¡d|_dS)z Removes the ``SIGCHLD`` handler.NF)rgrhriZremove_signal_handlerrjrkrmrrrÚ uninitializeIs   zSubprocess.uninitializecCs"t|j ¡ƒD]}| |¡qdS©N)Úlistr]Úkeysr^)rnr,rrrrlRs ÿzSubprocess._cleanupr,cCsdz t |tj¡\}}Wn tyYdSw|dkrdS||ks"J‚|j |¡}|j |j|¡dSr)) rÚwaitpidÚWNOHANGÚChildProcessErrorr]r5rGZ add_callbackÚ_set_returncode)rnr,Zret_pidr=Zsubprocrrrr^Ws ÿ  zSubprocess._try_cleanup_processr=cCsttjdkr d|_nt |¡rt |¡ |_n t |¡sJ‚t |¡|_|j|j_|j r8|j }d|_ ||jƒdSdS)Nr&éÿÿÿÿ) rr0rUrr6r8Ú WIFEXITEDr9rOrT)rVr=r[rrrrwcs    ýzSubprocess._set_returncode)T©r N)Ú__name__Ú __module__Ú __qualname__Ú__doc__ÚobjectrIrgr]r rZr rr_ÚboolrfÚ classmethodr\rprlr^rwrrrrr@¼s"'    r@rzrq)#r~rhrrrjrMrr ÚbinasciirZtornado.concurrentrrrÚtornadorZtornado.iostreamrZ tornado.logrÚtypingr r r Ú TYPE_CHECKINGr rcrrr#r+r>r?rr@rrrrÚs>      ÿÿÿ þ`