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.53 and 1.60

version 1.53, 2006/12/22 11:56:08	version 1.60, 2007/01/30 00:58:26
Line 22 from ZPublisher.HTTPResponse import HTTP	Line 22 from ZPublisher.HTTPResponse import HTTP
from ZPublisher.BaseRequest import RequestContainer	from ZPublisher.BaseRequest import RequestContainer
import threading	import threading
from BTrees.OOBTree import OOBTree	from BTrees.OOBTree import OOBTree
	import logging
	import transaction

	def unique(s):
	"""Return a list of the elements in s, but without duplicates.

	For example, unique([1,2,3,1,2,3]) is some permutation of [1,2,3],
	unique("abcabc") some permutation of ["a", "b", "c"], and
	unique(([1, 2], [2, 3], [1, 2])) some permutation of
	[[2, 3], [1, 2]].

	For best speed, all sequence elements should be hashable. Then
	unique() will usually work in linear time.

	If not possible, the sequence elements should enjoy a total
	ordering, and if list(s).sort() doesn't raise TypeError it's
	assumed that they do enjoy a total ordering. Then unique() will
	usually work in O(N*log2(N)) time.

	If that's not possible either, the sequence elements must support
	equality-testing. Then unique() will usually work in quadratic
	time.
	(from the python cookbook)
	"""

	n = len(s)
	if n == 0:
	return []

	# Try using a dict first, as that's the fastest and will usually
	# work. If it doesn't work, it will usually fail quickly, so it
	# usually doesn't cost much to try it. It requires that all the
	# sequence elements be hashable, and support equality comparison.
	u = {}
	try:
	for x in s:
	u[x] = 1
	except TypeError:
	del u # move on to the next method
	else:
	return u.keys()

	# We can't hash all the elements. Second fastest is to sort,
	# which brings the equal elements together; then duplicates are
	# easy to weed out in a single pass.
	# NOTE: Python's list.sort() was designed to be efficient in the
	# presence of many duplicate elements. This isn't true of all
	# sort functions in all languages or libraries, so this approach
	# is more effective in Python than it may be elsewhere.
	try:
	t = list(s)
	t.sort()
	except TypeError:
	del t # move on to the next method
	else:
	assert n > 0
	last = t[0]
	lasti = i = 1
	while i < n:
	if t[i] != last:
	t[lasti] = last = t[i]
	lasti += 1
	i += 1
	return t[:lasti]

	# Brute force is all that's left.
	u = []
	for x in s:
	if x not in u:
	u.append(x)
	return u


class BasketContent(SimpleItem):	class BasketContent(SimpleItem):
"""classe fuer den Inhalt eines Baskets"""	"""classe fuer den Inhalt eines Baskets"""
Line 64 class uploadATFfinallyThread(Thread):	Line 136 class uploadATFfinallyThread(Thread):
self.username=username	self.username=username
self.serverport=serverport	self.serverport=serverport


def __call__(self):	def __call__(self):
"""call of the thread (equals run)"""	"""call of the thread (equals run)"""
self.run()	self.run()
Line 96 class uploadATFfinallyThread(Thread):	Line 169 class uploadATFfinallyThread(Thread):
#add the files	#add the files
self.uploadATFfinallyThread(ctx,self.procedure,comment=self.comment,basketname=self.basketname,unlock=self.unlock,SESSION=self.SESSION,username=self.username)	self.uploadATFfinallyThread(ctx,self.procedure,comment=self.comment,basketname=self.basketname,unlock=self.unlock,SESSION=self.SESSION,username=self.username)
#commit the transactions	#commit the transactions
get_transaction().commit()	transaction.get().commit()
conn.close()	conn.close()
#set flag for end of this method	#set flag for end of this method
self.end=True	self.end=True
Line 192 class uploadATFfinallyThread(Thread):	Line 265 class uploadATFfinallyThread(Thread):

return True	return True

	class tmpStore(SimpleItem):
	"""simple item"""
	meta_type="cdli_upload"

	def __init__(self,id):
	"""init tmp"""
	self.id=id

class uploadATFThread(Thread):	class uploadATFThread(Thread):
"""class for checking the files befor uploading"""	"""class for checking the files befor uploading"""

Line 204 class uploadATFThread(Thread):	Line 285 class uploadATFThread(Thread):
Thread.__init__(self)	Thread.__init__(self)


def set(self,upload,basketId,username,serverport="8080"):	def set(self,upload,basketId,username,idTmp,serverport="8080"):
"""set start values for the thread"""	"""set start values for the thread"""
self.result=""	self.result=""
self.upload=upload	self.upload=upload
self.basketId=basketId	self.basketId=basketId
self.username=username	self.username=username
self.serverport=serverport	self.serverport=serverport
	self.idTmp=idTmp

def __call__(self):	def __call__(self):
"""call method """	"""call method """
Line 229 class uploadATFThread(Thread):	Line 311 class uploadATFThread(Thread):
return app.__of__(RequestContainer(REQUEST = req))	return app.__of__(RequestContainer(REQUEST = req))

def run(self):	def run(self):
	idTmp=self.idTmp
self.result=""	self.result=""
#find context within ZODB	#find context within ZODB
from Zope import DB	from Zope import DB
Line 237 class uploadATFThread(Thread):	Line 319 class uploadATFThread(Thread):
root = conn.root()	root = conn.root()
app = root['Application']	app = root['Application']
ctx = self.getContext(app,serverport=self.serverport)	ctx = self.getContext(app,serverport=self.serverport)
self.uploadATFThread(ctx,self.upload,self.basketId)	logging.info("run intern")
	ctx.temp_folder._setObject(idTmp,tmpStore(idTmp))
	logging.info("call thread intern")
	self.uploadATFThread(ctx,self.upload,idTmp,self.basketId)

#ctx.cdliRoot.cdli_main.tmpStore2[self.getName()[0:]]=self.returnValue	#ctx.cdliRoot.cdli_main.tmpStore2[self.getName()[0:]]=self.returnValue

get_transaction().commit()

while self.continueVar:	transaction.get().commit()
pass

conn.close()	conn.close()

Line 253 class uploadATFThread(Thread):	Line 336 class uploadATFThread(Thread):
"""method for accessing result"""	"""method for accessing result"""
return self.result	return self.result

def uploadATFThread(self,ctx,upload,basketId=0):	def uploadATFThread(self,ctx,upload,idTmp,basketId=0):
"""upload an atf file"""	"""upload an atf file"""
#TODO: add comments	#TODO: add comments
#TODO: finish uploadATF	#TODO: finish uploadATF

	stObj=getattr(ctx.temp_folder,idTmp)
	logging.info("start, upload thread")
self.result="<html><body><h2>I got your file, start now to split it into single atf-files!</h2><p>"	self.result="<html><body><h2>I got your file, start now to split it into single atf-files!</h2><p>"

#make sure that id is a string and not an integer	#make sure that id is a string and not an integer
Line 295 class uploadATFThread(Thread):	Line 381 class uploadATFThread(Thread):
basketNameFromId=getattr(ctx2.basketContainer,basketId).title	basketNameFromId=getattr(ctx2.basketContainer,basketId).title
basketLen=getattr(ctx2.basketContainer,basketId).getLastVersion().numberOfItems()	basketLen=getattr(ctx2.basketContainer,basketId).getLastVersion().numberOfItems()

	logging.info("got the file, upload thread")
self.result+="""<html><body><h2>I got the files</h2><	self.result+="""<html><body><h2>I got the files</h2><
p>I am computing the differences to the exisiting files</p>"""	p>I am computing the differences to the exisiting files</p>"""

Line 340 class uploadATFThread(Thread):	Line 426 class uploadATFThread(Thread):
#ready, set the returnValues	#ready, set the returnValues
self.result+="<h3>Done</h3></body></html>"	self.result+="<h3>Done</h3></body></html>"

