mercurial/hg.py
changeset 210 d2badbd7d1ad
parent 207 ec327cf0d3a9
child 216 201115f2859b
equal deleted inserted replaced
209:63af1db35611 210:d2badbd7d1ad
   327 
   327 
   328     def transaction(self):
   328     def transaction(self):
   329         return transaction(self.opener, self.join("journal"),
   329         return transaction(self.opener, self.join("journal"),
   330                            self.join("undo"))
   330                            self.join("undo"))
   331 
   331 
   332     def recover(self, f = "journal"):
   332     def recover(self):
   333         self.lock()
   333         self.lock()
   334         if os.path.exists(self.join(f)):
   334         if os.path.exists(self.join("recover")):
   335             self.ui.status("attempting to rollback %s information\n" % f)
   335             self.ui.status("attempting to rollback interrupted transaction\n")
   336             return rollback(self.opener, self.join(f))
   336             return rollback(self.opener, self.join("recover"))
   337         else:
   337         else:
   338             self.ui.warn("no %s information available\n" % f)
   338             self.ui.warn("no interrupted transaction available\n")
       
   339 
       
   340     def undo(self):
       
   341         self.lock()
       
   342         if os.path.exists(self.join("undo")):
       
   343             self.ui.status("attempting to rollback last transaction\n")
       
   344             rollback(self.opener, self.join("undo"))
       
   345             self.manifest = manifest(self.opener)
       
   346             self.changelog = changelog(self.opener)
       
   347 
       
   348             self.ui.status("discarding dircache\n")
       
   349             node = self.changelog.tip()
       
   350             mf = self.changelog.read(node)[0]
       
   351             mm = self.manifest.read(mf)
       
   352             f = mm.keys()
       
   353             f.sort()
       
   354 
       
   355             self.setcurrent(node)
       
   356             self.dircache.clear()
       
   357             self.dircache.taint(f)
       
   358         
       
   359         else:
       
   360             self.ui.warn("no undo information available\n")
   339 
   361 
   340     def lock(self, wait = 1):
   362     def lock(self, wait = 1):
   341         try:
   363         try:
   342             return lock.lock(self.join("lock"), 0)
   364             return lock.lock(self.join("lock"), 0)
   343         except lock.LockHeld, inst:
   365         except lock.LockHeld, inst:
   474                 try: s = os.stat(os.path.join(self.root, fn))
   496                 try: s = os.stat(os.path.join(self.root, fn))
   475                 except: continue
   497                 except: continue
   476                 if fn in dc:
   498                 if fn in dc:
   477                     c = dc[fn]
   499                     c = dc[fn]
   478                     del dc[fn]
   500                     del dc[fn]
   479                     if not c:
   501                     if not c or c[1] < 0:
   480                         if fcmp(fn):
   502                         if fcmp(fn):
   481                             changed.append(fn)
   503                             changed.append(fn)
   482                     elif c[1] != s.st_size:
   504                     elif c[1] != s.st_size:
   483                         changed.append(fn)
   505                         changed.append(fn)
   484                     elif c[0] != s.st_mode or c[2] != s.st_mtime:
   506                     elif c[0] != s.st_mode or c[2] != s.st_mtime: