
    g1                     @   d Z ddlZddlZddlZddlZddlZddlZddlZddlm	Z	 ddl
mZmZmZ ddlmZ ddlmZ ddlmZ ddlZddlmZmZmZ ej0                  rdd	lmZ ej4                  Zd
efdZddZda	 ddee   dee   d
efdZd
ee   fdZ  G d de!      Z"y)zUtilities 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                      t         y	 t        j                         S # t        $ r Y nw xY w	 t        j                  d      S # t
        t        f$ r Y nw xY wt        j                  d       y)z1Returns the number of processors on this machine.   SC_NPROCESSORS_CONFz1Could not detect number of processors; assuming 1)	multiprocessing	cpu_countNotImplementedErrorossysconfAttributeError
ValueErrorr	   error     D/var/www/openai/venv/lib/python3.12/site-packages/tornado/process.pyr   r   1   sm    ((** zz/00J' MMEFs    	))A AAc                  .   dt         j                  vry dd l} 	 t        t	        t        j                  d            d      }| j                  |       y # t        $ r8 t        t        j                         dz        t        j                         z  }Y Rw xY w)Nrandomr      i  )sysmodulesr   intr   r   urandomr   timegetpidseed)r   r&   s     r   _reseed_randomr'   A   sq    s{{"
572::b>*B/ KK  5499;%&45s   (A >BBnum_processesmax_restartsc                 (  	 t         j                  dk(  rt        d      |d}t        J | | dk  r
t	               } t        j                  d|        i 	dt        dt        t           f	fd	}t        |       D ]  } ||      }||c S  d}	rt        j                         \  }}|	vr	j                  |      }t        j                  |      r,t        j                  d
||t        j                  |             n\t        j                   |      dk7  r,t        j                  d||t        j                   |             nt        j                  d||       |dz  }||kD  rt#        d       ||      }||S 	rt        j$                  d       y)aq  Starts 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
    win32zfork not available on windowsNd   r   zStarting %d processesir   c                 ^    t        j                         }|dk(  rt                | a| S | |<   y Nr   )r   forkr'   _task_id)r-   pidchildrens     r   start_childz#fork_processes.<locals>.start_child   s1    ggi!8HHHSMr   z1child %d (pid %d) killed by signal %d, restartingz3child %d (pid %d) exited with status %d, restartingz!child %d (pid %d) exited normallyr   z"Too many child restarts, giving up)r    platform	Exceptionr1   r   r	   infor"   r
   ranger   waitpopWIFSIGNALEDwarningWTERMSIGWEXITSTATUSRuntimeErrorexit)
r(   r)   r4   r-   idnum_restartsr2   statusnew_idr3   s
            @r   fork_processesrE   S   s   < ||w 788  2!LL(-8H
s 
x} 
 =!^>I " L
ggiVh\\#>>&!OOCF#	 ^^F#q(OOEv&	 LL<b#F,&CDDRM7 @ HHQKr   c                      t         S )zpReturns the current task id, if any.

    Returns None if this process was not created by `fork_processes`.
    )r1   r   r   r   task_idrG      s	     Or   c                       e Zd ZdZ e       ZdZi ZdededdfdZ	de
egdf   ddfd	Zdd
eddfdZedd       Zedd       Zedd       Zededdfd       ZdeddfdZy)
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           	      f   t         j                  j                         | _        g }g }|j	                  d      t
        j                  u rPt        j                         \  }}||d<   |j                  ||f       |j                  |       t        |      | _        |j	                  d      t
        j                  u rPt        j                         \  }}||d<   |j                  ||f       |j                  |       t        |      | _        |j	                  d      t
        j                  u rPt        j                         \  }	}
|
|d<   |j                  |	|
f       |j                  |
       t        |	      | _        	 t        j                   |i || _        |D ]  }t        j$                  |        | j"                  j&                  | _        dD ]0  }t)        | |      rt+        | |t-        | j"                  |             2 d | _        d | _        y #  |D ]  }t        j$                  |         xY w)Nstdinstdoutstderr)rM   rN   rO   )r   IOLoopcurrentio_loopgetrI   STREAMr   pipeextendappendr   rM   rN   rO   
