223 lines
8.0 KiB
Python
223 lines
8.0 KiB
Python
# (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)
|