mercurial/changegroup.py
changeset 19334 95a49112e7ab
parent 19325 ec896f9e8894
child 19708 fd4f612f7cb6
equal deleted inserted replaced
19333:0cfb62e043e8 19334:95a49112e7ab
   352                                 reorder=reorder):
   352                                 reorder=reorder):
   353             yield chunk
   353             yield chunk
   354         progress(msgbundling, None)
   354         progress(msgbundling, None)
   355 
   355 
   356         mfs.clear()
   356         mfs.clear()
   357         total = len(changedfiles)
   357 
   358         # for progress output
   358         def linknodes(filerevlog, fname):
   359         msgfiles = _('files')
       
   360         for i, fname in enumerate(sorted(changedfiles)):
       
   361             filerevlog = repo.file(fname)
       
   362             if not filerevlog:
       
   363                 raise util.Abort(_("empty or missing revlog for %s") % fname)
       
   364 
       
   365             if fastpathlinkrev:
   359             if fastpathlinkrev:
   366                 ln, llr = filerevlog.node, filerevlog.linkrev
   360                 ln, llr = filerevlog.node, filerevlog.linkrev
   367                 needed = set(cl.rev(x) for x in clnodes)
   361                 needed = set(cl.rev(x) for x in clnodes)
   368                 def genfilenodes():
   362                 def genfilenodes():
   369                     for r in filerevlog:
   363                     for r in filerevlog:
   370                         linkrev = llr(r)
   364                         linkrev = llr(r)
   371                         if linkrev in needed:
   365                         if linkrev in needed:
   372                             yield filerevlog.node(r), cl.node(linkrev)
   366                             yield filerevlog.node(r), cl.node(linkrev)
   373                 fnodes[fname] = dict(genfilenodes())
   367                 fnodes[fname] = dict(genfilenodes())
   374 
   368             return fnodes.get(fname, {})
   375             linkrevnodes = fnodes.pop(fname, {})
   369 
       
   370         for chunk in self.generatefiles(changedfiles, linknodes, commonrevs,
       
   371                                         source):
       
   372             yield chunk
       
   373 
       
   374         yield self.close()
       
   375         progress(msgbundling, None)
       
   376 
       
   377         if clnodes:
       
   378             repo.hook('outgoing', node=hex(clnodes[0]), source=source)
       
   379 
       
   380     def generatefiles(self, changedfiles, linknodes, commonrevs, source):
       
   381         repo = self._repo
       
   382         progress = self._progress
       
   383         reorder = self._reorder
       
   384         msgbundling = _('bundling')
       
   385 
       
   386         total = len(changedfiles)
       
   387         # for progress output
       
   388         msgfiles = _('files')
       
   389         for i, fname in enumerate(sorted(changedfiles)):
       
   390             filerevlog = repo.file(fname)
       
   391             if not filerevlog:
       
   392                 raise util.Abort(_("empty or missing revlog for %s") % fname)
       
   393 
       
   394             linkrevnodes = linknodes(filerevlog, fname)
   376             # Lookup for filenodes, we collected the linkrev nodes above in the
   395             # Lookup for filenodes, we collected the linkrev nodes above in the
   377             # fastpath case and with lookupmf in the slowpath case.
   396             # fastpath case and with lookupmf in the slowpath case.
   378             def lookupfilelog(x):
   397             def lookupfilelog(x):
   379                 return linkrevnodes[x]
   398                 return linkrevnodes[x]
   380 
   399 
   384                          total=total)
   403                          total=total)
   385                 yield self.fileheader(fname)
   404                 yield self.fileheader(fname)
   386                 for chunk in self.group(filenodes, filerevlog, lookupfilelog,
   405                 for chunk in self.group(filenodes, filerevlog, lookupfilelog,
   387                                         reorder=reorder):
   406                                         reorder=reorder):
   388                     yield chunk
   407                     yield chunk
   389         yield self.close()
       
   390         progress(msgbundling, None)
       
   391 
       
   392         if clnodes:
       
   393             repo.hook('outgoing', node=hex(clnodes[0]), source=source)
       
   394 
   408 
   395     def revchunk(self, revlog, rev, prev, linknode):
   409     def revchunk(self, revlog, rev, prev, linknode):
   396         node = revlog.node(rev)
   410         node = revlog.node(rev)
   397         p1, p2 = revlog.parentrevs(rev)
   411         p1, p2 = revlog.parentrevs(rev)
   398         base = prev
   412         base = prev