cdli/cdli_files.py - diff

Return to cdli_files.py CVS log

Up to [Repository] / cdli

Diff for /cdli/cdli_files.py between versions 1.99 and 1.103

version 1.99, 2008/10/15 07:48:05	version 1.103, 2008/11/05 19:53:32
Line 1	Line 1
"""CDLI extensions of the filearchive"""	"""CDLI extensions of the filearchive"""
from Products.versionedFile.extVersionedFile import *	from Products.versionedFile.extVersionedFile import *
from Products.ZCatalog.CatalogPathAwareness import CatalogAware	from Products.ZCatalog.CatalogPathAwareness import CatalogAware
from tempfile import mkstemp,mkdtemp
import os.path	import os.path
import os	import os
from types import *
import urlparse	import urlparse
import urllib	import urllib
import cgi	import cgi
Line 21 from ZPublisher.HTTPRequest import HTTPR	Line 19 from ZPublisher.HTTPRequest import HTTPR
from ZPublisher.HTTPResponse import HTTPResponse	from ZPublisher.HTTPResponse import HTTPResponse
from ZPublisher.BaseRequest import RequestContainer	from ZPublisher.BaseRequest import RequestContainer
import threading	import threading
from BTrees.OOBTree import OOBTree, OOTreeSet
import logging	import logging
import transaction	import transaction
import copy	import copy
Line 32 import cdliSplitter	Line 29 import cdliSplitter
from sets import Set	from sets import Set
import md5	import md5
from DownloadBasket import DownloadBasketFinallyThread	from DownloadBasket import DownloadBasketFinallyThread
	from types import *
	import pickle

def makelist(mySet):	def makelist(mySet):
x = list(mySet)	x = list(mySet)
Line 224 def unique(s):	Line 223 def unique(s):
class BasketContent(SimpleItem):	class BasketContent(SimpleItem):
"""classe fuer den Inhalt eines Baskets"""	"""classe fuer den Inhalt eines Baskets"""

	def getFileAndVersionFromId(self,pnum,versionNr):

	obj=self.cdliRoot.getFileObject(pnum)
	logging.debug("obj : %s"%obj)
	version=obj.getVersionNr(versionNr)
	logging.debug("-------vs: %s"%version.getFileName())
	return version,obj

def __init__(self,content=[]):	def __init__(self,content=[]):
"""content"""	"""content"""
self.contentList=content[0:]
	self.setContent(content[0:])

def getContent(self,filtered=True):	def getContent(self,filtered=True):
	return self.contentList

	def getContentOld(self,filtered=True):
"""get content"""	"""get content"""
	logging.debug("content object: content List %s"%self.contentList)
ret=[]	ret=[]
if filtered:
for x in self.contentList:
if not((x[0] is None) or (x[1] is None)):
ret.append(x)
return ret

else:	return [self.getFileAndVersionFromId(x[0],x[1]) for x in self.contentList]
return self.contentList	#
	# if filtered:
	# for x in self.contentList:
	# if not((x[0] is None) or (x[1] is None)):
	# ret.append(x)
	# logging.debug("content object: content List -done filtered")
	# return ret
	#
	# else:
	# logging.debug("content object: content List -done not filtered")
	# return self.contentList

def allContent(self):	def allContent(self):
"""get all content"""	"""get all content"""
return self.getContent(filtered=False)	return self.getContent(filtered=False)

def setContent(self,content):	def setContent(self,content):
self.contentList=content[0:]	contentList=[]
	for x in content:
	if not((x[0] is None) or (x[1] is None)):

	contentList.append((x[1].getId(),x[0].getVersionNumber()))
	logging.debug("cl: %s"%contentList)
	self.contentList=contentList[0:]

def numberOfItems(self):	def numberOfItems(self):
"""number"""	"""number"""
Line 618 class CDLIBasketContainer(OrderedFolder)	Line 641 class CDLIBasketContainer(OrderedFolder)
security=ClassSecurityInfo()	security=ClassSecurityInfo()
meta_type="CDLIBasketContainer"	meta_type="CDLIBasketContainer"

	def getResultHash(self):
	"""get the result hash for debug purposes"""
	return self.resultHash.keys()

