Return to DownloadBasket.py CVS log

Up to [Repository] / cdli

monorCVS: ----------------------------------------------------------------------

    1: from threading import Thread
    2: from ZPublisher.HTTPResponse import HTTPResponse
    3: from ZPublisher.HTTPRequest import HTTPRequest
    4: from ZPublisher.BaseRequest import RequestContainer
    5: import logging
    6: import os
    7: import transaction
    8: class DownloadBasketFinallyThread(Thread):
    9: 
   10:     def __init__(self):
   11:         """init for uploadATFfinallyThread"""
   12:         self.continueVar=True
   13:         self.returnValue=None
   14:         self.end=False
   15:         self.counter=0 # zaehlt wieviele Files schon gefunden wurden
   16:     
   17:         self.number=0 # Anzahl der Files im Basket
   18:         Thread.__init__(self)
   19: 
   20:     def set(self,lock,procedure,user,current,basketID,versionNumber,serverport="28080"):
   21:         self.procedure=procedure
   22:         self.lock=lock
   23:         self.user=user
   24:         self.basketID = basketID
   25:         self.versionNumber = versionNumber
   26:         self.serverport=serverport
   27:         self.current=current
   28:         logging.debug("download thread:set")
   29:         logging.debug("download thread:user"+repr(self.user))
   30:        
   31:     def __call__(self):
   32:         """call of the thread (equals run)"""
   33:         logging.debug("download thread:call")
   34:         self.run()
   35:         return True
   36:     
   37:     def run(self):
   38:         """call of the thread (equals run)"""
   39:         logging.error("---------download thread:run")
   40:         
   41:         from Zope2 import DB
   42:         self.conn = DB.open()
   43:         root = self.conn.root()
   44:         app  = root['Application']
   45:         self.ctx = self.getContext(app,serverport=self.serverport).cdliRoot.basketContainer
   46:         logging.error("---------download thread:run2")
   47:         baskets=self.ctx.ZopeFind(self.ctx,obj_metatypes=['CDLIBasket'],obj_ids=[self.basketID])
   48:         logging.error("---------download thread:run3")
   49:         if len(baskets)!=1:
   50:             logging.error("ERROR: downloadBasket: cannot find basket:"+self.basketID)
   51:             self.end=True
   52:             return
   53:         
   54:         basket=baskets[0]
   55:         logging.error("donwloadBasket: found basket:"+repr(basket))
   56:         
   57:         basketVersion=getattr(basket[1],self.versionNumber)
   58:         
   59:         self.downloadObjectsAsOneFileFinally(self.lock,self.procedure,self.user,self.current,basketVersion)
   60:         self.end=True
   61:         
   62:     def getResult(self):
   63:         """method for accessing result"""
   64:         
   65:         return self.result
   66:     
   67:     def getCounter(self):
   68:         """gibt den Counter zurueck, wieviele Objekte schon gefunden wurden"""
   69:         logging.error("counter:"+repr(self.counter))
   70:         return self.counter
   71:     
   72: 
   73:     
   74:     def getNumberOfFiles(self):
   75:         """gibt anzahl zurueck"""
   76:         return self.number;
   77:     def getContext(self, app,serverport="8080"):
   78:         """get the context within the ZODB"""
   79:         
   80:         resp = HTTPResponse(stdout=None)
   81:         env = {
   82:             'SERVER_NAME':'localhost',
   83:             'SERVER_PORT':serverport,
   84:             'REQUEST_METHOD':'GET'
   85:             }
   86:         req = HTTPRequest(None, env, resp)
   87:         return app.__of__(RequestContainer(REQUEST = req))
   88:           
   89:     def downloadObjectsAsOneFileFinally(self,lock=None,procedure=None,user=None,current="no",basketVersion=None):
   90:         """print do the download"""
   91:         logging.debug("download thread")
   92:   
   93:         logging.debug("donwloadBasketasonefile: found basket:"+repr(basketVersion))
   94:         ret=""
   95: 
   96:         self.counter=0
   97:         #fh=file("/var/tmp/test","w")
   98:         files=[]
   99:         objects=basketVersion.getContent()
  100:         self.number=len(objects)
  101:         for object in objects:
  102:        
  103:                 self.counter+=1
  104: #                logging.error("ret:"+repr(object[0]))
  105: #                logging.error("    -"+repr(procedure))
  106: 		try:
  107: 	                lockedBy=object[1].lockedBy
  108: 		except:
  109: 			logging.error("no object:"+repr(self.counter))
  110: 			logging.error("no object:"+repr(object))
  111: 			continue
  112: 			
  113: #                lockedBy=""
  114: #                logging.error("    -"+repr(lockedBy))
  115: #                
  116:                 if (procedure=="downloadAll") or (lockedBy=='') or (lockedBy==user):
  117:                     #logging.error("ret1")
  118:                     if current=="no": #version as they are in the basket
  119:                         #logging.error("ret2")
  120:                         #object[0].addToFile2("/var/tmp/test2")
  121:                         #ret+=str(object[0].getData())+"\n"
  122:                         files.append(object[0].getFileName())
  123:                     elif current=="yes":
  124:                         logging.error("ret3")
  125:                         #search current object
  126:                         #founds=self.CDLICatalog.search({'title':object[1].getId().split(".")[0]})
  127:                         obj=self.ctx.getFileObjectLastVersion(object[1].getId())
  128:                         if obj:
  129:                             files.append(obj.getFileName())
  130:                         else:
  131:                             logging.error("donwloadBasketasonefile: don't know: "+repr(object[0].getId()))
  132:                         #if len(founds)>0:      
  133:                           #  ret+=str(founds[0].getObject().getLastVersion().getData())+"\n"
  134:                       
  135:       
  136:                 #if lock and lockedBy=='':
  137:                     #obj=self.ctx.getFileObject(object[1].getId())
  138:                    # founds=self.ctx.CDLICatalog.search({'title':object[1].getId().split(".")[0]})
  139:                    #if len(founds)>0:      
  140:                           #founds[0].getObject().lockedBy=user
  141:                       
  142:                 #    object[1].lockedBy=user
  143:                 #    transaction.get().commit()
  144:                     #obj.lockedBy=user
  145: #        logging.error("---------download thread:run5")
  146: #        pin,pout =os.popen2("xargs cat")
  147: #        logging.error("---------download thread:run6")
  148: #        pin.write(" ".join(files))
  149: #        logging.error("---------download thread:run7")
  150: #        pin.close()
  151: #        logging.error("---------download thread:run8")
  152: #    
  153: #      
  154: #        
  155: #        fw = file("/var/tmp/test","w")
  156: #        fw.write(pout.read())
  157: #        fw.close()
  158:         
  159:         if not hasattr(self.ctx,'resultHash'):
  160:             self.ctx.resultHash={}
  161:         self.ctx.resultHash[self.getName()]=files
  162:         transaction.get().commit()
  163:         self.conn.close()
  164:         logging.error("---------download thread:run9")
  165:         return True
  166: