view DirectorySession.py @ 0:032bc65ebafc

added core components

"""
DiractorySession.py

Created by  George Fazekas, QMUL on 2009-06-03.
Copyright (c) 2009 QMUL. All rights reserved.

This Cherrypy extension implements a hybrid session type,
where data is held in memory, while files are written to
a directory created for each session.

To use it as a builtin session type, we use:
cherrypy.lib.sessions.DirectorySession = DirectorySession
"""
from __future__ import with_statement
import os,sys,time,shutil,datetime,logging,threading,cherrypy
from cherrypy.lib.sessions import Session
from cherrypy.lib import static

from sawautil import convertFilename

class DirectorySession(Session):

	cache = {}
	locks = {}
	instanceList = []
	
	def __init__(self, id=None, **kwargs):
		# for i in self.instanceList : 
		# 	print 'previous-sessions: ', i.id
		# 	if (i.id == id) :
		# 		print 'got instance already!'
		# self.instanceList.append(self)
		# print 'instance initialised:' + str(len(self.instanceList))
		# kwargs['SESSIONS_PATH'] = os.path.abspath(kwargs['SESSIONS_PATH'])

		if not id in self.cache: 
			new_session_signal = True
		else :
			new_session_signal = False
			
		Session.__init__(self, id=id, **kwargs)

		if new_session_signal or not self.has_key('name'):
			active_sessions = str(self.__len__())
			self.name = "Session %s.%s: " %(active_sessions, str(self.id)[-2:])
			self['name'] = self.name
			self['log_count'] = 0
			try :
				# try to write initial session data into the log file
				log_msg = "%sCherrypy::DirectorySession:New Session Created: ID = %s active sessions: %s \n" %(self.name,str(self.id),active_sessions)
				log_msg += '\n'.join(map ( lambda x: "    %s: %s " %x , cherrypy.request.headers.items() ))
				cherrypy.log(log_msg)
			except :
				print "An error has occured while writing initial session data to the log file."

	def setup(cls,**kwargs):
		print 'Setting up storage class... Nothing to do here yet.'
		for k, v in kwargs.iteritems():
			setattr(cls, k, v)
			print k,v
		# cls.SESSIONS_PATH = kwargs['SESSIONS_PATH'] we could setup a cleanup thread here for the dirs too. kwargs['sessions_path'] = os.path.abspath(kwargs['sessions_path'])
		
		# NOTE: This is now passed in via tools.config: 
		# tools.sessions.SESSIONS_PATH
		
		# DELETION COMMENTED OUT
		#if (os.path.exists(cls.SESSIONS_PATH)) :
		#	shutil.rmtree (cls.SESSIONS_PATH, ignore_errors=True, onerror=None)
		#	cherrypy.log('Cherrypy::DirectorySession:setup (classmethod) Existing session directory removed.')
		if not (os.path.exists(cls.SESSIONS_PATH)) :
			os.mkdir(cls.SESSIONS_PATH)
			cherrypy.log('Cherrypy::DirectorySession:setup (classmethod) New sessions path created: %s' %str(cls.SESSIONS_PATH))
			

	setup = classmethod(setup)
	
	def get_session_name(self):
		""" Return the human readable name of the session. """
		if self.has_key('name') :
			return self['name']
		else :
			return 'Session None: '
			
	def log(self,msg,context='',severity=logging.DEBUG,traceback=True):
		""" Write into cherrypy.log using the session prefix."""
		if not self.has_key('log_count') : self['log_count'] = 0
		log_msg = self.get_session_name() + "m%03i. %s"  %(self['log_count'],msg)
		self['log_count'] += 1
		cherrypy.log(log_msg,context,severity,traceback)
	
	def get_session_path(self):
		""" Return a valid path for this session """
		if self.has_key('session_path') : 
			return self.get('session_path',None)
		else :
			if not self.id : 
				raise AssertionError("Can not create directory for uninitialised session.")
				return None
			sessionPath = os.path.join(self.SESSIONS_PATH,str(self.id))
			if os.path.exists(sessionPath) :
				# clash of session IDs (unprobable), flush data
				shutil.rmtree (sessionPath, ignore_errors=True, onerror=None)
				print "flushed data in %s" % sessionPath
			try : 
				os.makedirs(sessionPath)
			except:
				raise IOError("Session directory for id %r not created." % self.id)
				return None
			if os.path.exists(sessionPath) :
				# create an entry in self so that the clean_up thread knows about this session
				# setattr(self._data,'session_path',sessionPath)
				self['session_path'] = sessionPath
				return  sessionPath

			
	# TODO: the other use case: write the output of a pipe
	def write_file(self,fileObj,fileName,filetype = None):
		pass
		
	def write_data(self,data,filename,filetype = None):
		data = str(data)
		sessionPath = self.get_session_path()
		filePath = os.path.join(sessionPath,filename)
		# print 'writing file to: ',filePath
		with open(filePath,'wb') as f:
			f.writelines(data)

		# check file and save filetype key if given
		if not os.path.exists(filePath) \
		or not os.stat(filePath).st_size > 0 :
			cherrypy.log("Session x.xx: mxxx. Cherrypy::DirectorySession:write_data: Warning: Could not verify file: %s " %filePath)
			return False
		elif not filetype :
			return True
		elif self.has_key(filetype) :
			ol = self.get(filetype,None)
			ol.append(os.path.basename(filePath))
			self[filetype] = list(ol)
		else :
			self[filetype]= list([os.path.basename(filePath)])
		self.save()
		return True


	def write_fsfile(self,fsFile,filetype = None):
		'''Write file to session given as CGI field-storage object.'''
		#fsFile is a cgi.FieldStorage object : cherrypy._cpcgifs.FieldStorage()
		if hasattr (fsFile,'filename') and hasattr(fsFile,'file'):
			return self._write_file(fsFile.file,fsFile.filename,filetype)
			
	def write_fsfile_as(self,fsFile,filename,filetype = None):
		'''Write file to session given as CGI field-storage object.'''
		#fsFile is a cgi.FieldStorage object : cherrypy._cpcgifs.FieldStorage()
		if hasattr (fsFile,'filename') and hasattr(fsFile,'file'):
			return self._write_file(fsFile.file,filename,filetype)
	
	def _write_file(self,file,filename,filetype):
		'''Write file to session given as python file object.'''
		filename = convertFilename(filename)
		sessionPath = self.get_session_path()
		filePath = os.path.join(sessionPath,filename)
		# print 'writing file to: ',filePath

		file.seek(0)
		newFile = open(filePath,'wb')
		try :
			shutil.copyfileobj(file,newFile)
		except :
			try :
				while True:
					data = file.read(8192)
					if not data: break
					newFile.write(data)
			except:
				# newFile.close()
				cherrypy.log("Session x.xx: mxxx. Cherrypy::DirectorySession: Could not write file to session: %i " %self.id)
				raise IOError("Cherrypy::DirectorySession: Could not write file to session %r " %self.id)
		finally:
			newFile.close()
			
		if not os.path.exists(filePath) \
		or not os.stat(filePath).st_size > 0 :
			cherrypy.log("Session x.xx: mxxx. Cherrypy::DirectorySession:_write_file: Warning: Failed to verify file at: %s " %filePath)
			return False
		elif not filetype : 
			return True
		elif self.has_key(filetype) :
			ol = self.get(filetype,None)
			ol.append(os.path.basename(filePath))
			self[filetype] = list(ol)
		else :
			self[filetype]= list([os.path.basename(filePath)])
		self.save()
		return True
			
	def getFiles(self,filelist):
		pass
           
	def clean_up(self):
		"""Clean up expired sessions."""
		now = datetime.datetime.now()
		log_msg = "Session x.xx: mxxx. Cherrypy::DirectorySession: Cleaning up session data at: %s Length of cache = %i " %(str(now), len(self.cache))
		print '\nCeaning up session data at %s: \n===========================' % now
		print 'Length of cache = ', len(self.cache)
		print 'cache members: ', self.cache.keys()
		cherrypy.log(log_msg)
		
		#clean up temp if server not in use
		temp_path='/Users/Shared/george/sawa/sonic-annotator-webapp/static/temp/'
		if len(self.cache.keys()) == 0 and os.path.exists(temp_path):
			try :
				for fname in os.listdir(temp_path):
					os.remove(os.path.join(temp_path,fname))
				print "Note: Cleaned temp directory."
			except:
				print "Warning: could not clear temp directory."
				pass
		
		for id, (data, expiration_time) in self.cache.items():
			print 'Id: ', id
			print 'expiration time: ', expiration_time
			print 'Length of data: ', len(data)
			print 'data members: ', data.keys()
			print 'SESSIONS_PATH: ', self.SESSIONS_PATH

			if expiration_time < now:

				path = os.path.join(self.SESSIONS_PATH,str(id))
				if os.path.exists(path) :
					for fname in os.listdir(path):
						os.remove(os.path.join(path,fname))
					# os.removedirs(path) -> removes sessions too
					os.rmdir(path)					
				try:
					del self.cache[id]
				except KeyError:
					pass
				try:
					del self.locks[id]
				except KeyError:
					pass
	
	def _exists(self):
		return self.id in self.cache
	
	def _load(self):
		return self.cache.get(self.id)

	#this is always called on an on_end_request hook (by cherrypy.session.save)
	def _save(self, expiration_time):
		print 'Saving Session ', self.id
		self.cache[self.id] = (self._data, expiration_time)
	
	def _delete(self):
		del self.cache[self.id]
	
	def acquire_lock(self):
		"""Acquire an exclusive lock on the currently-loaded session data."""
		self.locked = True
		self.locks.setdefault(self.id, threading.RLock()).acquire()
	
	def release_lock(self):
		"""Release the lock on the currently-loaded session data."""
		self.locks[self.id].release()
		self.locked = False
	
	def __len__(self):
		"""Return the number of active sessions."""
		return len(self.cache)

cherrypy.lib.sessions.DirectorySession = DirectorySession