Gecko [ emad.team ]

Name	Size	Permission	Date
auth	[ DIR ]	drwxr-xr-x	2022-08-06 15:50
cowbell	[ DIR ]	drwxr-xr-x	2022-08-06 15:50
debug	[ DIR ]	drwxr-xr-x	2022-08-06 15:50
evalexception	[ DIR ]	drwxr-xr-x	2022-08-06 15:50
exceptions	[ DIR ]	drwxr-xr-x	2022-08-06 15:50
util	[ DIR ]	drwxr-xr-x	2022-08-06 15:50
cascade.py	4.4 KB	-rw-r--r--	2011-12-21 20:42
cascade.pyc	4.23 KB	-rw-r--r--	2014-09-17 20:43
cascade.pyo	4.23 KB	-rw-r--r--	2014-09-17 20:43
cgiapp.py	9.37 KB	-rw-r--r--	2011-12-21 20:42
cgiapp.pyc	8.08 KB	-rw-r--r--	2014-09-17 20:43
cgiapp.pyo	7.87 KB	-rw-r--r--	2014-09-17 20:43
cgitb_catcher.py	3.66 KB	-rw-r--r--	2011-12-21 20:42
cgitb_catcher.pyc	3.64 KB	-rw-r--r--	2014-09-17 20:43
cgitb_catcher.pyo	3.64 KB	-rw-r--r--	2014-09-17 20:43
config.py	4.21 KB	-rw-r--r--	2011-12-21 20:42
config.pyc	4.99 KB	-rw-r--r--	2014-09-17 20:43
config.pyo	4.99 KB	-rw-r--r--	2014-09-17 20:43
errordocument.py	13.45 KB	-rw-r--r--	2011-12-21 20:42
errordocument.pyc	12.47 KB	-rw-r--r--	2014-09-17 20:43
errordocument.pyo	12.47 KB	-rw-r--r--	2014-09-17 20:43
fileapp.py	13.29 KB	-rw-r--r--	2011-12-21 20:42
fileapp.pyc	12.6 KB	-rw-r--r--	2014-09-17 20:43
fileapp.pyo	12.48 KB	-rw-r--r--	2014-09-17 20:43
fixture.py	56.63 KB	-rw-r--r--	2014-09-17 20:43
fixture.py.stdlib	56.71 KB	-rw-r--r--	2011-12-21 20:42
fixture.pyc	57.42 KB	-rw-r--r--	2014-09-17 20:43
fixture.pyo	55.18 KB	-rw-r--r--	2014-09-17 20:43
flup_session.py	3.85 KB	-rw-r--r--	2011-12-21 20:42
flup_session.pyc	3.77 KB	-rw-r--r--	2014-09-17 20:43
flup_session.pyo	3.77 KB	-rw-r--r--	2014-09-17 20:43
gzipper.py	3.61 KB	-rw-r--r--	2011-12-21 20:42
gzipper.pyc	4.28 KB	-rw-r--r--	2014-09-17 20:43
gzipper.pyo	4.28 KB	-rw-r--r--	2014-09-17 20:43
httpexceptions.py	23.65 KB	-rw-r--r--	2011-12-21 20:42
httpexceptions.pyc	26.94 KB	-rw-r--r--	2014-09-17 20:43
httpexceptions.pyo	26.2 KB	-rw-r--r--	2014-09-17 20:43
httpheaders.py	42.08 KB	-rw-r--r--	2011-12-21 20:42
httpheaders.pyc	43.1 KB	-rw-r--r--	2014-09-17 20:43
httpheaders.pyo	41.88 KB	-rw-r--r--	2014-09-17 20:43
httpserver.py	54.36 KB	-rw-r--r--	2011-12-21 20:42
httpserver.pyc	46.26 KB	-rw-r--r--	2014-09-17 20:43
httpserver.pyo	45.61 KB	-rw-r--r--	2014-09-17 20:43
lint.py	14.65 KB	-rw-r--r--	2011-12-21 20:42
lint.pyc	16.94 KB	-rw-r--r--	2014-09-17 20:43
lint.pyo	12.91 KB	-rw-r--r--	2014-09-17 20:43
modpython.py	7.79 KB	-rw-r--r--	2011-12-21 20:42
modpython.pyc	8.44 KB	-rw-r--r--	2014-09-17 20:43
modpython.pyo	8.44 KB	-rw-r--r--	2014-09-17 20:43
pony.py	2.23 KB	-rw-r--r--	2011-12-21 20:42
pony.pyc	2.62 KB	-rw-r--r--	2014-09-17 20:43
pony.pyo	2.62 KB	-rw-r--r--	2014-09-17 20:43
progress.py	7.97 KB	-rw-r--r--	2011-12-21 20:42
progress.pyc	8.93 KB	-rw-r--r--	2014-09-17 20:43
progress.pyo	8.93 KB	-rw-r--r--	2014-09-17 20:43
proxy.py	9.94 KB	-rw-r--r--	2011-12-21 20:42
proxy.pyc	8.33 KB	-rw-r--r--	2014-09-17 20:43
proxy.pyo	8.33 KB	-rw-r--r--	2014-09-17 20:43
recursive.py	14.32 KB	-rw-r--r--	2011-12-21 20:42
recursive.pyc	17.1 KB	-rw-r--r--	2014-09-17 20:43
recursive.pyo	16.79 KB	-rw-r--r--	2014-09-17 20:43
registry.py	21.67 KB	-rw-r--r--	2011-12-21 20:42
registry.pyc	21.76 KB	-rw-r--r--	2014-09-17 20:43
registry.pyo	21.76 KB	-rw-r--r--	2014-09-17 20:43
reloader.py	5.87 KB	-rw-r--r--	2011-12-21 20:42
reloader.pyc	5.82 KB	-rw-r--r--	2014-09-17 20:43
reloader.pyo	5.82 KB	-rw-r--r--	2014-09-17 20:43
request.py	13.81 KB	-rw-r--r--	2011-12-21 20:42
request.pyc	13.33 KB	-rw-r--r--	2014-09-17 20:43
request.pyo	13.24 KB	-rw-r--r--	2014-09-17 20:43
response.py	7.48 KB	-rw-r--r--	2011-12-21 20:42
response.pyc	8.9 KB	-rw-r--r--	2014-09-17 20:43
response.pyo	8.82 KB	-rw-r--r--	2014-09-17 20:43
session.py	11.07 KB	-rw-r--r--	2011-12-21 20:42
session.pyc	11.34 KB	-rw-r--r--	2014-09-17 20:43
session.pyo	11.34 KB	-rw-r--r--	2014-09-17 20:43
transaction.py	4.26 KB	-rw-r--r--	2011-12-21 20:42
transaction.pyc	5.49 KB	-rw-r--r--	2014-09-17 20:43
transaction.pyo	5.49 KB	-rw-r--r--	2014-09-17 20:43
translogger.py	4.7 KB	-rw-r--r--	2011-12-21 20:42
translogger.pyc	4.15 KB	-rw-r--r--	2014-09-17 20:43
translogger.pyo	4.15 KB	-rw-r--r--	2014-09-17 20:43
url.py	14.28 KB	-rw-r--r--	2011-12-21 20:42
url.pyc	17.29 KB	-rw-r--r--	2014-09-17 20:43
url.pyo	17.29 KB	-rw-r--r--	2014-09-17 20:43
urlmap.py	8.82 KB	-rw-r--r--	2011-12-21 20:42
urlmap.pyc	9.15 KB	-rw-r--r--	2014-09-17 20:43
urlmap.pyo	9.01 KB	-rw-r--r--	2014-09-17 20:43
urlparser.py	25.8 KB	-rw-r--r--	2011-12-21 20:42
urlparser.pyc	21.52 KB	-rw-r--r--	2014-09-17 20:43
urlparser.pyo	21.34 KB	-rw-r--r--	2014-09-17 20:43
wsgilib.py	19.66 KB	-rw-r--r--	2011-12-21 20:42
wsgilib.pyc	20.91 KB	-rw-r--r--	2014-09-17 20:43
wsgilib.pyo	20.86 KB	-rw-r--r--	2014-09-17 20:43
wsgiwrappers.py	21.65 KB	-rw-r--r--	2011-12-21 20:42
wsgiwrappers.pyc	23.21 KB	-rw-r--r--	2014-09-17 20:43
wsgiwrappers.pyo	23.21 KB	-rw-r--r--	2014-09-17 20:43

