Operation   : Linux premium131.web-hosting.com 4.18.0-553.44.1.lve.el8.x86_64 #1 SMP Thu Mar 13 14:29:12 UTC 2025 x86_64
Software     : Apache
Server IP    : 162.0.232.56 | Your IP: 216.73.216.111
Domains      : 1034 Domain(s)
Permission   : [ 0755 ]

U

e5dۿ�@s�
dZd
dl
Z
d
dlZd
dlZd
dlZd
dlZd
dlZd
dlZd
dlZd
dl	Z	d
dl
Z
d
dlZd
dlZddl
mZ
ddl
mZ
ddl
mZ
ddl
mZ
ddl
mZ
dd	l
mZ
dd
l
mZ
ddl
mZ
ddl
mZ
dd
l
mZ
ddlmZ
dZe
jdkr�ed�
�
dd�ZGdd�dej�ZGdd�dej �Z!Gdd�dej"ej#�Z$Gdd�dej%�Z&Gdd�d�Z'dd�Z(Gd d!�d!e'�Z)Gd"d#�d#e)�Z*Gd$d%�d%e)�Z+Gd&d'�d'e'�Z,Gd(d)�d)e'�Z-Gd*d+�d+ej.�Z/eZ0e/Z1dS),z2Selector event loop for Unix with signal handling.�N�
)
�base_events)
�base_subprocess)
�	constants)
�
coroutines)
�events)
�
exceptions)
�futures)
�selector_events)
�tasks)
�
transports)
�logger)�SelectorEventLoop�AbstractChildWatcher�SafeChildWatcher�FastChildWatcher�MultiLoopChildWatcher�ThreadedChildWatcher�DefaultEventLoopPolicyZwin32z+Signals are not really supported on Windowsc
Csd
S)zDummy signal handler.N�)�signum�framerr�+/usr/lib64/python3.8/asyncio/unix_events.py�_sighandler_noop*srcs�eZ
dZd
Zd)�f
dd�	Z�f
dd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
d*dd�
Zd+dd�
Zd,dd�
Z
dd�Zd-ddddd�dd�Zd.dddddd�dd �Zd!d"�Zd#d$�Zd%d&�Zd'd(�Z�ZS)/�_UnixSelectorEventLoopzdUnix event loop.

    Adds signal handling and UNIX Domain Socket support to SelectorEventLoop.
    Ncst��
|
�

i|_dS�
N)�super�__init__�_signal_handlers)�self�selector�
�	__class__rrr5s

z_UnixSelectorEventLoop.__init__c
sZt��
�
t��s.t|j�
D]}
|�|
�

qn(|jrVtjd
|�d�t	|d�
|j�
�
dS)NzClosing the loop z@ on interpreter shutdown stage, skipping signal handlers removal�
�source)r�close�sys�
is_finalizing�listr�remove_signal_handler�warnings�warn�ResourceWarning�clear�r�sigr!rrr%9s






�z_UnixSelectorEventLoop.closecCs|
D]}|sq|�|�

qdSr)
�_handle_signal)r�datarrrr�_process_self_dataGs


z)_UnixSelectorEventLoop._process_self_datac
GsL
t�
|�
st�|�
rtd
�
�
|�|
�

|��
zt�|j�	��

Wn2t
tfk
rt
}
ztt
|�
�
�
W5d}~XYnXt�|||d�}||j|
<zt�|
t�
t�|
d�
Wn�tk
�
rF
}
zz|j|
=|j�
szt�d�

Wn4t
tfk
�
r
}
zt�d|�
W5d}~XYnX|jtjk�
r4td|
�d��
�
n�W5d}~XYnXdS)z�Add a handler for a signal.  UNIX only.

        Raise ValueError if the signal number is invalid or uncatchable.
        Raise RuntimeError if there is a problem setting up the handler.
        z3coroutines cannot be used with add_signal_handler()NF����set_wakeup_fd(-1) failed: %s�sig � cannot be caught)rZiscoroutineZiscoroutinefunction�	TypeError�
_check_signalZ
_check_closed�signal�
set_wakeup_fdZ_csock�fileno�
ValueError�OSError�RuntimeError�strrZHandlerr�siginterruptr
�info�errno�EINVAL)rr/�callback�args�exc�handleZnexcrrr�add_signal_handlerNs2

�














z)_UnixSelectorEventLoop.add_signal_handlercCs8|j�
|
�
}|d
krd
S|jr*|�|
�

n
|�|�

d
S)z2Internal helper that is the actual signal handler.N)r�getZ
_cancelledr)Z_add_callback_signalsafe)rr/rGrrrr0{s



z%_UnixSelectorEventLoop._handle_signalc
Cs�|�|
�

z|j
|
=Wntk
r,


Yd
SX|
tjkr@tj}ntj}zt�|
|�
WnBtk
r�
}
z$|jtj	kr�t
d|
�d��
�
n�W5d}~XYnX|j
s�zt�d�

Wn2ttfk
r�
}
zt
�d|�
W5d}~XYnXdS)zwRemove a handler for a signal.  UNIX only.

        Return True if a signal handler was removed, False if not.
        Fr5r6Nr3r4T)r8r�KeyErrorr9�SIGINT�default_int_handler�SIG_DFLr=rBrCr>r:r<r
rA)rr/�handlerrFrrrr)�s(














z,_UnixSelectorEventLoop.remove_signal_handlercCs6t|
t
�std
|
���
�
|
t��kr2td|
���
�
dS)z�Internal helper to validate a signal.

        Raise ValueError if the signal number is invalid or uncatchable.
        Raise RuntimeError if there is a problem setting up the handler.
        zsig must be an int, not zinvalid signal number N)�
isinstance�intr7r9�
valid_signalsr<r.rrrr8�s


z$_UnixSelectorEventLoop._check_signalcCst||
|||�Sr)
�_UnixReadPipeTransport�r�pipe�protocol�waiter�extrarrr�_make_read_pipe_transport�sz0_UnixSelectorEventLoop._make_read_pipe_transportcCst||
|||�Sr)
�_UnixWritePipeTransportrSrrr�_make_write_pipe_transport�sz1_UnixSelectorEventLoop._make_write_pipe_transportc	

�s�t�
���}
|
��std
�
�
|��}t||
||||||f||d�|	��
}|
�|��|j|�
z|IdH
WnDt	t
fk
r�


�Yn,tk
r�


|��
|�
�IdH
�YnXW5QRX|S)NzRasyncio.get_child_watcher() is not activated, subprocess support is not installed.)rVrW)r�get_child_watcher�	is_activer>�
create_future�_UnixSubprocessTransport�add_child_handlerZget_pid�_child_watcher_callback�
SystemExit�KeyboardInterrupt�
BaseExceptionr%Z_wait)
rrUrE�shell�stdin�stdout�stderr�bufsizerW�kwargs�watcherrV�transprrr�_make_subprocess_transport�s8




���

�






z1_UnixSelectorEventLoop._make_subprocess_transportcCs|�|j
|�
dSr)�call_soon_threadsafeZ_process_exited)r�pid�
returncoderkrrrr`�s
z._UnixSelectorEventLoop._child_watcher_callback)�ssl�sock�server_hostname�ssl_handshake_timeoutc	�s 
|dkst|t
�st�
|r,|dkrLtd
�
�
n |dk	r<td�
�
|dk	rLtd�
�
|dk	r�|dk	rdtd�
�
t�|�
}t�tjtjd�}z |�	d�

|�
||�IdH
Wq�


|��
�Yq�Xn@|dkr�td�
�
|jtjks�|j
tjkr�td|���
�
|�	d�

|j||
|||d	�IdH\}}||fS)
Nz/you have to pass server_hostname when using sslz+server_hostname is only meaningful with ssl�1ssl_handshake_timeout is only meaningful with ssl�3path and sock can not be specified at the same timer
Fzno path and sock were specified�.A UNIX Domain Stream Socket was expected, got )
rs)rOr?�AssertionErrorr<�os�fspath�socket�AF_UNIX�SOCK_STREAM�setblockingZsock_connectr%�family�typeZ_create_connection_transport)	r�protocol_factory�pathrprqrrrs�	transportrUrrr�create_unix_connection�sT



�



�


�













�
�


�z-_UnixSelectorEventLoop.create_unix_connection�dT)rq�backlogrprs�
start_servingc
�s�
t|t
�rtd
�
�
|dk	r&|s&td�
�
|dk	�
rH|dk	r@td�
�
t�|�
}t�tjtj�}|ddkr�z t	�
t�	|�
j�
r�t�|�

WnBt
k
r�


Yn0tk
r�
}
zt�d||�
W5d}~XYnXz|�|�

Wnltk
�
r0
}	
z8|��
|	jtjk�
rd|�d�}
ttj|
�d�n�W5d}	~	XYn


|��
�YnXn<|dk�
rZtd	�
�
|jtjk�
sv|jtjk�
r�td
|���
�
|�d�

t�||g
|
|||�}|�
r�|��
tjd|d�IdH
|S)
Nz*ssl argument must be an SSLContext or Nonertrur
)r
�
z2Unable to check or remove stale UNIX socket %r: %rzAddress z is already in usez-path was not specified, and no sock specifiedrvF)
�loop)rO�boolr7r<rxryrzr{r|�stat�S_ISSOCK�st_mode�remove�FileNotFoundErrorr=r
�errorZbindr%rBZ
EADDRINUSEr~rr}rZServerZ_start_servingr�sleep)rr�r�rqr�rprsr��errrF�msgZserverrrr�create_unix_server
sn



�



�








�











�

�
�


�
z)_UnixSelectorEventLoop.create_unix_serverc
�s�z
tj

Wn,tk
r6
}
zt�d
�
�
W5d}~XYnXz|��}Wn2ttjfk
rv
}
zt�d�
�
W5d}~XYnXzt�|�
j	}Wn,t
k
r�
}
zt�d�
�
W5d}~XYnX|r�|n|}	|	s�dS|��}
|�|
d|
||||	d�
|
IdHS)Nzos.sendfile() is not availableznot a regular filer
)
rx�sendfile�AttributeErrorr�SendfileNotAvailableErrorr;�io�UnsupportedOperation�fstat�st_sizer=r]�_sock_sendfile_native_impl)rrq�file�offset�countrFr;r�Zfsize�	blocksize�futrrr�_sock_sendfile_nativeJ
s2





�











�z,_UnixSelectorEventLoop._sock_sendfile_nativec	Cs,|��}	|dk	r|�
|�

|
��r4|�|||�
dS|rd||}|d
k
rd|�|||�
|
�|�

dSzt�|	|||�}
W�
nDttfk
r�


|dkr�|�	|
|�
|�
|	|j|
|	||||||�

Y�
nbtk
�
rj
}
z�|dk	�
r|j
t
jk�
rt|�
tk	�
rtdt
j�}||_|}|d
k�
rBt�d�
}
|�|||�
|
�|
�

n|�|||�
|
�|�

W5d}~XYn�ttfk
�
r�


�Yn�tk
�
r�
}
z|�|||�
|
�|�

W5d}~XYnjX|
d
k�
r�|�|||�
|
�|�

nD||
7}||
7}|dk�r
|�	|
|�
|�
|	|j|
|	||||||�

dS)Nr
zsocket is not connectedzos.sendfile call failed)r;�
remove_writer�	cancelled�_sock_sendfile_update_fileposZ
set_resultrxr��BlockingIOError�InterruptedError�_sock_add_cancellation_callbackZ
add_writerr�r=rBZENOTCONNr�ConnectionError�	__cause__rr�Z
set_exceptionrarbrc)rr�Z
registered_fdrqr;r�r�r��
total_sent�fdZsentrF�new_excr�rrrr�a
s�


















�




�
�
�



�















�z1_UnixSelectorEventLoop._sock_sendfile_native_implcCs|d
krt�
|
|tj�
dS�Nr
)rx�lseek�SEEK_SET)rr;r�r�rrrr��
s

z4_UnixSelectorEventLoop._sock_sendfile_update_fileposcs��
fd
d�}|
�|�

dS)Nc
s&|��r"�
�
�}
|
d
kr"��|
�

dS)Nr3)r�r;r�)r�r��rrqrr�cb�
s



zB_UnixSelectorEventLoop._sock_add_cancellation_callback.<locals>.cb)
Zadd_done_callback)rr�rqr�rr�rr��
s
z6_UnixSelectorEventLoop._sock_add_cancellation_callback)
N)NN)NN)
N)
N)
N)�__name__�
__module__�__qualname__�__doc__rr%r2rHr0r)r8rXrZrlr`r�r�r�r�r�r��
__classcell__rrr!rr/sH
-
 
