Return to DownloadBasket.py CVS log

Up to [Repository] / cdli

minor

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