def _setPickle(self, data):
tmppath = self._picklepath + '.tmp'
try:
cPickle.dump(data, open(tmppath, 'w'), 1)
os.rename(tmppath, self._picklepath)
except:
logException()
def _setPickle(self, data):
tmppath = self._picklepath + '.tmp'
try:
cPickle.dump(data, open(tmppath, 'w'), 1)
os.rename(tmppath, self._picklepath)
except:
logException()
def __parseComponentName(self, name):
"""
I expect a name of the following sort: host[:port]absolutePath,
where absolutePath begins with a slash, and contains no colons,
and port is an integer, and host contains neither a colon nor a slash.
"""
DEBUG(REMOTE_CLIENT, "in __parseComponentName with name %s" % name)
try:
slashIndex = name.find("/")
assert slashIndex > 0
path = name[1 + slashIndex :]
DEBUG(REMOTE_CLIENT, "path is %s" % path)
colonIndex = name.find(":")
assert colonIndex < slashIndex
if colonIndex > -1:
assert colonIndex > 0
host = name[:colonIndex]
DEBUG(REMOTE_CLIENT, "host is %s" % host)
port = int(name[1 + colonIndex : slashIndex])
else:
host = name[:slashIndex]
port = DEFAULT_PORT
except:
logException()
raise ValueError, "component name could not be parsed"
return host, port, path
def _processRequest(conn, sessionDict):
DEBUG(EXTCGI, 'extcgi Processing Request')
#dict of environ, headers, stdin
kid_stdin, parent_to_kid_stdin = os.pipe()
parent_to_kid_stdout, kid_stdout = os.pipe()
parent_to_kid_stderr, kid_stderr = os.pipe()
pid = os.fork()
try:
if pid: #ok I'm the parent
DEBUG(EXTCGI, 'child pid is %d' % pid)
#close kid sides
os.close(kid_stdin)
os.close(kid_stdout)
os.close(kid_stderr)
stdin = conn._stdin
return _doCGI(conn, pid, parent_to_kid_stdin,
parent_to_kid_stdout,
parent_to_kid_stderr, stdin)
else: #I'm the kid
#close parent side of pipes
os.close(parent_to_kid_stdin)
os.close(parent_to_kid_stdout)
os.close(parent_to_kid_stderr)
#dup kid sides to my stdin/out/err
os.dup2(kid_stdin, 0)
os.dup2(kid_stdout, 1)
os.dup2(kid_stderr, 2)
env = _fix(conn.env)
if DEBUGIT(EXTCGI):
DEBUG(EXTCGI, "environment is %s" % _dispenv(env))
prog = Configuration.CGIProgram
args = ( (prog,) + (prog,) +
Configuration.CGIProgramArgs +(env,))
DEBUG(EXTCGI, 'args is %s' % repr(args))
oldpwd = os.getcwd()
try:
os.chdir(os.path.split(env["PATH_TRANSLATED"])[0])
os.execle(*args)
finally:
os.chdir(oldpwd)
except:
if pid == 0: #I'm the kid
logException()
#give the parent some info as to why I died
os.write(kid_stderr, "exception executing CGI : %s %s" % (
sys.exc_info()[0], sys.exc_info()[1]))
DEBUG(EXTCGI, "I'm still here! killing self");
os.kill(os.getpid(), 9)
else: #I'm the parent
e, t, tb = sys.exc_info()
try:
os.kill(pid, 9) # we screwed up, kill kid
except: #in event that it's already dead, that's ok too
pass
raise e, t, tb
def _beginSession(sock, sessionDict):
# capture the ip & port (or path, for a unix socket)
# on which the request came, for scoping of configuration
# data on their basis
ip, port, unixpath=None, None, None
try:
addr=sock.getsockname()
if type(addr)==types.TupleType:
ip, port=addr
else:
unixpath=addr
except:
ERROR("failed to read addr off socket!")
logException()
raise
if ip and port:
sessionDict[constants.IP]=ip
sessionDict[constants.PORT]=port
else:
sessionDict[constants.UNIXPATH]=unixpath
# get configuration data for the job
Configuration.scope(sessionDict)
# job must be defined, or else die here
if Configuration.job==None:
message="No job specified for service on %s:%d, "\
"request cannot be processed!" % (ip, port)
ERROR(message)
raise SkunkCriticalError, message
BeginSession(Configuration.job, sock, sessionDict)
def getConfiguredSlots(path=None, slotfilename=None):
"""
get the slots configured for given path.
"""
if path is None:
path = current_component()
if slotfilename is None:
slotfilename = C.slotConfigFilename
elif not path.endswith('/'):
path = path + '/'
slots = {}
conffiles=[pathjoin(path[:(x or 1)], slotfilename) \
for x, y in enumerate(path) if y=='/']
for c in conffiles:
try:
newslots = datacomp(c, path=path)
except FileNotFoundException:
continue
except VFSException:
logException()
continue
else:
slots.update(newslots)
return slots
def getConfiguredSlots(path=None, slotfilename=None):
"""
get the slots configured for given path.
"""
if path is None:
path=current_component()
if slotfilename is None:
slotfilename=C.slotConfigFilename
elif not path.endswith('/'):
path=path+'/'
slots={}
conffiles=[pathjoin(path[:(x or 1)], slotfilename) \
for x, y in enumerate(path) if y=='/']
for c in conffiles:
try:
newslots=datacomp(c, path=path)
except FileNotFoundException:
continue
except VFSException:
logException()
continue
else:
slots.update(newslots)
return slots
def _processRequest(conn, sessionDict):
DEBUG(EXTCGI, 'extcgi Processing Request')
#dict of environ, headers, stdin
kid_stdin, parent_to_kid_stdin = os.pipe()
parent_to_kid_stdout, kid_stdout = os.pipe()
parent_to_kid_stderr, kid_stderr = os.pipe()
pid = os.fork()
try:
if pid: #ok I'm the parent
DEBUG(EXTCGI, 'child pid is %d' % pid)
#close kid sides
os.close(kid_stdin)
os.close(kid_stdout)
os.close(kid_stderr)
stdin = conn._stdin
return _doCGI(conn, pid, parent_to_kid_stdin, parent_to_kid_stdout,
parent_to_kid_stderr, stdin)
else: #I'm the kid
#close parent side of pipes
os.close(parent_to_kid_stdin)
os.close(parent_to_kid_stdout)
os.close(parent_to_kid_stderr)
#dup kid sides to my stdin/out/err
os.dup2(kid_stdin, 0)
os.dup2(kid_stdout, 1)
os.dup2(kid_stderr, 2)
env = _fix(conn.env)
if DEBUGIT(EXTCGI):
DEBUG(EXTCGI, "environment is %s" % _dispenv(env))
prog = Configuration.CGIProgram
args = ((prog, ) + (prog, ) + Configuration.CGIProgramArgs +
(env, ))
DEBUG(EXTCGI, 'args is %s' % repr(args))
oldpwd = os.getcwd()
try:
os.chdir(os.path.split(env["PATH_TRANSLATED"])[0])
os.execle(*args)
finally:
os.chdir(oldpwd)
except:
if pid == 0: #I'm the kid
logException()
#give the parent some info as to why I died
os.write(
kid_stderr, "exception executing CGI : %s %s" %
(sys.exc_info()[0], sys.exc_info()[1]))
DEBUG(EXTCGI, "I'm still here! killing self")
os.kill(os.getpid(), 9)
else: #I'm the parent
e, t, tb = sys.exc_info()
try:
os.kill(pid, 9) # we screwed up, kill kid
except: #in event that it's already dead, that's ok too
pass
raise e, t, tb
def _processRequest(conn, sessionDict):
DEBUG(PYCGI, "pycgi processing request")
try:
env=_fix(conn.env, conn.uri)
except vfs.FileNotFoundException:
DEBUG(PYCGI, "file not found!")
return fourOhFourHandler(conn, sessionDict)
DEBUG(PYCGI, "file evidently exists")
oldpwd=os.getcwd()
os.environ.update(env)
# what to do with argv?
save_argv=sys.argv
sys.argv=[env['SCRIPT_NAME']]
saved=_swap_streams(conn)
try:
try:
(directory, file) = os.path.split(env['SCRIPT_FILENAME'])
os.chdir(directory)
DEBUG(PYCGI, "about to execfile %s" % file)
execfile(file)
except SystemExit:
pass
except:
logException()
raise
finally:
os.chdir(oldpwd)
sys.argv=save_argv
new=_swap_streams(conn, saved)
new[0].seek(0)
respp = rfc822.Message(new[0])
for k,v in respp.items():
conn.responseHeaders[k] = v
conn.write(new[0].read())
return conn.response()
def _getPickle(self):
if os.path.exists(self._picklepath):
try:
data=cPickle.load(open(self._picklepath))
except:
logException()
data={}
return data
def __readManifest(self):
try:
data=self.__fsclass(self.file).open(os.path.join('/', manifest.MANIFEST_FILE)).read()
except vfs.VFSException:
ERROR("error in reading product manifest: %s" % self.file)
logException()
raise
self.manifest=manifest.read_manifest(data)
def _getPickle(self):
if os.path.exists(self._picklepath):
try:
data = cPickle.load(open(self._picklepath))
except:
logException()
data = {}
return data
def _initCookies(self):
self.requestCookie = Cookie.SimpleCookie()
if self.requestHeaders.has_key('Cookie'):
try:
self.requestCookie.load(self.requestHeaders['Cookie'])
except Cookie.CookieError:
logException()
self.responseCookie = Cookie.SimpleCookie()
def __readManifest(self):
try:
data=self.__fsclass(self.file).open(os.path.join('/', manifest.MANIFEST_FILE)).read()
except vfs.VFSException:
ERROR("error in reading product manifest: %s" % self.file)
logException()
raise
self.manifest=manifest.read_manifest(data)
def _initCookies(self):
self.requestCookie = Cookie.SimpleCookie()
if self.requestHeaders.has_key('Cookie'):
try:
self.requestCookie.load(self.requestHeaders['Cookie'])
except Cookie.CookieError:
logException()
self.responseCookie = Cookie.SimpleCookie()
def _sendResponse(sock,
responseData,
requestData,
sessionDict):
try:
SocketScience.send_it_all(sock, responseData)
except IOError, en: #ignore broken pipes
if en != errno.EPIPE:
logException()
def _sendResponse(sock,
responseData,
requestData,
sessionDict):
try:
SocketScience.send_it_all(sock, responseData)
except IOError, en: #ignore broken pipes
if en != errno.EPIPE:
logException()
def _resolve_string(controllerName):
try:
c=_import_a_class(controllerName)
except ImportError:
logException()
return None
else:
# do we need to instantiate one?
# who says this needs to be a instance anyway?
return c
def _resolve_string(controllerName):
try:
c = _import_a_class(controllerName)
except ImportError:
logException()
return None
else:
# do we need to instantiate one?
# who says this needs to be a instance anyway?
return c
def __setPickle(self, data):
f=open(self._picklepath, 'w')
fd=f.fileno()
fcntl.flock(fd, fcntl.LOCK_EX)
try:
cPickle.dump(data, f, 1)
except:
logException()
fcntl.flock(fd, fcntl.LOCK_UN)
f.close()
def __getPickle(self):
if os.path.exists(self._picklepath):
f=open(self._picklepath)
fd=f.fileno()
# let reads coexist
fcntl.flock(fd, fcntl.LOCK_SH)
try:
data=cPickle.load(f)
except:
logException()
data={}
fcntl.flock(fd, fcntl.LOCK_UN)
f.close()
return data
def execSql(self, sql, args=None):
try:
db=self.getConnection()
cursor=db.cursor()
cursor.execute(sql, args)
retval=cursor.fetchall()
cursor.close()
db.commit()
return retval
except Exception, e:
DEBUG(SESSIONHANDLER, "sql exception -- see error log")
logException()
try:
db.rollback()
except:
pass
def authFailed(self, conn):
try:
page=AE.Component.callComponent(
self.loginPage, {'CONNECTION':conn})
# string exception left here for backwards compatibility
except ("OK", OK):
#this is the magical "do whatever you would've done" bit
AE.Component.resetComponentStack()
return
except:
DEBUG(AUTH, 'ACK! exception rendering login page')
logException()
page = "error occurred rendering login page"
conn._output.write(page)
resp = conn.response()
DEBUG(AUTH, "page is %s" % resp)
raise PreemptiveResponse, resp
def authFailed(self, conn):
try:
page = AE.Component.callComponent(self.loginPage,
{'CONNECTION': conn})
# string exception left here for backwards compatibility
except ("OK", OK):
#this is the magical "do whatever you would've done" bit
AE.Component.resetComponentStack()
return
except:
DEBUG(AUTH, 'ACK! exception rendering login page')
logException()
page = "error occurred rendering login page"
conn._output.write(page)
resp = conn.response()
DEBUG(AUTH, "page is %s" % resp)
raise PreemptiveResponse, resp
def _initArgs(self, requestData):
stdin = cStringIO.StringIO(requestData['stdin'])
env = requestData['environ']
try:
query = cgi.FieldStorage(fp = stdin, environ = env,
keep_blank_values = 1)
self.args=self._convertArgs(query)
ok=1
except:
# may be some exotic content-type
logException()
DEBUG(WEB, "content-type: %s" % self.requestHeaders.get("content-type"))
self.args={}
ok=0
if ok and Configuration.mergeQueryStringWithPostData and \
env.get("REQUEST_METHOD")=='POST':
#if POST, see if any GET args too
environ = env.copy()
environ["REQUEST_METHOD"] = 'GET'
query = cgi.FieldStorage(fp = stdin, environ = environ,
keep_blank_values = 1)
self.args.update(self._convertArgs(query))
def _sendResponse(sock,
responseData,
requestData,
sessionDict):
try:
SocketScience.send_it_all(sock, responseData)
except:
logException()
# reset alarm
signal.alarm(Configuration.PostResponseTimeout)
try:
DEBUG(REQUESTHANDLER, 'post request hook')
PostRequest(Configuration.job, requestData, sessionDict)
except:
logException()
try:
DEBUG(REQUESTHANDLER, "cleaning up")
CleanupRequest(Configuration.job, requestData, sessionDict)
except:
logException()
HaveConnection(Configuration.job, connection, sessionDict)
# DEBUG(WEB, 'survived HaveConnection hook')
# overlay of config information
Configuration.trim()
Configuration.scope(sessionDict)
#Configuration.saveMash()
# DEBUG(WEB, 'executing PreHandleConnection hook')
PreHandleConnection(Configuration.job, connection, sessionDict)
except PreemptiveResponse, pr:
# DEBUG(WEB, 'got preemptive response')
response=pr.responseData
except:
logException()
else:
RouteConnection(Configuration.job, connection, sessionDict)
# DEBUG(WEB, 'handling connection')
response=HandleConnection(Configuration.job, connection, sessionDict)
# so the response can be further processed, add it to the sessionDict temporarily
sessionDict['RESPONSE']=response
ProcessResponse(connection, sessionDict)
response=sessionDict['RESPONSE']
del sessionDict['RESPONSE']
# the connection should be available to postResponse and cleanup hooks.
sessionDict[constants.CONNECTION]=connection
# DEBUG(WEB, 'returning response: %s' % response)
#if response!=None:
def _endSession(sessionDict):
try:
EndSession(Configuration.job, sessionDict)
except:
logException()
Configuration.trim()
else:
# DEBUG(REQUESTHANDLER, 'handling request')
rawResponse=HandleRequest(Configuration.job,
requestData,
sessionDict)
# DEBUG(REQUESTHANDLER, 'response returned: %s' % str(rawResponse))
# DEBUG(REQUESTHANDLER, 'marshalling response')
responseData=protocolImpl.marshalResponse(rawResponse,
sessionDict)
except:
try:
# the current exception is available anyway, so is not passed;
# perhaps nothing should be
# DEBUG(REQUESTHANDLER, 'marshalling exception')
responseData=protocolImpl.marshalException(logException(),
sessionDict)
except:
logException()
finally:
# DEBUG(REQUESTHANDLER, 'sending response')
_sendResponse(sock,
responseData,
requestData,
sessionDict)
signal.alarm(0)
signal_plus.unblockTERM()
# the protocol can close the connection by return a negative timeout;
# sessionDict allows it to reference state that has been stored there.