�

�
�
�

�.�

�CFrcs�eZ
dZd
Zd�f
dd�	Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Zdd�Ze
jf
dd�
Zddd�
Zdd�Zdd�Z�ZS) rRiNcs�t��
|�

||jd
<|
|_||_|��|_||_d|_d|_	t
�|j�
j}t
�|�
s�t
�|�
s�t
�|�
s�d|_d|_d|_td�
�
t
�|jd�
|j�|jj|�
|j�|jj|j|j�
|dk	r�|j�tj|d�
dS)NrTFz)Pipe transport is for pipes/sockets only.)rr�_extra�_loop�_piper;�_fileno�	_protocol�_closing�_pausedrxr�r�r��S_ISFIFOr��S_ISCHRr<�set_blocking�	call_soon�connection_made�_add_reader�_read_readyr	�_set_result_unless_cancelled)rr�rTrUrVrW�moder!rrr�
s:












��



�

�z_UnixReadPipeTransport.__init__c
Cs�|jj
g
}
|jdkr |
�d
�

n|jr0|
�d�

|
�d|j���

t|jdd�}|jdk	r�|dk	r�t�	||jt
j�}|r�|
�d�

q�|
�d�

n |jdk	r�|
�d�

n
|
�d
�

d�d	�
|
�
�
S)
N�closed�closing�fd=�	_selector�polling�idle�open�<{}>�
 )r"r�r��appendr�r��getattrr�r
�_test_selector_event�	selectorsZ
EVENT_READ�format�join)rrAr r�rrr�__repr__�
s(












�





z_UnixReadPipeTransport.__repr__c

Cs�zt�
|j|j�}
WnDttfk
r,


Yn�tk
rX
}
z|�|d
�
W5d}~XYn^X|
rl|j�	|
�

nJ|j
��r�t�
d|�
d|_|j
�|j�

|j
�|jj�

|j
�|jd�
dS)Nz"Fatal read error on pipe transport�%r was closed by peerT)rx�readr��max_sizer�r�r=�_fatal_errorr�Z
data_receivedr��	get_debugr
rAr��_remove_readerr�Zeof_received�_call_connection_lost)rr1rFrrrr��
s












z"_UnixReadPipeTransport._read_readyc

Cs>|js|j
rdSd
|_
|j�|j�

|j��r:t�d|�
dS)NTz%r pauses reading)r�r�r�r�r�r�r
�debug�
rrrr�
pause_reading�
s






z$_UnixReadPipeTransport.pause_readingc

CsB|js|j
sdSd
|_
|j�|j|j�
|j��r>t�d|�
dS)NFz%r resumes reading)	r�r�r�r�r�r�r�r
r�r�rrr�resume_readings






z%_UnixReadPipeTransport.resume_readingcCs
|
|_dSr�
r��rrUrrr�set_protocol
s
z#_UnixReadPipeTransport.set_protocolc


Cs|jSrr�r�rrr�get_protocols
z#_UnixReadPipeTransport.get_protocolc


Cs|jSr�
r�r�rrr�
is_closings
z!_UnixReadPipeTransport.is_closingc

Cs|js|�
d�

dSr)r��_closer�rrrr%s

z_UnixReadPipeTransport.closecCs,|jdk	r(|
d
|��t
|d�
|j��
dS�Nzunclosed transport r#�r�r,r%�r�_warnrrr�__del__s



z_UnixReadPipeTransport.__del__�Fatal error on pipe transportcCsZt|
t
�r4|
jtjkr4|j��rLtjd
||dd�
n|j�||
||j	d��

|�
|
�

dS�Nz%r: %sT�
�exc_info)�message�	exceptionr�rU)rOr=rBZEIOr�r�r
r��call_exception_handlerr�r��rrFr�rrrr�s






�z#_UnixReadPipeTransport._fatal_errorcCs(d
|_|j
�|j�

|j
�|j|
�
dS�NT)r�r�r�r�r�r��rrFrrrr�-s


z_UnixReadPipeTransport._closecCs4z|j�|
�

W5|j�
�
d|_d|_d|_XdSr�r�r%r�r�Zconnection_lostr�rrrr�2s





z,_UnixReadPipeTransport._call_connection_lost)NN)
r�)r�r�r�r�rr�r�r�r�r�r�r�r%r*r+r�r�r�r�r�rrr!rrR�
s
rRcs�eZ
dZd%�f
dd�	Zdd�Zdd�Zdd	�Zd
d�Zdd
�Zdd�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zejf
dd�
Zdd�Zd&dd �
Zd'd!d"�
Zd#d$�Z�ZS)(rYNc
s�t��
||
�
||jd
<||_|��|_||_t�|_d|_	d|_
t�|j�
j
}t�|�
}t�|�
}t�|�
}	|s�|s�|	s�d|_d|_d|_td�
�
t�|jd�
|j�|jj|�
|	s�|r�tj�d�
s�|j�|jj|j|j�
|dk	r�|j�tj|d�
dS)NrTr
Fz?Pipe transport is only for pipes, sockets and character devicesZaix)rrr�r�r;r�r��	bytearray�_buffer�
_conn_lostr�rxr�r�r�r�r�r�r<r�r�r�r�r&�platform�
startswithr�r�r	r�)
rr�rTrUrVrWr�Zis_charZis_fifoZ	is_socketr!rrr?s:






















�

�z _UnixWritePipeTransport.__init__c
Cs�|jj
g
}
|jdkr |
�d
�

n|jr0|
�d�

|
�d|j���

t|jdd�}|jdk	r�|dk	r�t�	||jt
j�}|r�|
�d�

n
|
�d�

|��}|
�d|���

n |jdk	r�|
�d�

n
|
�d
�

d	�
d
�|
�
�
S)Nr�r�r�r�r�r�zbufsize=r�r�r�)r"r�r�r�r�r�r�r�r
r�r�ZEVENT_WRITE�get_write_buffer_sizer�r�)rrAr r�rhrrrr�ds,












�







z _UnixWritePipeTransport.__repr__c

Cs
t|j
�
Sr)�lenr�r�rrrr�|s
z-_UnixWritePipeTransport.get_write_buffer_sizec

Cs6|j�
�rt�d
|�
|jr*|�t��

n|��
dS)Nr�)r�r�r
rAr�r��BrokenPipeErrorr�rrrr�s




z#_UnixWritePipeTransport._read_readyc
CsR
t|
t
ttf�stt|
�
�
�
t|
t�r.t|
�
}
|
s6dS|jsB|jrj|jtj	krXt
�d
�

|jd7_dS|j�
s8zt
�|j|
�}Wntttfk
r�


d}YnZttfk
r�


�YnBtk
r�
}
z$|jd7_|�|d�
WY�dSd}~XYnX|t|
�
k�
rdS|dk�
r&t|
�
|d�}
|j�|j|j�
|j|
7_|��
dS)Nz=pipe closed by peer or os.write(pipe, data) raised exception.rr
�#Fatal write error on pipe transport)rO�bytesr��
memoryviewrw�reprr�r�rZ!LOG_THRESHOLD_FOR_CONNLOST_WRITESr
�warningr�rx�writer�r�r�rarbrcr�r�r�Z_add_writer�_write_readyZ_maybe_pause_protocol)rr1�
nrFrrrr
�s8

