subprocessPopenproccloser2   hasattrsetattrgetattr_exit_callback
returncode)selfrJ   rK   pipe_fdsto_closein_rin_wout_rout_werr_rerr_wfdattrs                r   __init__zSubprocess.__init__   s   }},,. ::g*"3"33JD$"F7OOOT4L)OOD!%d+DJ::h:#4#44779LE5$F8OOUEN+OOE"&u-DK::h:#4#44779LE5$F8OOUEN+OOE"&u-DK	"(($9&9DI
 BHHRL 99==1D4&dGDIIt$<= 2 #	 s   <H H0callbackc                     || _         t        j                          | t        j                  | j                  <   t        j                  | j                         y)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)r_   rI   
initialize_waitingr2   _try_cleanup_process)ra   rm   s     r   set_exit_callbackzSubprocess.set_exit_callback   s>    " '(,
DHH%''1r   raise_errorzFuture[int]c                 ^    t               dt        ddffd}| j                  |       S )a2  Returns 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   Nc                 Z    | dk7  rrt        t        | d             y t        |        y )Nr   unknown)r   CalledProcessErrorr   )ru   futurers   s    r   rm   z*Subprocess.wait_for_exit.<locals>.callback(  s-    axK5.sI> 363?r   )r   r"   rr   )ra   rs   rm   ry   s    ` @r   wait_for_exitzSubprocess.wait_for_exit  s7    $ 	@# 	@$ 	@ 	x(r   c                     | j                   ryt        j                         }|j                  t        j
                  | j                         d| _         y)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_loopadd_signal_handlersignalSIGCHLD_cleanupclsloops     r   ro   zSubprocess.initialize4  s>     %%'=r   c                     | j                   syt        j                         }|j                  t        j
                         d| _         y)z Removes the ``SIGCHLD`` handler.NF)r|   r}   r~   remove_signal_handlerr   r   r   s     r   uninitializezSubprocess.uninitializeI  s8     %%'""6>>2 r   c                 v    t        | j                  j                               D ]  }| j                  |        y N)listrp   keysrq   )r   r2   s     r   r   zSubprocess._cleanupR  s,    ))+,C$$S) -r   r2   c                    	 t        j                  |t         j                        \  }}|dk(  ry ||k(  sJ | j                  j                  |      }|j                  j                  |j                  |       y # t        $ r Y y w xY wr/   )	r   waitpidWNOHANGChildProcessErrorrp   r:   rR   add_callback_set_returncode)r   r2   ret_pidrC   subprocs        r   rq   zSubprocess._try_cleanup_processW  sy    	 jjbjj9OGV a<#~~,,""3'$$W%<%<fE ! 		s   'A8 8	BBrC   c                    t         j                  dk(  rd| _        nbt        j                  |      rt        j
                  |       | _        n1t        j                  |      sJ t        j                  |      | _        | j                  | j                  _        | j                  r&| j                  }d | _	         || j                         y y )Nr+   )
r    r5   r`   r   r;   r=   	WIFEXITEDr>   rZ   r_   )ra   rC   rm   s      r   r   zSubprocess._set_returncodec  s    <<7" DO~~f%#%;;v#6"6||F+++"$.."8  $		**H"&DT__% r   )Tr   N)__name__
__module____qualname____doc__objectrT   r|   rp   r   rl   r   r"   rr   boolrz   classmethodro   r   r   rq   r   r   r   r   rI   rI      s    * XFLH%c %S %T %N2(C5$;*? 2D 2,  @    ( ! ! * * 	Fs 	Ft 	F 	F&c &d &r   rI   r   r   )#r   r}   r   r   r   rX   r    r$   binasciir   tornado.concurrentr   r   r   tornador   tornado.iostreamr   tornado.logr	   typingr
   r   r   TYPE_CHECKINGr   rx   r"   r   r'   r1   rE   rG   r   rI   r   r   r   <module>r      s      	    
   
  )   * *	  22 3    AE]C=]08]]@# w& w&r   