self.returnValue={}	stObj.returnValue={}
self.returnValue['changed']=changed
self.returnValue['errors']=errors
self.returnValue['lockerrors']=lockerrors
self.returnValue['newPs']=newPs
self.returnValue['tmpdir']=dir
self.returnValue['basketLen']=basketLen
self.returnValue['numberOfFiles']=numberOfFiles
self.returnValue['basketNameFromId']=basketNameFromId
self.returnValue['basketNameFromFile']=basketNameFromFile
self.returnValue['basketId']=basketId
self.returnValue['dir']=dir

	stObj.returnValue['errors']=errors

	stObj.returnValue['newPs']=newPs
	stObj.returnValue['tmpdir']=dir
	stObj.returnValue['basketLen']=basketLen
	stObj.returnValue['numberOfFiles']=numberOfFiles
	stObj.returnValue['basketNameFromId']=basketNameFromId
	stObj.returnValue['basketNameFromFile']=basketNameFromFile
	stObj.returnValue['basketId']=basketId
	stObj.returnValue['dir']=dir

	stObj.returnValue['changed']=[x[0].getId() for x in changed]
	stObj.returnValue['lockerrors']=[x[0].getId() for x in lockerrors]
	self.returnValue=True
#ctx2.cdli_main.setTemp('v_uploadATF_returnValue',True)	#ctx2.cdli_main.setTemp('v_uploadATF_returnValue',True)


Line 559 class BasketObject_old(Folder):	Line 648 class BasketObject_old(Folder):

self.temp_folder.downloadCounter+=1	self.temp_folder.downloadCounter+=1
self._p_changed=1	self._p_changed=1
get_transaction().commit()

	transaction.get().commit()

for object in self.contents:	for object in self.contents:

Line 578 class BasketObject_old(Folder):	Line 667 class BasketObject_old(Folder):
self.REQUEST.RESPONSE.write(ret)	self.REQUEST.RESPONSE.write(ret)
self.temp_folder.downloadCounter-=1	self.temp_folder.downloadCounter-=1
self._p_changed=1	self._p_changed=1
get_transaction().commit()	transaction.get().commit()



