Return to DownloadBasket.py CVS log

Up to [Repository] / cdli

*** empty log message ***

    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:         lockedFiles=[]
  100:         objects=basketVersion.getContent()
  101:         self.number=len(objects)
  102:         logging.error("objects:"+repr(self.number))
  103:         for object in objects:
  104:        
  105:                 self.counter+=1
  106: #                logging.error("ret:"+repr(object[0]))
  107: #                logging.error("    -"+repr(procedure))
  108:                 try:
  109: 	                lockedBy=object[1].lockedBy
  110:                 except:
  111:                     logging.error("no object:"+repr(self.counter))
  112:                     logging.error("no object:"+repr(object))
  113:                     continue
  114: 			
  115: #                lockedBy=""
  116: #                logging.error("    -"+repr(lockedBy))
  117: #                
  118:                 if (procedure=="downloadAll") or (lockedBy=='') or (lockedBy==user):
  119:                     logging.error("ret1")
  120:                     if current=="no": #version as they are in the basket
  121:                         logging.error("ret2")
  122:                         #object[0].addToFile2("/var/tmp/test2")
  123:                         #ret+=str(object[0].getData())+"\n"
  124:                         files.append(object[0].getFileName())
  125:                     elif current=="yes":
  126:                         logging.error("ret3")
  127:                         #search current object
  128:                         #founds=self.CDLICatalog.search({'title':object[1].getId().split(".")[0]})
  129:                         obj=self.ctx.getFileObjectLastVersion(object[1].getId())
  130:                         if obj:
  131:                             files.append(obj.getFileName())
  132:                         else:
  133:                             logging.error("donwloadBasketasonefile: don't know: "+repr(object[0].getId()))
  134:                         #if len(founds)>0:      
  135:                           #  ret+=str(founds[0].getObject().getLastVersion().getData())+"\n"
  136:                       
  137:                 else:
  138:                     logging.error("ret4")
  139:                     lockedFiles.append(object[0].getId())
  140:       
  141:                 #if lock and lockedBy=='':
  142:                     #obj=self.ctx.getFileObject(object[1].getId())
  143:                    # founds=self.ctx.CDLICatalog.search({'title':object[1].getId().split(".")[0]})
  144:                    #if len(founds)>0:      
  145:                           #founds[0].getObject().lockedBy=user
  146:                       
  147:                 #    object[1].lockedBy=user
  148:                 #    transaction.get().commit()
  149:                     #obj.lockedBy=user
  150: #        logging.error("---------download thread:run5")
  151: #        pin,pout =os.popen2("xargs cat")
  152: #        logging.error("---------download thread:run6")
  153: #        pin.write(" ".join(files))
  154: #        logging.error("---------download thread:run7")
  155: #        pin.close()
  156: #        logging.error("---------download thread:run8")
  157: #    
  158: #      
  159: #        
  160: #        fw = file("/var/tmp/test","w")
  161: #        fw.write(pout.read())
  162: #        fw.close()
  163:         
  164:         if not hasattr(self.ctx,'resultHash'):
  165:             self.ctx.resultHash={}
  166:         self.ctx.resultHash[self.getName()]=files
  167:         
  168:         if not hasattr(self.ctx,'resultLockedHash'):
  169:             self.ctx.resultLockedHash={}
  170:         self.ctx.resultLockedHash[self.getName()]=lockedFiles
  171:         
  172:         transaction.get().commit()
  173:         self.conn.close()
  174:         logging.error("---------download thread:run9")
  175:         return True
  176: