Current File : //proc/227033/root/opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyc
�
a�Nc @ sD d Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l
Z
d d l Z d d l Z d d l
m Z d d l m Z m Z d d l m Z d d l m Z d d l Z y d d l m Z Wn e k
re Z n Xd d d
d g Z d Z d
e f d � � YZ d f d � � YZ y2 d d l m Z m! Z! e j" e j# e j$ f Z% Wn9 e k
r�e Z e j" f Z% d e f d � � YZ& n6 Xd e f d � � YZ' d e f d � � YZ& d � Z( d
e e f d � � YZ) d e f d � � YZ* d e f d � � YZ+ d e f d � � YZ, d e& f d � � YZ- d e e- f d � � YZ. d! e, e- f d" � � YZ/ d# e0 f d$ � � YZ1 e e e e e e e e2 e e e d% e d& d' � Z3 d( � Z4 e3 j p�d) d* e4 _ e5 d+ k r@d d, l6 m7 Z7 e3 e7 d- d. d/ d0 d1 d2 �n d S(3 s�
WSGI HTTP Server
This is a minimalistic WSGI server using Python's built-in BaseHTTPServer;
if pyOpenSSL is installed, it also provides SSL capabilities.
i����N( t count( t BaseHTTPRequestHandlert
HTTPServer( t ThreadingMixIn( t
converters( t
killthreadt WSGIHandlerMixint
WSGIServert WSGIHandlert serves 0.5t ContinueHookc B sD e Z d Z d � Z d � Z d d � Z d d � Z d d � Z RS( sN
When a client request includes a 'Expect: 100-continue' header, then
it is the responsibility of the server to send 100 Continue when it
is ready for the content body. This allows authentication, access
levels, and other exceptions to be detected *before* bandwith is
spent on the request body.
This is a rfile wrapper that implements this functionality by
sending 100 Continue to the client immediately after the user
requests the content via a read() operation on the rfile stream.
After this response is sent, it becomes a pass-through object.
c C s� | | _ | | _ x9 d D]1 } t | | � r t | | t | | � � q q Wx= d
D]5 } t | | � rU t | | t | d | � � qU qU Wd S( Nt closet closedt filenot flusht modet bufsizet softspacet readt readlinet readlinest _ContinueFile_( s closes closeds filenos flushs modes bufsizes softspace( s reads readlines readlines( t _ContinueFile_rfilet _ContinueFile_writet hasattrt setattrt getattr( t selft rfilet writet attr( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyt __init__7 s
c C sV | j d � | j } x9 d D]1 } t | | � r t | | t | | � � q q Wd S( Ns HTTP/1.1 100 Continue
R R R ( s reads readlines readlines( R R R R R ( R R R ( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyt _ContinueFile_sendB s
i����c C s | j � | j j | � S( N( R R R ( R t size( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyt _ContinueFile_readI s
c C s | j � | j j | � S( N( R R R ( R R! ( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyt _ContinueFile_readlineM s
i c C s | j � | j j | � S( N( R R R ( R t sizehint( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyt _ContinueFile_readlinesQ s
( t __name__t
__module__t __doc__R R R" R# R% ( ( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyR
) s c B sh e Z d Z e Z d � Z d � Z d � Z d � Z d d � Z
d d � Z d d � Z d d � Z
RS(
s�
WSGI mix-in for HTTPRequestHandler
This class is a mix-in to provide WSGI functionality to any
HTTPRequestHandler derivative (as provided in Python's BaseHTTPServer).
This assumes a ``wsgi_application`` handler on ``self.server``.
c O s d S( s� disable success request logging
Logging transactions should not be part of a WSGI server,
if you want logging; look at paste.translogger
N( ( R t argst kwargs( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyt log_request_ s c O s d S( s� disable error message logging
Logging transactions should not be part of a WSGI server,
if you want logging; look at paste.translogger
N( ( R R) R* ( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyt log_messageg s c C s& | j s | j S| j d | j Sd S( s. behavior that BaseHTTPServer should have had t N( t sys_versiont server_version( R ( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyt version_stringo s c
C s6 | j r# | j r# t d � � n | j s"t | _ | j \ } } | j d d � \ } } | j t | � | � t } xx | D]p \ } } | j � } d | k r� t } n d | k r� d | j � k r� d | _ t } q� n | j
| | � q W| rd | _ | j
d d � n | j � n | j j
| � d S( sn
Write a chunk of the output stream; send headers if they
have not already been sent.
s- Content returned before start_response calledR- i s content-lengtht
connectionR t
ConnectionN( t wsgi_headers_sentt wsgi_curr_headerst RuntimeErrort Truet splitt
send_responset intt lowert Falset close_connectiont send_headert end_headerst wfileR (
R t chunkt statust headerst codet messaget
send_closet kt vt lk( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyt wsgi_write_chunkv s.
c C so | r; z( | j r- | d | d | d � n Wd d } Xn | j rY d sY t d � � n | | f | _ | j S( Ni i i s4 Attempt to set headers a second time w/o an exc_info( R3 t NoneR4 t AssertionErrorRI ( R RA t response_headerst exc_info( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyt wsgi_start_response� s
c C s� t j | j � \ } } } } } t j | � } | j d � } t j | � } | rm | d k rm | d 7} n | j j d \ } } | j
}
y t | j j
d d � � } Wn t k
r� d } n Xd | j j
d d � j � k rt t |
| j j � | � }
n$ t | j d � s+t |
| � }
n | j d } i d0 d 6d d
6|
d 6t j d 6t d 6t d 6t d 6| j d 6d d 6| d 6| d 6| j j
d d � d 6| j j
d d � d 6| d 6t | � d 6| j d 6| d 6| _ | r�| | j d <n | r| | j d <n | j ri| j d � sf| j d! � sf| j d" � rJqid/ }
|
ri|
| j d# <qin t | j d$ � r�| j | j j" j# t$ j% � d
<| j j" | j d% <n xm | j j& � D]\ \ } } d& | j' d' d( � j( � } | d1 k r�q�n d+ j) | j j* | � � | j | <q�Wt | j d � rCd, | j d
<n | r�t+ | t, � s^t- � | j j. | � d- | j
d. � k r�d, | j d
<q�n d/ | _/ t | _0 d/ S(2 s
Setup the member variables used by this WSGI mixin, including
the ``environ`` and status member variables.
After the basic environment is created; the optional ``environ``
argument can be used to override any settings.
t /i s Content-Lengtht 0i s 100-continuet Expectt t get_contexti s wsgi.versiont https wsgi.url_schemes
wsgi.inputs wsgi.errorss wsgi.multithreads wsgi.multiprocesss
wsgi.run_oncet REQUEST_METHODt SCRIPT_NAMEt PATH_INFOt QUERY_STRINGs Content-Typet CONTENT_TYPEt CONTENT_LENGTHt SERVER_NAMEt SERVER_PORTt SERVER_PROTOCOLt REMOTE_ADDRs paste.httpserver.proxy.schemes paste.httpserver.proxy.hosts 192.168.s 10.s 172.16.t REMOTE_HOSTt thread_pools paste.httpserver.thread_poolt HTTP_t -t _t HTTP_CONTENT_TYPEt HTTP_CONTENT_LENGTHt ,t httpst ont HTTPSN( i i ( Rd Re (1 t urlparset urlsplitt patht urllibt unquotet endswitht posixpatht normpatht servert server_addressR R9 RB t gett
ValueErrorR: t LimitedLengthFileR
R? R R R1 t client_addresst syst stderrR6 R; t commandt strt request_versiont wsgi_environt lookup_addressest
startswithRJ R` t worker_trackert threadt get_identt itemst replacet uppert joint
getheaderst
isinstancet dictRK t updateR4 R3 ( R t environt schemet netlocRl t queryt fragmentt endslasht server_namet server_portR t content_lengtht remote_addresst address_stringRF RG t key( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyt
wsgi_setup� s� !
!!
& c C s d S( s�
Override this if you're interested in socket exceptions, such
as when the user clicks 'Cancel' during a file download.
N( ( R t exceR� ( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyt wsgi_connection_drop s c C s
| j | � y� | j j | j | j � } z; x | D] } | j | � q5 W| j se | j d � n Wd t | d � r� | j � n d } XWnv t
j k
r� } | j | | � d S| j s� d } d d d t
t | � � f g f | _ | j d � n � n Xd S(
s;
Invoke the server's ``wsgi_application``.
RR NR s Internal Server Error
s 500 Internal Server Errors Content-types
text/plains Content-length( s Content-types
text/plain( R� Rr t wsgi_applicationR} RN RI R3 R R RJ t sockett errorR� R{ t lenR4 ( R R� t resultR@ R� t error_msg( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyt wsgi_execute s.
!N( R& R' R( R6 R~ R+ R, R0 RI RJ RN R� R� R� ( ( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyR U s " d ( t SSLt tsafet SecureHTTPServerc B s e Z d d d � Z RS( c C sC | s t d � � t j | | | � | r? | j j | � n d S( Ns pyOpenSSL not installed( RK R R R� t listen( R Rs t RequestHandlerClasst ssl_contextt request_queue_size( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyR D s N( R& R' RJ R ( ( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyR� C s t
_ConnFixerc B s) e Z d Z d � Z d � Z d � Z RS( s5 wraps a socket connection so it implements makefile c C s
| | _ d S( N( t _ConnFixer__conn( R t conn( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyR N s c C s t j | j | | � S( N( R� t _fileobjectR� ( R R R ( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyt makefileP s c C s t | j | � S( N( R R� ( R t attrib( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyt __getattr__R s ( R& R' R( R R� R� ( ( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyR� L s c B s& e Z d Z d d d � Z d � Z RS( s�
Provides SSL server functionality on top of the BaseHTTPServer
by overriding _private_ members of Python's standard
distribution. The interface for this instance only changes by
adding a an optional ssl_context attribute to the constructor:
cntx = SSL.Context(SSL.SSLv23_METHOD)
cntx.use_privatekey_file("host.pem")
cntx.use_certificate_file("host.pem")
c C s� t j | | | � t j | j | j � | _ | | _ | rn d t j f d � � Y} | | | j � | _ n | j � | r� | j j | � n | j
� d S( Nt TSafeConnectionc B s e Z d � Z d � Z RS( c W s6 | j j � z | j j | � SWd | j j � Xd S( N( t _lockt acquiret _ssl_connt
settimeoutt release( R R) ( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyR� m s
c S s3 | j j � z | j j � SWd | j j � Xd S( N( R� R� R� t
gettimeoutR� ( R ( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyR� s s
( R& R' R� R� ( ( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyR� l s ( R R R� t address_familyt socket_typeR� R� R2 t server_bindR� t server_activate( R Rs R� R� R� R� ( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyR b s
c C s7 | j j � \ } } | j r- t | � } n | | f S( N( R� t acceptR� R� ( R R� t info( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyt get_request s N( R& R' R( RJ R R� ( ( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyR� U s c C s d d l } d d l } d d l } | j j � } | j | j j d � | j j � } | j | j d t
j � � | j d � | j
d � d | j � _ d | j � _ d | j � _ d
| j � _ | j | � | j | d � t j t j � } | j | � | j | � | S( Ni����i i i< i im t *s Dummy Certificates Untrusted Authoritys Self-Signedt md5i i�Q i�3�( t OpenSSLt timet randomt cryptot PKeyt generate_keyt TYPE_RSAt X509t set_serial_numbert randintRx t maxintt gmtime_adj_notBeforet gmtime_adj_notAftert get_subjectt CNt Ot
get_issuert
set_pubkeyt signR� t Contextt
SSLv23_METHODt use_privatekeyt use_certificate( R� R� R� t pkeyt certt ctx( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyt _auto_ssl_context� s" $
c B s3 e Z d Z d e Z d � Z d � Z d � Z RS( sy
A WSGI handler that overrides POST, GET and HEAD to delegate
requests to the server's ``wsgi_application``.
s PasteWSGIServer/c C sF | j j � | _ | j s( d | _ d S| j � s8 d S| j � d S( s� Handle a single HTTP request.
You normally don't need to override this method; see the class
__doc__ string for information on how to handle specific HTTP
commands such as GET and POST.
i N( R R t raw_requestlineR< t
parse_requestR� ( R ( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyt handle_one_request� s c C s8 y t j | � Wn t k
r3 } | j | � n Xd S( N( R t handlet SocketErrorsR� ( R R� ( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyR� � s c C s d S( sy Return the client address formatted for logging.
This is overridden so that no hostname lookup is done.
RR ( ( R ( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyR� � s ( R& R' R( t __version__R/ R� R� R� ( ( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyR � s
Rv c B s_ e Z d � Z d � Z d d � Z d � Z d d � Z d � Z d � Z d � Z
d � Z RS(
c C s@ | | _ | | _ d | _ t | j d � r< | j | _ n d S( Ni t seek( t filet lengtht _consumedR t _seekR� ( R R� R� ( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyR � s
c C s" t | j � } | d d | j S( Ni����s length=%s>( t reprR� R� ( R t base_repr( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyt __repr__� s c C si | j | j } | d k r% | } n t | | � } | s> d S| j j | � } | j t | � 7_ | S( NRR ( R� R� RJ t minR� R R� ( R R� t leftt data( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyR � s c G s] | j | j } t | � r2 t | d | � } n | j j | � } | j t | � 7_ | S( Ni ( R� R� R� R� R� R ( R R) t max_readR� ( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyR � s c C s< | j j | � } x# | D] } | j t | � 7_ q W| S( N( R� R R� R� ( R t hintR� R@ ( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyR � s
c C s | S( N( ( R ( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyt __iter__� s c C s) | j | j d k r t � n | j � S( Ni ( R� R� t
StopIterationR ( R ( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyt next� s c C s | j j | � | | _ d S( N( R� R� R� ( R t place( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyR� � s c C s* t | j d � r | j j � S| j Sd S( Nt tell( R R� R� R� ( R ( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyR� � s
N( R& R' R R� RJ R R R R� R� R� R� ( ( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyRv � s
t
ThreadPoolc B s� e Z d Z e � Z d e d d d d d d d d d d � Z d � Z d
� Z d � Z
d � Z d
� Z d � Z
d � Z d d � Z d d � Z d e d � Z RS( s0
Generic thread pool with a queue of callables to consume.
Keeps a notion of the status of its worker threads:
idle: worker thread with nothing to do
busy: worker thread doing its job
hung: worker thread that's been doing a job for too long
dying: a hung thread that has been killed, but hasn't died quite
yet.
zombie: what was a worker thread that we've tried to kill but
isn't dead yet.
At any time you can call track_threads, to get a dictionary with
these keys and lists of thread_ids that fall in that status. All
keys will be present, even if they point to emty lists.
hung threads are threads that have been busy more than
hung_thread_limit seconds. Hung threads are killed when they live
longer than kill_thread_limit seconds. A thread is then
considered dying for dying_limit seconds, if it is still alive
after that it is considered a zombie.
When there are no idle workers and a request comes in, another
worker *may* be spawned. If there are less than spawn_if_under
threads in the busy state, another thread will be spawned. So if
the limit is 5, and there are 4 hung threads and 6 busy threads,
no thread will be spawned.
When there are more than max_zombie_threads_before_die zombie
threads, a SystemExit exception will be raised, stopping the
server. Use 0 or None to never raise this exception. Zombie
threads *should* get cleaned up, but killing threads is no
necessarily reliable. This is turned off by default, since it is
only a good idea if you've deployed the server with some process
watching from above (something similar to daemontools or zdaemon).
Each worker thread only processes ``max_requests`` tasks before it
dies and replaces itself with a new worker thread.
R� id i i i, i i c
C s� | | _ | | _ | | _ t j � | _ g | _ | | _ | d k rZ t j d � } n t
| t � r{ t j | � } n | | _ | | _
t � | _ | s� | | k s� t d | | f � � t s� d } | j j d � n | | _ | | _ | | _ | | k s t d | | f � � | | _ | | _ |
| _ d | _ i | _ g | _ i | _ d | _ | st j | j � n x' t! | j � D] }
| j" d d � q�Wd S( sD
Create thread pool with `nworkers` worker threads.
s paste.httpserver.ThreadPoolsC kill_thread_limit (%s) should be higher than hung_thread_limit (%s)i sB Cannot use kill_thread_limit as ctypes/killthread is not availables5 spawn_if_under (%s) should be less than nworkers (%s)RD s Initial worker poolN(# t nworkerst max_requestst namet Queuet queuet workerst daemonRJ t loggingt getLoggerR� t
basestringt loggert error_emailR t
_worker_countRK R R� t kill_thread_limitt dying_limitt hung_thread_limitt spawn_if_undert max_zombie_threads_before_diet hung_check_periodt requests_since_last_hung_checkR� t idle_workerst
dying_threadst _last_added_new_idle_workerst atexitt registert shutdownt ranget add_worker_thread( R R� R� R� R� R R R R R R R� R� t i( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyR 0 sN
c C sk | j j d | j j � � | j r_ | j d 7_ | j | j k r_ d | _ | j � q_ n | j r�| j r�d } t j � } | j j d � xs | j
D]h } t | d � s� q� n | j j
| j d � \ } } | d
k r� | | | j k r| d 7} qq� q� W| | j k rv| j j d | | j | � t j � | _ xA t | j | � D] } | j d d � qYWq�| j j d | � n t | j
� | j k rWt | j � d
k rWt j � | j | j k rW| j j d t | j
� | j t | j � � | j j d | j � x: t t | j
� | j � D] } | j j | j � q7Wn | j j | � d
S( s)
Add a task to the queue
s Added task (%i tasks queued)i i sB No idle workers for task; checking if we need to make more workerst thread_ids= No idle tasks, and only %s busy tasks; adding %s more workersRD s Response to lack of idle workerss) No extra workers needed (%s busy workers)i s2 Culling %s extra workers (%s idle workers present)s Idle workers: %sN( NN( R� t debugR� t qsizeR R t kill_hung_threadsR R R� R� R R� Rt R RJ R R� R R
R R� R� t putt SHUTDOWN( R t taskt busyt nowt workert time_startedR� R ( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyt add_taskn sN
#
#c C s~ t d g d g d g d g d g � } t j � } x� | j D]� } t | d � sX q= n | j j | j d � \ } } | d k r� | | | j k r� | d j | � q� | d j | � q= | d j | � q= Wx� | j
j � D]� \ } \ } } | j | � s>| j
j d | � y | j
| =Wq� t k
r7q� Xq� n | | | j k re| d j | � q� | d j | � q� W| S(
sw
Return a dict summarizing the threads in the pool (as
described in the ThreadPool docstring).
t idleR t hungt dyingt zombieR s! Killed thread %s no longer aroundN( NN( R� R� R� R R� Rt R RJ R t appendR R� t
thread_existsR� R� t KeyErrorR ( R R� R R R R� R t time_killed( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyt
track_threads� s2 ' "
c C s� t d k r t d � � n t j j | � } t j | t � y | j | =Wn t k
r^ n X| j
j d | � | | j k r� | j j
| � n t j � | f | j | <| j d d | � d S( s�
Removes the worker with the given thread_id from the pool, and
replaces it with a new worker thread.
This should only be done for mis-behaving workers.
s3 Cannot kill worker; killthread/ctypes not availables Killing thread %sRD s Replacement for killed thread %sN( R RJ R5 t threadingt _activeRt t async_raiset
SystemExitR� R" R� R� R� t removeR� R R ( R R t
thread_obj( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyt kill_worker� s
c C s
| t j k S( sH
Returns true if a thread with this id is still running
( R% R& ( R R ( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyR! � s c
O sX | j j � } t j d | j d | d | d d | � } | j | j � | j � d S( Nt targetR) R* R� s worker %d( R� R� R% t Threadt worker_thread_callbackt setDaemonR� t start( R R) R* t indexR ( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyR � s
c C s | j s
d St j � } d } d } d } d } d } d } xj| j D]_} t | d � sl | d 7} qG n | j j | j d � \ } }
| d k r� | d 7} qG n | d 7} t | | | � } | | | 7} | | | j k rG | j j
d | j | | � y d d l } | j |
� } Wn0 t
� }
t j d |
� d |
j � } n X| j d t d | j d
| | d | j d | � � | j | j � | d 7} qG qG W| r�t | � | } d
| } n d } | j j d | | | | | | | | | f � | j � d S( s0
Tries to kill any hung threads
Ni R i s/ Thread %s hung (working on task for %i seconds)i����R� s Error:
%ss� Killing worker thread (id=%(thread_id)s) because it has been
working on task for %(time)s seconds (limit is %(limit)s)
Info on task:
%(info)sR� t limitR� s %.2fsecs N/Asx kill_hung_threads status: %s threads (%s working, %s idle, %s starting) ave time %s, max time %.2fsec, killed %s workers( NN( R R� R� R R� Rt R RJ t maxR� t warningt pprintt pformatt StringIOt tracebackt print_exct getvaluet notify_problemR� R+ t floatR� t check_max_zombies( R R t max_timet
total_timeR t starting_workerst working_workerst killed_workersR R R� R5 t info_desct outt ave_time( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyR � sd
c C se | j s
d Sg } t j � } x} | j j � D]l \ } \ } } | j | � sx y | j | =Wq/ t k
rq q/ Xq/ n | | | j k r/ | j | � q/ q/ W| r� | j j d | � n t
| � | j k ra| j j d t
| � | j � | j d t
d t
| � d | j d d j t t | � � � d d
�| j d � d Gt j � GHt d
� � n d S( ss
Check if we've reached max_zombie_threads_before_die; if so
then kill the entire process.
Ns Found %s zombie threadss? Exiting process because %s zombie threads is more than %s limitsm Exiting process because %(found)s zombie threads (more than limit of %(limit)s)
Bad threads (ids):
%(ids)s
t foundR2 t idss
t subjects) Process restart (too many zombie threads)i
s
Shutting downi ( R R� R R� R! R" R R R� R� R� t fatalR; R� R� t mapR{ R R% t
currentThreadt
ServerExit( R RF R R R# R ( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyR= ' s8 "
c C st t j � } t j � } | _ | j j | � | j j | � d } t } | j j
d | | � zZxSt r�| j r� | j | k r� | j j
d | | | j f � t } Pn | j
j � } | t j k r� | j j
d | � Pn y | j j | � Wn t k
r n Xt j � d g | j | <| d 7} zG y | � Wn" t j d | IJt j � n X| | j k ruPn Wd y | j | =Wn t k
r�n Xt j � X| j j | � qg WWd y | j | =Wn t k
r�n Xy | j j | � Wn t k
rn Xy | j j | � Wn t k
r/n Xy | j | =Wn t k
rQn X| ro| j d d | � n Xd S(
sd
Worker thread should call this method to get and process queued
callables.
i s Started new worker %s: %ss; Thread %s processed %i requests (limit %s); stopping threads Worker %s asked to SHUTDOWNi s! Unexpected exception in worker %rNRD s# Voluntary replacement for thread %s( R% RK R� R� R R� R R R; R� R R6 R� R� Rt R� R R) Ru R� RJ R� Rx Ry R8 R9 R R" t exc_clearR ( R RD R* R t requests_processedt add_replacement_workert runnable( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyR. M sr
c C sw | j j d � x0 t t | j � � D] } | j j t j � q& Wg } x: | j D]/ } | j d � | j
� rS | j | � qS qS Wg } x0 | j D]% } | j
| � r� | j | � q� q� W| s� | rc| j j d t | � t | � � | r'x | D] } | j | j � q� W| j j d � n | rsg } t } t | � } xX | j D]M }
| r~| j
� r~t } | j | � n | j
� rOd | GHt } qOqOW| rMd d l } xy t | j � D]h } t | d d d � }
|
s�q�n t |
d
i � } | j d � } | d k r�| j j | � q�q�W| j � d
GHt j d � q`| j j d � qsn | j j d � d S( sL
Shutdown the queue (after finishing any pending requests).
s Shutting down threadpoolg �?s/ %s workers didn't stop properly, and %s zombiess Workers killed forcefullys Worker %s won't diei����Ni t im_funct func_globalsR& R% s Forcefully exiting processi s All workers eventually killeds All workers stopped( R� R� R
R� R� R� R R� R R� t isAliveR R R! R+ R R; t boolR6 R
t listt
_exithandlersR RJ Rt R) t _run_exitfuncst ost _exit( R t force_quit_timeoutR t hung_workersR t zombiesR R t timed_outt need_force_quitR� R
t callbackt funct globst mod( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyR � sZ
c
C s� | j s
d S| rE t j d | j d | | t f � } | j � d Sd } | s~ | j � j � d } | d } d | } n d | j d | d
| g } y d j t j
� � } Wn
d } n Xd
t d | d t j
d � d t j � d | d t j j t � � } d j | � d | } d d l }
|
j d � } g | j j d � D] } | j � rP| j � ^ qP}
| j | |
| � | j � d G|
G| GHd S( s�
Called when there's a substantial problem. msg contains the
body of the notification, subject the summary.
If spawn_thread is true, then the email will be send in
another thread (so this doesn't block).
NR, R) s errors@localhosti i2 s [http threadpool] %ss To: %ss From: %ss Subject: %sR- s (unknown)s� An error has occurred in the paste.httpserver.ThreadPool
Error:
%(msg)s
Occurred at: %(time)s
PID: %(pid)s
System: %(system)s
Server .py file: %(file)s
t msgR� s %ct pidt systemR� s
s
i����t localhostRf s
email sent to( R� R% R- R; R; R0 t stript
splitlinesR� RX t unameR� R� t strftimet getpidRl t abspatht __file__t smtplibt SMTPR7 t sendmailt quit( R Rc RH t spawn_threadt tt from_addressRB Re t bodyRD Rn Rr t et error_emails( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyR; � sD
N( R& R' R( t objectR R; RJ R R R$ R+ R! R R R= R. R R6 R; ( ( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyR� � s, , 4 1 % ? & G 7t ThreadPoolMixInc B sP e Z d Z e d � Z d � Z d � Z d � Z d � Z d � Z d � Z
RS( s=
Mix-in class to process requests from a thread pool
c K sM t | _ | d k s! t d � � t | d | j | j f | | � | _ d S( Ni s5 ThreadPoolMixIn servers must have at least one workers$ ThreadPoolMixIn HTTP server on %s:%d( R6 t runningRK R� R� R� R` ( R R� R� t threadpool_options( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyR s c s0 � j d � � j j � � � f d � � d S( sT
Queue the request to be processed by on of the thread pool threads
i c s � j � � � S( N( t process_request_in_thread( ( Rw t requestR ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyt <lambda> s N( t setblockingR` R ( R R} Rw ( ( Rw R} R sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyt process_request s
c C s@ t j � \ } } } | t k r' � n t t | � j | | � S( N( Rx RM RL t superRy t handle_error( R R} Rw t exc_classt exct tb( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyR� s c C sw y! | j | | � | j | � WnO | j | | � | j | � t j � d } t | t t f � rs � qs n Xd S( s�
The worker thread should call back here to do the rest of the
request processing. Error handling normaller done in 'handle_request'
must be done here.
i N( t finish_requestt
close_requestR� Rx RM R� t MemoryErrort KeyboardInterrupt( R R} Rw R� ( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyR| $ s
c C sN z9 x2 | j r7 y | j � Wq t j k
r3 q Xq WWd | j j � Xd S( sP
Overrides `serve_forever` to shut the threadpool down cleanly.
N( Rz t handle_requestR� t timeoutR` R ( R ( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyt
serve_forever4 s c C s | j j d � d S( sR
Overrides server_activate to set timeout on our listener socket.
i N( R� R� ( R ( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyR� C s c C s* t | _ | j j � | j j d � d S( sB
Finish pending requests and shutdown the server.
i< N( R; Rz R� R R` R ( R ( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyt server_closeJ s
( R& R' R( R; R R� R� R| R� R� R� ( ( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyRy s
t WSGIServerBasec B s# e Z d d d d � Z d � Z RS( c C s2 t j | | | | d | �| | _ d | _ d S( NR� ( R� R R� RJ t wsgi_socket_timeout( R R� Rs R� R� R� ( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyR S s
c C s; t j | � \ } } | j r1 | j | j � n | | f S( N( R� R� R� R� ( R R� R� ( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyR� \ s N( R& R' RJ R R� ( ( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyR� R s c B s e Z e Z RS( ( R& R' R; t daemon_threads( ( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyR c s t WSGIThreadPoolServerc B s# e Z d d d e d d d � Z RS( i
c C sN t j | | | | | d | �| d k r4 i } n t j | | | | � d S( NR� ( R� R RJ Ry ( R R� Rs R� R� R� R� R{ R� ( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyR g s N( R& R' RJ R; R ( ( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyR� f s RL c B s e Z d Z RS( sV
Raised to tell the server to really exit (SystemExit is normally
caught)
( R& R' R( ( ( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyRL s s i
i c C s] t } | s | r� t s$ t d � � t } t | p6 d � } | s� | d k rZ t � } q� t j t j � } | j | � | j | � q� n | p� d } | d k r� d | k r� | j d d � \ } } q� d } n | t | � f } | s� t } n | r| | _
d | _ n | r4| d k s(t � | | _ n | d k rIt } n t j | � r�t | | | | t | � | d |
d | �} n- t | | | | d | �} | r�| | _ n |
r�t |
� | _ n t j | � rY| r�d
p�d } | j d \ } } | d k r"d | | | f GHn d | | | f GHy | j � WqYt k
rUqYXn | S( sc
Serves your ``application`` over HTTP(S) via WSGI interface
``host``
This is the ipaddress to bind to (or a hostname if your
nameserver is properly configured). This defaults to
127.0.0.1, which is not a public interface.
``port``
The port to run on, defaults to 8080 for HTTP, or 4443 for
HTTPS. This can be a string or an integer value.
``handler``
This is the HTTP request handler to use, it defaults to
``WSGIHandler`` in this module.
``ssl_pem``
This an optional SSL certificate file (via OpenSSL). You can
supply ``*`` and a development-only certificate will be
created for you, or you can generate a self-signed test PEM
certificate file as follows::
$ openssl genrsa 1024 > host.key
$ chmod 400 host.key
$ openssl req -new -x509 -nodes -sha1 -days 365 \
-key host.key > host.cert
$ cat host.cert host.key > host.pem
$ chmod 400 host.pem
``ssl_context``
This an optional SSL context object for the server. A SSL
context will be automatically constructed for you if you supply
``ssl_pem``. Supply this to use a context of your own
construction.
``server_version``
The version of the server as reported in HTTP response line. This
defaults to something like "PasteWSGIServer/0.5". Many servers
hide their code-base identity with a name like 'Amnesiac/1.0'
``protocol_version``
This sets the protocol used by the server, by default
``HTTP/1.0``. There is some support for ``HTTP/1.1``, which
defaults to nicer keep-alive connections. This server supports
``100 Continue``, but does not yet support HTTP/1.1 Chunked
Encoding. Hence, if you use HTTP/1.1, you're somewhat in error
since chunked coding is a mandatory requirement of a HTTP/1.1
server. If you specify HTTP/1.1, every response *must* have a
``Content-Length`` and you must be careful not to read past the
end of the socket.
``start_loop``
This specifies if the server loop (aka ``server.serve_forever()``)
should be called; it defaults to ``True``.
``daemon_threads``
This flag specifies if when your webserver terminates all
in-progress client connections should be droppped. It defaults
to ``False``. You might want to set this to ``True`` if you
are using ``HTTP/1.1`` and don't set a ``socket_timeout``.
``socket_timeout``
This specifies the maximum amount of time that a connection to a
given client will be kept open. At this time, it is a rude
disconnect, but at a later time it might follow the RFC a bit
more closely.
``use_threadpool``
Server requests from a pool of worker threads (``threadpool_workers``)
rather than creating a new thread for each request. This can
substantially reduce latency since there is a high cost associated
with thread creation.
``threadpool_workers``
Number of worker threads to create when ``use_threadpool`` is true. This
can be a string or an integer value.
``threadpool_options``
A dictionary of options to be used when instantiating the
threadpool. See paste.httpserver.ThreadPool for specific
options (``threadpool_workers`` is a specific option that can
also go here).
``request_queue_size``
The 'backlog' argument to socket.listen(); specifies the
maximum number of queued connections.
s pyOpenSSL is not installedi[ R� s 127.0.0.1t :i i� s HTTP/0.9s HTTP/1.0s HTTP/1.1R{ R� Rg RT i s 0.0.0.0s/ serving on 0.0.0.0:%s view at %s://127.0.0.1:%ss serving on %s://%s:%sN( s HTTP/0.9s HTTP/1.0s HTTP/1.1( R; R� RK R6 R9 R� R� R� t use_privatekey_filet use_certificate_chain_fileRJ R7 R R/ R. t protocol_versionR t asboolR� R R� R� Rs R� R� ( t applicationt hostt portt handlert ssl_pemR� R/ R� t
start_loopR� t socket_timeoutt use_threadpoolt threadpool_workersR{ R� t is_sslRs Rr t protocol( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyR y sf k
c K s? d d l m } xR d d d d d d d d
d d d
g D]) } | | k r8 t | | � | | <q8 q8 Wx7 d d g D]) } | | k rr | | | � | | <qr qr Wi } xS | j � D]E \ } } | j d � r� | d k r� | | | t d � <| | =q� q� Wd | k r$d | k r$| d | d <n | | d <t | | � d S( Ni����( R� R� R� R� t threadpool_hung_thread_limitt threadpool_kill_thread_limitt threadpool_dying_limitt threadpool_spawn_if_undert( threadpool_max_zombie_threads_before_diet threadpool_hung_check_periodt threadpool_max_requestsR� R� R� t threadpool_R� R{ ( t paste.deploy.convertersR� R9 R� R R� R ( t wsgi_appt global_confR* R� R� R{ t value( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyt
server_runner& s.
RR s
You can also set these threadpool options:
``threadpool_max_requests``:
The maximum number of requests a worker thread will process
before dying (and replacing itself with a new worker thread).
Default 100.
``threadpool_hung_thread_limit``:
The number of seconds a thread can work on a task before it is
considered hung (stuck). Default 30 seconds.
``threadpool_kill_thread_limit``:
The number of seconds a thread can work before you should kill it
(assuming it will never finish). Default 600 seconds (10 minutes).
``threadpool_dying_limit``:
The length of time after killing a thread that it should actually
disappear. If it lives longer than this, it is considered a
"zombie". Note that even in easy situations killing a thread can
be very slow. Default 300 seconds (5 minutes).
``threadpool_spawn_if_under``:
If there are no idle threads and a request comes in, and there are
less than this number of *busy* threads, then add workers to the
pool. Busy threads are threads that have taken less than
``threadpool_hung_thread_limit`` seconds so far. So if you get
*lots* of requests but they complete in a reasonable amount of time,
the requests will simply queue up (adding more threads probably
wouldn't speed them up). But if you have lots of hung threads and
one more request comes in, this will add workers to handle it.
Default 5.
``threadpool_max_zombie_threads_before_die``:
If there are more zombies than this, just kill the process. This is
only good if you have a monitor that will automatically restart
the server. This can clean up the mess. Default 0 (disabled).
`threadpool_hung_check_period``:
Every X requests, check for hung threads that need to be killed,
or for zombie threads that should cause a restart. Default 100
requests.
``threadpool_logger``:
Logging messages will go the logger named here.
``threadpool_error_email`` (or global ``error_email`` setting):
When threads are killed or the process restarted, this email
address will be contacted (using an SMTP server on localhost).
t __main__( t dump_environR/ s Wombles/1.0R� s HTTP/1.1R� t 8888(8 R( R
R8 R� Rx R% Rj R� Rm Rp R� R� RX t itertoolsR t BaseHTTPServerR R t SocketServerR t
paste.utilR R� R t ImportErrorRJ t __all__R� Rx R
R R� R� R� R� t ZeroReturnErrort SysCallErrorR� R� R� R� R Rv R� Ry R� R R� R( RL R6 R R� R& t
paste.wsgilibR� ( ( ( sA /opt/alt/python27/lib/python2.7/site-packages/paste/httpserver.pyt <module> sh H
,�
3 %;� � Q
� <
Mini Shell