def manage_addBasket_oldObjectForm(self):	def manage_addBasket_oldObjectForm(self):
Line 1121 class CDLIBasketVersion(Implicit,Persist	Line 1211 class CDLIBasketVersion(Implicit,Persist

self.temp_folder.downloadCounterBaskets+=1	self.temp_folder.downloadCounterBaskets+=1
self._p_changed=1	self._p_changed=1
get_transaction().commit()	transaction.get().commit()

if lock:	if lock:

if str(self.REQUEST['AUTHENTICATED_USER'])=='Anonymous User':	if str(self.REQUEST['AUTHENTICATED_USER'])=='Anonymous User':
self.temp_folder.downloadCounterBaskets-=1	self.temp_folder.downloadCounterBaskets-=1
self._p_changed=1	self._p_changed=1
get_transaction().commit()	transaction.get().commit()
self.temp_folder.downloadCounterBaskets-=1	self.temp_folder.downloadCounterBaskets-=1
self._p_changed=1	self._p_changed=1
get_transaction().commit()	transaction.get().commit()
return "please login first"	return "please login first"

#check if a locked object exist in the basket.	#check if a locked object exist in the basket.
Line 1151 class CDLIBasketVersion(Implicit,Persist	Line 1241 class CDLIBasketVersion(Implicit,Persist

self.temp_folder.downloadCounterBaskets-=1	self.temp_folder.downloadCounterBaskets-=1
self._p_changed=1	self._p_changed=1
get_transaction().commit()	transaction.get().commit()

return pt()	return pt()

Line 1181 class CDLIBasketVersion(Implicit,Persist	Line 1271 class CDLIBasketVersion(Implicit,Persist

self.temp_folder.downloadCounterBaskets-=1	self.temp_folder.downloadCounterBaskets-=1
self._p_changed=1	self._p_changed=1
get_transaction().commit()	transaction.get().commit()

self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s.atf" """%basket_name)	self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s.atf" """%basket_name)
self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")	self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
Line 1760 class CDLIFileFolder(extVersionedFileFol	Line 1850 class CDLIFileFolder(extVersionedFileFol

self.temp_folder.downloadCounter+=1	self.temp_folder.downloadCounter+=1
self._p_changed=1	self._p_changed=1
get_transaction().commit()	transaction.get().commit()

list=[(x.getId,x) for x in catalog()]	list=[(x.getId,x) for x in catalog()]
list.sort(sortF)	list.sort(sortF)
Line 1780 class CDLIFileFolder(extVersionedFileFol	Line 1870 class CDLIFileFolder(extVersionedFileFol
RESPONSE.write(obj.getLastVersion().getData()[0:])	RESPONSE.write(obj.getLastVersion().getData()[0:])
self.temp_folder.downloadCounter-=1	self.temp_folder.downloadCounter-=1
self._p_changed=1	self._p_changed=1
get_transaction().commit()	transaction.get().commit()
#os.close(tf)	#os.close(tf)
#RESPONSE.redirect(self.absolute_url()+"/downloadFile?fn="%tfilename)	#RESPONSE.redirect(self.absolute_url()+"/downloadFile?fn="%tfilename)
return True	return True
Line 1862 class CDLIRoot(Folder):	Line 1952 class CDLIRoot(Folder):
meta_type="CDLIRoot"	meta_type="CDLIRoot"
downloadCounterBaskets=0# counts the current basket downloads if counter > 10 no downloads are possible	downloadCounterBaskets=0# counts the current basket downloads if counter > 10 no downloads are possible

	def findWordRegExp(self,searchTerm):
	"""find all words in index which match regexp in SearchTerm"""
	ret=[]
	for x in self.lineIndex.iterkeys():
	if re.match(searchTerm,x):
	ret.append(x)
	return ret

	def searchRegExpInLineIndexDocs(self,searchTerm):
	"""search in inLineIndex with regexp"""
	if not searchTerm:
	return []
	ret=[]
	words=self.findWordRegExp(searchTerm) # suche nach allen Treffern
	logging.info("wd:%s"%words)
	for word in words:
	ret+=self.searchInLineIndexDocs(word)

	return unique(ret)

def showInLineIndex(self):	def showInLineIndex(self):
"""get the index for debug purposes"""	"""get the index for debug purposes"""
print "show"	print "show"
for x in self.lineIndex.iterkeys():	for x in self.lineIndex.iterkeys():
print "word:",x	logging.info("word:%s"%repr(x))
for y in self.lineIndex[x].iterkeys():	#for y in self.lineIndex[x].iterkeys():
print "doc",y,self.lineIndex[x][y]	# print "doc",repr(y),repr(self.lineIndex[x][y])

return self.lineIndex	return self.lineIndex

def searchInLineIndexDocs(self,word):	def searchInLineIndexDocs(self,word,uniq=True,regExp=False):
"""search occurences"""	"""search occurences"""
return list(self.lineIndex.get(word.upper()).keys())

def getLinesFromIndex(self,word,doc):	if regExp:
	return self.searchRegExpInLineIndexDocs(word)

	try:
	lst=list(self.lineIndex.get(word).keys())
	except:
	lst=[]
	if uniq:
	return unique(lst)
	else:
	return lst

	def getLinesFromIndex(self,word,doc,regExp=False):
"""get lines"""	"""get lines"""
return self.lineIndex[word][doc]	if not regExp:
	return self.lineIndex.get(word)[doc]
	else: # wenn regexp, suche welches word
	for w in self.findWordRegExp(word):
	if self.lineIndex.get(w): # ein word in im dex gefunden
	try:
	dc=self.lineIndex.get(word)[doc]
	return dc # und ein document dann gib es zurueck
	except:
	pass #andernfalls weiter

def cleanInLineIndex(self):	def cleanInLineIndex(self):
"""delete InlineIndex"""	"""delete InlineIndex"""
Line 1897 class CDLIRoot(Folder):	Line 2027 class CDLIRoot(Folder):

if li.has_key(key):	if li.has_key(key):

if li[key].has_key(value[0]) and (not (value[1] in li[key][value[0]])):	# if li[key].has_key(value[0]) and (not (value[1] in li[key][value[0]])):
li[key][value[0]].append(value[1]) # add it if now in the array	if li[key].has_key(value[0]):
	tmp=li[key][value[0]]
	tmp.append(value[1]) # add it if now in the array
	li[key][value[0]]=tmp[0:]
else:	else:
li[key][value[0]]=[value[1]] # new array for lines	li[key][value[0]]=[value[1]] # new array for lines

Line 1910 class CDLIRoot(Folder):	Line 2043 class CDLIRoot(Folder):

self.lineIndex=li	self.lineIndex=li

get_transaction().commit()	transaction.get().commit()


def showFile(self,fileId):	def showFile(self,fileId):
Line 1921 class CDLIRoot(Folder):	Line 2054 class CDLIRoot(Folder):

return f[0].getObject().getLastVersionFormattedData()	return f[0].getObject().getLastVersionFormattedData()

	def showLineFromFile(self,fileId,lineNum,word):
	"""get line lineNum fromFileId"""

	file=self.showFile(fileId)
	#str="^%s\.[^%s\.]%s[^\n]\n"%(lineNum,lineNum,word)
	#str="^%s\..?%s[^\n]\n"%(lineNum,word)

	#print str
	#m=re.search(str,file,flags=re.M\|re.DOTALL)
	#if m:
	# return m.group()
	#else:
	# return ""
	#ret=lineNum+"."
	#splitted=file.split(lineNum+".")
	#if len(splitted)>1:
	#for part in splitted[1:]:
	#if part.find(word)>-1:
	# for x in part.split("\n"):
	#ret+=x
	#if x.find(word)>-1:
	#break
	#break;
	#return ret

	def showWordInFile(self,fileId,word,lineList=None):
	"""get lines with word fromFileId"""

	file=self.showFile(fileId)

	ret=[]
	for line in file.split("\n"):
	if line.find(word)>-1:
	if lineList: #liste of moeglichen Zeilennummern
	num=line.split(".")[0] #Zeilenummer ist alles vor dem . in der Zeile

	if num in lineList:

	ret.append(line)
	else: # nimm alles ohne line check
	ret.append(line)
	return ret

	def tagWordInFile(self,fileId,word,lineList=None):
	"""get lines with word fromFileId"""

	file=self.showFile(fileId)
	tagStr="""<span class="found">%s</span>"""
	ret=[]
	for line in file.split("\n"):
	if line.find(word)>-1:
	if lineList: #liste of moeglichen Zeilennummern
	num=line.split(".")[0] #Zeilenummer ist alles vor dem . in der Zeile

	if num in lineList:

	ret.append(line.replace(word,tagStr%word))
	else: # nimm alles ohne line check
	ret.append(line.replace(word,tagStr%word))
	else:
	ret.append(line)
	return "<br>\n".join(ret)

def URLquote(self,str):	def URLquote(self,str):
"""quote url"""	"""quote url"""
return urllib.quote(str)	return urllib.quote(str)
Line 1929 class CDLIRoot(Folder):	Line 2125 class CDLIRoot(Folder):
"""unquote url"""	"""unquote url"""
return urllib.unquote(str)	return urllib.unquote(str)

	def URLquote_plus(self,str):
	"""quote url"""
	return urllib.quote_plus(str)

	def URLunquote_plus(self,str):
	"""unquote url"""
	return urllib.unquote_plus(str)


def forceunlock(self):	def forceunlock(self):
"break all locks"	"break all locks"
Line 2006 class CDLIRoot(Folder):	Line 2210 class CDLIRoot(Folder):
def uploadATF(self,repeat=None,upload=None,basketId=0,RESPONSE=None):	def uploadATF(self,repeat=None,upload=None,basketId=0,RESPONSE=None):
"""standard ausgabe"""	"""standard ausgabe"""
#self._v_uploadATF.returnValue=None	#self._v_uploadATF.returnValue=None
	from random import randint
	if not self.REQUEST.SESSION.get('idTmp',None):

	idTmp=str(randint(0,1000000000))
	self.REQUEST.SESSION['idTmp']=idTmp
	else:
	idTmp=self.REQUEST.SESSION.get('idTmp',None)

threadName=repeat	threadName=repeat
if not threadName or threadName=="":	if not threadName or threadName=="":
Line 2019 class CDLIRoot(Folder):	Line 2230 class CDLIRoot(Folder):
self._v_uploadATF[threadName]=thread	self._v_uploadATF[threadName]=thread
#self._xmltrans.start()	#self._xmltrans.start()
#thread=Thread(target=self._v_uploadATF)	#thread=Thread(target=self._v_uploadATF)
	logging.info("set thread. extern")
self._v_uploadATF[threadName].set(upload,basketId,self.REQUEST['AUTHENTICATED_USER'],serverport=self.REQUEST['SERVER_PORT'])	self._v_uploadATF[threadName].set(upload,basketId,self.REQUEST['AUTHENTICATED_USER'],idTmp,serverport=self.REQUEST['SERVER_PORT'])
#thread.start()	#thread.start()
	logging.info("start thread. extern")
self._v_uploadATF[threadName].start()	self._v_uploadATF[threadName].start()


Line 2043 class CDLIRoot(Folder):	Line 2255 class CDLIRoot(Folder):
if threadName == thread.getName():	if threadName == thread.getName():
self._v_uploadATF[threadName]=thread	self._v_uploadATF[threadName]=thread

if not self._v_uploadATF[threadName].returnValue:	if self._v_uploadATF.get(threadName,None) and (not self._v_uploadATF[threadName].returnValue):


wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])	wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
Line 2066 class CDLIRoot(Folder):	Line 2278 class CDLIRoot(Folder):
#	#
# #	# #
#tmp=self.cdli_main.tmpStore2[threadName]	#tmp=self.cdli_main.tmpStore2[threadName]
tmp=self._v_uploadATF[threadName].returnValue

self._v_uploadATF[threadName].continueVar=False	tmp=getattr(self.temp_folder,idTmp).returnValue




self.REQUEST.SESSION['changed']=[x[0].getId() for x in tmp['changed']]
self.REQUEST.SESSION['lockerrors']=[x[0].getId() for x in tmp['lockerrors']]
self.REQUEST.SESSION['errors']=tmp['errors']
self.REQUEST.SESSION['newPs']=tmp['newPs']
self.REQUEST.SESSION['tmpdir']=tmp['dir']
#del(self.cdli_main.tmpStore2[threadName])	#del(self.cdli_main.tmpStore2[threadName])


Line 2106 class CDLIRoot(Folder):	Line 2315 class CDLIRoot(Folder):

self._v_uploadATF[threadName]=thread	self._v_uploadATF[threadName]=thread

	idTmp=self.REQUEST.SESSION['idTmp']
self._v_uploadATF[threadName].set(procedure,comment=comment,basketname=basketname,unlock=unlock,SESSION=self.REQUEST.SESSION,username=self.REQUEST['AUTHENTICATED_USER'],serverport=self.REQUEST['SERVER_PORT'])	stObj=getattr(self.temp_folder,idTmp)
	self._v_uploadATF[threadName].set(procedure,comment=comment,basketname=basketname,unlock=unlock,SESSION=stObj.returnValue,username=self.REQUEST['AUTHENTICATED_USER'],serverport=self.REQUEST['SERVER_PORT'])

self._v_uploadATF[threadName].start()	self._v_uploadATF[threadName].start()

Line 2140 class CDLIRoot(Folder):	Line 2350 class CDLIRoot(Folder):
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)	pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
return pt(txt='/uploadATFfinally',threadName=threadName)	return pt(txt='/uploadATFfinally',threadName=threadName)
else:	else:
	self.REQUEST.SESSION['idTmp']=None
if RESPONSE is not None:	if RESPONSE is not None:
RESPONSE.redirect(self.absolute_url())	RESPONSE.redirect(self.absolute_url())

Line 2161 class CDLIRoot(Folder):	Line 2371 class CDLIRoot(Folder):
if not obj:	if not obj:
manage_addCDLIFileFolder(root,folder,folder)	manage_addCDLIFileFolder(root,folder,folder)
fobj=getattr(root,folder)	fobj=getattr(root,folder)
#get_transaction().commit()	#transaction.get().commit()
else:	else:
fobj=obj[0][1]	fobj=obj[0][1]

Line 2189 class CDLIRoot(Folder):	Line 2399 class CDLIRoot(Folder):

if count > 1000:	if count > 1000:
print "committing"	print "committing"
get_transaction().commit()	transaction.get().commit()
count=0	count=0
get_transaction().commit()	transaction.get().commit()
return "ok"	return "ok"

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

Removed from v.1.53
changed lines
	Added in v.1.60