File Manager

Hackfut Security File Manager

Current Path: /opt/alt/python27/lib/python2.7/site-packages/paste

opt / alt / python27 / lib / python2.7 / site-packages / paste /

📁 ..
📁 auth
📄 cascade.py(4.4 KB)
📄 cascade.pyc(4.37 KB)
📄 cascade.pyo(4.37 KB)
📄 cgiapp.py(9.37 KB)
📄 cgiapp.pyc(8.35 KB)
📄 cgiapp.pyo(8.14 KB)
📄 cgitb_catcher.py(3.66 KB)
📄 cgitb_catcher.pyc(3.76 KB)
📄 cgitb_catcher.pyo(3.76 KB)
📄 config.py(4.21 KB)
📄 config.pyc(5.16 KB)
📄 config.pyo(5.16 KB)
📁 cowbell
📁 debug
📄 errordocument.py(13.45 KB)
📄 errordocument.pyc(12.77 KB)
📄 errordocument.pyo(12.77 KB)
📁 evalexception
📁 exceptions
📄 fileapp.py(13.29 KB)
📄 fileapp.pyc(13.04 KB)
📄 fileapp.pyo(12.91 KB)
📄 fixture.py(56.63 KB)
📄 fixture.py.stdlib(56.71 KB)
📄 fixture.pyc(59.3 KB)
📄 fixture.pyo(57.08 KB)
📄 flup_session.py(3.85 KB)
📄 flup_session.pyc(3.87 KB)
📄 flup_session.pyo(3.87 KB)
📄 gzipper.py(3.61 KB)
📄 gzipper.pyc(4.47 KB)
📄 gzipper.pyo(4.47 KB)
📄 httpexceptions.py(23.65 KB)
📄 httpexceptions.pyc(27.71 KB)
📄 httpexceptions.pyo(26.98 KB)
📄 httpheaders.py(42.08 KB)
📄 httpheaders.pyc(44.21 KB)
📄 httpheaders.pyo(42.94 KB)
📄 httpserver.py(54.36 KB)
📄 httpserver.pyc(47.52 KB)
📄 httpserver.pyo(46.87 KB)
📄 lint.py(14.65 KB)
📄 lint.pyc(17.47 KB)
📄 lint.pyo(13.45 KB)
📄 modpython.py(7.79 KB)
📄 modpython.pyc(8.74 KB)
📄 modpython.pyo(8.74 KB)
📄 pony.py(2.23 KB)
📄 pony.pyc(2.69 KB)
📄 pony.pyo(2.69 KB)
📄 progress.py(7.97 KB)
📄 progress.pyc(9.2 KB)
📄 progress.pyo(9.2 KB)
📄 proxy.py(9.94 KB)
📄 proxy.pyc(8.58 KB)
📄 proxy.pyo(8.58 KB)
📄 recursive.py(14.32 KB)
📄 recursive.pyc(17.72 KB)
📄 recursive.pyo(17.4 KB)
📄 registry.py(21.67 KB)
📄 registry.pyc(22.4 KB)
📄 registry.pyo(22.4 KB)
📄 reloader.py(5.87 KB)
📄 reloader.pyc(5.99 KB)
📄 reloader.pyo(5.99 KB)
📄 request.py(13.81 KB)
📄 request.pyc(13.74 KB)
📄 request.pyo(13.64 KB)
📄 response.py(7.48 KB)
📄 response.pyc(9.25 KB)
📄 response.pyo(9.16 KB)
📄 session.py(11.07 KB)
📄 session.pyc(11.77 KB)
📄 session.pyo(11.77 KB)
📄 transaction.py(4.26 KB)
📄 transaction.pyc(5.72 KB)
📄 transaction.pyo(5.72 KB)
📄 translogger.py(4.7 KB)
📄 translogger.pyc(4.27 KB)
📄 translogger.pyo(4.27 KB)
📄 url.py(14.28 KB)
📄 url.pyc(18.15 KB)
📄 url.pyo(18.15 KB)
📄 urlmap.py(8.82 KB)
📄 urlmap.pyc(9.54 KB)
📄 urlmap.pyo(9.4 KB)
📄 urlparser.py(25.8 KB)
📄 urlparser.pyc(22.14 KB)
📄 urlparser.pyo(21.97 KB)
📁 util
📄 wsgilib.py(19.66 KB)
📄 wsgilib.pyc(21.71 KB)
📄 wsgilib.pyo(21.66 KB)
📄 wsgiwrappers.py(21.65 KB)
📄 wsgiwrappers.pyc(23.88 KB)
📄 wsgiwrappers.pyo(23.88 KB)