Rename

# (c) 2005 Ian Bicking and contributors; written for Paste (http://pythonpaste.org)
# Licensed under the MIT license: http://www.opensource.org/licenses/mit-license.php
# (c) 2005 Clark C. Evans
# This module is part of the Python Paste Project and is released under
# the MIT License: http://www.opensource.org/licenses/mit-license.php
# This code was written with funding by http://prometheusresearch.com
"""
Upload Progress Monitor

This is a WSGI middleware component which monitors the status of files
being uploaded.  It includes a small query application which will return
a list of all files being uploaded by particular session/user.

>>> from paste.httpserver import serve
>>> from paste.urlmap import URLMap
>>> from paste.auth.basic import AuthBasicHandler
>>> from paste.debug.debugapp import SlowConsumer, SimpleApplication
>>> # from paste.progress import *
>>> realm = 'Test Realm'
>>> def authfunc(username, password):
...     return username == password
>>> map = URLMap({})
>>> ups = UploadProgressMonitor(map, threshold=1024)
>>> map['/upload'] = SlowConsumer()
>>> map['/simple'] = SimpleApplication()
>>> map['/report'] = UploadProgressReporter(ups)
>>> serve(AuthBasicHandler(ups, realm, authfunc))
serving on...

.. note::

This is experimental, and will change in the future.
"""
import time
from paste.wsgilib import catch_errors

