PK UªC8h”ã‰é é wsgiutils/SessionServer.pyc;ò
>ŽAc @ sq d Z d k Z d k Z d k Z d k Z d k Z d k Z d k Z d k Z d e f d „ ƒ YZ
d „ Z d S( sR SessionServer
Copyright (c) 2004 Colin Stewart (http://www.owlfish.com/)
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. The name of the author may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
If you make any bug fixes or feature enhancements please let me know!
A Unix daemon server that provides Session persistence.
Ns Serverc B s, t Z d „ Z d „ Z d „ Z d „ Z RS( Nc C sM | | _ | | _ t i | d ƒ | _ t i d ƒ | _ | i i d ƒ d S( Ns cs
SessionServers Server init function.(
s addrs selfs dbfiles anydbms opens dbs loggings getLoggers logs info( s selfs addrs dbfile( ( s; build/bdist.darwin-8.0.1-x86/egg/wsgiutils/SessionServer.pys __init__) s
c C s t i d ƒ | i ƒ d S( Ns Starting to serve.( s loggings infos selfs serve( s self( ( s; build/bdist.darwin-8.0.1-x86/egg/wsgiutils/SessionServer.pys runServer0 s
c C sK y? t i t i t i ƒ } | i | i ƒ | i d ƒ t } Wn5 t
j
o) } | i i
d t | ƒ ƒ t } n XxÍ | oÅ y | i ƒ \ } } WnM t
j
oA } | i i d t | ƒ ƒ | i i ƒ | i i ƒ d Sn Xy | i | ƒ Wqz t
j
o; } y( | i i d t | ƒ ƒ | i ƒ WqBqBXqz Xqz Wd S( Ni s' Unable to start listening on socket: %ss. Exception occured while waiting for a client: s+ Error handling client (%s), closing socket.( s sockets AF_UNIXs SOCK_STREAMs listenSockets binds selfs addrs listens Trues servings Exceptions es logs criticals strs Falses accepts
connSockets connAddrs errors dbs syncs closes handleClients info( s selfs listenSockets servings es connAddrs
connSocket( ( s; build/bdist.darwin-8.0.1-x86/egg/wsgiutils/SessionServer.pys serve4 s2
c
C s
d } xö| oît i d | i d ƒ ƒ d } | i | ƒ } t i | ƒ } | i
ƒ } t i ƒ } | d j oW | i
ƒ } | i
ƒ } | i i d | ƒ | | i | <| i i ƒ | i d ƒ nô | d j oƒ | i
ƒ } | i i | ƒ o? | i i d | ƒ | i | } | i d
ƒ | i | ƒ q¼| i i d | ƒ | i d ƒ nd | d
j o$ | i i ƒ | i d ƒ d } n3 | i i d | ƒ | i d ƒ | i d | ƒ | i ƒ } t i d t | ƒ ƒ } | i | ƒ | i | ƒ q W| i ƒ d S( Ni s !li i s SETs Saving session ID %ss OKs GETs Loading session ID %ss FOUNDs Session ID %s not founds NOTFOUNDs BYEs Unknown command type: s ERROR( s servings structs unpacks
connSockets recvs msgLens rawmsgs xdrlibs Unpackers msgs
unpack_strings msgTypes Packers replymsgs keys values selfs logs infos dbs syncs pack_strings has_keys warns
get_buffers packs lens sendalls close(
s selfs
connSockets servings rawmsgs replymsgs values msgTypes keys msgs msgLen( ( s; build/bdist.darwin-8.0.1-x86/egg/wsgiutils/SessionServer.pys handleClientN sH
( s __name__s
__module__s __init__s runServers serves handleClient( ( ( s; build/bdist.darwin-8.0.1-x86/egg/wsgiutils/SessionServer.pys Server( s c C s y t i t ƒ Wn n Xd S( N( s oss removes SOCKET_ADDR( ( ( s; build/bdist.darwin-8.0.1-x86/egg/wsgiutils/SessionServer.pys
preStartupy s ( s __doc__s oss loggings threadings Queues sockets anydbms xdrlibs structs objects Servers
preStartup(
s
preStartups anydbms loggings sockets xdrlibs Servers Queues threadings oss struct( ( s; build/bdist.darwin-8.0.1-x86/egg/wsgiutils/SessionServer.pys ? s HQPK )ˆf3®EDC wsgiutils/__init__.py__version__ = "0.7"
PK TªC8®”òŠg: g: wsgiutils/wsgiAdaptor.pyc;ò
PWBc @ sÄ d Z d k Z d k Z d k Z d k Z d k Z d k Z d k Z d k Z d k Z d k
Z
d k Z
d k Z d k
Z
d e i f d „ ƒ YZ d e f d „ ƒ YZ d e f d „ ƒ YZ d S( sO wsgiAdaptor
Copyright (c) 2004 Colin Stewart (http://www.owlfish.com/)
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. The name of the author may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
If you make any bug fixes or feature enhancements please let me know!
Provides a basic web environment within a WSGI server.
Ns simpleCookiec B s& t Z e d „ Z d „ Z d „ Z RS( Nc C sS | | _ t i d ƒ | _ | t j o t i i | | ƒ n t i i | ƒ d S( Ns simpleCookie(
s digestKeys selfs loggings getLoggers logs
dataToLoads Nones Cookies
BaseCookies __init__( s selfs digestKeys
dataToLoad( ( s9 build/bdist.darwin-8.0.1-x86/egg/wsgiutils/wsgiAdaptor.pys __init__% s
c C s¾ t i i | | ƒ \ } } | i t j o | | f Sn t i
| i ƒ } | d d !} | d } | i | ƒ | i ƒ | j o | | f Sn+ | i i d | i ƒ | f ƒ t | f Sd S( sŽ Return the value decoded - note that the documentation is wrong and the return value
is actuall a tuple of unquotedvalue, originalvalue
i i s1 Cookie tampering detected key %s expected key %s!N( s Cookies SimpleCookies value_decodes selfs avalues
unqoutedvalues dummys digestKeys Nones hmacs news coders expectedKeys realValues updates hexdigests logs warn( s selfs avalues dummys realValues coders expectedKeys
unqoutedvalue( ( s9 build/bdist.darwin-8.0.1-x86/egg/wsgiutils/wsgiAdaptor.pys value_decode- s
c C sm | i t j o t i i | | ƒ Sn t i | i ƒ } | i
| ƒ | i ƒ | } t i i | | ƒ Sd S( s Return the value encoded - note that the documentation is wrong and the return value
is actuall a tuple of originalvalue, quotedevalue
N(
s selfs digestKeys Nones Cookies SimpleCookies value_encodes avalues hmacs news coders updates hexdigests valuetostore( s selfs avalues valuetostores coder( ( s9 build/bdist.darwin-8.0.1-x86/egg/wsgiutils/wsgiAdaptor.pys value_encode? s
( s __name__s
__module__s Nones __init__s value_decodes value_encode( ( ( s9 build/bdist.darwin-8.0.1-x86/egg/wsgiutils/wsgiAdaptor.pys simpleCookie$ s s Requestc B s† t Z d „ Z d „ Z d „ Z d „ Z d „ Z d „ Z d „ Z d „ Z d d
„ Z
d „ Z d „ Z d d
„ Z
e d „ Z RS( Nc C s@ t | _ t | _ t | _ t | _ d | _ d | _ d | _ g | _ g | _
| d | _ | i
d d ƒ | _ | d d } | i d ƒ o | | d 7} nr | | d
7} | d d j o+ | d d
j o | d | d 7} qn( | d d j o | d | d 7} n | t i | i
d d ƒ ƒ 7} | | _ d S( Ns
text/plains Application returned no content.s 500 Internal Server Errors wsgi.errorss PATH_INFOs s wsgi.url_schemes ://s HTTP_HOSTs SERVER_NAMEs httpss SERVER_PORTs 443s :s 80s SCRIPT_NAME( s Nones selfs sessions users passwords
formFieldss contentTypes contentValues responses authorisationHeaderss redirectHeaderss environments errorStreams gets relativePaths urls has_keys urllibs quotes urlPrefix( s selfs environments url( ( s9 build/bdist.darwin-8.0.1-x86/egg/wsgiutils/wsgiAdaptor.pys __init__K s,
c C s | i Sd S( N( s selfs
formFields( s self( ( s9 build/bdist.darwin-8.0.1-x86/egg/wsgiutils/wsgiAdaptor.pys
getFormFieldsj s c C s | i Sd S( N( s selfs session( s self( ( s9 build/bdist.darwin-8.0.1-x86/egg/wsgiutils/wsgiAdaptor.pys
getSessionm s c C s | i Sd S( N( s selfs user( s self( ( s9 build/bdist.darwin-8.0.1-x86/egg/wsgiutils/wsgiAdaptor.pys getUsernamep s c C s | i Sd S( N( s selfs password( s self( ( s9 build/bdist.darwin-8.0.1-x86/egg/wsgiutils/wsgiAdaptor.pys getPasswords s c C s | i Sd S( N( s selfs errorStream( s self( ( s9 build/bdist.darwin-8.0.1-x86/egg/wsgiutils/wsgiAdaptor.pys getErrorStreamv s c C s | i Sd S( N( s selfs relativePath( s self( ( s9 build/bdist.darwin-8.0.1-x86/egg/wsgiutils/wsgiAdaptor.pys getRelativePathy s c C s | i Sd S( N( s selfs urlPrefix( s self( ( s9 build/bdist.darwin-8.0.1-x86/egg/wsgiutils/wsgiAdaptor.pys getURLPrefix| s s
text/plainc C s | | _ | | _ d | _ d S( Ns 200 OK( s contentValues selfs contentTypes response( s selfs contentValues contentType( ( s9 build/bdist.darwin-8.0.1-x86/egg/wsgiutils/wsgiAdaptor.pys sendContent s c C s' d | _ | i i d d | f ƒ d S( Ns 401 Unauthorizeds WWW-Authenticates Basic realm="%s"( s selfs responses authorisationHeaderss appends realm( s selfs realm( ( s9 build/bdist.darwin-8.0.1-x86/egg/wsgiutils/wsgiAdaptor.pys sendUnauthorisedBasic„ s c C s5 d | _ | i i d | f ƒ d | _ d | _ d S( Ns
303 See Others Locations
Loading...s
text/plain( s selfs responses redirectHeaderss appends newDestinations contentValues contentType( s selfs newDestination( ( s9 build/bdist.darwin-8.0.1-x86/egg/wsgiutils/wsgiAdaptor.pys sendSeeOtherRedirectˆ s c C s | | _ | | _ | | _ d S( N( s responseStrs selfs responses contentValues contentType( s selfs responseStrs contentValues contentType( ( s9 build/bdist.darwin-8.0.1-x86/egg/wsgiutils/wsgiAdaptor.pys sendResponseŽ s c C sH | t j o t i i t i ƒ ƒ } n t i i | ƒ } t i | ƒ } | i
d ƒ o | d } n t i i t i i | | ƒ ƒ } t i i
| | g ƒ | j o d | | f }
t |
ƒ ‚ n z t | d ƒ } | i ƒ } Wd y | i ƒ Wn n XXt i i | ƒ d } t i i | } | | _ | | _ d | _ d S( sñ Returns a tuple of the file found at path as a string and the guessed content type of the file.
path - URL Encoded path that points to a file.
rootDir - The root directory the path is relative to. If None is specified then use CWD
s /i s= Attempt to read file %s which is outside of root directory %ss rNs 200 OK( s rootDirs Nones oss paths abspaths getcwds startDirs urllibs unquotes decodedPaths
startswiths joins realPaths commonprefixs msgs IOErrors opens theFiles reads theFileContentss closes splitexts
fileExtensions SimpleHTTPServers SimpleHTTPRequestHandlers extensions_maps contentTypes selfs contentValues response( s selfs paths rootDirs decodedPaths realPaths contentTypes theFiles
fileExtensions theFileContentss startDirs msg( ( s9 build/bdist.darwin-8.0.1-x86/egg/wsgiutils/wsgiAdaptor.pys sendFileForPath“ s0
! ( s __name__s
__module__s __init__s
getFormFieldss
getSessions getUsernames getPasswords getErrorStreams getRelativePaths getURLPrefixs sendContents sendUnauthorisedBasics sendSeeOtherRedirects sendResponses Nones sendFileForPath( ( ( s9 build/bdist.darwin-8.0.1-x86/egg/wsgiutils/wsgiAdaptor.pys RequestJ s s wsgiAdaptorc B sG t Z d „ Z d „ Z d „ Z d „ Z d „ Z d „ Z d „ Z RS( Nc C sF | | _ | | _ | | _ t i d ƒ | _ h d | i <| _ d S( Ns wsgiAdaptors basic( s applications selfs cookieKeys
sessionClients loggings getLoggers logs parseBasicAuthorisations authHandlers( s selfs applications cookieKeys
sessionClient( ( s9 build/bdist.darwin-8.0.1-x86/egg/wsgiutils/wsgiAdaptor.pys __init__¸ s
c C s t | ƒ Sd S( s: Used by sub-classes to define their own Request objects. N( s Requests environment( s selfs environment( ( s9 build/bdist.darwin-8.0.1-x86/egg/wsgiutils/wsgiAdaptor.pys
getRequest¿ s c C s¼ | i d ƒ o¤ | i i d ƒ | d } | i d ƒ } | | i ƒ } | | d } | i i | t
ƒ } | o | | | ƒ d Sq´ | i i d | ƒ | i d d ƒ d Sn d Sd S( Ns HTTP_AUTHORIZATIONs Found authorization header.s i i s) Unsupported authorisation method %s used!s 501 Not Implementeds! Unsupported authorisation method.( s environments has_keys selfs logs debugs credentialss finds authTypeOffsets lowers authTypes authCredentialss authHandlerss gets Nones authHandlers requests errors sendResponse( s selfs requests environments authTypes authHandlers authCredentialss credentialss authTypeOffset( ( s9 build/bdist.darwin-8.0.1-x86/egg/wsgiutils/wsgiAdaptor.pys handleAuthorisationà s
c C sJ | i d ƒ o | d } t | i | ƒ } n t | i d ƒ } | Sd S( Ns HTTP_COOKIEs ( s environments has_keys cookieValues simpleCookies selfs cookieKeys cookies( s selfs environments cookiess cookieValue( ( s9 build/bdist.darwin-8.0.1-x86/egg/wsgiutils/wsgiAdaptor.pys
getCookiesØ s
c C si t i | ƒ } | i d ƒ } | d | !} | | d } | | _ | | _ | i i d | | f ƒ d S( Ns :i i s: Received via basic authorisation username: %s password: %s(
s base64s decodestrings authCredentialss userpasss finds userpassOffsets userNames passwords requests users selfs logs info( s selfs requests authCredentialss userNames userpassOffsets userpasss password( ( s9 build/bdist.darwin-8.0.1-x86/egg/wsgiutils/wsgiAdaptor.pys parseBasicAuthorisationâ s
c C s# | i | ƒ } | i | | ƒ o | i | | t ƒ Sn | i | ƒ } | i
i | ƒ | _ t
i d | d d | ƒ | _ y | i i | ƒ WnR t j
oF } | i i d t | ƒ ƒ | i d d ƒ | i | | | ƒ Sn X| i t j o | i
i | i ƒ n | i | | | ƒ Sd S( Ns fps
wsgi.inputs environs) Application experienced unhandled error: s 500 Internal Server Errors Internal application error( s selfs
getRequests environments requests handleAuthorisations renderToClients start_responses Nones
getCookiess cookiess
sessionClients
getSessions sessions cgis FieldStorages
formFieldss applications requestHandlers Exceptions es logs criticals strs sendResponses saveSession( s selfs environments start_responses es requests cookies( ( s9 build/bdist.darwin-8.0.1-x86/egg/wsgiutils/wsgiAdaptor.pys wsgiHookë s c C sý | i d j o
| i } n$ | i d j o
| i } n g } | i d | i f ƒ | i d t t | i ƒ ƒ f ƒ | t j o4 x1 | i ƒ D] } | i d | i ƒ f ƒ q’ Wn | | i | ƒ t | i g ƒ S| | i | ƒ t | i g ƒ Sd S( Ns 401 Unauthorizeds
303 See Others Content-types Content-lengths
Set-Cookie( s requests responses authorisationHeaderss headerss redirectHeaderss appends contentTypes strs lens contentValues cookiess Nones valuess cookies OutputStrings start_responses iter( s selfs start_responses requests cookiess headerss cookie( ( s9 build/bdist.darwin-8.0.1-x86/egg/wsgiutils/wsgiAdaptor.pys renderToClient s
"
!( s __name__s
__module__s __init__s
getRequests handleAuthorisations
getCookiess parseBasicAuthorisations wsgiHooks renderToClient( ( ( s9 build/bdist.darwin-8.0.1-x86/egg/wsgiutils/wsgiAdaptor.pys wsgiAdaptor· s
( s __doc__s Cookies hmacs base64s sockets xdrlibs structs pickles cgis urllibs oss os.paths SimpleHTTPServers loggings SimpleCookies simpleCookies objects Requests wsgiAdaptor( s cgis wsgiAdaptors loggings structs SimpleHTTPServers oss base64s Requests xdrlibs urllibs Cookies simpleCookies pickles hmacs socket( ( s9 build/bdist.darwin-8.0.1-x86/egg/wsgiutils/wsgiAdaptor.pys ? s
l &mPK \yO2Õé É ) ) wsgiutils/wsgiAdaptor.py""" wsgiAdaptor
Copyright (c) 2004 Colin Stewart (http://www.owlfish.com/)
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. The name of the author may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
If you make any bug fixes or feature enhancements please let me know!
Provides a basic web environment within a WSGI server.
"""
import Cookie, hmac, base64, socket, xdrlib, struct, pickle, cgi, urllib, os, os.path, SimpleHTTPServer
import logging
class simpleCookie (Cookie.SimpleCookie):
def __init__ (self, digestKey, dataToLoad = None):
self.digestKey = digestKey
self.log = logging.getLogger ("simpleCookie")
if (dataToLoad is not None):
Cookie.BaseCookie.__init__ (self, dataToLoad)
else:
Cookie.BaseCookie.__init__ (self)
def value_decode (self, avalue):
""" Return the value decoded - note that the documentation is wrong and the return value
is actuall a tuple of unquotedvalue, originalvalue
"""
unqoutedvalue, dummy = Cookie.SimpleCookie.value_decode (self, avalue)
if (self.digestKey is None):
return unqoutedvalue, dummy
coder = hmac.new(self.digestKey)
expectedKey = unqoutedvalue [0:32]
realValue = unqoutedvalue [32:]
coder.update (realValue)
if (coder.hexdigest() == expectedKey):
# Correctly encoded!
return realValue, avalue
else:
self.log.warn ("Cookie tampering detected key %s expected key %s!" % (coder.hexdigest(), expectedKey))
return None, avalue
def value_encode (self, avalue):
""" Return the value encoded - note that the documentation is wrong and the return value
is actuall a tuple of originalvalue, quotedevalue
"""
if (self.digestKey is None):
return Cookie.SimpleCookie.value_encode (self, avalue)
coder = hmac.new(self.digestKey)
coder.update (avalue)
valuetostore = coder.hexdigest() + avalue
return Cookie.SimpleCookie.value_encode (self, valuetostore)
class Request (object):
def __init__ (self, environment):
self.session = None
self.user = None
self.password = None
self.formFields = None
self.contentType = 'text/plain'
self.contentValue = "Application returned no content."
self.response = "500 Internal Server Error"
self.authorisationHeaders = []
self.redirectHeaders = []
self.errorStream = environment ['wsgi.errors']
self.relativePath = environment.get ('PATH_INFO', "")
# Re-construct the URL prefix.
url = environment ['wsgi.url_scheme'] + '://'
if environment.has_key ('HTTP_HOST'):
url += environment ['HTTP_HOST']
else:
url += environment ['SERVER_NAME']
if environment ['wsgi.url_scheme'] == 'https':
if environment ['SERVER_PORT'] != '443':
url += ':' + environment ['SERVER_PORT']
else:
if environment ['SERVER_PORT'] != '80':
url += ':' + environment ['SERVER_PORT']
url += urllib.quote(environment.get('SCRIPT_NAME',''))
self.urlPrefix = url
def getFormFields (self):
return self.formFields
def getSession (self):
return self.session
def getUsername (self):
return self.user
def getPassword (self):
return self.password
def getErrorStream (self):
return self.errorStream
def getRelativePath (self):
return self.relativePath
def getURLPrefix (self):
return self.urlPrefix
def sendContent (self, contentValue, contentType = "text/plain"):
self.contentValue = contentValue
self.contentType = contentType
self.response = "200 OK"
def sendUnauthorisedBasic (self, realm):
self.response = "401 Unauthorized"
self.authorisationHeaders.append (('WWW-Authenticate','Basic realm="%s"' % realm))
def sendSeeOtherRedirect (self, newDestination):
self.response = "303 See Other"
self.redirectHeaders.append (('Location', newDestination))
self.contentValue = "Loading..."
self.contentType = "text/plain"
def sendResponse (self, responseStr, contentValue, contentType = "text/plain"):
self.response = responseStr
self.contentValue = contentValue
self.contentType = contentType
def sendFileForPath (self, path, rootDir = None):
""" Returns a tuple of the file found at path as a string and the guessed content type of the file.
path - URL Encoded path that points to a file.
rootDir - The root directory the path is relative to. If None is specified then use CWD
"""
if (rootDir is None):
startDir = os.path.abspath (os.getcwd ())
else:
startDir = os.path.abspath (rootDir)
decodedPath = urllib.unquote (path)
if (decodedPath.startswith ('/')):
decodedPath = decodedPath [1:]
# Build the path and collapse any indirection (../)
realPath = os.path.abspath (os.path.join (startDir, decodedPath))
# Check that the path is really underneath the root directory
if (os.path.commonprefix ([startDir, realPath]) != startDir):
msg = "Attempt to read file %s which is outside of root directory %s" % (realPath, startDir)
raise IOError (msg)
# Read the file and return it
try:
theFile = open (realPath, 'r')
theFileContents = theFile.read()
finally:
try:
theFile.close()
except:
pass
# Guess the content type.
fileExtension = os.path.splitext (realPath)[1]
contentType = SimpleHTTPServer.SimpleHTTPRequestHandler.extensions_map [fileExtension]
self.contentValue = theFileContents
self.contentType = contentType
self.response = "200 OK"
class wsgiAdaptor (object):
def __init__ (self, application, cookieKey, sessionClient):
self.application = application
self.cookieKey = cookieKey
self.sessionClient = sessionClient
self.log = logging.getLogger ("wsgiAdaptor")
self.authHandlers = {'basic': self.parseBasicAuthorisation}
def getRequest (self, environment):
""" Used by sub-classes to define their own Request objects. """
return Request (environment)
def handleAuthorisation (self, request, environment):
# Find authorisation headers and handle them, updating the request object.
# If a response is to be immediately sent to the user then return true, otherwise false
# Look for authorised users.
if (environment.has_key ('HTTP_AUTHORIZATION')):
self.log.debug ("Found authorization header.")
credentials = environment ['HTTP_AUTHORIZATION']
authTypeOffset = credentials.find (' ')
authType = credentials [:authTypeOffset].lower()
authCredentials = credentials [authTypeOffset + 1:]
authHandler = self.authHandlers.get (authType, None)
if (authHandler):
authHandler (request, authCredentials)
return 0
else:
self.log.error ("Unsupported authorisation method %s used!" % authType)
# Internal application error.
request.sendResponse ("501 Not Implemented", "Unsupported authorisation method.")
return 1
return 0
def getCookies (self, environment):
# Do we have any cookies?
if (environment.has_key ('HTTP_COOKIE')):
# Yes we have cookies!
cookieValue = environment ['HTTP_COOKIE']
cookies = simpleCookie (self.cookieKey, cookieValue)
else:
cookies = simpleCookie (self.cookieKey, "")
return cookies
def parseBasicAuthorisation (self, request, authCredentials):
userpass = base64.decodestring (authCredentials)
userpassOffset = userpass.find (':')
userName = userpass [0:userpassOffset]
password = userpass [userpassOffset + 1:]
request.user = userName
request.password = password
self.log.info ("Received via basic authorisation username: %s password: %s" % (userName, password))
def wsgiHook (self, environment, start_response):
request = self.getRequest(environment)
if (self.handleAuthorisation (request, environment)):
return self.renderToClient (start_response, request, None)
cookies = self.getCookies (environment)
# Get our session
request.session = self.sessionClient.getSession (cookies)
# And the form parameters
request.formFields = cgi.FieldStorage (fp=environment ['wsgi.input'], environ=environment)
try:
self.application.requestHandler (request)
except Exception, e:
self.log.critical ("Application experienced unhandled error: " + str (e))
request.sendResponse ("500 Internal Server Error", "Internal application error")
return self.renderToClient (start_response, request, cookies)
if (request.session is not None):
# Persist the session
self.sessionClient.saveSession (request.session)
return self.renderToClient (start_response, request, cookies)
def renderToClient (self, start_response, request, cookies):
# Get all the headers
if (request.response == "401 Unauthorized"):
headers = request.authorisationHeaders
elif (request.response == "303 See Other"):
headers = request.redirectHeaders
else:
headers = []
headers.append (('Content-type', request.contentType))
headers.append (('Content-length', str (len (request.contentValue))))
if (cookies is not None):
# Add the cookies
for cookie in cookies.values():
headers.append (('Set-Cookie', cookie.OutputString()))
# Finally start the transaction with wsgi
start_response (request.response, headers)
# Now return an iterator for the output
return iter ([request.contentValue])
# Finally start the transaction with wsgi
start_response (request.response, headers)
# Now return an iterator for the output
return iter ([request.contentValue])
PK UªC8NŸ§ëÄ# Ä# wsgiutils/wsgiServer.pyc;ò
/}nCc @ s¢ d Z d k Z d k Z d k Z d k Z d k Z d k Z d k Z d k Z d k Z d k
Z
d Z d e i f d „ ƒ YZ
d e i e i f d „ ƒ YZ d S( s; wsgiServer
Copyright (c) 2004 Colin Stewart (http://www.owlfish.com/)
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. The name of the author may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
If you make any bug fixes or feature enhancements please let me know!
A basic multi-threaded WSGI server.
NsÓ
Server Error
Server Error
A server error has occurred. Please contact the system administrator for
more information.
s WSGIHandlerc B sS t Z d „ Z d „ Z d „ Z d „ Z d „ Z d „ Z e d „ Z d „ Z
RS( Nc G s d S( N( ( s selfs args( ( s8 build/bdist.darwin-8.0.1-x86/egg/wsgiutils/wsgiServer.pys log_message3 s c G s d S( N( ( s selfs args( ( s8 build/bdist.darwin-8.0.1-x86/egg/wsgiutils/wsgiServer.pys log_request6 s c C sç t i d | i ƒ \ } } } } } } x¨ | i i D]š \ } }
| i | ƒ o~ | t
| ƒ } t
| ƒ d j o# | i d ƒ o d | } q— n | i d ƒ o | d } n | } |
| | | f Sq5 q5 Wt t t t f Sd S( Ns http://dummyhost%si s /iÿÿÿÿ( s urlparses selfs paths protocols hosts
parameterss querys fragments servers wsgiApplicationss appPaths apps
startswiths lens pathInfos endswiths
scriptNames None( s selfs protocols
parameterss fragments pathInfos
scriptNames hosts appPaths querys paths app( ( s8 build/bdist.darwin-8.0.1-x86/egg/wsgiutils/wsgiServer.pys getApp9 s (
c C sw | i ƒ \ } } } } | o= | i i o t i i
| ƒ d Sn | i d d ƒ d Sn | i | | | | ƒ d S( Ni” s Application not found.(
s selfs getApps apps
scriptNames pathInfos querys servers
serveFiless SimpleHTTPServers SimpleHTTPRequestHandlers do_GETs
send_errors
runWSGIApp( s selfs pathInfos
scriptNames querys app( ( s8 build/bdist.darwin-8.0.1-x86/egg/wsgiutils/wsgiServer.pys do_GETL s
c C sR | i ƒ \ } } } } | o | i d d ƒ d Sn | i | | | | ƒ d S( Ni” s Application not found.( s selfs getApps apps
scriptNames pathInfos querys
send_errors
runWSGIApp( s selfs pathInfos
scriptNames apps query( ( s8 build/bdist.darwin-8.0.1-x86/egg/wsgiutils/wsgiServer.pys do_POSTX s
c
C sê t i d | | f ƒ h d d d f <d d <d | i <d t i <d d <d
d <d d <d | i <d
| <d | <d | <d | i
i d d ƒ <d | i
i d d ƒ <d | i d <d | i
i d <d t | i
i d ƒ <d | i <} x= | i
i ƒ D], \ }
} | | d |
i d d ƒ i ƒ t Z d Z d d „ Z d „ Z d „ Z d „ Z d „ Z RS( s‚ The session server client is a multi-thread safe factory class which
generates Session objects for use in a web application.
i c C sS | | _ | | _ | | _ t i d ƒ | _ t i ƒ | _
t | _ | i
ƒ d S( Ns SessionServerClient( s socketLocations selfs sessionLifeSpans lifeSpans
cookieNames loggings getLoggers logs threadings Locks
socketLocks Nones sessionServerSockets connectToServer( s selfs socketLocations
cookieNames sessionLifeSpan( ( s; build/bdist.darwin-8.0.1-x86/egg/wsgiutils/SessionClient.pys __init__l s c C s8 | i i ƒ yT | i t j o@ | i i d ƒ | i } t | _ | i ƒ | i i d ƒ n Wn/ t
j
o# } | i i d t
| ƒ ƒ n XyY | i i d | i ƒ t i t i t i ƒ | _ | i i | i ƒ | i i d ƒ Wn8 t
j
o, } | i i d t
| ƒ ƒ t | _ n X| i i ƒ d S( Ns& Found old socket, attempting to close.s Close succeddeds6 Error attempting to close old socket (%s) carrying on.sC Attempting to connect to session server listening on unix socket %ss) Connection to session server established!s' Unable to connect to session server: %s( s selfs
socketLocks acquires sessionServerSockets Nones logs infos oldSocks closes debugs Exceptions es warns strs socketLocations sockets AF_UNIXs SOCK_STREAMs connects errors release( s selfs es oldSock( ( s; build/bdist.darwin-8.0.1-x86/egg/wsgiutils/SessionClient.pys connectToServeru s&
c C sî t } | i | i ƒ o( | | i i } | i i d | ƒ n | i i d | i ƒ | t j o$ t ƒ } | | | i | i i% d t | ƒ ƒ t ƒ } | | | i } | i i ƒ | i i d t | ƒ ƒ | i ƒ d Sn Xt i | ƒ } | i ƒ } | i i d | ƒ | d j o | i i d
ƒ n | i i d ƒ t d ƒ ‚ d S(
Ns SETs !ls Sending SET message to server.s Waiting for response.i i sG Error communicating with the session server (%s), trying to re-connect.s Response is message type: %ss OKs Session saved OK.s Error saving session!s Error saving session.(" s xdrlibs Packers msgs pack_strings times sessions lastAccesseds getSessionIDs cPickles dumpss
get_buffers structs packs lens msgLens selfs
socketLocks acquires logs infos sessionServerSockets sendalls unpacks recvs rawmsgs releases Exceptions es errors strs connectToServers Unpackers
unpack_strings msgType( s selfs sessions es rawmsgs msgTypes msgs msgLen( ( s; build/bdist.darwin-8.0.1-x86/egg/wsgiutils/SessionClient.pys saveSessionÇ s8
"
c C sF t i ƒ } | i d ƒ | i ƒ } t i d t | ƒ ƒ } y¸ | i
i ƒ | i i
d ƒ | i i | ƒ | i i | ƒ | i i
d ƒ t i d | i i d ƒ ƒ d } | i i | ƒ } | i i
d ƒ | i i ƒ t | _ | i
i ƒ WnJ t j
o> } | i
i ƒ | i i d t | ƒ ƒ | i ƒ d Sn Xd S( Ns BYEs !ls Sending BYE message to server.s Waiting for response.i i s Closing socket connection.sG Error communicating with the session server (%s), trying to re-connect.( s xdrlibs Packers msgs pack_strings
get_buffers structs packs lens msgLens selfs
socketLocks acquires logs infos sessionServerSockets sendalls unpacks recvs rawmsgs closes Nones releases Exceptions es errors strs connectToServer( s selfs es rawmsgs msgs msgLen( ( s; build/bdist.darwin-8.0.1-x86/egg/wsgiutils/SessionClient.pys closeClientë s*
"
( s __name__s
__module__s __doc__s __init__s connectToServers
getSessions saveSessions closeClient( ( ( s; build/bdist.darwin-8.0.1-x86/egg/wsgiutils/SessionClient.pys SessionServerClienth s < $( s __doc__s sockets xdrlibs structs cPickles randoms times anydbms threadings loggings dicts Sessions getNewSessionIDs objects LocalSessionClients SessionServerClient(
s cPickles anydbms loggings structs randoms xdrlibs SessionServerClients threadings Sessions times LocalSessionClients getNewSessionIDs socket( ( s; build/bdist.darwin-8.0.1-x86/egg/wsgiutils/SessionClient.pys ? s 6 3PK Sg1Ó"ƒ ƒ wsgiutils/SessionServer.py""" SessionServer
Copyright (c) 2004 Colin Stewart (http://www.owlfish.com/)
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. The name of the author may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
If you make any bug fixes or feature enhancements please let me know!
A Unix daemon server that provides Session persistence.
"""
import os, logging, threading, Queue, socket, anydbm, xdrlib, struct
# Wire protocol is based on XDR messages. Each message is precedded by a 4 byte length in network byte order.
# Client can issue a message of two strings, GET, KEY
# OR three strings: SET, KEY, DATA
# Server responds with an XDR message of FOUND, DATA or NOTFOUND
# For set operation return will be OK or ERROR
class Server (object):
def __init__ (self, addr, dbfile):
self.addr = addr
self.dbfile = dbfile
self.db = anydbm.open (dbfile, 'c')
self.log = logging.getLogger ("SessionServer")
self.log.info ("Server init function.")
def runServer (self):
logging.info ("Starting to serve.")
self.serve()
def serve (self):
try:
listenSocket = socket.socket (socket.AF_UNIX, socket.SOCK_STREAM)
listenSocket.bind (self.addr)
listenSocket.listen(2)
serving = True
except Exception, e:
self.log.critical ("Unable to start listening on socket: %s" % str (e))
serving = False
while (serving):
try:
connSocket, connAddr = listenSocket.accept()
except Exception, e:
self.log.error ("Exception occured while waiting for a client: " + str (e))
self.db.sync()
self.db.close()
return
try:
self.handleClient (connSocket)
except Exception, e:
try:
self.log.info ("Error handling client (%s), closing socket." % str (e))
connSocket.close()
except:
pass
def handleClient (self, connSocket):
# Repeated handle incoming messages until the socket goes away.
serving = 1
while (serving):
# Read the message length
msgLen = struct.unpack ('!l', connSocket.recv (4))[0]
rawmsg = connSocket.recv (msgLen)
msg = xdrlib.Unpacker (rawmsg)
msgType = msg.unpack_string()
replymsg = xdrlib.Packer()
if (msgType == "SET"):
key = msg.unpack_string()
value = msg.unpack_string()
self.log.info ("Saving session ID %s" % key)
self.db [key] = value
self.db.sync()
replymsg.pack_string ("OK")
elif (msgType == "GET"):
key = msg.unpack_string()
if (self.db.has_key (key)):
self.log.info ("Loading session ID %s" % key)
value = self.db [key]
replymsg.pack_string ("FOUND")
replymsg.pack_string (value)
else:
self.log.info ("Session ID %s not found" % key)
replymsg.pack_string ("NOTFOUND")
elif (msgType == "BYE"):
self.db.sync()
replymsg.pack_string ("OK")
serving = 0
else:
self.log.warn ("Unknown command type: " + msgType)
replymsg.pack_string ("ERROR")
replymsg.pack_string ("Unknown command type: " + msgType)
replymsg = replymsg.get_buffer()
msgLen = struct.pack ('!l', len (replymsg))
connSocket.sendall (msgLen)
connSocket.sendall (replymsg)
connSocket.close()
def preStartup ():
try:
os.remove (SOCKET_ADDR)
except:
# No such file, that's OK.
pass
PK )ˆf3|BŠ½X X wsgiutils/wsgiServer.py""" wsgiServer
Copyright (c) 2004 Colin Stewart (http://www.owlfish.com/)
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. The name of the author may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
If you make any bug fixes or feature enhancements please let me know!
A basic multi-threaded WSGI server.
"""
import SimpleHTTPServer, SocketServer, BaseHTTPServer, urlparse
import sys, logging, socket, errno
import traceback, StringIO
SERVER_ERROR = """\
Server Error
Server Error
A server error has occurred. Please contact the system administrator for
more information.
"""
class WSGIHandler (SimpleHTTPServer.SimpleHTTPRequestHandler):
def log_message (self, *args):
pass
def log_request (self, *args):
pass
def getApp (self):
protocol, host, path, parameters, query, fragment = urlparse.urlparse ('http://dummyhost%s' % self.path)
# Find any application we might have
for appPath, app in self.server.wsgiApplications:
if (path.startswith (appPath)):
# We found the application to use - work out the scriptName and pathInfo
pathInfo = path [len (appPath):]
if (len (pathInfo) > 0):
if (not pathInfo.startswith ('/')):
pathInfo = '/' + pathInfo
if (appPath.endswith ('/')):
scriptName = appPath[:-1]
else:
scriptName = appPath
# Return all this
return app, scriptName, pathInfo, query
return None, None, None, None
def do_GET (self):
app, scriptName, pathInfo, query = self.getApp ()
if (not app):
if (self.server.serveFiles):
# Not a request for an application, just a file.
SimpleHTTPServer.SimpleHTTPRequestHandler.do_GET (self)
return
self.send_error (404, 'Application not found.')
return
self.runWSGIApp (app, scriptName, pathInfo, query)
def do_POST (self):
app, scriptName, pathInfo, query = self.getApp ()
if (not app):
# We don't have an application corresponding to this path!
self.send_error (404, 'Application not found.')
return
self.runWSGIApp (app, scriptName, pathInfo, query)
def runWSGIApp (self, application, scriptName, pathInfo, query):
logging.info ("Running application with script name %s path %s" % (scriptName, pathInfo))
env = {'wsgi.version': (1,0)
,'wsgi.url_scheme': 'http'
,'wsgi.input': self.rfile
,'wsgi.errors': sys.stderr
,'wsgi.multithread': 1
,'wsgi.multiprocess': 0
,'wsgi.run_once': 0
,'REQUEST_METHOD': self.command
,'SCRIPT_NAME': scriptName
,'PATH_INFO': pathInfo
,'QUERY_STRING': query
,'CONTENT_TYPE': self.headers.get ('Content-Type', '')
,'CONTENT_LENGTH': self.headers.get ('Content-Length', '')
,'REMOTE_ADDR': self.client_address[0]
,'SERVER_NAME': self.server.server_address [0]
,'SERVER_PORT': str (self.server.server_address [1])
,'SERVER_PROTOCOL': self.request_version
}
for httpHeader, httpValue in self.headers.items():
env ['HTTP_%s' % httpHeader.replace ('-', '_').upper()] = httpValue
# Setup the state
self.wsgiSentHeaders = 0
self.wsgiHeaders = []
try:
# We have there environment, now invoke the application
result = application (env, self.wsgiStartResponse)
try:
try:
for data in result:
if data:
self.wsgiWriteData (data)
finally:
if hasattr(result, 'close'):
result.close()
except socket.error, socketErr:
# Catch common network errors and suppress them
if (socketErr.args[0] in (errno.ECONNABORTED, errno.EPIPE)):
logging.debug ("Network error caught: (%s) %s" % (str (socketErr.args[0]), socketErr.args[1]))
# For common network errors we just return
return
except socket.timeout, socketTimeout:
# Socket time-out
logging.debug ("Socket timeout")
return
except:
errorMsg = StringIO.StringIO()
traceback.print_exc(file=errorMsg)
logging.error (errorMsg.getvalue())
if not self.wsgiSentHeaders:
self.wsgiStartResponse('500 Server Error', [('Content-type', 'text/html')])
self.wsgiWriteData(SERVER_ERROR)
if (not self.wsgiSentHeaders):
# We must write out something!
self.wsgiWriteData (" ")
return
def wsgiStartResponse (self, response_status, response_headers, exc_info=None):
if (self.wsgiSentHeaders):
raise Exception ("Headers already sent and start_response called again!")
# Should really take a copy to avoid changes in the application....
self.wsgiHeaders = (response_status, response_headers)
return self.wsgiWriteData
def wsgiWriteData (self, data):
if (not self.wsgiSentHeaders):
status, headers = self.wsgiHeaders
# Need to send header prior to data
statusCode = status [:status.find (' ')]
statusMsg = status [status.find (' ') + 1:]
self.send_response (int (statusCode), statusMsg)
for header, value in headers:
self.send_header (header, value)
self.end_headers()
self.wsgiSentHeaders = 1
# Send the data
self.wfile.write (data)
class WSGIServer (SocketServer.ThreadingMixIn, BaseHTTPServer.HTTPServer):
def __init__ (self, serverAddress, wsgiApplications, serveFiles=1):
BaseHTTPServer.HTTPServer.__init__ (self, serverAddress, WSGIHandler)
appList = []
for urlPath, wsgiApp in wsgiApplications.items():
appList.append ((urlPath, wsgiApp))
self.wsgiApplications = appList
self.serveFiles = serveFiles
self.serverShuttingDown = 0
PK ««o1Ú¢ø% ø% wsgiutils/SessionClient.py""" SessionClient
Copyright (c) 2004 Colin Stewart (http://www.owlfish.com/)
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. The name of the author may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
If you make any bug fixes or feature enhancements please let me know!
Clients that provide Session services.
"""
import socket, xdrlib, struct, cPickle, random, time
import anydbm
import threading
import logging
class Session (dict):
def __init__ (self, sessionID):
dict.__init__ (self)
self.sessionID = sessionID
self.lastAccessed = time.time()
def getLastAccessed (self):
return self.lastAccessed
def getSessionID (self):
return self.sessionID
def getNewSessionID ():
return str (random.randint (0, 99000000000)) + str (time.time())
class LocalSessionClient (object):
def __init__ (self, dbFileLocation, cookieName, sessionLifeSpan = 3600):
self.lifeSpan = sessionLifeSpan
self.cookieName = cookieName
self.log = logging.getLogger ("LocalSessionClient")
self.dbLock = threading.Lock()
self.db = anydbm.open (dbFileLocation, 'c')
def getSession (self, cookies):
cookieValue = None
if (cookies.has_key (self.cookieName)):
cookieValue = cookies [self.cookieName].value
self.log.info ("Found session ID %s" % cookieValue)
else:
self.log.info ("No %s cookie found." % self.cookieName)
# Nothing to load, no session present.
if (cookieValue is None):
sessID = getNewSessionID ()
cookies [self.cookieName] = sessID
return Session (sessID)
self.dbLock.acquire()
if (self.db.has_key (cookieValue)):
pickledSessionData = self.db [cookieValue]
self.dbLock.release()
else:
self.dbLock.release()
self.log.warn ("Session for ID %s was not found!" % str (cookieValue))
sessID = getNewSessionID ()
cookies [self.cookieName] = sessID
return Session(sessID)
self.log.info ("Session for ID %s found in db." % str (cookieValue))
sessionData = cPickle.loads (pickledSessionData)
if ((time.time() - sessionData.getLastAccessed()) > self.lifeSpan):
self.log.info ("Session has expired - cleaning up old data.")
sessionData.clear()
return sessionData
def saveSession (self, session):
self.dbLock.acquire()
session.lastAccessed = time.time()
self.db [session.getSessionID()] = cPickle.dumps (session)
self.db.sync()
self.dbLock.release()
def closeClient (self):
self.db.sync()
self.db.close()
self.db = None
class SessionServerClient (object):
""" The session server client is a multi-thread safe factory class which
generates Session objects for use in a web application.
"""
def __init__ (self, socketLocation, cookieName, sessionLifeSpan = 3600):
self.socketLocation = socketLocation
self.lifeSpan = sessionLifeSpan
self.cookieName = cookieName
self.log = logging.getLogger ("SessionServerClient")
self.socketLock = threading.Lock()
self.sessionServerSocket = None
self.connectToServer()
def connectToServer (self):
self.socketLock.acquire()
try:
if (self.sessionServerSocket is not None):
self.log.info ("Found old socket, attempting to close.")
oldSock = self.sessionServerSocket
self.sessionServerSocket = None
oldSock.close()
self.log.debug ("Close succedded")
except Exception, e:
self.log.warn ("Error attempting to close old socket (%s) carrying on." % str (e))
try:
self.log.info ("Attempting to connect to session server listening on unix socket %s" % self.socketLocation)
self.sessionServerSocket = socket.socket (socket.AF_UNIX, socket.SOCK_STREAM)
self.sessionServerSocket.connect (self.socketLocation)
self.log.info ("Connection to session server established!")
except Exception, e:
self.log.error ("Unable to connect to session server: %s" % str (e))
self.sessionServerSocket = None
self.socketLock.release()
def getSession (self, cookies):
cookieValue = None
if (cookies.has_key (self.cookieName)):
cookieValue = cookies [self.cookieName].value
self.log.info ("Found session ID %s" % cookieValue)
else:
self.log.info ("No %s cookie found." % self.cookieName)
# Nothing to load, no session present.
if (cookieValue is None):
sessID = getNewSessionID ()
cookies [self.cookieName] = sessID
return Session (sessID)
msg = xdrlib.Packer()
msg.pack_string ("GET")
msg.pack_string (cookieValue)
msg = msg.get_buffer()
msgLen = struct.pack ('!l', len (msg))
# Must get the lock at this stage!
try:
self.socketLock.acquire()
self.log.info ("Sending GET message to server.")
self.sessionServerSocket.sendall (msgLen)
self.sessionServerSocket.sendall (msg)
# Get the response
self.log.info ("Waiting for response.")
msgLen = struct.unpack ('!l', self.sessionServerSocket.recv (4))[0]
rawmsg = self.sessionServerSocket.recv (msgLen)
# Can now release the lock
self.socketLock.release()
except Exception, e:
# Something went wrong talking to the session server.
self.socketLock.release()
self.log.error ("Error communicating with the session server (%s), trying to re-connect." % str (e))
self.connectToServer()
# Return a new session with the old session ID
return Session(cookieValue)
msg = xdrlib.Unpacker (rawmsg)
msgType = msg.unpack_string()
self.log.info ("Response is message type: %s" % msgType)
if (msgType == 'NOTFOUND'):
self.log.warn ("Session for ID %s was not found!" % str (cookieValue))
sessID = getNewSessionID ()
cookies [self.cookieName] = sessID
return Session(sessID)
elif (msgType == 'FOUND'):
self.log.info ("Session for ID %s found in server." % str (cookieValue))
pickledSessionData = msg.unpack_string()
# The pickled object
# Now de-pickle the list of name-value pairs.
sessionData = cPickle.loads (pickledSessionData)
if ((time.time() - sessionData.getLastAccessed()) > self.lifeSpan):
self.log.info ("Session has expired - cleaning up old data.")
sessionData.clear()
return sessionData
else:
self.log.error ("Unsupported message command respones from session server: " + str (msgType))
raise Exception ("Unsupported message command respones from session server: " + str (msgType))
def saveSession (self, session):
msg = xdrlib.Packer()
msg.pack_string ("SET")
session.lastAccessed = time.time()
msg.pack_string (session.getSessionID())
msg.pack_string (cPickle.dumps (session))
msg = msg.get_buffer()
msgLen = struct.pack ('!l', len (msg))
# Must get the lock at this stage!
try:
self.socketLock.acquire()
self.log.info ("Sending SET message to server.")
self.sessionServerSocket.sendall (msgLen)
self.sessionServerSocket.sendall (msg)
# Get the response
self.log.info ("Waiting for response.")
msgLen = struct.unpack ('!l', self.sessionServerSocket.recv (4))[0]
rawmsg = self.sessionServerSocket.recv (msgLen)
# Can now release the lock
self.socketLock.release()
except Exception, e:
# Something went wrong talking to the session server.
self.socketLock.release()
self.log.error ("Error communicating with the session server (%s), trying to re-connect." % str (e))
self.connectToServer()
return
msg = xdrlib.Unpacker (rawmsg)
msgType = msg.unpack_string()
self.log.info ("Response is message type: %s" % msgType)
if (msgType == 'OK'):
self.log.info ("Session saved OK.")
else:
self.log.error ("Error saving session!")
raise Exception ("Error saving session.")
def closeClient (self):
msg = xdrlib.Packer()
msg.pack_string ("BYE")
msg = msg.get_buffer()
msgLen = struct.pack ('!l', len (msg))
# Must get the lock at this stage!
try:
self.socketLock.acquire()
self.log.info ("Sending BYE message to server.")
self.sessionServerSocket.sendall (msgLen)
self.sessionServerSocket.sendall (msg)
# Get the response
self.log.info ("Waiting for response.")
msgLen = struct.unpack ('!l', self.sessionServerSocket.recv (4))[0]
rawmsg = self.sessionServerSocket.recv (msgLen)
self.log.info ("Closing socket connection.")
self.sessionServerSocket.close()
self.sessionServerSocket = None
# Can now release the lock
self.socketLock.release()
except Exception, e:
# Something went wrong talking to the session server.
self.socketLock.release()
self.log.error ("Error communicating with the session server (%s), trying to re-connect." % str (e))
self.connectToServer()
return
PK SªC8{ßK´ ´ wsgiutils/__init__.pyc;ò
/}nCc @ s
d Z d S( s 0.7N( s __version__( s __version__( ( s6 build/bdist.darwin-8.0.1-x86/egg/wsgiutils/__init__.pys ? s PK YªC8“×2 EGG-INFO/zip-safe
PK MªC8ÿ _9 9 EGG-INFO/SOURCES.txtREADME.txt
setup.py
lib/WSGIUtils.egg-info/PKG-INFO
lib/WSGIUtils.egg-info/SOURCES.txt
lib/WSGIUtils.egg-info/dependency_links.txt
lib/WSGIUtils.egg-info/top_level.txt
lib/wsgiutils/SessionClient.py
lib/wsgiutils/SessionServer.py
lib/wsgiutils/__init__.py
lib/wsgiutils/wsgiAdaptor.py
lib/wsgiutils/wsgiServer.py
PK MªC8“×2 EGG-INFO/dependency_links.txt
PK MªC8F}+!: : EGG-INFO/PKG-INFOMetadata-Version: 1.0
Name: WSGIUtils
Version: 0.7
Summary: WSGI Utils are a collection of useful libraries for use in a WSGI environnment.
Home-page: http://www.owlfish.com/software/wsgiutils/index.html
Author: Colin Stewart
Author-email: colin@owlfish.com
License: UNKNOWN
Description: UNKNOWN
Platform: UNKNOWN
PK MªC8ˆ:¨N
EGG-INFO/top_level.txtwsgiutils
PK UªC8h”ã‰é é ¤ wsgiutils/SessionServer.pycPK )ˆf3®EDC ¤" wsgiutils/__init__.pyPK TªC8®”òŠg: g: ¤i wsgiutils/wsgiAdaptor.pycPK \yO2Õé É ) ) ¤Q wsgiutils/wsgiAdaptor.pyPK UªC8NŸ§ëÄ# Ä# ¤[z wsgiutils/wsgiServer.pycPK VªC8o âº1 1 ¤Už wsgiutils/SessionClient.pycPK Sg1Ó"ƒ ƒ ¤ Ð wsgiutils/SessionServer.pyPK )ˆf3|BŠ½X X ¤Ùá wsgiutils/wsgiServer.pyPK ««o1Ú¢ø% ø% ¤fü wsgiutils/SessionClient.pyPK SªC8{ßK´ ´ ¤–" wsgiutils/__init__.pycPK YªC8“×2 ¤~# EGG-INFO/zip-safePK MªC8ÿ _9 9 ¤®# EGG-INFO/SOURCES.txtPK MªC8“×2 ¤% EGG-INFO/dependency_links.txtPK MªC8F}+!: : ¤U% EGG-INFO/PKG-INFOPK MªC8ˆ:¨N
¤¾& EGG-INFO/top_level.txtPK ü&