Editing: flup_session.py

# (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

"""
Creates a session object.

In your application, use::

environ['paste.flup_session_service'].session

This will return a dictionary.  The contents of this dictionary will
be saved to disk when the request is completed.  The session will be
created when you first fetch the session dictionary, and a cookie will
be sent in that case.  There's current no way to use sessions without
cookies, and there's no way to delete a session except to clear its
data.
"""

from paste import httpexceptions
from paste import wsgilib
import flup.middleware.session
flup_session = flup.middleware.session

# This is a dictionary of existing stores, keyed by a tuple of
# store type and parameters
store_cache = {}

class NoDefault(object):
    pass

class SessionMiddleware(object):

session_classes = {
        'memory': (flup_session.MemorySessionStore,
                   [('session_timeout', 'timeout', int, 60)]),
        'disk': (flup_session.DiskSessionStore,
                 [('session_timeout', 'timeout', int, 60),
                  ('session_dir', 'storeDir', str, '/tmp/sessions')]),
        'shelve': (flup_session.ShelveSessionStore,
                   [('session_timeout', 'timeout', int, 60),
                    ('session_file', 'storeFile', str,
                     '/tmp/session.shelve')]),
        }

def __init__(self, app,
                 global_conf=None,
                 session_type=NoDefault,
                 cookie_name=NoDefault,
                 **store_config
                 ):
        self.application = app
        if session_type is NoDefault:
            session_type = global_conf.get('session_type', 'disk')
        self.session_type = session_type
        try:
            self.store_class, self.store_args = self.session_classes[self.session_type]
        except KeyError:
            raise KeyError(
                "The session_type %s is unknown (I know about %s)"
                % (self.session_type,
                   ', '.join(self.session_classes.keys())))
        kw = {}
        for config_name, kw_name, coercer, default in self.store_args:
            value = coercer(store_config.get(config_name, default))
            kw[kw_name] = value
        self.store = self.store_class(**kw)
        if cookie_name is NoDefault:
            cookie_name = global_conf.get('session_cookie', '_SID_')
        self.cookie_name = cookie_name
        
    def __call__(self, environ, start_response):
        service = flup_session.SessionService(
            self.store, environ, cookieName=self.cookie_name,
            fieldName=self.cookie_name)
        environ['paste.flup_session_service'] = service

def cookie_start_response(status, headers, exc_info=None):
            service.addCookie(headers)
            return start_response(status, headers, exc_info)

try:
            app_iter = self.application(environ, cookie_start_response)
        except httpexceptions.HTTPException, e:
            headers = (e.headers or {}).items()
            service.addCookie(headers)
            e.headers = dict(headers)
            service.close()
            raise
        except:
            service.close()
            raise

return wsgilib.add_close(app_iter, service.close)
            
def make_session_middleware(app, global_conf,
                            session_type=NoDefault,
                            cookie_name=NoDefault,
                            **store_config):
    """
    Wraps the application in a session-managing middleware.
    The session service can then be found in
    ``environ['paste.flup_session_service']``
    """
    return SessionMiddleware(
        app, global_conf=global_conf,
        session_type=session_type, cookie_name=cookie_name,
        **store_config)

Hackfut Security File Manager

Editing: flup_session.py

Upload File

Create Folder