DEFAULT_THRESHOLD = 1024 * 1024  # one megabyte
DEFAULT_TIMEOUT   = 60*5         # five minutes
ENVIRON_RECEIVED  = 'paste.bytes_received'
REQUEST_STARTED   = 'paste.request_started'
REQUEST_FINISHED  = 'paste.request_finished'

class _ProgressFile(object):
    """
    This is the input-file wrapper used to record the number of
    ``paste.bytes_received`` for the given request.
    """

def __init__(self, environ, rfile):
        self._ProgressFile_environ = environ
        self._ProgressFile_rfile   = rfile
        self.flush = rfile.flush
        self.write = rfile.write
        self.writelines = rfile.writelines

def __iter__(self):
        environ = self._ProgressFile_environ
        riter = iter(self._ProgressFile_rfile)
        def iterwrap():
            for chunk in riter:
                environ[ENVIRON_RECEIVED] += len(chunk)
                yield chunk
        return iter(iterwrap)

def read(self, size=-1):
        chunk = self._ProgressFile_rfile.read(size)
        self._ProgressFile_environ[ENVIRON_RECEIVED] += len(chunk)
        return chunk

def readline(self):
        chunk = self._ProgressFile_rfile.readline()
        self._ProgressFile_environ[ENVIRON_RECEIVED] += len(chunk)
        return chunk

def readlines(self, hint=None):
        chunk = self._ProgressFile_rfile.readlines(hint)
        self._ProgressFile_environ[ENVIRON_RECEIVED] += len(chunk)
        return chunk