z_UnixWritePipeTransport.writec

Cs
|jst
d
�
�
zt�|j|j�}
Wn�ttfk
r:


Yn�ttfk
rR


�Yn�t	k
r�
}
z6|j�
�
|jd7_|j�
|j�

|�|d�
W5d}~XYnhX|
t|j�
kr�|j�
�
|j�
|j�

|��
|jr�|j�|j�

|�d�

dS|
dk�
r|jd|
�=dS)NzData should not be emptyrr

r
)r�rwrxr
r�r�r�rarbrcr-r�r��_remove_writerr�r�Z_maybe_resume_protocolr�r�r�)rr
rFrrrr
�s,






















z$_UnixWritePipeTransport._write_readyc


Csd
Sr�rr�rrr�
can_write_eof�s
z%_UnixWritePipeTransport.can_write_eofc

CsB|jr
dS|j
st�
d
|_|js>|j�|j�

|j�|jd�
dSr�)	r�r�rwr�r�r�r�r�r�r�rrr�	write_eof�s







z!_UnixWritePipeTransport.write_eofcCs
|
|_dSrr�r�rrrr��s
z$_UnixWritePipeTransport.set_protocolc


Cs|jSrr�r�rrrr��s
z$_UnixWritePipeTransport.get_protocolc


Cs|jSrr�r�rrrr��s
z"_UnixWritePipeTransport.is_closingc

Cs|jdk	r|j
s|��
dSr)r�r�r
r�rrrr%�s
z_UnixWritePipeTransport.closecCs,|jdk	r(|
d
|��t
|d�
|j��
dSr�r�r�rrrr��s



z_UnixWritePipeTransport.__del__c

Cs|�d�

dSr)
r�r�rrr�abort�s
z_UnixWritePipeTransport.abortr�cCsNt|
t
�r(|j��r@tjd
||dd�
n|j�||
||jd��

|�|
�

dSr�)	rOr=r�r�r
r�r�r�r�r�rrrr��s







�z$_UnixWritePipeTransport._fatal_errorcCsFd
|_|j
r|j�|j�

|j
��
|j�|j�

|j�|j|
�
dSr�)	r�r�r�r	
r�r-r�r�r�r�rrrr��s






z_UnixWritePipeTransport._closecCs4z|j�|
�

W5|j�
�
d|_d|_d|_XdSrr�r�rrrr��s





z-_UnixWritePipeTransport._call_connection_lost)NN)
r�)
N)r�r�r�rr�r�r�r
r
r

r
r�r�r�r%r*r+r�r
r�r�r�r�rrr!rrY<s"%	#	

rYc@seZ
dZd
d�ZdS)r^c		Ks�d}|tj
krt��\}}zPtj|
f
||||d
|d�|��
|_|dk	rh|��
t|��d|d�|j_	d}W5|dk	r�|��
|��
XdS)NF)rdrerfrgZuniversal_newlinesrh�wb)
�	buffering)
�
subprocess�PIPErzZ
socketpairr%�Popen�_procr��detachre)	rrErdrerfrgrhriZstdin_wrrr�_starts.





�

��




z_UnixSubprocessTransport._startN)r�r�r�r
rrrrr^	sr^c@sHeZ
dZd
Zdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dS)raHAbstract base class for monitoring child processes.

    Objects derived from this class monitor a collection of subprocesses and
    report their termination or interruption by a signal.

    New callbacks are registered with .add_child_handler(). Starting a new
    process must be done within a 'with' block to allow the watcher to suspend
    its activity until the new process if fully registered (this is needed to
    prevent a race condition in some implementations).

    Example:
        with watcher:
            proc = subprocess.Popen("sleep 1")
            watcher.add_child_handler(proc.pid, callback)

    Notes:
        Implementations of this class must be thread-safe.

        Since child watcher objects may catch the SIGCHLD signal and call
        waitpid(-1), there should be only one active object per process.
    c
Gs
t��
d
S)a
Register a new child handler.

        Arrange for callback(pid, returncode, *args) to be called when
        process 'pid' terminates. Specifying another callback for the same
        process replaces the previous handler.

        Note: callback() must be thread-safe.
        N�
�NotImplementedError�rrnrDrErrrr_9s	z&AbstractChildWatcher.add_child_handlerc
Cs
t��
d
S)z�Removes the handler for process 'pid'.

        The function returns True if the handler was successfully removed,
        False if there was nothing to remove.Nr
�rrnrrr�remove_child_handlerDsz)AbstractChildWatcher.remove_child_handlerc
Cs
t��
d
S)z�Attach the watcher to an event loop.

        If the watcher was previously attached to an event loop, then it is
        first detached before attaching to the new loop.

        Note: loop may be None.
        Nr
�rr�rrr�attach_loopLsz AbstractChildWatcher.attach_loopc


Cs
t��
d
S)zlClose the watcher.

        This must be called to make sure that any underlying resource is freed.
        Nr
r�rrrr%VszAbstractChildWatcher.closec


Cs
t��
d
S)z�Return ``True`` if the watcher is active and is used by the event loop.

        Return True if the watcher is installed and ready to handle process exit
        notifications.

        Nr
r�rrrr\]szAbstractChildWatcher.is_activec


Cs
t��
d
S)zdEnter the watcher's context and allow starting new processes

        This function must return selfNr
r�rrr�	__enter__fszAbstractChildWatcher.__enter__c
Cs
t��
d
S)zExit the watcher's contextNr
�r�
a�
b�
crrr�__exit__lszAbstractChildWatcher.__exit__N)r�r�r�r�r_r
r
r%r\r
r!
rrrrr"s

	rc

Cs2t�
|�
rt�|�
St�|�
r*t�|�
S|SdSr)rx�WIFSIGNALED�WTERMSIG�	WIFEXITED�WEXITSTATUS)
�statusrrr�_compute_returncodeqs





r'
c@sDeZ
dZd
d�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dS)�BaseChildWatcherc

Csd|_i|_
dSr)r��
_callbacksr�rrrr�s

zBaseChildWatcher.__init__c

Cs|�d�

dSr)
r
r�rrrr%�s
zBaseChildWatcher.closec

Cs|jdk	o|j�
�Sr)r�Z
is_runningr�rrrr\�s
zBaseChildWatcher.is_activec
Cs
t��
dSrr
)r�expected_pidrrr�_do_waitpid�s
zBaseChildWatcher._do_waitpidc


Cs
t��
dSrr
r�rrr�_do_waitpid_all�s
z BaseChildWatcher._do_waitpid_allcCs~|
dkst|
t
j�st�
|jdk	r<|
dkr<|jr<t�d
t�
|jdk	rT|j�	t
j�

|
|_|
dk	rz|
�t
j|j
�
|��
dS)NzCA loop is being detached from a child watcher with pending handlers)rOrZAbstractEventLooprwr�r)
r*r+�RuntimeWarningr)r9�SIGCHLDrH�	_sig_chldr,
r
rrrr
�s


�



zBaseChildWatcher.attach_loopc

Cs^z|��
WnLt
tfk
r&


�Yn4tk
rX
}

z|j�d
|
d��

W5d}
~
XYnXdS)N�$Unknown exception in SIGCHLD handler)r�r�)r,
rarbrcr�r�r�rrrr/
�s






�zBaseChildWatcher._sig_chldN)
r�r�r�rr%r\r+
r,
r
r/
rrrrr(
sr(
csPeZ
dZd
Z�f
dd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
�ZS)rad
'Safe' child watcher implementation.

    This implementation avoids disrupting other code spawning processes by
    polling explicitly each process in the SIGCHLD handler instead of calling
    os.waitpid(-1).

    This is a safe solution but it has a significant overhead when handling a
    big number of children (O(n) each time SIGCHLD is raised)
    c

s|j�
�
t���
dSr)r)
r-rr%r�r!rrr%�s


zSafeChildWatcher.closec


Cs|Srrr�rrrr
�s
zSafeChildWatcher.__enter__c
CsdSrrr
rrrr!
�s
zSafeChildWatcher.__exit__cGs||f|j|
<|�
|
�

dSr)r)
r+
r
rrrr_�s
z"SafeChildWatcher.add_child_handlercCs*z|j|
=Wd
St
k
r$


YdSXdS�NTF�r)
rJr
rrrr
�s





z%SafeChildWatcher.remove_child_handlerc
Cst|j
�
D]}
|�|
�

q
dSr�r(r)
r+
r
rrrr,
�s
z SafeChildWatcher._do_waitpid_allcCs�|
d
kst�
zt
�|
t
j�\}}Wn(tk
rJ


|
}d}t�d|�
Yn.X|d
krXdSt|�
}|j�	�rxt�
d|
|�
z|j�|�
\}}Wn.t
k
r�


|j�	�r�tjd|dd�
YnX|||f|��
dS)Nr
��8Unknown child process pid %d, will report returncode 255�$process %s exited with returncode %s�'Child watcher got an unexpected pid: %rTr�)rwrx�waitpid�WNOHANG�ChildProcessErrorr
r
r'
r�r�r�r)
�poprJ)rr*
rnr&
rorDrErrrr+
�s6






�




�




�zSafeChildWatcher._do_waitpid)r�r�r�r�r%r
r!
r_r
r,
r+
r�rrr!rr�s

rcsTeZ
dZd
Z�f
dd�Z�f
dd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
�ZS)raW
'Fast' child watcher implementation.

    This implementation reaps every terminated processes by calling
    os.waitpid(-1) directly, possibly breaking other code spawning processes
    and waiting for their termination.

    There is no noticeable overhead when handling a big number of children
    (O(1) each time a child terminates).
    c

s$t��
�
t��|_i|_d
|_dSr�)rr�	threadingZLock�_lock�_zombies�_forksr�r!rrrs





zFastChildWatcher.__init__c

s"|j�
�
|j�
�
t���
dSr)r)
r-r>
rr%r�r!rrr%s




zFastChildWatcher.closec


Cs0|j� 
|j
d
7_
|W5QR�SQRXdS)Nr)r=
r?
r�rrrr
s

zFastChildWatcher.__enter__c	Cs^|j�B
|j
d
8_
|j
s"|js0W5QR�dSt|j�
}|j��
W5QRXt�d|�
dS)Nrz5Caught subprocesses termination from unknown pids: %s)r=
r?
r>
r?r-r
r
)rr
r
r 
Zcollateral_victimsrrrr!
s






�zFastChildWatcher.__exit__c	Gst|jst
d
�
�
|j�F
z|j�|
�
}Wn.tk
rT


||f|j|
<YW5QR�dSXW5QRX||
|f|��
dS)NzMust use the context manager)r?
rwr=
r>
r;
rJr)
)rrnrDrErorrrr_'s




z"FastChildWatcher.add_child_handlercCs*z|j|
=Wd
St
k
r$


YdSXdSr1
r2
r
rrrr
5s





z%FastChildWatcher.remove_child_handlerc
	Cs�zt�
d
tj�\}
}Wntk
r,


YdSX|
dkr:dSt|�
}|j��
z|j�|
�
\}}WnNtk
r�


|j	r�||j
|
<|j��r�t
�d|
|�
YW5QR�qd}YnX|j��r�t
�d|
|�
W5QRX|dkr�t
�d|
|�
q||
|f|��
qdS)Nr3r
z,unknown process %s exited with returncode %sr6
z8Caught subprocess termination from unknown pid: %d -> %d)rxr8
r9
r:
r'
r=
r)
r;
rJr?
r>
r�r�r
r�r
)rrnr&
rorDrErrrr,
<s@








�




�


�z FastChildWatcher._do_waitpid_all)r�r�r�r�rr%r
r!
r_r
r,
r�rrr!rr�s
	rc@sheZ
dZd
Zdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�Zdd�Zdd�Z
dd�ZdS)ra~
A watcher that doesn't require running loop in the main thread.

    This implementation registers a SIGCHLD signal handler on
    instantiation (which may conflict with other code that
    install own handler for this signal).

    The solution is safe but it has a significant overhead when
    handling a big number of processes (*O(n)* each time a
    SIGCHLD is received).
    c

Csi|_d|_
dSr)r)
�_saved_sighandlerr�rrrrzs

zMultiLoopChildWatcher.__init__c

Cs
|jdk	Sr)
r@
r�rrrr\~s
zMultiLoopChildWatcher.is_activec
CsT|j�
�
|jdkrdSt�tj�
}
|
|jkr:t�d
�

nt�tj|j�
d|_dS)Nz+SIGCHLD handler was changed by outside code)	r)
r-r@
r9�	getsignalr.
r/
r
r
)rrNrrrr%�s








zMultiLoopChildWatcher.closec


Cs|Srrr�rrrr
�s
zMultiLoopChildWatcher.__enter__c
CsdSrr�r�exc_typeZexc_valZexc_tbrrrr!
�s
zMultiLoopChildWatcher.__exit__cGs&t�
�}|||f|j|
<|�|
�

dSr)r�get_running_loopr)
r+
)rrnrDrEr�rrrr_�s

z'MultiLoopChildWatcher.add_child_handlercCs*z|j|
=Wd
St
k
r$


YdSXdSr1
r2
r
rrrr
�s





z*MultiLoopChildWatcher.remove_child_handlercCsN|jdk	rdSt
�
t
j|j�|_|jdkr<t�d
�

t
j|_t
�t
jd�
dS)NzaPrevious SIGCHLD handler was set by non-Python code, restore to default handler on watcher close.F)r@
r9r.
r/
r
r
rMr@r
rrrr
�s





z!MultiLoopChildWatcher.attach_loopc
Cst|j
�
D]}
|�|
�

q
dSrr3
r
rrrr,
�s

z%MultiLoopChildWatcher._do_waitpid_allc	Cs�|
d
kst�
zt
�|
t
j�\}}Wn,tk
rN


|
}d}t�d|�
d}YnX|d
kr\dSt|�
}d}z|j�	|�
\}}}Wn$t
k
r�


tjd|dd�
YnHX|��r�t�d||�
n.|r�|��r�t�
d	|
|�
|j|||f|��
dS)
Nr
r4
r5
FTr7
r��%Loop %r that handles pid %r is closedr6
)rwrxr8
r9
r:
r
r
r'
r)
r;
rJ�	is_closedr�r�rm)	rr*
rnr&
roZ	debug_logr�rDrErrrr+
�s<






�





�


�z!MultiLoopChildWatcher._do_waitpidc	CsLz|��
Wn:t
tfk
r&


�Yn"tk
rF


tjd
dd�
YnXdS)Nr0
Tr�)r,
rarbrcr
r
)rrrrrrr/
�s





