Return to DownloadBasket.py CVS log

Up to [Repository] / cdli

Dateiaustausch zwischen Downloadbasket-Thred und Haupt-Thread nun mit Pickle

from threading import Thread
from ZPublisher.HTTPResponse import HTTPResponse
from ZPublisher.HTTPRequest import HTTPRequest
from ZPublisher.BaseRequest import RequestContainer
import logging
import os
import transaction
import pickle

def correctFileName(filename):
    m1=filename[0:3]
    m2=filename[3:5]
    name=os.path.join("cdliRoot","cdlimain",m1,m2,filename)
    logging.debug("%s corrected zu name %s"%(filename,name))
    return name

class DownloadBasketFinallyThread(Thread):

    def __init__(self):
        """init for uploadATFfinallyThread"""
        self.continueVar=True
        self.returnValue=None
        self.end=False
        self.counter=0 # zaehlt wieviele Files schon gefunden wurden
    
        self.number=0 # Anzahl der Files im Basket
        Thread.__init__(self)

    def set(self,lock,procedure,user,current,basketID,versionNumber,serverport="28080"):
        self.procedure=procedure
        self.lock=lock
        self.user=user
        self.basketID = basketID
        self.versionNumber = versionNumber
        self.serverport=serverport
        self.current=current
        logging.debug("download thread:set")
        logging.debug("download thread:user"+repr(self.user))
       
    def __call__(self):
        """call of the thread (equals run)"""
        logging.debug("download thread:call")
        self.run()
        return True
    
    def run(self):
        """call of the thread (equals run)"""
        logging.error("---------download thread:run")
        
        from Zope2 import DB
        self.conn = DB.open()
        root = self.conn.root()
        app  = root['Application']
        self.ctx = self.getContext(app,serverport=self.serverport).cdliRoot.basketContainer
        logging.error("---------download thread:run2")
        baskets=self.ctx.ZopeFind(self.ctx,obj_metatypes=['CDLIBasket'],obj_ids=[self.basketID])
        logging.error("---------download thread:run3")
        if len(baskets)!=1:
            logging.error("ERROR: downloadBasket: cannot find basket:"+self.basketID)
            self.end=True
            return
        
        basket=baskets[0]
        logging.error("donwloadBasket: found basket:"+repr(basket))
        
        basketVersion=getattr(basket[1],self.versionNumber)
        
        self.downloadObjectsAsOneFileFinally(self.lock,self.procedure,self.user,self.current,basketVersion)
        self.end=True
        
    def getResult(self):
        """method for accessing result"""
        
        return self.result
    
    def getCounter(self):
        """gibt den Counter zurueck, wieviele Objekte schon gefunden wurden"""
        logging.error("counter:"+repr(self.counter))
        return self.counter
    

    
    def getNumberOfFiles(self):
        """gibt anzahl zurueck"""
        return self.number;
    def getContext(self, app,serverport="8080"):
        """get the context within the ZODB"""
        
        resp = HTTPResponse(stdout=None)
        env = {
            'SERVER_NAME':'localhost',
            'SERVER_PORT':serverport,
            'REQUEST_METHOD':'GET'
            }
        req = HTTPRequest(None, env, resp)
        return app.__of__(RequestContainer(REQUEST = req))
      
        
    def downloadObjectsAsOneFileFinally(self,lock=None,procedure=None,user=None,current="no",basketVersion=None):
        """print do the download"""
        logging.debug("download thread")
  
        logging.debug("downloadBasketasonefile: found basket:"+repr(basketVersion))
        ret=""

        self.counter=0
        #fh=file("/var/tmp/test","w")
        files=[]
        lockedFiles=[]
        objects=basketVersion.getContent()
        logging.debug("got object in main call")
        self.number=len(objects)
        logging.debug("objects:"+repr(self.number))
        for object in objects:
                obj=self.ctx.getFileObject(object[0])
                self.counter+=1
#                logging.error("ret:"+repr(object[0]))
#                logging.error("    -"+repr(procedure))
                try:
	                lockedBy=obj.lockedBy
                except:
                    logging.error("no object:"+repr(self.counter))
                    logging.error("no object:"+repr(object))
                    continue
			
#                lockedBy=""
#                logging.error("    -"+repr(lockedBy))
#                
                
                    #logging.error("ret1")
                if current=="no": #version as they are in the basket
                    #logging.error("ret2")
                    #object[0].addToFile2("/var/tmp/test2")
                    #ret+=str(object[0].getData())+"\n"
                    logging.debug("CURRENT YES")
                    files.append(obj.getVersionNr(object[1]).getFileName())
                elif current=="yes":
                    #logging.error("ret3")
                    #search current object
                    #founds=self.CDLICatalog.search({'title':object[1].getId().split(".")[0]})
                    obj=self.ctx.getFileObjectLastVersion(object[0])
                    if obj:
                        logging.debug("CURRENT NO")
                        files.append(correctFileName(obj.getFileName()))
                    else:
                        logging.error("downloadBasketasonefile: don't know: "+repr(object[0]))
                    #if len(founds)>0:      
                      #  ret+=str(founds[0].getObject().getLastVersion().getData())+"\n"
                  
                #falls die Datei gesperrit ist nimm sie in die Liste auf.
                if not((procedure=="downloadAll") or (lockedBy=='') or (lockedBy==user)):
                    #logging.error("ret4")
                    lockedFiles.append((object[0],str(lockedBy)))
      
                #if lock and lockedBy=='':
                    #obj=self.ctx.getFileObject(object[1].getId())
                   # founds=self.ctx.CDLICatalog.search({'title':object[1].getId().split(".")[0]})
                   #if len(founds)>0:      
                          #founds[0].getObject().lockedBy=user
                      
                #    object[1].lockedBy=user
                #    transaction.get().commit()
                    #obj.lockedBy=user
#        logging.error("---------download thread:run5")
#        pin,pout =os.popen2("xargs cat")
#        logging.error("---------download thread:run6")
#        pin.write(" ".join(files))
#        logging.error("---------download thread:run7")
#        pin.close()
#        logging.error("---------download thread:run8")
#    
#      
#        
#        fw = file("/var/tmp/test","w")
#        fw.write(pout.read())
#        fw.close()
        
#        if not hasattr(self.ctx,'resultHash'):
#            logging.debug("-------------create hash")
#            self.ctx.resultHash={}
        logging.debug("-------------writing hash: %s"%self.getName())
        #self.ctx.resultHash[self.getName()]=files
        o1 = file("/tmp/"+self.getName(),'w')
        pickle.dump(files, o1)
        o1.close()
        
        transaction.get().commit()
        if not hasattr(self.ctx,'resultLockedHash'):
            self.ctx.resultLockedHash={}
        #self.ctx.resultLockedHash[self.getName()]=lockedFiles
        o2 = file("/tmp/"+self.getName()+'_lockedFiles','w')
      
        pickle.dump(lockedFiles, o2)
        o2.close()
        transaction.get().commit()
        self.conn.close()
        logging.error("---------download thread:run9")
        return True