def getPNumbersOfBasket(self,basketName):	def getPNumbersOfBasket(self,basketName):
"""get all pnumbers of a basket as a list, returns an empty list if basket not found	"""get all pnumbers of a basket as a list, returns an empty list if basket not found
@param basketName: name of the basket	@param basketName: name of the basket
Line 627 class CDLIBasketContainer(OrderedFolder)	Line 654 class CDLIBasketContainer(OrderedFolder)
if not basketId:	if not basketId:
return []	return []

ob=getattr(self,basketId).getContent()	ob=getattr(self,basketId).getContent() #get the content of a basket

ret=[x[0].split(".")[0] for x in ob]	ret=[x[0].split(".")[0] for x in ob]

Line 646 class CDLIBasketContainer(OrderedFolder)	Line 673 class CDLIBasketContainer(OrderedFolder)
return ""	return ""

ob=getattr(self,basketId).getLastVersion()	ob=getattr(self,basketId).getLastVersion()
for object in ob.getContent():	for pnum,versionNr in ob.getContent():
	obj=self.cdliRoot.getFileObject(pnum)
	# logging.debug("obj : %s"%obj)
	# version=obj.getVersionNr(versionNr)

if current=="no": #version as they are in the basket	if current=="no": #version as they are in the basket
ret+=str(object[0].getData())+"\n"	cur= obj.getVersionNr(versionNr)
	ret+=str(cur.getData())+"\n"
elif current=="yes":	elif current=="yes":
#search current object	#search current object
#logging.debug("current: %s"%object[1].getId().split(".")[0])	#logging.debug("current: %s"%object[1].getId().split(".")[0])
founds=self.CDLICatalog.search({'title':object[1].getId().split(".")[0]})	obj.getData()
if len(founds)>0:
ret+=str(founds[0].getObject().getLastVersion().getData())+"\n"
return ret	return ret

security.declareProtected('manage','upDateBaskets')	security.declareProtected('manage','upDateBaskets')
Line 1060 class CDLIBasket(Folder,CatalogAware):	Line 1090 class CDLIBasket(Folder,CatalogAware):
return [x[1].getId() for x in self.getLastVersion().getContent()]	return [x[1].getId() for x in self.getLastVersion().getContent()]


def isActual(self,obj):	def isActual(self,obj,nummer):
	"""teste ob im basket die aktuelle version ist, obj kann entweder ein CDLIFile sein oder eine
	eine pnummer, die auf ein CDLIFile verweist"""
	try:
	#logging.debug("isActual:"+repr(obj))
	if isinstance(obj, CDLIFile):
	actualNo=obj.getLastVersion().getVersionNumber()
	else:
	actualNo=self.cdliRoot.getFileObjectLastVersion(obj).getVersionNumber()

	if actualNo==nummer:
	return True , 0
	else:
	return False, actualNo
	except:
	logging.error( """is actual: %s (%s %s)"""%(repr(obj),sys.exc_info()[0],sys.exc_info()[1]))
	logging.error(""" PARAMS: %s %s"""%(obj,nummer))
	return False, -1
	def isActualOld(self,obj):
"""teste ob im basket die aktuelle version ist"""	"""teste ob im basket die aktuelle version ist"""
try:	try:
#logging.debug("isActual:"+repr(obj))	#logging.debug("isActual:"+repr(obj))
Line 1228 class CDLIBasket(Folder,CatalogAware):	Line 1276 class CDLIBasket(Folder,CatalogAware):
def swap(x):	def swap(x):
return (x[1],x[0])	return (x[1],x[0])

	logging.info("add to basket (%s)"%(repr(ids)))
logging.info("add to basket (%s)"%(self.getId()))	logging.info("add to basket (%s)"%(self.getId()))
lastVersion=self.getLastVersion()	lastVersion=self.getLastVersion()

Line 1256 class CDLIBasket(Folder,CatalogAware):	Line 1305 class CDLIBasket(Folder,CatalogAware):
hash = md5.new(repr(makelist(ids))).hexdigest() # erzeuge hash als identification	hash = md5.new(repr(makelist(ids))).hexdigest() # erzeuge hash als identification
#logging.debug("JJJJJJJ:"+repr(self.makelist(ids)))	#logging.debug("JJJJJJJ:"+repr(self.makelist(ids)))

	retrieved = self.CDLICache.retrieve(hash)
if hasattr(self.cdliRoot,'v_tmpStore') and self.cdliRoot.v_tmpStore.has_key("hash"): #TODO: muss eigentlich self.cdliRoot.v_tmpStore.has_key(hash): heissen (ohne "), erstmal so gesetzt damit der hash hier nie benutzt wird	if retrieved:
logging.debug("from store!")	newContent=Set(map(swap,retrieved))
newContent=Set(map(swap,self.cdliRoot.v_tmpStore[hash]))

else:	else:
logging.debug("not from store!")
newContent=Set([(self.getFileObjectLastVersion(x),self.getFileObject(x)) for x in ids])	newContent=Set([(self.getFileObjectLastVersion(x),self.getFileObject(x)) for x in ids])



	#remove all Elements which are not stored
	if (None,None) in newContent:
	newContent.remove((None,None))
content=Set(oldContent).union(newContent)	content=Set(oldContent).union(newContent)
added = len(content)-len(oldContent)	added = len(content)-len(oldContent)
if not username:	if not username:
Line 1285 class CDLIBasket(Folder,CatalogAware):	Line 1335 class CDLIBasket(Folder,CatalogAware):
ret=[]	ret=[]

lv=self.getLastVersion()	lv=self.getLastVersion()
for obj in lv.content.getContent():	#for obj in lv.content.getContent():
#logging.info("XXXXXXXXXX %s"%repr(obj))	#logging.info("XXXXXXXXXX %s"%repr(obj))
ret.append((obj[1].getId(),obj[0].versionNumber))	# ret.append((obj[1].getId(),obj[0].versionNumber))

return ret	return lv