zMultiLoopChildWatcher._sig_chldN)r�r�r�r�rr\r%r
r!
r_r
r
r,
r+
r/
rrrrrgs
%rc@sneZ
dZd
Zdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	e
jf
dd�
Zdd�Z
dd�Zdd�Zdd�ZdS)raA
Threaded child watcher implementation.

    The watcher uses a thread per process
    for waiting for the process finish.

    It doesn't require subscription on POSIX signal
    but a thread creation is not free.

    The watcher has O(1) complexity, its performance doesn't depend
    on amount of spawn processes.
    c

Cst�
d
�
|_i|_dSr�)�	itertoolsr��_pid_counter�_threadsr�rrrr�s

zThreadedChildWatcher.__init__c


Csd
Sr�rr�rrrr\�s
zThreadedChildWatcher.is_activec

Cs|��
dSr)
�
_join_threadsr�rrrr%�s
zThreadedChildWatcher.closec
Cs.d
d�t|j
���
D�
}
|
D]}|��
qdS)z%Internal: Join all non-daemon threadsc
Ssg|]}
|
��r|
j
s|
�qSr)�is_alive�daemon��.0�threadrrr�
<listcomp>�s
�z6ThreadedChildWatcher._join_threads.<locals>.<listcomp>N)r(rI
�valuesr�)r�threadsrO
rrrrJ
�s
z"ThreadedChildWatcher._join_threadsc


Cs|Srrr�rrrr
s
zThreadedChildWatcher.__enter__c
CsdSrrrB
rrrr!
s
zThreadedChildWatcher.__exit__cCs6d
d�t|j
���
D�
}|r2|
|j�d�t|d�
dS)Nc
Ssg|]}
|
��r|
�qSr)
rK
rM
rrrrP
	s
�z0ThreadedChildWatcher.__del__.<locals>.<listcomp>z0 has registered but not finished child processesr#)r(rI
rQ
r"r,)rr�rR
rrrr�s



�zThreadedChildWatcher.__del__cGsFt�
�}tj|jd
t|j�
��||
||fdd�}||j|
<|��
dS)Nzwaitpid-T)�target�namerErL
)	rrD
r<
ZThreadr+
�nextrH
rI
�start)rrnrDrEr�rO
rrrr_s





�

z&ThreadedChildWatcher.add_child_handlerc
Csd
Sr�rr
rrrr
sz)ThreadedChildWatcher.remove_child_handlerc
CsdSrrr
rrrr
s
z ThreadedChildWatcher.attach_loopcCs�|d
kst�
zt
�|d
�\}}Wn(tk
rH


|}d}t�d|�
Yn Xt|�
}|
��rht�d||�
|
�	�r�t�d|
|�
n|
j
|||f|��
|j�|�

dS)Nr
r4
r5
r6
rE
)
rwrxr8
r:
r
r
r'
r�r�rF
rmrI
r;
)rr�r*
rDrErnr&
rorrrr+
"s(






�



�
z ThreadedChildWatcher._do_waitpidN)r�r�r�r�rr\r%rJ
r
r!
r*r+r�r_r
r
r+
rrrrr�s
	rcsHeZ
dZd
ZeZ�f
dd�Zdd�Z�f
dd�Zdd	�Z	d
d�Z
�ZS)�_UnixDefaultEventLoopPolicyz:UNIX event loop policy with a watcher for child processes.c

st��
�
d|_dSr)rr�_watcherr�r!rrrAs


z$_UnixDefaultEventLoopPolicy.__init__c

	CsHtj
�8
|jdkr:t�|_tt��tj�r:|j�|j	j
�

W5QRXdSr)rr=
rX
rrOr<
�current_thread�_MainThreadr
�_localr�r�rrr�
_init_watcherEs





�z)_UnixDefaultEventLoopPolicy._init_watchercs6t��
|
�

|jd
k	r2tt��tj�r2|j�|
�

d
S)z�Set the event loop.

        As a side effect, if a child watcher was set before, then calling
        .set_event_loop() from the main thread will call .attach_loop(loop) on
        the child watcher.
        N)r�set_event_looprX
rOr<
rY
rZ
r
r
r!rrr]
Ms


�z*_UnixDefaultEventLoopPolicy.set_event_loopc

Cs|jd
kr|�
�
|jS)z~Get the watcher for child processes.

        If not yet set, a ThreadedChildWatcher object is automatically created.
        N)rX
r\
r�rrrr[[s

z-_UnixDefaultEventLoopPolicy.get_child_watchercCs4|
d
kst|
t
�st�
|jd
k	r*|j��
|
|_d
S)z$Set the watcher for child processes.N)rOrrwrX
r%)rrjrrr�set_child_watcheres


z-_UnixDefaultEventLoopPolicy.set_child_watcher)r�r�r�r�rZ
_loop_factoryrr\
r]
r[r^
r�rrr!rrW
=s


rW
)2r�rBr�rG
rxr�r9rzr�r
r&r<
r*�rrrrrrr	r
rr�logr
�__all__r��ImportErrorrZBaseSelectorEventLooprZ
ReadTransportrRZ_FlowControlMixinZWriteTransportrYZBaseSubprocessTransportr^rr'
r(
rrrrZBaseDefaultEventLoopPolicyrW
rrrrrr�<module>
s`




















	

	
�NO5Ji}Y3