Return to DownloadBasket.py CVS log

Up to [Repository] / cdli

*** empty log message ***

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
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("donwloadBasketasonefile: found basket:"+repr(basketVersion))
        ret=""

        self.counter=0
        #fh=file("/var/tmp/test","w")
        files=[]
        lockedFiles=[]
        objects=basketVersion.getContent()
        self.number=len(objects)
        logging.error("objects:"+repr(self.number))
        for object in objects:
       
                self.counter+=1
#                logging.error("ret:"+repr(object[0]))
#                logging.error("    -"+repr(procedure))
                try:
	                lockedBy=object[1].lockedBy
                except:
                    logging.error("no object:"+repr(self.counter))
                    logging.error("no object:"+repr(object))
                    continue
			
#                lockedBy=""
#                logging.error("    -"+repr(lockedBy))
#                
                if (procedure=="downloadAll") or (lockedBy=='') or (lockedBy==user):
                    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"
                        files.append(object[0].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[1].getId())
                        if obj:
                            files.append(obj.getFileName())
                        else:
                            logging.error("donwloadBasketasonefile: don't know: "+repr(object[0].getId()))
                        #if len(founds)>0:      
                          #  ret+=str(founds[0].getObject().getLastVersion().getData())+"\n"
                      
                else:
                    logging.error("ret4")
                    lockedFiles.append(object[0].getId())
      
                #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'):
            self.ctx.resultHash={}
        self.ctx.resultHash[self.getName()]=files
        
        if not hasattr(self.ctx,'resultLockedHash'):
            self.ctx.resultLockedHash={}
        self.ctx.resultLockedHash[self.getName()]=lockedFiles
        
        transaction.get().commit()
        self.conn.close()
        logging.error("---------download thread:run9")
        return True