File: //usr/lib/python3/dist-packages/trac/web/__pycache__/_fcgi.cpython-310.pyc
o
�k�`� � @ sL d Z dZdZddlZddlZddlZddlZddlZddlZddl Z ddl
Z
ddl Z z ddl Z ddl
Z
dZW n eyI ddlZ ddlZ
dZY nw ee d�sRde _d gZdZd
ZdZdZd Zd Zd
ZdZ dZ dZ d
Z dZ dZ!dZ"e"Z#dZ$dZ%dZ&d Z'd Z(dZ)dZ*d Z+d Z,dZ-dZ.dZ/dZ0dZ1dZ2dZ3e�4e2�Z5e�4e3�Z6 ddl7Z7dZ8dZ9d d � Z:G d d � d e;�Z<G d d!� d!e<�Z=G d"d#� d#e;�Z>G d$d%� d%e;�Z?G d&d'� d'e;�Z@d<d(d)�ZAd*d+� ZBG d,d-� d-e;�ZCG d.d/� d/e;�ZDG d0d1� d1eD�ZEG d2d3� d3e;�ZFG d4d5� d5eF�ZGG d6d7� d7e;�ZHG d8d � d eH�ZIeJd9k�r$d:d;� ZKeIeK��L� dS dS )=a�
fcgi - a FastCGI/WSGI gateway.
For more information about FastCGI, see <http://www.fastcgi.com/>.
For more information about the Web Server Gateway Interface, see
<http://www.python.org/peps/pep-0333.html>.
Example usage:
#!/usr/bin/env python
from myapplication import app # Assume app is your WSGI application object
from fcgi import WSGIServer
WSGIServer(app).run()
See the documentation for WSGIServer/Server for more information.
On most platforms, fcgi will fallback to regular CGI behavior if run in a
non-FastCGI context. If you want to force CGI behavior, set the environment
variable FCGI_FORCE_CGI to "Y" or "y".
z Allan Saddi <allan@saddi.com>z$Revision: 2025 $� NTF�SHUT_WR� �
WSGIServer� � � � � � � � �
� �FCGI_MAX_CONNS�
FCGI_MAX_REQS�FCGI_MPXS_CONNSz!BBHHBxz!HB5xz!LB3xz!B7xz
/tmp/fcgi.logc C sp t | k rd S z+ttddd��}|�dt�� dd� |f � W d � W d S 1 s*w Y W d S Y d S )N�azutf-8)�encodingz %sfcgi: %s
r ���)�DEBUG�open�DEBUGLOG�write�time�ctime)�level�msg�f� r �0/usr/lib/python3/dist-packages/trac/web/_fcgi.py�_debugw s &�r c @ sb e Zd ZdZdd� Zdd� Zdd� Zdd d
�Zdd d
�Zddd�Z dd� Z
dd� Z e Z dd� Z
d S )� InputStreamz�
File-like object representing FastCGI input streams (FCGI_STDIN and
FCGI_DATA). Supports the minimum methods required by WSGI spec.
c C s2 || _ |jj| _d| _g | _d| _d| _d| _d S )N� r F) �_conn�server�inputStreamShrinkThreshold�_shrinkThreshold�_buf�_bufList�_pos�_avail�_eof)�self�connr r r �__init__� s
zInputStream.__init__c C sJ | j | jkr!| j| j d� | _| j| j 8 _d| _ | jdks#J �dS dS )z6Gets rid of already read data (since we can't rewind).Nr )r) r& r' r* �r, r r r �
_shrinkBuffer� s �zInputStream._shrinkBufferc C s | j �� dS )z(Waits for more data to become available.N)r# �
process_inputr/ r r r � _waitForData� � zInputStream._waitForData���c C s� | j | jkr | jr dS |dk s| j| j |k r$| jr | j}n | �� q | j | } | jr;| jd�| j�7 _g | _| j| j |� }|| _ | �� |S )Nr" Tr )r) r* r+ r2 r( r' �joinr0 )r, �n�newPos�rr r r �read� s$
zInputStream.readNc C s� | j | jkr | jr dS | jr | jd�| j�7 _g | _| j�d| j �}|dk r5| jr0| j}n
| �� q |d } |d urJ| j | |k rJ| j | }| j| j |� }|| _ | �� |S )Nr" T�
r r ) r) r* r+ r( r' r5 �findr2 r0 )r, �length�ir7 r8 r r r �readline� s,
zInputStream.readliner c C sT d}g }| � � }|r(|�|� |t|�7 }d| k r!|kr" |S | � � }|s
|S )Nr )r> �append�len)r, �sizehint�total�lines�liner r r � readlines� s
��zInputStream.readlinesc C s | S �Nr r/ r r r �__iter__� s zInputStream.__iter__c C s | � � }|st�|S rF )r> �
StopIteration)r, r8 r r r �__next__� s zInputStream.__next__c C s0 |sd| _ d S | j�|� | jt|�7 _d S �NT)r+ r( r? r* r@ �r, �datar r r �add_data� s
zInputStream.add_data�r4 rF �r )�__name__�
__module__� __qualname__�__doc__r. r0 r2 r9 r> rE rG rI �nextrM r r r r r! � s
r! c sP e Zd ZdZ� fdd�Zdd� Zd� fdd� Zd� fd
d � Z� fd d
�Z� Z S )�MultiplexedInputStreamz�
A version of InputStream meant to be used with MultiplexedConnections.
Assumes the MultiplexedConnection (the producer) and the Request
(the consumer) are running in different threads.
c s$ t � �|� t�� }t�|�| _d S rF ��superr. � threading�RLock� Condition�_lock)r, r- �lock�� __class__r r r. � s z MultiplexedInputStream.__init__c C s | j �� d S rF )r[ �waitr/ r r r r2 r3 z#MultiplexedInputStream._waitForDatar4 c �0 | j �� z t� �|�W | j �� S | j �� w rF )r[ �acquirerW r9 �release)r, r6 r] r r r9 �
zMultiplexedInputStream.readNc r` rF )r[ ra rW r> rb )r, r< r] r r r> rc z MultiplexedInputStream.readlinec s> | j �� zt� �|� | j �� W | j �� d S | j �� w rF )r[ ra rW rM �notifyrb rK r] r r rM s
z MultiplexedInputStream.add_datarN rF )
rP rQ rR rS r. r2 r9 r> rM �
__classcell__r r r] r rU � s
rU c @ sB e Zd ZdZddd�Zdd� Zdd� Zd d
� Zd d � Zd
d� Z dS )� OutputStreamz�
FastCGI output stream (FCGI_STDOUT/FCGI_STDERR). By default, calls to
write() or writelines() immediately result in Records being sent back
to the server. Buffering should be done in a higher level!
Fc C s. || _ || _|| _|| _g | _d| _d| _d S �NF)r# �_req�_type� _bufferedr( � dataWritten�closed)r, r- �req�type�bufferedr r r r. ' s
zOutputStream.__init__c C sp t |�}|r6t|| jjjt �}t| j| jj�}||_ |d |� |_
| j � |� ||d � }||8 }|sd S d S rF )
r@ �minrh r$ �maxwrite�FCGI_HEADER_LEN�Recordri � requestId�
contentLength� contentDatar# � writeRecord)r, rL r< �toWrite�recr r r �_write0 s �zOutputStream._writec C s< | j rJ �|s d S d| _| jr| j�|� d S | �|� d S rJ )rl rk rj r( r? rz rK r r r r = s
zOutputStream.writec C s" | j rJ �|D ]}| �|� qd S rF )rl r �r, rC rD r r r �
writelinesJ s
�zOutputStream.writelinesc C s* | j rd�| j�}g | _| �|� d S d S )Nr" )rj r5 r( rz rK r r r �flushP s
�zOutputStream.flushc C sB | j s | jr | �� t| j| jj�}| j�|� d| _ dS dS dS )z/Sends end-of-stream notification, if necessary.TN) rl rk r} rs ri rh rt r# rw �r, ry r r r �closeX s
�zOutputStream.closeN�F)
rP rQ rR rS r. rz r r| r} r r r r r rf ! s
rf c @ �0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
S ) �TeeOutputStreamzq
Simple wrapper around two or more output file-like objects that copies
written data to all streams.
c C s
|| _ d S rF )� _streamList)r, �
streamListr r r r. e �
zTeeOutputStream.__init__c C s | j D ]}|�|� qd S rF )r� r )r, rL r r r r r h s
�zTeeOutputStream.writec C � |D ]}| � |� qd S rF �r r{ r r r r| l � �zTeeOutputStream.writelinesc C s | j D ]}|�� qd S rF )r� r} )r, r r r r r} p s
�zTeeOutputStream.flushN)rP rQ rR rS r. r r| r} r r r r r� ` s r� c @ r� ) �
StdoutWrapperzN
Wrapper for sys.stdout so we know if data has actually been written.
c C s || _ d| _d S rg )�_filerk )r, �stdoutr r r r. x �
zStdoutWrapper.__init__c C s |rd| _ | j�|� d S rJ )rk r� r rK r r r r | s zStdoutWrapper.writec C r� rF r� r{ r r r r| � r� zStdoutWrapper.writelinesc C s t | j|�S rF )�getattrr� )r, �namer r r � __getattr__� s zStdoutWrapper.__getattr__N)rP rQ rR rS r. r r| r� r r r r r� t s r� c C s� t | | �}|d@ r t�d| ||d � �d d@ }|d7 }n|d7 }t | | �}|d@ rBt�d| ||d � �d d@ }|d7 }n|d7 }| ||| � }||7 }| ||| � }||7 }|||ffS )zv
Decodes a name/value pair.
The number of bytes decoded as well as the name/value pair
are returned.
� �!Lr r i���r )�ord�struct�unpack)�s�pos�
nameLength� valueLengthr� �valuer r r � decode_pair� s
r� c C sh t | �}|dk r
t|�}nt�d|dB �}t |�}|dk r$|t|�7 }n
|t�d|dB �7 }|| | S )zI
Encodes a name/value pair.
The encoded string is returned.
r� r� l )r@ �chrr� �pack)r� r� r� r� r� r r r � encode_pair� s
r� c @ sF e Zd ZdZeefdd�Zedd� �Zdd� Z edd � �Z
d
d � Z d S )
rs zD
A FastCGI Record.
Used for encoding/decoding records.
c C s( t | _|| _|| _d| _d| _d| _d S )Nr r" )�FCGI_VERSION_1�versionrn rt ru �
paddingLengthrv )r, rn rt r r r r. � s
zRecord.__init__c
C s� g }d}|rGz| � |�}W n# tjy0 } z|d tjkr+t�| gg g � W Y d}~q� d}~ww |s4n|�|� t|�}||7 }||8 }|sd�|�|fS )z�
Attempts to receive length bytes from a socket, blocking if necessary.
(Socket may be blocking or non-blocking.)
r Nr" ) �recv�socket�error�errno�EAGAIN�selectr? r@ r5 )�sockr< �dataList�recvLenrL �e�dataLenr r r �_recvall� s( ��
�zRecord._recvallc C s� z
| � |t�\}}W n t�|tk rt�t�t|�\| _| _| _| _ | _
t dd|� � | j| j| j f � | j rRz | � || j �\| _
}W n t�|| j k rRt�| j
rez
| � || j
� W dS t�dS )z'Read and decode a Record from a socket.Tr z<read: fd = %d, type = %d, requestId = %d, contentLength = %dN)r� rr �EOFErrorr� r� � FCGI_Headerr� rn rt ru r� r �filenorv )r, r� �headerr< r r r r9 � s:
����
�z Record.readc
C s� t |�}|r?z| �|�}W n# tjy0 } z|d tjkr+t�g | gg � W Y d}~q� d}~ww ||d� }||8 }|sdS dS )zY
Writes data to a socket and does not return until all the data is sent.
r N)r@ �sendr� r� r� r� r� )r� rL r< �sentr� r r r �_sendall s �� �zRecord._sendallc C s� | j d@ | _tdd|�� | j| j| j f � t�t| j | j| j| j | j�}| �
||� | j r6| �
|| j � | jrD| �
|d| j � dS dS )z&Encode and write a Record to a socket.r Tr z=write: fd = %d, type = %d, requestId = %d, contentLength = %d� N) ru r� r r� rn rt r� r� r� r� r� rv )r, r� r� r r r r s ��� �z Record.writeN) rP rQ rR rS �FCGI_UNKNOWN_TYPE�FCGI_NULL_REQUEST_IDr. � staticmethodr� r9 r� r r r r r rs � s
"
rs c @ s6 e Zd ZdZdd� Zdd� Zdefdd�Zd d
� Zd S ) �Requesta8
Represents a single FastCGI request.
These objects are passed to your handler and is the main interface
between your handler and the fcgi module. The methods should not
be called by your handler. However, server, params, stdin, stdout,
stderr, and data are free for your handler's use.
c C sL || _ |j| _i | _||�| _t|| t�| _t|| tdd�| _||�| _ d S )NT)ro )
r# r$ �params�stdinrf � FCGI_STDOUTr� � FCGI_STDERR�stderrrL )r, r- �inputStreamClassr r r r. . s
zRequest.__init__c
C s� z
| j �| �\}}W n tj| jd� | j�� | jjs$| j �| � t d}}Y t
dd||f � z
| � � | � ||� W dS t
jy\ } z|d tjkrQ� W Y d}~dS d}~ww )z<Runs the handler, flushes the streams, and ends the request.)�filer Tr z#protocolStatus = %d, appStatus = %dN)r$ �handler� traceback� print_excr� r} r� rk r� �FCGI_REQUEST_COMPLETEr �_flush�_endr� r� �EPIPE)r, �protocolStatus� appStatusr� r r r �run8 s(
����z Request.runr c C s | j �| ||� d S rF )r# � end_request�r, r� r� r r r r� N s z Request._endc C s | j �� | j�� d S rF )r� r r� r/ r r r r� Q s
zRequest._flushN) rP rQ rR rS r. r� r� r� r� r r r r r� % s
r� c @ s. e Zd ZdZdd� Zdefdd�Zdd� Zd S )
�
CGIRequestz4A normal CGI request disguised as a FastCGI request.c C sT d| _ t| _d| _d| _|| _ttj�| _ t
j | _ t t
j
�| _
t
j| _t�� | _d S )Nr r F)rt �FCGI_RESPONDER�role�flags�abortedr$ �dict�os�environr� �sysr� r� r� r� �io�BytesIOrL )r, r$ r r r r. W s zCGIRequest.__init__r c C s t �|� d S rF )r� �exitr� r r r r� e s zCGIRequest._endc C s d S rF r r/ r r r r� h s zCGIRequest._flushN)rP rQ rR rS r. r� r� r� r r r r r� U s
r� c @ s� e Zd ZdZdZeZdd� Zdd� Zdd� Z d d
� Z
d d � Z d
e dfdd�Z
dd� Zdd� Zdd� Zdd� Zdd� Zdd � Zd d � Zd d � Zd!S )"�
Connectionz�
A Connection with the web server.
Each Connection is associated with a single socket (which is
connected to the web server) and is responsible for handling all
the FastCGI message processing for that socket.
Fc C s || _ || _|| _i | _d S rF )�_sock�_addrr$ � _requests)r, r� �addrr$ r r r r. w s
zConnection.__init__c C sj z | j �tj� W n Y dS z t�| j gg g �\}}}|r&| j �d�s'nqW n Y | j �� dS )z Close the Connection's socket.NTi )r� �shutdownr� r r� r� r )r, r8 �wr� r r r �_cleanupSocket s �zConnection._cleanupSocketc
C sx d| _ | j r6z| �� W n& ty Y n! tjtjfy2 } z|d tjkr-W Y d}~n � d}~ww | j s| �� dS )z&Begin processing data from the socket.Tr N) �
_keepGoingr1 r� r� r� r� r� �EBADFr� )r, r� r r r r� � s ���
zConnection.runc C s | j r"zt�| jgg g d�\}}}W n ty t�w |r n| j s| j s'dS t� }|�| j� |jtkr<| � |� dS |jt
krH| � |� dS |jt krT| �
|� dS |jtkr`| �|� dS |jtkrl| �|� dS |jtkrx| �|� dS |jtkr�| �|� dS dS )z?Attempt to read a single Record from the socket and process it.� �?N)r� r� r� �
ValueErrorr� rs r9 rn �FCGI_GET_VALUES�_do_get_values�FCGI_BEGIN_REQUEST�_do_begin_request�FCGI_ABORT_REQUEST�_do_abort_request� FCGI_PARAMS�
_do_params�
FCGI_STDIN� _do_stdin� FCGI_DATA�_do_datart r� �_do_unknown_type)r, r8 r� r� ry r r r r1 � s6 ��
zConnection.process_inputc C s |� | j� dS )z/
Write a Record to the socket.
N)r r� r~ r r r rw � s zConnection.writeRecordr Tc C st t t|j�}t�t||�|_t|_| � |� |r | j
|j= t dd|j � |j t
@ s6| j
s8| �� d| _dS dS dS )a
End a Request.
Called by Request objects. An FCGI_END_REQUEST Record is
sent to the web server. If the web server no longer requires
the connection, the socket is closed, thereby ending this
Connection (run() returns).
Tr zend_request: flags = %dFN)rs �FCGI_END_REQUESTrt r� r� �FCGI_EndRequestBodyrv �FCGI_EndRequestBody_LENru rw r� r r� �FCGI_KEEP_CONNr� r� )r, rm r� r� �removery r r r r� � s
�
�zConnection.end_requestc C s| t t�}d}||jk r1t|j|�\}\}}| jj�|�}|dur,| jt|t |��7 _||jk s t
|j�|_| � |� dS )z6Handle an FCGI_GET_VALUES request from the web server.r N) rs �FCGI_GET_VALUES_RESULTru r� rv r$ �
capability�getr� �strr@ rw )r, �inrec�outrecr� r� r� �capr r r r� � s
� zConnection._do_get_valuesc C sr t �t|j�\}}| j�| | j�}|j|||_|_|_ d|_
| j s1| j r1| j
|dtdd� dS || j |j< dS )z1Handle an FCGI_BEGIN_REQUEST from the web server.Fr )r� N)r� r� �FCGI_BeginRequestBodyrv r$ �
request_class�_inputStreamClassrt r� r� r� � _multiplexedr� r� �FCGI_CANT_MPX_CONN)r, r� r� r� rm r r r r� � s z Connection._do_begin_requestc C s$ | j �|j�}|durd|_dS dS )z{
Handle an FCGI_ABORT_REQUEST from the web server.
We just mark a flag in the associated Request.
NT)r� r� rt r� �r, r� rm r r r r� � s
�z Connection._do_abort_requestc C � |� � dS )zRun the request.N)r� �r, rm r r r �_start_request s zConnection._start_requestc C sl | j �|j�}|dur4|jr-d}||jk r+t|j|�\}\}}||j|< ||jk sdS dS | �|� dS dS )zw
Handle an FCGI_PARAMS Record.
If the last FCGI_PARAMS Record is received, start the request.
Nr )r� r� rt ru r� rv r� r )r, r� rm r� r� r� r r r r� s
��zConnection._do_paramsc C �, | j �|j�}|dur|j�|j� dS dS )z Handle the FCGI_STDIN stream.N)r� r� rt r� rM rv r r r r r� � �zConnection._do_stdinc C r )z Handle the FCGI_DATA stream.N)r� r� rt rL rM rv r r r r r� " r zConnection._do_datac C s, t t�}t�t|j�|_t|_| � |� dS )z4Handle an unknown request type. Respond accordingly.N)
rs r� r� r� �FCGI_UnknownTypeBodyrn rv �FCGI_UnknownTypeBody_LENru rw )r, r� r� r r r r� ( s zConnection._do_unknown_typeN)rP rQ rR rS r r! r� r. r� r� r1 rw r� r� r� r� r� r r� r� r� r� r r r r r� l s( %
�
r� c s� e Zd ZdZdZeZ� fdd�Z� fdd�Zdd� Z d e
df� fd
d � Z � fd d
�Z � fdd�Z
dd� Z� fdd�Z� fdd�Z� fdd�Z� ZS )�MultiplexedConnectionz[
A version of Connection capable of handling multiple requests
simultaneously.
Tc s( t � �|||� t�� }t�|�| _d S rF rV )r, r� r� r$ r\ r] r r r. 7 s z MultiplexedConnection.__init__c s8 | j �� | jr| j �� | js| j �� t� �� d S rF )r[ ra r� r_ rb rW r� r/ r] r r r� A s
�
z$MultiplexedConnection._cleanupSocketc C s4 | j �� z|�| j� W | j �� d S | j �� w rF )r[ ra r r� rb r~ r r r rw J s
z!MultiplexedConnection.writeRecordr c sD | j �� zt� �||||� | j �� W | j �� d S | j �� w rF )r[ ra rW r� rd rb )r, rm r� r� r� r] r r r� T s
� z!MultiplexedConnection.end_requestc �4 | j �� zt� �|� W | j �� d S | j �� w rF )r[ ra rW r� rb �r, r� r] r r r� _ �
z'MultiplexedConnection._do_begin_requestc r rF )r[ ra rW r� rb r r] r r r� f r
z'MultiplexedConnection._do_abort_requestc C s t �|jd� d S )Nr )�thread�start_new_threadr� r r r r r m s z$MultiplexedConnection._start_requestc r rF )r[ ra rW r� rb r r] r r r� p r
z MultiplexedConnection._do_paramsc r rF )r[ ra rW r� rb r r] r r r� w r
z MultiplexedConnection._do_stdinc r rF )r[ ra rW r� rb r r] r r r� ~ r
z MultiplexedConnection._do_data)rP rQ rR rS r rU r� r. r� rw r� r� r� r� r r� r� r� re r r r] r r
/ s
� r
c @ s� e Zd ZdZeZeZdZ d dd�Z dd � Z
d
d � Z d d
� Z dd� Z
dd� Zdd� Zd dd�Zdd� Zd!dd�Zdd � Zd d � ZdS )"�Serverz�
The FastCGI server.
Waits for connections from the web server, processing each
request.
If run in a normal CGI context, it will instead instantiate a
CGIRequest and run the handler through there.
i p N� Fc C s� |dur|| _ || _trEzddl}|�|j�d }W n
ttfy' d}Y nw |}|r4t| _ |d9 }nt
| _ t |t |t
|r@dpAdi| _n t
| _ t dt dt
di| _|| _|| _dS )a^
handler, if present, must reference a function or method that
takes one argument: a Request object. If handler is not
specified at creation time, Server *must* be subclassed.
(The handler method below is abstract.)
maxwrite is the maximum number of bytes (per Record) to write
to the server. I've noticed mod_fastcgi has a relatively small
receive buffer (8K or so).
bindAddress, if present, must either be a string or a 2-tuple. If
present, run() will open its own listening socket. You would use
this if you wanted to run your application as an 'external' FastCGI
app. (i.e. the webserver would no longer be responsible for starting
your app) If a string, it will be interpreted as a filename and a UNIX
socket will be opened. If a tuple, the first element, a string,
is the interface name/IP to bind to, and the second element (an int)
is the port number.
Set multiplexed to True if you want to handle multiple requests
per connection. Some FastCGI backends (namely mod_fastcgi) don't
multiplex requests at all, so by default this is off (which saves
on thread creation/locking overhead). If threads aren't available,
this keyword is ignored; it's not possible to multiplex requests
at all.
Nr �d r r )r� rq �thread_available�resource� getrlimit�
RLIMIT_NOFILE� ImportError�AttributeErrorr
�_connectionClassr� r r r r� � _bindAddress�_umask) r, r� rq � bindAddress�umask� multiplexedr �maxConns�maxReqsr r r r. � s4 �
��
zServer.__init__c
C s� | j d u rZd}t�ttjtj�}z|�� W n% tjy; } z|d tj kr)d}n|d tj
kr1� W Y d }~nd }~ww |rJt j �
dd��� �d�rX| �| �}|�� t�d� |S d }t| j �tu r�t�tjtj�}zt �| j � W n ty| Y nw | jd ur�t �| j�}n#t| j �tu s�J �t | j �dks�J �t�tjtj�}|� tj tj d� |� | j � |�!tj"� |d ur�t �|� |S ) NTr F�FCGI_FORCE_CGI�N�Yr r )#r r� �fromfd�FCGI_LISTENSOCK_FILENO�AF_INET� SOCK_STREAM� getpeernamer� r� �ENOTSOCK�ENOTCONNr� r� r� �upper�
startswith�cgirequest_classr� r� r� rn r� �AF_UNIX�unlink�OSErrorr r �tupler@ �
setsockopt�
SOL_SOCKET� SO_REUSEADDR�bind�listen� SOMAXCONN)r, �isFCGIr� r� rm �oldUmaskr r r � _setupSocket� sR
� �� �
� �
�
zServer._setupSocketc C r )zCloses the main socket.N)r )r, r� r r r r� s zServer._cleanupSocketc C sP dd� t jt jt jfD �| _t � t j| j� t � t j| j� t � t j| j� d S )Nc S s g | ] }|t �|�f�qS r )�signal� getsignal)�.0�xr r r �
<listcomp>
s z1Server._installSignalHandlers.<locals>.<listcomp>)r; �SIGHUP�SIGINT�SIGTERM�_oldSIGs� _hupHandler� _intHandlerr/ r r r �_installSignalHandlers s �z Server._installSignalHandlersc C s | j D ]
\}}t�||� qd S rF )rC r; )r, �signumr� r r r �_restoreSignalHandlers s �z Server._restoreSignalHandlersc C s d| _ d| _d S )NTF)� _hupReceivedr� �r, rG �framer r r rD r� zServer._hupHandlerc C s
d| _ d S rg )r� rJ r r r rE r� zServer._intHandlerr� c
C s\ t j�d�}|durttdd� |�d���}| �� }d| _d| _| � � | jr�zt
�
|gg g |�\}}}W n t
j yP } z|d t j
krKW Y d}~q$� d}~ww |r�z|�� \}}W n tj yy } z|d t j
t jfv rtW Y d}~q$� d}~ww |r�t|�d ks�|d |vr�|�� q$| �||| �} t�| jd
� | �� | js'| �� | �|� | jS ) z�
The main loop. Exits on SIGHUP, SIGINT, SIGTERM. Returns True if
SIGHUP was received, False otherwise.
�FCGI_WEB_SERVER_ADDRSNc S s | � � S rF )�strip)r> r r r �<lambda>% s z Server.run.<locals>.<lambda>�,TFr r r )r� r� r� �list�map�splitr: r� rI rF r� r� r� �EINTR�acceptr� r� r@ r r r r r� �_mainloopPeriodicrH r� )
r, �timeout�web_server_addrsr� r8 r� r� �
clientSockr� r- r r r r� sL
� �� ���
z
Server.runc C s dS )zi
Called with just about each iteration of the main loop. Meant to
be overridden.
Nr r/ r r r rU S s zServer._mainloopPeriodicc C s | j r d| _ || _dS dS )z�
Protected convenience method for subclasses to force an exit. Not
really thread-safe, which is why it isn't public.
FN)r� rI )r, �reloadr r r �_exitZ s
�z Server._exitc C s t | jjd ��)z�
Default handler, which just raises an exception. Unless a handler
is passed at initialization time, this must be implemented by
a subclass.
z.handler)�NotImplementedErrorr^ rP r r r r r� c s zServer.handlerc C s& ddl }|j�d|�t�� � � dS )zt
Called by Request if an exception occurs within the handler. May and
should be overridden.
r NzContent-Type: text/html
)�cgitbr� r �htmlr� �exc_info)r, rm r\ r r r r� k s
�z Server.error)Nr NNF)r� r� )rP rQ rR rS r� r� r� r- r% r. r: r� rF rH rD rE r� rU rZ r� r� r r r r r � s&
�=4
5
r c s6 e Zd ZdZ d
� fdd� Zdd� Zdd � Z� ZS ) r z|
FastCGI server that supports the Web Server Gateway Interface. See
<http://www.python.org/peps/pep-0333.html>.
NTc sL d|v r|d= t � jdi |�� |du ri }|| _|| _|| _t�� | _dS )a
environ, if present, must be a dictionary-like object. Its
contents will be copied into application's environ. Useful
for passing application-specific variables.
Set multithreaded to False if your application is not MT-safe.
r� Nr )rW r. � applicationr� �
multithreadedr �
allocate_lock� _app_lock)r, r_ r� r` �kwr] r r r. y s zWSGIServer.__init__c
s� �j tkr tdfS �j}|�| j� d|d< �j|d< | jdu r$�j}nt t
j�jf�}||d< t �t � o:t
o:| j|d< d|d < t �t �|d
< |�d d ��� d
v rWd|d< n|�dd ��� dkrfd|d< nd|d< | �|� g �g � d�� ���fdd��d� ��fdd� }| js�| j�� zYz0| �||��z �D ]}|r��|� q�� s��d � W t�d�r���� n t�d�r���� w w W n tjy� } z|d tjkrт W Y d}~nd}~ww W | js�| j�� t dfS | js�| j�� w w )zSpecial handler for WSGI.r )r r z wsgi.version�
wsgi.inputN� wsgi.errorszwsgi.multithreadTzwsgi.multiprocessz
wsgi.run_once�HTTPSr" )�yes�on�1�httpszwsgi.url_scheme�HTTP_X_FORWARDED_PROTO�httpc s� t | �tu s
J d���sJ d��� sf� \}}� d d �< d}|D ]\}}|�� dkr.d} nq |sM�d urMzt��dkrG|�dtt| ��f� W n Y d| }|D ]}|d | 7 }qS|d
7 }�j�|� �j�| � �j�� d S ) Nz write() argument must be stringz write() before start_response()Fzcontent-lengthTr zContent-Lengthz Status: %s
z%s: %s
z
)rn r� �lowerr@ r? r� r r} )rL �status�responseHeaders�foundr� r� r� )� headers_sent� headers_setrm �resultr r r � s4 �
�� z!WSGIServer.handler.<locals>.writec s� |rz
� r |d �W d }n d }w �rJ d��t | �tu s J d��t| �dks*J d��t| d d� �s6J d��| d dks@J d ��t |�tu sJJ d
�� |D ]\}}t |�tu s[J d ��t |�tu seJ d
��qM| |g�d d �< �S )Nr zHeaders already set!zStatus must be a stringr z$Status must be at least 4 charactersr z#Status must begin with 3-digit code� z#Status must have a space after codezHeaders must be a listTz Header names must be stringsz Header values must be strings)rn r� r@ �intrP )rn �response_headersr^ r� �val)rq rr r r r �start_response� s$ � z*WSGIServer.handler.<locals>.start_responser rF ) r� r� �FCGI_UNKNOWN_ROLEr� �updater� r� r r� r� r� �
isinstancer� r r` r� rm � _sanitizeEnvrb ra r_ �hasattrr r� r� r� r� rb r� )r, rm r� r� rx rL r� r )rq rr rm rs r r r� � sz
��
��
�
�
�� ����
� �zWSGIServer.handlerc C s\ d|vrd|d< d|vrd|d< dD ]\}}||vr+|d � d| jj|f � |||< qdS )z7Ensure certain values are present, if required by WSGI.� SCRIPT_NAMEr" � PATH_INFO))�REQUEST_METHOD�GET)� SERVER_NAME� localhost)� SERVER_PORT�80)�SERVER_PROTOCOLzHTTP/1.0re z/%s: missing FastCGI param %s required by WSGI!
N)r r^ rP )r, r� r� �defaultr r r r| s
���zWSGIServer._sanitizeEnvrJ )rP rQ rR rS r. r� r| re r r r] r r t s �q�__main__c c s� � ddl }|ddg� dV t| �D ]}d||�| | �f V q|j| d | dd �}|jr1d
V |jD ] }d|j|jf V q4d V dS ) z(Probably not the most efficient example.r Nz200 OK)z Content-Typez text/htmls\ <html><head><title>Hello World!</title></head>
<body>
<p>Hello World!</p>
<table border="1">s <tr><td>%s</td><td>%s</td></tr>
rd r )�fpr� �keep_blank_valuess' <tr><th colspan="2">Form data</th></tr>s </table>
</body></html>
)�cgi�sorted�escape� FieldStoragerP r� r� )r� rx r� r� �form�fieldr r r �test_app s$ � � �
�
r� rO )MrS �
__author__� __version__r� r� r� r; r� r� r� r� r� r rX r r � dummy_thread�dummy_threadingr} r �__all__r% rr r� r� r� r� r� r� r� r� r� r� r� r� � FCGI_MAXTYPEr� r� r� �FCGI_AUTHORIZER� FCGI_FILTERr� r �FCGI_OVERLOADEDry r r r r� r� r� r �calcsizer� r r r r r �objectr! rU rf r� r� r� r� rs r� r� r� r
r r rP r� r� r r r r �<module> s� �
v*?
m0 DV p
!