def getContentIds(self):	def getContentIds(self):
"""print basket content"""	"""print basket content"""
Line 1373 class CDLIBasketVersion(Implicit,Persist	Line 1423 class CDLIBasketVersion(Implicit,Persist

objs=self.getContent()	objs=self.getContent()
for obj in objs:	for obj in objs:
if not self.isActual(obj)[0]:	if not self.isActual(obj[0],obj[1])[0]:
return True	return True
return False	return False

Line 1400 class CDLIBasketVersion(Implicit,Persist	Line 1450 class CDLIBasketVersion(Implicit,Persist
return """I am sorry, currently the server has to many requests for downloads, please come back later!"""	return """I am sorry, currently the server has to many requests for downloads, please come back later!"""


if (check=="yes") and self.containsNonActualFiles():	#if (check=="yes") and self.containsNonActualFiles():
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','downloadObjectAsOneFile_check.zpt')).__of__(self)	# pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','downloadObjectAsOneFile_check.zpt')).__of__(self)
	#
	# return pt(lock=lock)

	# neue Version aus Performancegruenden, es wird nicht mehr getestet, ob es nicht aktuelle Objekte gibt
	# sondern lediglich gefragt.
	if (check=="yes"):
	pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','downloadObjectAsOneFile_ask.zpt')).__of__(self)

return pt(lock=lock)	return pt(lock=lock)

Line 1427 class CDLIBasketVersion(Implicit,Persist	Line 1484 class CDLIBasketVersion(Implicit,Persist
#check if a locked object exist in the basket.	#check if a locked object exist in the basket.
lockedObjects={}	lockedObjects={}
for object in self.content.getContent():	for object in self.content.getContent():
	obj=self.getFileObject(object[0])
if (not str(object[1].lockedBy)=="") and (not (str(object[1].lockedBy)==str(self.REQUEST['AUTHENTICATED_USER']))):	if (not str(obj.lockedBy)=="") and (not (str(obj.lockedBy)==str(self.REQUEST['AUTHENTICATED_USER']))):
lockedObjects[object[1].title]=repr(object[1].lockedBy)	lockedObjects[obj.title]=repr(obj.lockedBy)


keys=lockedObjects.keys()	keys=lockedObjects.keys()
Line 1480 class CDLIBasketVersion(Implicit,Persist	Line 1537 class CDLIBasketVersion(Implicit,Persist
if lock:	if lock:
logging.debug("-----start locking")	logging.debug("-----start locking")
for object in self.content.getContent():	for object in self.content.getContent():
if object[1].lockedBy =='':	obj=self.ctx.getFileObject(object[0])
object[1].lockedBy=self.REQUEST['AUTHENTICATED_USER']	if obj.lockedBy =='':
	obj.lockedBy=self.REQUEST['AUTHENTICATED_USER']
logging.debug("-----finished locking")	logging.debug("-----finished locking")

#obj.lockedBy=user	#obj.lockedBy=user
Line 1531 class CDLIBasketVersion(Implicit,Persist	Line 1589 class CDLIBasketVersion(Implicit,Persist
self._v_downloadBasket[threadName]=thread	self._v_downloadBasket[threadName]=thread

#files = self._v_downloadBasket[threadName].result	#files = self._v_downloadBasket[threadName].result
files=self.basketContainer.resultHash[threadName]	# lade die files und die locked files, bei grossen Baskets muss u.U. gewartet werden
lockedFiles=self.basketContainer.resultLockedHash[threadName]	# bis das Commit aus dem Thread alles geschrieben hat, in dem Falle existiert resultHash[threadName]
	# noch nicht.
	o1 = file("/tmp/"+threadName,'r')
	files=pickle.load(o1)
	os.remove("/tmp/"+threadName)
	o2 = file("/tmp/"+threadName+'_lockedFiles','r')

	lockedFiles=pickle.load(o2)
	os.remove("/tmp/"+threadName+'_lockedFiles')
	# try:
	# files=self.basketContainer.resultHash[threadName]
	# except:
	# i=0
	# while (not self.basketContainer.resultHash.has_key(threadName)) and (i<100):
	# logging.debug(" downloadFinally: I am waiting for thread %s to write the resultHashfile: %s"%(threadName,i))
	# time.sleep(5)
	# i+=1
	# files=self.basketContainer.resultHash[threadName]
	#
	# try:
	# lockedFiles=self.basketContainer.resultLockedHash[threadName]
	# except:
	# i=0
	# while (not self.basketContainer.resultLockedHash.has_key(threadName)) and (i<100):
	# logging.debug(" downloadFinally: I am waiting for thread %s to write the LockedHashfile: %s"%(threadName,i))
	# time.sleep(5)
	# i+=1
	# lockedFiles=self.basketContainer.resultLockedHash[threadName]

# fh=file("/var/tmp/test")	# fh=file("/var/tmp/test")
#ret =fh.read()	#ret =fh.read()
Line 1556 class CDLIBasketVersion(Implicit,Persist	Line 1641 class CDLIBasketVersion(Implicit,Persist
self.REQUEST.RESPONSE.write(ret)	self.REQUEST.RESPONSE.write(ret)

for fileName in files:	for fileName in files:
	logging.debug("download: %s"%fileName)
try:	try:
self.REQUEST.RESPONSE.write(file(fileName).read())	self.REQUEST.RESPONSE.write(file(fileName).read())
except:	except:
Line 1589 class CDLIBasketVersion(Implicit,Persist	Line 1675 class CDLIBasketVersion(Implicit,Persist

def getContent(self):	def getContent(self):
"""get Basket Content"""	"""get Basket Content"""
return self.content.getContent()	logging.debug("retrieving content A")
	cnt = self.content
	logging.debug("retrieving content: obj %s"%cnt)
	tmp = self.content.getContent()
	logging.debug("got content")
	return tmp


def __init__(self,id,user,comment="",basketContent=[]):	def __init__(self,id,user,comment="",basketContent=[]):
Line 1612 class CDLIBasketVersion(Implicit,Persist	Line 1703 class CDLIBasketVersion(Implicit,Persist
security.declareProtected('manage','index_html')	security.declareProtected('manage','index_html')
def index_html(self):	def index_html(self):
"""view the basket"""	"""view the basket"""
	logging.debug("start index_html - Basket version")
if self.REQUEST.get('change',False):	if self.REQUEST.get('change',False):
ob=self.aq_parent.updateObjects(self.REQUEST['change'])	ob=self.aq_parent.updateObjects(self.REQUEST['change'])

self.REQUEST.RESPONSE.redirect(ob.absolute_url())#go to new basket, because changing generates a new basket	self.REQUEST.RESPONSE.redirect(ob.absolute_url())#go to new basket, because changing generates a new basket
	logging.debug("start index_html - Basket version:template")
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketVersionMain.zpt')).__of__(self)	pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketVersionMain.zpt')).__of__(self)
return pt()	return pt()

def getObjUrl(self,result):	def getObjUrl(self,result):
"""getUrl of the version of the object"""	"""getUrl of the version of the object"""
objId=result[1].getTitle()
founds=self.CDLICatalog.search({'title':objId})	founds=self.CDLICatalog.search({'title':result})
if len(founds)>0:	if len(founds)>0:
return founds[0].getObject().getLastVersion().absolute_url()	return founds[0].getObject().getLastVersion().absolute_url()

else: #assume version number	else: #assume version number
splitted=objId.split("_")	splitted=result.split("_")
founds=self.CDLICatalog.search({'title':splitted[1]})	founds=self.CDLICatalog.search({'title':splitted[1]})
return founds[0].getObject().getLastVersion().absolute_url()+'/'+objId	return founds[0].getObject().getLastVersion().absolute_url()+'/'+result

def manage_addCDLIBasketVersion(self,user,comment="",basketContent=[],RESPONSE=None):	def manage_addCDLIBasketVersion(self,user,comment="",basketContent=[],RESPONSE=None):
"""add a version"""	"""add a version"""
Line 2134 class CDLIFileFolder(extVersionedFileFol	Line 2225 class CDLIFileFolder(extVersionedFileFol
pt=getattr(self,'filelist.html')	pt=getattr(self,'filelist.html')
return pt(basketName=basketName,numberOfObjects=numberOfObjects)	return pt(basketName=basketName,numberOfObjects=numberOfObjects)

if hash is not None and hasattr(self.cdliRoot,'v_tmpStore') and self.cdliRoot.v_tmpStore.has_key(hash):

logging.debug("asking for storage2")	result =self.CDLICache.retrieve(hash)
result =self.cdliRoot.v_tmpStore[hash]
if result:	if result:
logging.debug("give result from storage2")	logging.debug("give result from storage2")
return hash,self.cdliRoot.v_tmpStore[hash]	return hash,result

if list is not None: # got already a list	if list is not None: # got already a list

Line 2200 class CDLIFileFolder(extVersionedFileFol	Line 2289 class CDLIFileFolder(extVersionedFileFol
return pt(search=ids)	return pt(search=ids)
else:	else:
#self.REQUEST.SESSION['hash'] = ret # store in session	#self.REQUEST.SESSION['hash'] = ret # store in session
if not hasattr(self,'v_tmpStore'):
self.cdliRoot.v_tmpStore={}
#logging.debug("HHHHHHNEU:"+repr(self.makelist(ids)))	#logging.debug("HHHHHHNEU:"+repr(self.makelist(ids)))
#logging.debug("HHHHHHNEU:"+repr(hash))	#logging.debug("HHHHHHNEU:"+repr(hash))
self.cdliRoot.v_tmpStore[hash] = ret # store in session	self.CDLICache.store(hash,ret)

if returnHash == True:	if returnHash == True:
return hash,ret	return hash,ret
return ret	return ret
Line 2341 class CDLIRoot(Folder):	Line 2430 class CDLIRoot(Folder):
'graphemes':cdliSplitter.graphemeSplitter()}	'graphemes':cdliSplitter.graphemeSplitter()}


	def unicodify(self,txt):
	return unicodify(txt)
	def invalidateOldCacheVersion(self):
	"""loescht die alte Version des Cache"""
	del self.v_tmpStore
	return "done"

def viewATF(self,id,RESPONSE):	def viewATF(self,id,RESPONSE):
"""view an Object"""	"""view an Object"""
ob = self.CDLICatalog({'title':id})	ob = self.CDLICatalog({'title':id})

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>

Removed from v.1.99
changed lines
	Added in v.1.103