class UploadProgressMonitor(object):
    """
    monitors and reports on the status of uploads in progress

Parameters:

``application``

This is the next application in the WSGI stack.

``threshold``

This is the size in bytes that is needed for the
            upload to be included in the monitor.

``timeout``

This is the amount of time (in seconds) that a upload
            remains in the monitor after it has finished.

Methods:

``uploads()``

This returns a list of ``environ`` dict objects for each
            upload being currently monitored, or finished but whose time
            has not yet expired.

For each request ``environ`` that is monitored, there are several
    variables that are stored:

``paste.bytes_received``

This is the total number of bytes received for the given
            request; it can be compared with ``CONTENT_LENGTH`` to
            build a percentage complete.  This is an integer value.

``paste.request_started``

This is the time (in seconds) when the request was started
            as obtained from ``time.time()``.  One would want to format
            this for presentation to the user, if necessary.

``paste.request_finished``

This is the time (in seconds) when the request was finished,
            canceled, or otherwise disconnected.  This is None while
            the given upload is still in-progress.

TODO: turn monitor into a queue and purge queue of finished
          requests that have passed the timeout period.
    """
    def __init__(self, application, threshold=None, timeout=None):
        self.application = application
        self.threshold = threshold or DEFAULT_THRESHOLD
        self.timeout   = timeout   or DEFAULT_TIMEOUT
        self.monitor   = []

def __call__(self, environ, start_response):
        length = environ.get('CONTENT_LENGTH', 0)
        if length and int(length) > self.threshold:
            # replace input file object
            self.monitor.append(environ)
            environ[ENVIRON_RECEIVED] = 0
            environ[REQUEST_STARTED] = time.time()
            environ[REQUEST_FINISHED] = None
            environ['wsgi.input'] = \
                _ProgressFile(environ, environ['wsgi.input'])
            def finalizer(exc_info=None):
                environ[REQUEST_FINISHED] = time.time()
            return catch_errors(self.application, environ,
                       start_response, finalizer, finalizer)
        return self.application(environ, start_response)

def uploads(self):
        return self.monitor

class UploadProgressReporter(object):
    """
    reports on the progress of uploads for a given user

This reporter returns a JSON file (for use in AJAX) listing the
    uploads in progress for the given user.  By default, this reporter
    uses the ``REMOTE_USER`` environment to compare between the current
    request and uploads in-progress.  If they match, then a response
    record is formed.

``match()``

This member function can be overriden to provide alternative
            matching criteria.  It takes two environments, the first
            is the current request, the second is a current upload.

``report()``

This member function takes an environment and builds a
            ``dict`` that will be used to create a JSON mapping for
            the given upload.  By default, this just includes the
            percent complete and the request url.

"""
    def __init__(self, monitor):
        self.monitor   = monitor

def match(self, search_environ, upload_environ):
        if search_environ.get('REMOTE_USER', None) == \
           upload_environ.get('REMOTE_USER', 0):
            return True
        return False

def report(self, environ):
        retval = { 'started': time.strftime("%Y-%m-%d %H:%M:%S",
                                time.gmtime(environ[REQUEST_STARTED])),
                   'finished': '',
                   'content_length': environ.get('CONTENT_LENGTH'),
                   'bytes_received': environ[ENVIRON_RECEIVED],
                   'path_info': environ.get('PATH_INFO',''),
                   'query_string': environ.get('QUERY_STRING','')}
        finished = environ[REQUEST_FINISHED]
        if finished:
            retval['finished'] = time.strftime("%Y:%m:%d %H:%M:%S",
                                               time.gmtime(finished))
        return retval

def __call__(self, environ, start_response):
        body = []
        for map in [self.report(env) for env in self.monitor.uploads()
                                             if self.match(environ, env)]:
            parts = []
            for k, v in map.items():
                v = str(v).replace("\\", "\\\\").replace('"', '\\"')
                parts.append('%s: "%s"' % (k, v))
            body.append("{ %s }" % ", ".join(parts))
        body = "[ %s ]" % ", ".join(body)
        start_response("200 OK", [('Content-Type', 'text/plain'),
                                  ('Content-Length', len(body))])
        return [body]

__all__ = ['UploadProgressMonitor', 'UploadProgressReporter']

if "__main__" == __name__:
    import doctest
    doctest.testmod(optionflags=doctest.ELLIPSIS)