File: //usr/local/CyberCP/lib/python3.10/site-packages/asyncssh/__pycache__/process.cpython-310.pyc
o
�h� � @ s� d Z ddlZddlmZmZmZ ddlZddlZddlZddl Z ddl
m Z ddl Z ddl
Z
ddlmZ ddlmZmZmZmZmZmZmZ ddlmZmZmZmZm Z m Z ddlm Z m Z m Z m!Z!m"Z" dd l#m$Z$m%Z% d
d l&m'Z'm(Z(m)Z) d
d l*m+Z+m,Z, d
d
l-m.Z. d
dl/m0Z0m1Z1m2Z2m3Z3m4Z4 d
dl/m5Z5m6Z6m7Z7m8Z8 d
dl/m9Z9m:Z:m;Z; d
dl<m=Z= d
dl>m?Z?m@Z@mAZA d
dl>mBZBmCZC d
dl>mDZD e deEeFdd�ZGe!eeE df ZHe!eIeFe j e e?eE ejJeHf ZKe!eIeFe j e e@eE ejLeHf ZMedge2d f ZNdZOdZPG d d � d e$e �ZQG d d � d e$�ZRG d d!� d!e$eG �ZSd"eeE d#eTfd$d%�ZUG d&d'� d'eRee �ZVG d(d)� d)eSe �ZWG d*d+� d+eVe �ZXG d,d-� d-eVe �ZYG d.d/� d/eWe �ZZG d0d1� d1eWe �Z[G d2d3� d3eVe ej\�Z]G d4d5� d5eWe ej\�Z^G d6d7� d7eRee �Z_G d8d9� d9eSe �Z`G d:d;� d;eVe �ZaG d<d=� d=eWe �ZbG d>d?� d?eSe �ZcG d@dA� dAeSe �ZdG dBdC� dCe1�ZeG dDdE� dEeeejf�ZfG dFdG� dGe6�ZgG dHdI� dIeAee �ZhG dJdK� dKehe eBe �ZiG dLdM� dMehe eCe �ZjdS )NzSSH process handlers� N)�DEVNULL�PIPE�STDOUT)�PurePath)�
TracebackType)�Any�AnyStr� Awaitable�Callable�Dict�Generic�IO)�Iterable�List�Mapping�Optional�Set�TextIO)�Tuple�Type�TypeVar�Union�cast)�Protocol�Self� )�
SSHChannel�SSHClientChannel�SSHServerChannel)� DEFAULT_LANG�EXTENDED_DATA_STDERR)� SSHLogger)�
BytesOrStr�Error�
MaybeAwait� TermModes�TermSize)�
ProtocolError�Record� open_file�set_terminal_size)�
BreakReceived�SignalReceived�TerminalSizeChanged)�DataType)� SSHReader� SSHWriter�SSHStreamSession)�SSHClientStreamSession�SSHServerStreamSession)�SFTPServerFactory�
_AnyStrContraT)�
contravariantz_AsyncFileProtocol[bytes]zSSHServerProcess[AnyStr]� � c @ s@ e Zd ZdZd
dedefdd�Zdeddfd d
�Zdd d �ZdS )�_AsyncFileProtocolzProtocol for an async file����n�returnc � � �dS )zRead from an async fileN� )�selfr; r> r> �C/usr/local/CyberCP/lib/python3.10/site-packages/asyncssh/process.py�readK � z_AsyncFileProtocol.read�dataNc � r= )zWrite to an async fileNr> �r? rC r> r> r@ �writeN rB z_AsyncFileProtocol.writec � r= )zClose an async fileNr> �r? r> r> r@ �closeQ rB z_AsyncFileProtocol.close)r: �r< N) �__name__�
__module__� __qualname__�__doc__�intr rA rE rG r> r> r> r@ r9 H s
r9 c @ s. e Zd ZdZd
dd�Zd
dd�Zd
dd �ZdS ) �_ReaderProtocolz2A class that can be used as a reader in SSHProcessr< Nc C � dS )z
Pause readingNr> rF r> r> r@ �
pause_readingX � z _ReaderProtocol.pause_readingc C rO )zResume readingNr> rF r> r> r@ �resume_reading[ rQ z _ReaderProtocol.resume_readingc C rO �zStop forwarding dataNr> rF r> r> r@ rG ^ rQ z_ReaderProtocol.closerH )rI rJ rK rL rP rR rG r> r> r> r@ rN U s
rN c @ sH e Zd ZdZdeddfdd�Zdeddfdd �Zdd
d �Zdd d
�Z dS )�_WriterProtocolz2A class that can be used as a writer in SSHProcessrC r< Nc C rO )z
Write dataNr> rD r> r> r@ rE e rQ z_WriterProtocol.write�excc C rO )z5Write exception (break, signal, terminal size change)Nr> �r? rU r> r> r@ �write_exceptionh s z _WriterProtocol.write_exceptionc C rO )z)Close output when end of file is receivedNr> rF r> r> r@ � write_eofm rQ z_WriterProtocol.write_eofc C rO rS r> rF r> r> r@ rG p rQ z_WriterProtocol.closerH )
rI rJ rK rL r5 rE � ExceptionrW rX rG r> r> r> r@ rT b s
rT �filer< c C s. z t �t�| �� �j�W S ty Y dS w )z8Return if argument is a regular file or file-like objectT)�stat�S_ISREG�os�fstat�fileno�st_mode�OSError)rZ r> r> r@ �_is_regular_filet s
�rb c sb e Zd ZdZ ddee dedef� fdd�
Zdded ed
e fd d �Z
ddd�Z ddd�Z � Z
S )�_UnicodeReaderz%Handle buffering partial Unicode dataF�encoding�errors�textmodec �0 t � �� |r|st�|�|�| _d S d | _d S �N)�super�__init__�codecs�getincrementaldecoder�_decoder�r? rd re rf �� __class__r> r@ rj �
�
z_UnicodeReader.__init__rC �finalr< c
C sV | j r$z
tt| j �||��}W |S ty# } ztt|��d�d}~ww tt|�}|S )z5Decode Unicode bytes when reading from binary sourcesN)rm r r �decode�UnicodeDecodeErrorr' �str)r? rC rr � decoded_datarU r> r> r@ rs � s ���
z_UnicodeReader.decodeNc C s | � dd� dS )z1Check if there's partial Unicode data left at EOF� TN)rs rF r> r> r@ �
check_partial� � z _UnicodeReader.check_partialc C rO )z@Perform necessary cleanup on error (provided by derived classes)Nr> rF r> r> r@ rG � rQ z_UnicodeReader.close�FrH )rI rJ rK rL r ru �boolrj �bytesr rs rx rG �
__classcell__r> r> ro r@ rc | s ��
rc c sH e Zd ZdZ d dee dedef� fdd�
Zded e fd
d �Z
� Z S )
�_UnicodeWriterz.Handle encoding Unicode data before writing itFrd re rf c rg rh )ri rj rk �getincrementalencoder�_encoderrn ro r> r@ rj � rq z_UnicodeWriter.__init__rC r< c C s> | j r| j dus
J �tt| j �tt|���}|S tt|�}|S )z3Encode Unicode bytes when writing to binary targetsN)r� r r| �encoderu )r? rC � encoded_datar> r> r@ r� � s
�z_UnicodeWriter.encoderz ) rI rJ rK rL r ru r{ rj r r| r� r} r> r> ro r@ r~ � s ��
r~ c sj e Zd ZdZdddee dededee de f � fd d
� Z
dd
d�Z ddd�Z ddd�Z
ddd�Z� ZS )� _FileReaderzForward data from a file�process�SSHProcess[AnyStr]rZ �bufsize�datatyperd re c s8 t � �||t|d�� || _|| _|| _|| _d| _d S �Nrd F)ri rj �hasattr�_process�_file�_bufsize� _datatype�_paused�r? r� rZ r� r� rd re ro r> r@ rj � s
z_FileReader.__init__r< Nc C sX | j s*| j�| j�}|r| j�| �|�| j� n
| �� | j� | j� dS | j rdS dS �zFeed file dataN�
r� r� rA r� r� � feed_datars r� rx �feed_eofrD r> r> r@ �feed� s �z_FileReader.feedc C �
d| _ dS �zPause reading from the fileTN�r� rF r> r> r@ rP � �
z_FileReader.pause_readingc C � d| _ | �� dS �z Resume reading from the fileFN�r� r� rF r> r> r@ rR � � z_FileReader.resume_readingc C � | j �� dS �z"Stop forwarding data from the fileN)r� rG rF r> r> r@ rG � � z_FileReader.closerH )rI rJ rK rL r
r| rM r. r ru rj r� rP rR rG r} r> r> ro r@ r� � s ����
r� c st e Zd ZdZdddee dededee de f � fd d
� Z
dd
d�Z ddd�Z ddd�Z
ddd�Zddd�Z� ZS )�_AsyncFileReaderz Forward data from an aiofiler� r� rZ r� r� rd re c sD t � �||t|d�� |j�� | _|| _|| _|| _|| _ d| _
d S r� ) ri rj r� �channel�get_connection�_connr� r� r� r� r� r� ro r> r@ rj � s
z_AsyncFileReader.__init__r< Nc � �` �| j s.| j�| j�I dH }|r | j�| �|�| j� n
| �� | j� | j� dS | j rdS dS r� r� rD r> r> r@ �_feed� � ��z_AsyncFileReader._feedc C � | j �| �� � dS )zStart feeding file dataN�r� � create_taskr� rF r> r> r@ r� � z_AsyncFileReader.feedc C r� r� r� rF r> r> r@ rP r� z _AsyncFileReader.pause_readingc C r� r� r� rF r> r> r@ rR r� z _AsyncFileReader.resume_readingc C s | j �| j�� � dS r� )r� r� r� rG rF r> r> r@ rG � z_AsyncFileReader.closerH )rI rJ rK rL r9 r| rM r. r ru rj r� r� rP rR rG r} r> r> ro r@ r� � s$ �����
r� c s` e Zd ZdZdee dedee def� fdd� Z de
d d
fd d �Z dd
d�Z ddd�Z
� ZS )� _FileWriterzForward data to a filerZ � needs_closerd re c s& t � �||t|d�� || _|| _d S )Nrd )ri rj r� r� � _needs_close)r? rZ r� rd re ro r> r@ rj s
z_FileWriter.__init__rC r< Nc C s | j �| �|�� dS )�Write data to the fileN)r� rE r� rD r> r> r@ rE ! r� z_FileWriter.writec C � | � � dS �z.Close output file when end of file is receivedN�rG rF r> r> r@ rX & � z_FileWriter.write_eofc C s | j r
| j�� dS dS �z Stop forwarding data to the fileN)r� r� rG rF r> r> r@ rG + s �z_FileWriter.closerH )rI rJ rK rL r
r| r{ r ru rj r rE rX rG r} r> r> ro r@ r� s ��
r� c sv e Zd ZdZdddee dedee dee de f � fd d
� Z
dd
d�Z de d d fdd�Z
ddd�Zddd�Z� ZS )�_AsyncFileWriterzForward data to an aiofiler� r� rZ r� r� rd re c sX t � �||t|d�� || _|| _|| _|| _d| _t� � | _
|j � � �
| �� �| _d S r� )ri rj r� r� r� r� r� r� �asyncio�Queue�_queuer� r� r� �_writer� _write_task)r? r� rZ r� r� rd re ro r> r@ rj 5 s
�z_AsyncFileWriter.__init__r< Nc � s� � | j �� I dH }|du r| j �� n&| j�| �|��I dH | j �� | jr9| j �� tk r9| j �
| j � d| _q| j rG| j�
� I dH dS dS )zProcess writes to the fileTNF)r� �get� task_doner� rE r� r� �qsize�_QUEUE_LOW_WATERr� �resume_feedingr� r� rG rD r> r> r@ r� C s �
��z_AsyncFileWriter._writerrC c C �@ | j �|� | js | j �� tkr d| _| j�| j� dS dS dS )r� TN�r� �
put_nowaitr� r� �_QUEUE_HIGH_WATERr� �
pause_feedingr� rD r> r> r@ rE W �
�z_AsyncFileWriter.writec C r� r� r� rF r> r> r@ rX ` r� z_AsyncFileWriter.write_eofc C �2 | j rd| _ | j�d� | j�| j�� � dS dS r� �r� r� r� r� �add_cleanup_task�joinrF r> r> r@ rG e �
�z_AsyncFileWriter.closerH )rI rJ rK rL r9 r| r{ r rM ru rj r� r rE rX rG r} r> r> ro r@ r� 2 s" �����
r� c s� e Zd ZdZdddedee def� fdd� Zd ej d
d fd d
�Z
dee d
d fdd�Z de
d
d fdd�Zd dd�Zd dd�Zd dd�Zd dd�Z� ZS ) � _PipeReaderzForward data from a piper� r� r� rd re c s$ t � �||� || _|| _d | _d S rh )ri rj r� r� �
_transport�r? r� r� rd re ro r> r@ rj q s
z_PipeReader.__init__� transportr< Nc C s t tj|�| _dS )�Handle a newly opened pipeN)r r� �
ReadTransportr� )r? r� r> r> r@ �connection_madey � z_PipeReader.connection_maderU c C s | j �| j� | �� dS �zHandle closing of the pipeN)r� �
feed_closer� rG rV r> r> r@ �connection_lost~ s z_PipeReader.connection_lostrC c C s | j �| �|�| j� dS )zForward data from the pipeN)r� r� rs r� rD r> r> r@ �
data_received� s z_PipeReader.data_receivedc C s | � � | j�| j� dS )zForward EOF from the pipeN)rx r� r� r� rF r> r> r@ � eof_received� s z_PipeReader.eof_receivedc C � | j dusJ �| j �� dS )zPause reading from the pipeN)r� rP rF r> r> r@ rP � � z_PipeReader.pause_readingc C r� )z Resume reading from the pipeN)r� rR rF r> r> r@ rR � r� z_PipeReader.resume_readingc C r� )z"Stop forwarding data from the pipeN)r� rG rF r> r> r@ rG � r� z_PipeReader.closerH )rI rJ rK rL r. r ru rj r� �
BaseTransportr� rY r� r| r� r� rP rR rG r} r> r> ro r@ r� n s
��
r� c s� e Zd ZdZdddedee def� fdd� Zd ej d
d fd d
�Z
dee d
d fdd�Z d dd�Z
d dd�Zded
d fdd�Zde d
d fdd�Zd dd�Zd d d �Z� ZS ) � _PipeWriterzForward data to a piper� r� r� rd re c s4 t � �||� || _|| _d | _d | _t�� | _d S rh ) ri rj r� r� r� �_ttyr� �Event� _close_eventr� ro r> r@ rj � s z_PipeWriter.__init__r� r< Nc C sR t tj|�| _|�d�}t| jt�r%|�� r'|| _ t
|g| jj �R � dS dS dS )r� �pipeN) r r� �WriteTransportr� �get_extra_info�
isinstancer� �SSHServerProcess�isattyr� r* � term_size)r? r� r� r> r> r@ r� � s
�z_PipeWriter.connection_maderU c C r� r� )r� �setrV r> r> r@ r� � r� z_PipeWriter.connection_lostc C � | j �| j� dS )zPause writing to the pipeN�r� r� r� rF r> r> r@ �
pause_writing� r� z_PipeWriter.pause_writingc C r� )zResume writing to the pipeN�r� r� r� rF r> r> r@ �resume_writing� r� z_PipeWriter.resume_writingrC c C s$ | j dusJ �| j �| �|�� dS )zWrite data to the pipeN)r� rE r� rD r> r> r@ rE � s z_PipeWriter.writec C s0 t |t�r| jrt| jg|j�R � dS dS dS )z6Write terminal size changes to the pipe if it is a TTYN)r� r- r� r* r� rV r> r> r@ rW � s �z_PipeWriter.write_exceptionc C r� )zWrite EOF to the pipeN)r� rX rF r> r> r@ rX � r� z_PipeWriter.write_eofc C s. | j dusJ �| j �� | j�| j�� � dS )z Stop forwarding data to the pipeN)r� rG r� r� r� �waitrF r> r> r@ rG � s
z_PipeWriter.closerH )rI rJ rK rL r. r ru rj r� r� r� rY r� r� r� r rE rW rX rG r} r> r> ro r@ r� � s
��
r� c sH e Zd ZdZdddef� fdd� Zdd d
�Zdd d �Zdd
d�Z� Z S )�_ProcessReaderz%Forward data from another SSH processr� r� r� c � t � �� || _|| _d S rh �ri rj r� r� �r? r� r� ro r> r@ rj � �
z_ProcessReader.__init__r< Nc C r� )z$Pause reading from the other channelNr� rF r> r> r@ rP � r� z _ProcessReader.pause_readingc C r� )z%Resume reading from the other channelNr� rF r> r> r@ rR � r� z _ProcessReader.resume_readingc C r� )z+Stop forwarding data from the other channelN)r� � clear_writerr� rF r> r> r@ rG � r� z_ProcessReader.closerH )
rI rJ rK rL r. rj rP rR rG r} r> r> ro r@ r� � s
r� c sb e Zd ZdZdddef� fdd� Zdedd fd
d �Zd edd fd
d�Z ddd�Z
ddd�Z � Z S )�_ProcessWriterz#Forward data to another SSH processr� r� r� c r� rh r� r� ro r> r@ rj � r� z_ProcessWriter.__init__rC r< Nc C s | j �|| j� dS )z Write data to the other channelN)r� r� r� rD r> r> r@ rE r� z_ProcessWriter.writerU c C s t t| j��|� dS )z'Write an exception to the other channelN)r �SSHClientProcessr� �feed_exceptionrV r> r> r@ rW r� z _ProcessWriter.write_exceptionc C r� )z Write EOF to the other channelN)r� r� r� rF r> r> r@ rX
r� z_ProcessWriter.write_eofc C r� )z)Stop forwarding data to the other channelN)r� � clear_readerr� rF r> r> r@ rG r� z_ProcessWriter.closerH )
rI rJ rK rL r. rj r rE rY rW rX rG r} r> r> ro r@ r� � s
r� c sr e Zd ZdZdddejdededee de f � fd d
� Z
dd
d�Z ddd�Z ddd�Z
ddd�Zddd�Z� ZS )�
_StreamReaderz#Forward data from an asyncio streamr� r� �readerr� r� rd re c s< t � �||� || _|j�� | _|| _|| _|| _d| _ d S �NF)
ri rj r� r� r� r� �_readerr� r� r� )r? r� r� r� r� rd re ro r> r@ rj s
z_StreamReader.__init__r< Nc � r� )zFeed stream dataN)
r� r� rA r� r� r� rs r� rx r� rD r> r> r@ r� ( r� z_StreamReader._feedc C r� )zStart feeding stream dataNr� rF r> r> r@ r� 5 r� z_StreamReader.feedc C r� )z Pause reading from the streamTNr� rF r> r> r@ rP : r� z_StreamReader.pause_readingc C r� )z Resume reading from the streamFNr� rF r> r> r@ rR ? r� z _StreamReader.resume_readingc C rO )zAIgnore close -- the caller must clean up the associated transportNr> rF r> r> r@ rG E rQ z_StreamReader.closerH )rI rJ rK rL r� � StreamReaderrM r. r ru rj r� r� rP rR rG r} r> r> ro r@ r� s$ �����
r� c st e Zd ZdZdddejdedee dee de f � fd d
� Z
dd
d�Z de d d fdd�Z
ddd�Zddd�Z� ZS )�
_StreamWriterz!Forward data to an asyncio streamr� r� �writer�recv_eofr� rd re c sP t � �||� || _|| _|| _|| _d| _t�� | _ |j
� � � | �
� �| _d S r� )ri rj r� r� � _recv_eofr� r� r� r� r� r� r� r� r� r� )r? r� r� r� r� rd re ro r> r@ rj L s
�z_StreamWriter.__init__r< Nc � s� � | j �� I dH }|du r| j �� n+| j�| �|�� | j�� I dH | j �� | jr>| j �� t k r>| j
� | j � d| _q| j
rI| j�� dS dS )zFeed data to the streamTNF)r� r� r� r� rE r� �drainr� r� r� r� r� r� r� rX rD r> r> r@ r� Z s �
��z_StreamWriter._feedrC c C r� )zWrite data to the streamTNr� rD r> r> r@ rE o r� z_StreamWriter.writec C r� )zWrite EOF to the streamNr� rF r> r> r@ rX x r� z_StreamWriter.write_eofc C r� )z"Stop forwarding data to the streamNr� rF r> r> r@ rG } r� z_StreamWriter.closerH )rI rJ rK rL r� � StreamWriterr{ r rM ru rj r� r rE rX rG r} r> r> ro r@ r� I s" �����
r� c @ s6 e Zd ZdZdeddfdd�Zd dd�Zd d d
�ZdS ) �_DevNullWriterz Discard datarC r< Nc C rO )zDiscard data being writtenNr> rD r> r> r@ rE � rQ z_DevNullWriter.writec C rO �zIgnore end of fileNr> rF r> r> r@ rX � rQ z_DevNullWriter.write_eofc C rO �z Ignore closeNr> rF r> r> r@ rG � rQ z_DevNullWriter.closerH )rI rJ rK rL r rE rX rG r> r> r> r@ r � s
r c sH e Zd ZdZd� fdd� Zdeddfd d
�Zdd d �Zdd
d�Z� Z S )�
_StdoutWriterz8Forward data to an SSH process' stdout instead of stderrr� r� c s t � �� || _d S rh )ri rj r� )r? r� ro r> r@ rj � s
z_StdoutWriter.__init__rC r< Nc C s | j �|d� dS )z#Pretend data was received on stdoutN)r� r� rD r> r> r@ rE � r� z_StdoutWriter.writec C rO r r> rF r> r> r@ rX � rQ z_StdoutWriter.write_eofc C rO r r> rF r> r> r@ rG � rQ z_StdoutWriter.close)r� r� rH )
rI rJ rK rL rj r rE rX rG r} r> r> ro r@ r � s
r c s| e Zd ZdZdefdeeeef dee dee dee dee ee
eef dee d e d
e d ed ef� fd
d�
Z � Z
S )� ProcessErrora> SSH Process error
This exception is raised when an :class:`SSHClientProcess` exits
with a non-zero exit status and error checking is enabled. In
addition to the usual error code, reason, and language, it
contains the following fields:
============ ======================================= =================
Field Description Type
============ ======================================= =================
env The environment the client requested `str` or `None`
to be set for the process
command The command the client requested the `str` or `None`
process to execute (if any)
subsystem The subsystem the client requested the `str` or `None`
process to open (if any)
exit_status The exit status returned, or -1 if an `int` or `None`
exit signal is sent
exit_signal The exit signal sent (if any) in the `tuple` or `None`
form of a tuple containing the signal
name, a `bool` for whether a core dump
occurred, a message associated with the
signal, and the language the message
was in
returncode The exit status returned, or negative `int` or `None`
of the signal number when an exit
signal is sent
stdout The output sent by the process to `str` or `bytes`
stdout (if not redirected)
stderr The output sent by the process to `str` or `bytes`
stderr (if not redirected)
============ ======================================= =================
� �env�command� subsystem� exit_status� exit_signal�
returncode�stdout�stderr�reason�langc s� || _ || _|| _|| _|| _|| _|| _|| _|r3|\} } }
}
d| |
r)d|
nd | r/dnd } n|r:d|� �} t� � |p@d| |
� d S )NzProcess exited with signal z: r z (core dumped)z)Process exited with non-zero exit status r )
r r r
r r r
r r ri rj )r? r r r
r r r
r r r r �signal� core_dumped�msgro r> r@ rj � s$ �
�
zProcessError.__init__)rI rJ rK rL r r r ru rM r r{ r" rj r} r> r> ro r@ r � s. (����������r c @ s e Zd ZdZdS )� TimeoutErroraG SSH Process timeout error
This exception is raised when a timeout occurs when calling the
:meth:`wait <SSHClientProcess.wait>` method on :class:`SSHClientProcess`
or the :meth:`run <SSHClientConnection.run>` method on
:class:`SSHClientConnection`. It is a subclass of :class:`ProcessError`
and contains all of the fields documented there, including any output
received on stdout and stderr prior to when the timeout occurred. It
is also a subclass of :class:`asyncio.TimeoutError`, for code that
might be expecting that.
N)rI rJ rK rL r> r> r> r@ r � s r c @ s� e Zd ZU dZeeeef ed< ee ed< ee ed< ee ed< ee ee
eef ed< ee ed< ee ed< ee ed < d
S ) �SSHCompletedProcessa Results from running an SSH process
This object is returned by the :meth:`run <SSHClientConnection.run>`
method on :class:`SSHClientConnection` when the requested command
has finished running. It contains the following fields:
============ ======================================= =================
Field Description Type
============ ======================================= =================
env The environment the client requested `dict` or `None`
to be set for the process
command The command the client requested the `str` or `None`
process to execute (if any)
subsystem The subsystem the client requested the `str` or `None`
process to open (if any)
exit_status The exit status returned, or -1 if an `int`
exit signal is sent
exit_signal The exit signal sent (if any) in the `tuple` or `None`
form of a tuple containing the signal
name, a `bool` for whether a core dump
occurred, a message associated with the
signal, and the language the message
was in
returncode The exit status returned, or negative `int`
of the signal number when an exit
signal is sent
stdout The output sent by the process to `str` or `bytes`
stdout (if not redirected)
stderr The output sent by the process to `str` or `bytes`
stderr (if not redirected)
============ ======================================= =================
r r r
r r r
r r N) rI rJ rK rL r r ru �__annotations__rM r r{ r" r> r> r> r@ r � s
" r c
s� e Zd ZdZdT� fdd� Zdefdd�Zdeee d ee d
ee
de fd d �Z e
dee fd
d��Ze
defdd��Ze
dee fdd��Ze
dee fdd��Ze
deeef fdd��ZdUdededefdd�Z dUded ed e d e d e ddf d d!�Z dUd"e d ed e d e d e ddf d#d$�Z d e de f� fd%d&� Z de f� fd'd(� Z!d)e"ddfd*d+�Z#d,ee$ ddf� fd-d.� Z%d/ed e ddf� fd0d1� Z&de f� fd2d3� Z'dT� fd4d5� Z(dT� fd6d7� Z)d/ed e ddfd8d9�Z*d e ddfd:d;�Z+d e ddfd<d=�Z,d e d>e-e ddfd?d@�Z.d e ddfdAdB�Z/d e ddfdCdD�Z0dEee1 d e d e ddfdFdG�Z2d e ddfdHdI�Z3d>ee-e d e d e ddfdJdK�Z4d e ddfdLdM�Z5dTdNdO�Z6de fdPdQ�Z7dTdRdS�Z8� Z9S )V�
SSHProcesszSSH process handlerr< Nc s6 t � j|� g | _i | _i | _i | _i | _t� | _d S rh ) ri rj �_cleanup_tasks�_readers� _send_eof�_writersr� r� �_paused_write_streams)r? �argsro r> r@ rj & s zSSHProcess.__init__c � s �| S )z7Allow SSHProcess to be used as an async context managerr> rF r> r> r@ �
__aenter__3 s �zSSHProcess.__aenter__� _exc_type�
_exc_value�
_tracebackc � s �| � � | �� I dH dS )z<Wait for a full channel close when exiting the async contextNF)rG � wait_closed)r? r r! r" r> r> r@ � __aexit__8 s �zSSHProcess.__aexit__c C � | j dusJ �| j S )z'The channel associated with the processN)�_chanrF r> r> r@ r� A � zSSHProcess.channelc C s | j dusJ �| j jS )z&The logger associated with the processN)r& �loggerrF r> r> r@ r( H s zSSHProcess.loggerc C � | j dusJ �| j �� S )z�The command the client requested to execute, if any
If the client did not request that a command be executed,
this property will be set to `None`.
N)r& � get_commandrF r> r> r@ r O �
zSSHProcess.commandc C r) )z�The subsystem the client requested to open, if any
If the client did not request that a subsystem be opened,
this property will be set to `None`.
N)r& �
get_subsystemrF r> r> r@ r
[ r+ zSSHProcess.subsystemc C r) )z6A mapping containing the environment set by the clientN)r& �get_environmentrF r> r> r@ r g s
zSSHProcess.env�name�defaultc C s | j dusJ �| j �||�S )a5 Return additional information about this process
This method returns extra information about the channel
associated with this process. See :meth:`get_extra_info()
<SSHClientChannel.get_extra_info>` on :class:`SSHClientChannel`
for additional information.
N)r& r� )r? r. r/ r> r> r@ r� n s
zSSHProcess.get_extra_info�sourcer� �send_eofr� r� c � s6 �dt f� �fdd� }|tkrd}n�|tkr%�jdus J ��j�� d}n�t|t�rI|�� \}} td|�}
t t
�� �} |
� | || � t |
| �}n�t|t
j�r[t�||� �j�j�}n�t|t�rht|d|d�} n0t|t�rwtt|�d|d�} n!t|t�r�tj|d|d�} nt|tj�r�tj|�� d|d�} n|} t| d�r�t� | j �s�t� | j �r�t �tt | �|� �j�j�}n=t!tt"t# | ��r�t$�tt"t# | �|� �j�j�}n#t|d �r�tt%|�j&} �j'dus�J ��j'�(|| �I dH \}
}tt |�}��)||� � t|t$t tf��r |�*� dS t|t ��r|
�+| | � dS dS )
z2Create a reader to forward data to the SSH channelr< c � t �� �j�j�S )zReturn a pipe read handler)r� � _encoding�_errorsr> �r� r? r> r@ � pipe_factory� r� z/SSHProcess._create_reader.<locals>.pipe_factoryNr� �rb�� bufferingrA �buffer),r� r r r& rX r� r/ �get_redirect_infor r� r �
set_writerr� r� r� r� r3 r4 ru r) r rM r] �fdopen�socket�detachr� �inspect�iscoroutinefunctionrA �isgeneratorfunctionr� r9 rb r
r| r� r r: �_loop�connect_read_pipe�
set_readerr� �
feed_recv_buf)r? r0 r� r1 r� r� r6 r� �
reader_stream�reader_datatype�reader_processr� rZ �_�protocolr> r5 r@ �_create_reader{ sh �
�
�
� �
�
�
�zSSHProcess._create_reader�targetc � sV �dt f� �fdd� }|tkrd}�n|tkrt� }n�|tkr$t��}n�t|t�rH|�� \}} t d|�}
t
�� �} |
� | || � t t
|
| �}n�t|tj�rZt�||� �j�j�}n�d} t|t�rit|d|d�}
n<t|t�rxtt|�d|d�}
n-t|t�r�tj|d||d �}
n t|tj�r�|r�|�� n|�� }tj|d||d �}
n|}
|} t |
d
�r�t � |
j �s�t � |
j �r�t!�t t"|
�| � �j�j�}nRt#t t$t% |
��r�t&t t$t% |
�| �j�j�}n:t |d �r�t t'|�j(}
|s�t�)t t$t% |
��� �}tj|dd d�}
�j*du�sJ ��j*�+||
�I dH \}}t t |�}��,||� � |�r)��-� |� dS dS )
z4Create a writer to forward data from the SSH channelr< c r2 )zReturn a pipe write handler)r� r3 r4 r> r5 r> r@ r6 � r� z/SSHProcess._create_writer.<locals>.pipe_factoryNr� T�wbr8 )r9 �closefdrE r: r ).r� r r r r r r� r0 r; r r� rE r� r r� r r� r3 r4 ru r) r rM r] r= r> r? r_ r� r@ rA rE rB r� r9 rb r
r| r� r r: �duprC �connect_write_piper< rF )r? rM r� r1 r� r� r6 r� �
writer_stream�writer_datatype�writer_processr� r� rZ �fdrJ rK r> r5 r@ �_create_writer� st �
�
�
�
�
��
�
�zSSHProcess._create_writerc s || j v p
t� �|�S )z;Return whether output is still being written to the channel)r ri �_should_block_drain�r? r� ro r> r@ rW s
�z SSHProcess._should_block_drainc s t | j�p t� �� S )z0Return whether to pause reading from the channel)r{ r ri �_should_pause_readingrF ro r> r@ rY s
�z SSHProcess._should_pause_reading�taskc C � | j �|� dS )z(Add a task to run when the process exitsN)r �append�r? rZ r> r> r@ r� ry zSSHProcess.add_cleanup_taskrU c sT t � �|� t| j�� �D ]}|�� q
t| j�� �D ]}|�� qi | _i | _dS )z!Handle a close of the SSH channelN)ri r� �listr �valuesrG r )r? rU r� r� ro r> r@ r� s
zSSHProcess.connection_lostrC c s0 | j �|�}|r|�|� dS t� �||� dS )z)Handle incoming data from the SSH channelN)r r� rE ri r� )r? rC r� r� ro r> r@ r� " s zSSHProcess.data_receivedc s4 t | j�� �D ]
\}}| j| r|�� qt� �� S )z3Handle an incoming end of file from the SSH channel)r^ r �itemsr� rX ri r� )r? r� r� ro r> r@ r� , s
�
zSSHProcess.eof_receivedc �* t � �� t| j�� �D ]}|�� q dS )z$Pause forwarding data to the channelN)ri r� r^ r r_ rP �r? r� ro r> r@ r� 5 �
�zSSHProcess.pause_writingc ra )z%Resume forwarding data to the channelN)ri r� r^ r r_ rR rb ro r> r@ r� = rc zSSHProcess.resume_writingc C s | j dusJ �| j �||� dS )zFeed data to the channelN)r& rE )r? rC r� r> r> r@ r� E s zSSHProcess.feed_datac C s> | j | r| jdus J �| j�� | j| �� | �|� dS )zFeed EOF to the channelN)r r& rX r rG r� rX r> r> r@ r� K s
zSSHProcess.feed_eofc C s || j v r | �|� dS dS )z Feed pipe close to the channelN)r r� rX r> r> r@ r� U s
�zSSHProcess.feed_closer� c C sj | j | D ]}t|t�r|�|� q|�|� | jt|�8 _q| j | �� | jr/|� � | �
� dS )z1Feed current receive buffer to a newly set writerN) � _recv_bufr� rY rW rE �
_recv_buf_len�len�clear�
_eof_receivedrX �_maybe_resume_reading)r? r� r� �bufr> r> r@ rF [ s
zSSHProcess.feed_recv_bufc C � | j �|� | �� dS )z#Pause feeding data from the channelN)r �add�_maybe_pause_readingrX r> r> r@ r� m � zSSHProcess.pause_feedingc C rk )z$Resume feeding data from the channelN)r �removeri rX r> r> r@ r� s rn zSSHProcess.resume_feedingr� c C s\ | j �|�}|r |�� |r#|| j |< || j|< | jr!|�� dS dS |r,| �|� dS dS )z0Set a reader used to forward data to the channelN)r r� rG r �
_write_pausedrP r� )r? r� r1 r� �
old_readerr> r> r@ rE y s
��zSSHProcess.set_readerc C s | j |= | j|= | �|� dS )z-Clear a reader forwarding data to the channelN)r r �_unblock_drainrX r> r> r@ r� � s zSSHProcess.clear_readerc C sB | j �|�}|r|�� | �|� |r || j |< || j|< dS dS )z2Set a writer used to forward data from the channelN)r r� rG r� r� )r? r� r� r� �
old_writerr> r> r@ r< � s
�zSSHProcess.set_writerc C s || j v r
| �|� | j|= dS )z/Clear a writer forwarding data from the channelN)r r� r rX r> r> r@ r� � s
zSSHProcess.clear_writerc C r� )zShut down the processN)r& rG rF r> r> r@ rG � r� zSSHProcess.closec C r) )z-Return if the channel is closing or is closedN)r& �
is_closingrF r> r> r@ rt � s
zSSHProcess.is_closingc � s@ �| j dusJ �| j �� I dH | jD ]}|I dH qg | _dS )z,Wait for the process to finish shutting downN)r& r# r r] r> r> r@ r# � s �
zSSHProcess.wait_closedrH rh ):rI rJ rK rL rj r r r r �
BaseExceptionr r{ r$ �propertyr r r� r! r( ru r r
r r r r� �
ProcessSourcerM r. rL �
ProcessTargetrV rW rY r r� rY r� r� r� r� r� r� r� r� rT rF r� r� rN rE r� r< r� rG rt r# r} r> r> ro r@ r # s�
��
� ����
�C ����
�G
�
�
��
���
�
r c sT e Zd ZU dZee ed< ee ed< dH� fdd� ZdIdedefd d
�Z dHd d �Z
e de e
fd
d��Ze de eeeeef fdd��Ze de e
fdd��Ze dee fdd��Ze dee fdd��Ze dee fdd��Zdeddfdd�Zdddej d d fd e e d e e d e e d e
d!ed"eddfd#d$�Z ej d fd%e d e
d!eddfd&d'�Z ej d fd(e d e
d"eddfd)d*�Z!ej d fd(e d e
d"eddfd+d,�Z"deeef fd-d.�Z#dId/e e deeef fd0d1�Z$ 2dJd3e
d4e
d5e
d6e
ddf
d7d8�Z%d9e
ddfd:d;�Z&d<eddfd=d>�Z'dHd?d@�Z(dHdAdB�Z) C dKdDedEe e* de+fdFdG�Z,� Z-S )Lr� zSSH client process handlerr& r� r< Nc s t � �� d | _d | _d | _d S rh )ri rj �_stdin�_stdout�_stderrrF ro r> r@ rj � s
zSSHClientProcess.__init__r� c C sp | j | }|r t|d t�r |dd� |dd� }| j |< ng | j |< tt| jr+dnd�}|�ttt |��S )z Return output from the processr: Nr rw )rd r� rY r r r3 r� r )r? r� �recv_bufrj r> r> r@ �_collect_output� s
"
z SSHClientProcess._collect_outputc C s< t t | | j�| _tt | | j�| _tt | | jt�| _dS )z4Start a process for this newly opened client channelN)r0 r r& ry r/ rz r r{ rF r> r> r@ �session_started� s z SSHClientProcess.session_startedc C �
| j �� S )z The exit status of the process)r& �get_exit_statusrF r> r> r@ r � �
z SSHClientProcess.exit_statusc C r )z'Exit signal information for the process)r& �get_exit_signalrF r> r> r@ r � r� z SSHClientProcess.exit_signalc C r )z>The exit status or negative exit signal number for the process)r& �get_returncoderF r> r> r@ r
� r� zSSHClientProcess.returncodec C r% )z>The :class:`SSHWriter` to use to write to stdin of the processN�ry rF r> r> r@ �stdin� r' zSSHClientProcess.stdinc C r% )z@The :class:`SSHReader` to use to read from stdout of the processN�rz rF r> r> r@ r � r' zSSHClientProcess.stdoutc C r% )z@The :class:`SSHReader` to use to read from stderr of the processN�r{ rF r> r> r@ r r' zSSHClientProcess.stderrrU c C sd t |t�r| j�|j|j|j|j� dS t |t�r"| j� |j
� dS t |t �r0| j� |j
� dS dS )z Feed exception to the channelN)r� r- r& �change_terminal_size�width�height�pixwidth� pixheightr+ �
send_break�msecr, � send_signalr rV r> r> r@ r� s
�
�z SSHClientProcess.feed_exceptionTr� r r r� r1 r� c � �Z �|r| � ||||�I dH |r| �||||�I dH |r+| �||||t�I dH dS dS )a�
Perform I/O redirection for the process
This method redirects data going to or from any or all of
standard input, standard output, and standard error for
the process.
The `stdin` argument can be any of the following:
* An :class:`SSHReader` object
* An :class:`asyncio.StreamReader` object
* A file object open for read
* An `int` file descriptor open for read
* A connected socket object
* A string or :class:`PurePath <pathlib.PurePath>` containing
the name of a file or device to open
* `DEVNULL` to provide no input to standard input
* `PIPE` to interactively write standard input
The `stdout` and `stderr` arguments can be any of the following:
* An :class:`SSHWriter` object
* An :class:`asyncio.StreamWriter` object
* A file object open for write
* An `int` file descriptor open for write
* A connected socket object
* A string or :class:`PurePath <pathlib.PurePath>` containing
the name of a file or device to open
* `DEVNULL` to discard standard error output
* `PIPE` to interactively read standard error output
The `stderr` argument also accepts the value `STDOUT` to
request that standard error output be delivered to stdout.
File objects passed in can be associated with plain files, pipes,
sockets, or ttys.
The default value of `None` means to not change redirection
for that stream.
.. note:: While it is legal to use buffered I/O streams such
as sys.stdin, sys.stdout, and sys.stderr as redirect
targets, you must make sure buffers are flushed
before redirection begins and that these streams
are put back into blocking mode before attempting
to go back using buffered I/O again. Also, no buffered
I/O should be performed while redirection is active.
.. note:: When passing in asyncio streams, it is the responsibility
of the caller to close the associated transport when it
is no longer needed.
:param stdin:
Source of data to feed to standard input
:param stdout:
Target to feed data from standard output to
:param stderr:
Target to feed data from standard error to
:param bufsize:
Buffer size to use when forwarding data from a file
:param send_eof:
Whether or not to send EOF to the channel when EOF is
received from stdin, defaulting to `True`. If set to `False`,
the channel will remain open after EOF is received on stdin,
and multiple sources can be redirected to the channel.
:param recv_eof:
Whether or not to send EOF to stdout and stderr when EOF is
received from the channel, defaulting to `True`. If set to
`False`, the redirect targets of stdout and stderr will remain
open after EOF is received on the channel and can be used for
multiple redirects.
:type bufsize: `int`
:type send_eof: `bool`
:type recv_eof: `bool`
N)rL rV r �r? r� r r r� r1 r� r> r> r@ �redirect s �Q ��zSSHClientProcess.redirectr0 c � s �| � |dd||d�I dH dS �z&Redirect standard input of the processNT�r� �r? r0 r� r1 r> r> r@ �redirect_stdinn � � z SSHClientProcess.redirect_stdinrM c � s �| � d|d|d|�I dH dS �z'Redirect standard output of the processNTr� �r? rM r� r� r> r> r@ �redirect_stdoutu r� z SSHClientProcess.redirect_stdoutc � s �| � dd||d|�I dH dS �z&Redirect standard error of the processNTr� r� r> r> r@ �redirect_stderr| r� z SSHClientProcess.redirect_stderrc C s | � � | � t�fS )a� Collect output from the process without blocking
This method returns a tuple of the output that the process
has written to stdout and stderr which has not yet been read.
It is intended to be called instead of read() by callers
that want to collect received data without blocking.
:returns: A tuple of output to stdout and stderr
)r} r rF r> r> r@ �collect_output� s �z SSHClientProcess.collect_output�inputc � s@ �d| _ | �� |r| j�|� | j�� | �� I dH | �� S )a Send input to and/or collect output from the process
This method is a coroutine which optionally provides input
to the process and then waits for the process to exit,
returning a tuple of the data written to stdout and stderr.
:param input:
Input data to feed to standard input of the process. Data
should be a `str` if encoding is set, or `bytes` if not.
:type input: `str` or `bytes`
:returns: A tuple of output to stdout and stderr
r N)�_limitri r& rE rX r# r� )r? r� r> r> r@ � communicate� s �
z SSHClientProcess.communicater r� r� r� r� c C s | j �||||� dS )a� Change the terminal window size for this process
This method changes the width and height of the terminal
associated with this process.
:param width:
The width of the terminal in characters
:param height:
The height of the terminal in characters
:param pixwidth: (optional)
The width of the terminal in pixels
:param pixheight: (optional)
The height of the terminal in pixels
:type width: `int`
:type height: `int`
:type pixwidth: `int`
:type pixheight: `int`
:raises: :exc:`OSError` if the SSH channel is not open
N)r& r� )r? r� r� r� r� r> r> r@ r� � s z%SSHClientProcess.change_terminal_sizer� c C r[ )z�Send a break to the process
:param msec:
The duration of the break in milliseconds
:type msec: `int`
:raises: :exc:`OSError` if the SSH channel is not open
N)r& r� )r? r� r> r> r@ r� � � zSSHClientProcess.send_breakr c C r[ )z�Send a signal to the process
:param signal:
The signal to deliver
:type signal: `str`
:raises: :exc:`OSError` if the SSH channel is not open
N)r& r� )r? r r> r> r@ r� � r� z SSHClientProcess.send_signalc C r� )zbTerminate the process
:raises: :exc:`OSError` if the SSH channel is not open
N)r& � terminaterF r> r> r@ r� � � zSSHClientProcess.terminatec C r� )zfForcibly kill the process
:raises: :exc:`OSError` if the SSH channel is not open
N)r& �killrF r> r> r@ r� � r� zSSHClientProcess.killF�check�timeoutc � s� �zt �| �� |�I dH \}}W n t jy0 | �� \}}t| j| j| j| j| j | j
||�d�w |rG| jrGt | j| j| j| j| j | j
||��t | j| j| j| j| j | j
||�S )a2 Wait for process to exit
This method is a coroutine which waits for the process to
exit. It returns an :class:`SSHCompletedProcess` object with
the exit status or signal information and the output sent
to stdout and stderr if those are redirected to pipes.
If the check argument is set to `True`, a non-zero exit
status from the process with trigger the :exc:`ProcessError`
exception to be raised.
If a timeout is specified and it expires before the process
exits, the :exc:`TimeoutError` exception will be raised. By
default, no timeout is set and this call will wait indefinitely.
:param check:
Whether or not to raise an error on non-zero exit status
:param timeout:
Amount of time in seconds to wait for process to exit, or
`None` to wait indefinitely
:type check: `bool`
:type timeout: `int`, `float`, or `None`
:returns: :class:`SSHCompletedProcess`
:raises: | :exc:`ProcessError` if check is set to `True`
and the process returns a non-zero exit status
| :exc:`TimeoutError` if the timeout expires
before the process exits
N)
r� �wait_forr� r r� r r r
r r r
r r )r? r� r� � stdout_data� stderr_datar> r> r@ r� � s0 �"
� ���
��zSSHClientProcess.waitrH rh )r r )FN).rI rJ rK rL r r r rj r. r} r~ rv r rM r r ru r{ r r
r0 r� r/ r r rY r� �io�DEFAULT_BUFFER_SIZErw rx r� r� r� r� r� r� r� r� r� r� r� �floatr r� r} r> r> ro r@ r� � s�
������
�\���
����
����
�
� ���
�
���r� c s. e Zd ZU dZee ed< ee ed< dedee de
de f� fdd � Z d
e
e d ee d ee d
ed fdd�Zed
ee fdd��Zed
efdd��Zed
efdd��Zed
e
e fdd��Zed
ee fdd��Zed
ee fdd ��Zd ed
df� fd d � Z ddde j d d fd
ee d ee d ee d!e
d"e d#e d
dfd$d%�Z!e j d fd&e d!e
d#e d
dfd'd(�Z"e j d fd)e d!e
d"e d
dfd*d+�Z#e j d fd)e d!e
d"e d
dfd,d-�Z$d
ee fd.d/�Z%d
e&e
e
e
e
f fd0d1�Z'd2e
d
ee
fd3d4�Z(d5e
d
dfd6d7�Z)d8d9e*fd:ed;e d<ed=ed
df
d>d?�Z+� Z,S )@r� zSSH server process handlerr& r� �process_factory� sftp_factory� sftp_version� allow_scpc s0 t � �| j|||� || _d | _d | _d | _d S rh )ri rj �_start_process�_process_factoryry rz r{ )r? r� r� r� r� ro r> r@ rj 4 s �
zSSHServerProcess.__init__r� r r r< Nc C s || _ || _|| _| �| �S )zStart a new server process)ry rz r{ r� )r? r� r r r> r> r@ r� @ s
z SSHServerProcess._start_processc C r )z�The terminal type set by the client
If the client didn't request a pseudo-terminal, this
property will be set to `None`.
)r& �get_terminal_typerF r> r> r@ � term_typeK �
zSSHServerProcess.term_typec C r )ai The terminal size set by the client
This property contains a tuple of four `int` values
representing the width and height of the terminal in
characters followed by the width and height of the
terminal in pixels. If the client hasn't set terminal
size information, the values will be set to zero.
)r& �get_terminal_sizerF r> r> r@ r� V s
zSSHServerProcess.term_sizec C r )z�A mapping containing the TTY modes set by the client
If the client didn't request a pseudo-terminal, this
property will be set to an empty mapping.
)r& �get_terminal_modesrF r> r> r@ �
term_modesd r� zSSHServerProcess.term_modesc C r% )z?The :class:`SSHReader` to use to read from stdin of the processNr� rF r> r> r@ r� o r' zSSHServerProcess.stdinc C r% )z?The :class:`SSHWriter` to use to write to stdout of the processNr� rF r> r> r@ r v r' zSSHServerProcess.stdoutc C r% )z?The :class:`SSHWriter` to use to write to stderr of the processNr� rF r> r> r@ r } r' zSSHServerProcess.stderrrU c s. | j �d�}|r|�|� dS t� �|� dS )z+Handle an incoming exception on the channelN)r r� rW ri �exception_received)r? rU r� ro r> r@ r� � s z#SSHServerProcess.exception_receivedTr� r1 r� c � r� )a^ Perform I/O redirection for the process
This method redirects data going to or from any or all of
standard input, standard output, and standard error for
the process.
The `stdin` argument can be any of the following:
* An :class:`SSHWriter` object
* An :class:`asyncio.StreamWriter` object
* A file object open for write
* An `int` file descriptor open for write
* A connected socket object
* A string or :class:`PurePath <pathlib.PurePath>` containing
the name of a file or device to open
* `DEVNULL` to discard standard error output
* `PIPE` to interactively read standard error output
The `stdout` and `stderr` arguments can be any of the following:
* An :class:`SSHReader` object
* An :class:`asyncio.StreamReader` object
* A file object open for read
* An `int` file descriptor open for read
* A connected socket object
* A string or :class:`PurePath <pathlib.PurePath>` containing
the name of a file or device to open
* `DEVNULL` to provide no input to standard input
* `PIPE` to interactively write standard input
File objects passed in can be associated with plain files, pipes,
sockets, or ttys.
The default value of `None` means to not change redirection
for that stream.
.. note:: When passing in asyncio streams, it is the responsibility
of the caller to close the associated transport when it
is no longer needed.
:param stdin:
Target to feed data from standard input to
:param stdout:
Source of data to feed to standard output
:param stderr:
Source of data to feed to standard error
:param bufsize:
Buffer size to use when forwarding data from a file
:param send_eof:
Whether or not to send EOF to the channel when EOF is
received from stdout or stderr, defaulting to `True`. If
set to `False`, the channel will remain open after EOF is
received on stdout or stderr, and multiple sources can be
redirected to the channel.
:param recv_eof:
Whether or not to send EOF to stdin when EOF is received
on the channel, defaulting to `True`. If set to `False`,
the redirect target of stdin will remain open after EOF
is received on the channel and can be used for multiple
redirects.
:type bufsize: `int`
:type send_eof: `bool`
:type recv_eof: `bool`
N)rV rL r r� r> r> r@ r� � s �G ��zSSHServerProcess.redirectrM c � s �| � |dd|d|�I dH dS r� r� r� r> r> r@ r� � r� z SSHServerProcess.redirect_stdinr0 c � s �| � d|d||d�I dH dS r� r� r� r> r> r@ r� � r� z SSHServerProcess.redirect_stdoutc � s �| � dd|||d�I dH dS r� r� r� r> r> r@ r� � r� z SSHServerProcess.redirect_stderrc C � | j S )a� Return the terminal type set by the client for the process
This method returns the terminal type set by the client
when the process was started. If the client didn't request
a pseudo-terminal, this method will return `None`.
:returns: A `str` containing the terminal type or `None` if
no pseudo-terminal was requested
)r� rF r> r> r@ r� � s z"SSHServerProcess.get_terminal_typec C r� )a� Return the terminal size set by the client for the process
This method returns the latest terminal size information set
by the client. If the client didn't set any terminal size
information, all values returned will be zero.
:returns: A tuple of four `int` values containing the width and
height of the terminal in characters and the width
and height of the terminal in pixels
)r� rF r> r> r@ r� s
z"SSHServerProcess.get_terminal_size�modec C s | j �|�S )a� Return the requested TTY mode for this session
This method looks up the value of a POSIX terminal mode
set by the client when the process was started. If the client
didn't request a pseudo-terminal or didn't set the requested
TTY mode opcode, this method will return `None`.
:param mode:
POSIX terminal mode taken from :ref:`POSIX terminal modes
<PTYModes>` to look up
:type mode: `int`
:returns: An `int` containing the value of the requested
POSIX terminal mode or `None` if the requested
mode was not set
)r� r� )r? r� r> r> r@ �get_terminal_mode s z"SSHServerProcess.get_terminal_mode�statusc C r[ )a% Send exit status and close the channel
This method can be called to report an exit status for the
process back to the client and close the channel.
:param status:
The exit status to report to the client
:type status: `int`
N)r& �exit)r? r� r> r> r@ r� & s zSSHServerProcess.exitFr r r r r c C s | j �||||�S )aG Send exit signal and close the channel
This method can be called to report that the process
terminated abnormslly with a signal. A more detailed
error message may also provided, along with an indication
of whether or not the process dumped core. After
reporting the signal, the channel is closed.
:param signal:
The signal which caused the process to exit
:param core_dumped: (optional)
Whether or not the process dumped core
:param msg: (optional)
Details about what error occurred
:param lang: (optional)
The language the error message is in
:type signal: `str`
:type core_dumped: `bool`
:type msg: `str`
:type lang: `str`
)r& �exit_with_signal)r? r r r r r> r> r@ r� 4 s z!SSHServerProcess.exit_with_signal)-rI rJ rK rL r r r �SSHServerProcessFactoryr r4 rM r{ rj r/ r0 r$ r� rv ru r� r& r� r% r� r� r r rY r� r� r� rx rw r� r� r� r� r� r r� r� r� r r� r} r> r> ro r@ r� . s�
���
��
�
������
�R���
����
����
� ����r� )krL r� �asyncio.subprocessr r r rk r@ r� r] �pathlibr r> r[ �typesr �typingr r r r
r r r
r r r r r r r r r r r �typing_extensionsr r r� r r r � constantsr r �loggingr! �miscr" r# r$ r% r& r' r( r) r* r+ r, r- �sessionr. �streamr/ r0 r1 r2 r3 r4 r| ru r5 �_FilerM r� rw r rx r� r� r� r9 rN rT r{ rb rc r~ r� r� r� r� � BaseProtocolr� r� r� r� r� r� r r r r r r r� r� r> r> r> r@ �<module> s� $ ���
#,3<4A 1=
@- p