File: //lib64/python3.6/site-packages/tornado/__pycache__/process.cpython-36.pyc
3
��f2 � @ sD d Z ddlZddlZddlZddlZddlZddlZddlZddlm Z ddl
m Z m Z m
Z
ddlmZ ddlmZ ddlmZ ddlmZ dd lmZ ddlZdd
lmZmZmZm Z ej r�dd lm Z ej Z e d �d
d�Z!dd �dd�Z"ee e f d �dd�Z#da$dee e e d�dd�Z%ee d �dd�Z&G dd� 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)�set_close_exec)�errno_from_exception)�Tuple�Optional�Any�Callable)�List)�returnc C s\ t dkr dS yt j� S tk
r( Y nX y
tjd�S ttfk
rL Y nX tjd� 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� r r � /usr/lib64/python3.6/process.pyr 3 s
r c C sj dt jkrd S dd l} ytttjd��d�}W n, tk
rZ ttj� d �tj � A }Y nX | j
|� d S )N�randomr � i� ) �sys�modulesr �intr r �urandomr �time�getpid�seed)r r% r r r �_reseed_randomC s
r& c C s$ t j� \} }t| � t|� | |fS )N)r �piper )�r�wr r r �
_pipe_cloexecR s r* )�
num_processes� max_restartsr c
s~ |dkr d}t dkst�| dks(| dkr.t� } tjd| � i � ttt d�� fdd� }x$t| �D ]}||�}|dk r`|S q`W d}x� �rnytj � \}}W n4 t
k
r� } zt |�t j
kr�w�� W Y dd}~X nX |� kr�q�� j|�}tj|��rtjd||tj|�� n8tj|�dk�r.tjd ||tj|�� ntjd
||� q�|d 7 }||k�rXtd ��||�} | dk r�| S q�W tjd� dS )
a� 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`` returns None if all child processes
have exited normally, but will otherwise only exit by throwing an
exception.
max_restarts defaults to 100.
N�d r zStarting %d processes)�ir c s. t j� }|dkr t� | a| S | � |< d S d S )Nr )r �forkr& �_task_id)r. �pid)�childrenr r � start_child� s z#fork_processes.<locals>.start_childz1child %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)r0 �AssertionErrorr r �infor! r �ranger �wait�OSErrorr
�errnoZEINTR�pop� WIFSIGNALEDZwarning�WTERMSIG� WEXITSTATUS� RuntimeErrorr �exit)
r+ r, r3 r. �idZ num_restartsr1 �status�eZnew_idr )r2 r �fork_processes\ sX
rC c C s t S )zpReturns the current task id, if any.
Returns None if this process was not created by `fork_processes`.
)r0 r r r r �task_id� s rD c @ s� e Zd ZdZe� ZdZi ZdZe e dd�dd�Z
e e gdf dd�dd �Z
d ed d �d
d�Zedd�dd��Zedd�dd��Zedd�dd��Zee dd�dd��Ze dd�dd�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.
FN)�args�kwargsr c
O s� t jj� | _g }g }|jd�tjkrXt� \}}||d< |j||f� |j |� t
|�| _ |jd�tjkr�t� \}}||d< |j||f� |j |� t
|�| _ |jd�tjkr�t� \} }
|
|d< |j| |
f� |j |
� t
| �| _
ytj||�| _W n( x|D ]} tj| � �q W � Y nX x|D ]} tj| � �q"W | jj| _x.dD ]&} t| | ��sFt| | t| j| �� �qFW d | _d | _d S )N�stdin�stdout�stderr)rH rI rJ )r �IOLoop�current�io_loop�getrE �STREAMr* �extend�appendr rH rI rJ �
subprocess�Popen�procr �closer1 �hasattr�setattr�getattr�_exit_callback�
returncode)
�selfrF rG Zpipe_fdsZto_closeZin_rZin_wZout_rZout_wZerr_rZerr_w�fd�attrr r r �__init__� sF
zSubprocess.__init__)�callbackr c C s* || _ tj� | tj| j< tj| 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.
N)rY rE �
initialize�_waitingr1 �_try_cleanup_process)r[ r_ r r r �set_exit_callback s z Subprocess.set_exit_callbackTz Future[int])� raise_errorr c s* t � � tdd�� �fdd� }| j|� � S )a 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
N)�retr c s, | dkr �r t � t| d�� n
t� | � d S )Nr �unknown)r �CalledProcessErrorr )re )�futurerd r r r_ , s z*Subprocess.wait_for_exit.<locals>.callback)r r! rc )r[ rd r_ r )rh rd r �
wait_for_exit s
zSubprocess.wait_for_exit)r c s8 � j r
dS tjj� �tjtj� �fdd��� _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.
Nc s �j � j�S )N)�add_callback_from_signal�_cleanup)Zsig�frame)�clsrM r r �<lambda>J s z'Subprocess.initialize.<locals>.<lambda>T)� _initializedr rK rL �signal�SIGCHLD� _old_sigchld)rm r )rm rM r r` 8 s
zSubprocess.initializec C s$ | j s
dS tjtj| j� d| _ dS )z Removes the ``SIGCHLD`` handler.NF)ro rp rq rr )rm r r r � uninitializeN s zSubprocess.uninitializec C s& x t | jj� �D ]}| j|� qW d S )N)�listra �keysrb )rm r1 r r r rk V s zSubprocess._cleanup)r1 r c C s� yt j|t j�\}}W n4 tk
rJ } zt|�tjkr:d S W Y d d }~X nX |dkrXd S ||ksdt�| jj |�}|j
j |j |� d S )Nr )
r �waitpid�WNOHANGr8 r
r9 ZECHILDr4 ra r: rM rj �_set_returncode)rm r1 Zret_pidrA rB Zsubprocr r r rb [ s z Subprocess._try_cleanup_process)rA r c C s^ t j|�rt j|� | _nt j|�s(t�t j|�| _| j| j_| jrZ| j}d | _|| j� d S )N) r r; r< rZ � WIFEXITEDr4 r= rT rY )r[ rA r_ r r r rx h s
zSubprocess._set_returncode)T)�__name__�
__module__� __qualname__�__doc__�objectrO ro ra rr r
r^ r r! rc �boolri � classmethodr` rs rk rb rx r r r r rE � s" ' rE )N))r} r9 r r rp rR r r# Zbinasciir Ztornado.concurrentr r r Ztornador Ztornado.iostreamr Z tornado.logr Ztornado.platform.autor Z tornado.utilr
Ztypingr r r
r Z
TYPE_CHECKINGr rg r! r r& r* r0 rC rD r~ rE r r r r �<module> s4 ^