upstream/mercurial-mirror Files · mercurial/ancestor.py

largefiles: don't copy largefiles from working dir to the store while converting...

largefiles: don't copy largefiles from working dir to the store while converting Previously, if one or more largefiles for a repo being converted were not in the usercache, the convert would abort with a reference to the largefile being missing (as opposed to the previous patch, where the standin was referenced as missing). This is because commitctx() tries to copy all largefiles to the local store, first from the user cache, and if the file isn't found there, from the working directory. No files will exist in the working directory during a convert, however. It is not sufficient to force the source repo to be local before proceeding, because clone and pull do not download largefiles by default. This is slightly less than ideal because while the conversion will now complete, it won't be possible to update to revs with missing largefiles unless the user intervenes manually, because there is no default path pointing back to the source repo. Ideally these files would be cached during the conversion. This check could have been done in reposetup.commitctx() instead, but this ensures the local store directory is created, which is necessary to enable the standin matcher. The rm -> 'rm -f' change in the test is to temporarily suppress an error clearing the cache- as noted, the cache is is not repopulated during convert. When that is fixed, this can be changed back and the verification errors will disappear too.

Martin Geisler - - Load All Authors

File last commit:

r14494:1ffeeb91 default


                r17878:d1d01402

stable

Download file

             ancestor.py
        
                    91 lines
            
             | 2.6 KiB
            
                | text/x-python
            
             |
                PythonLexer
            
             / mercurial / ancestor.py
          
                    History
                
                 |
                  Annotation
                 | Raw
                 |Copy content
                 |Copy permalink

      # ancestor.py - generic DAG ancestor algorithm for mercurial

      #

      # Copyright 2006 Matt Mackall <mpm@selenic.com>

      #

      # This software may be used and distributed according to the terms of the

      # GNU General Public License version 2 or any later version.

      import heapq

      def ancestor(a, b, pfunc):

          """

          Returns the common ancestor of a and b that is furthest from a

          root (as measured by longest path) or None if no ancestor is

          found. If there are multiple common ancestors at the same

          distance, the first one found is returned.

          pfunc must return a list of parent vertices for a given vertex

          """

          if a == b:

              return a

          a, b = sorted([a, b])

          # find depth from root of all ancestors

          # depth is stored as a negative for heapq

          parentcache = {}

          visit = [a, b]

          depth = {}

          while visit:

              vertex = visit[-1]

              pl = pfunc(vertex)

              parentcache[vertex] = pl

              if not pl:

                  depth[vertex] = 0

                  visit.pop()

              else:

                  for p in pl:

                      if p == a or p == b: # did we find a or b as a parent?

                          return p # we're done

                      if p not in depth:

                          visit.append(p)

                  if visit[-1] == vertex:

                      # -(maximum distance of parents + 1)

                      depth[vertex] = min([depth[p] for p in pl]) - 1

                      visit.pop()

          # traverse ancestors in order of decreasing distance from root

          def ancestors(vertex):

              h = [(depth[vertex], vertex)]

              seen = set()

              while h:

                  d, n = heapq.heappop(h)

                  if n not in seen:

                      seen.add(n)

                      yield (d, n)

                      for p in parentcache[n]:

                          heapq.heappush(h, (depth[p], p))

          def generations(vertex):

              sg, s = None, set()

              for g, v in ancestors(vertex):

                  if g != sg:

                      if sg:

                          yield sg, s

                      sg, s = g, set((v,))

                  else:

                      s.add(v)

              yield sg, s

          x = generations(a)

          y = generations(b)

          gx = x.next()

          gy = y.next()

          # increment each ancestor list until it is closer to root than

          # the other, or they match

          try:

              while True:

                  if gx[0] == gy[0]:

                      for v in gx[1]:

                          if v in gy[1]:

                              return v

                      gy = y.next()

                      gx = x.next()

                  elif gx[0] > gy[0]:

                      gy = y.next()

                  else:

                      gx = x.next()

          except StopIteration:

              return None

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages

				# ancestor.py - generic DAG ancestor algorithm for mercurial
				#
				# Copyright 2006 Matt Mackall <mpm@selenic.com>
				#
				# This software may be used and distributed according to the terms of the
				# GNU General Public License version 2 or any later version.

				import heapq

				def ancestor(a, b, pfunc):
				"""
				Returns the common ancestor of a and b that is furthest from a
				root (as measured by longest path) or None if no ancestor is
				found. If there are multiple common ancestors at the same
				distance, the first one found is returned.

				pfunc must return a list of parent vertices for a given vertex
				"""

				if a == b:
				return a

				a, b = sorted([a, b])

				# find depth from root of all ancestors
				# depth is stored as a negative for heapq
				parentcache = {}
				visit = [a, b]
				depth = {}
				while visit:
				vertex = visit[-1]
				pl = pfunc(vertex)
				parentcache[vertex] = pl
				if not pl:
				depth[vertex] = 0
				visit.pop()
				else:
				for p in pl:
				if p == a or p == b: # did we find a or b as a parent?
				return p # we're done
				if p not in depth:
				visit.append(p)
				if visit[-1] == vertex:
				# -(maximum distance of parents + 1)
				depth[vertex] = min([depth[p] for p in pl]) - 1
				visit.pop()

				# traverse ancestors in order of decreasing distance from root
				def ancestors(vertex):
				h = [(depth[vertex], vertex)]
				seen = set()
				while h:
				d, n = heapq.heappop(h)
				if n not in seen:
				seen.add(n)
				yield (d, n)
				for p in parentcache[n]:
				heapq.heappush(h, (depth[p], p))

				def generations(vertex):
				sg, s = None, set()
				for g, v in ancestors(vertex):
				if g != sg:
				if sg:
				yield sg, s
				sg, s = g, set((v,))
				else:
				s.add(v)
				yield sg, s

				x = generations(a)
				y = generations(b)
				gx = x.next()
				gy = y.next()

				# increment each ancestor list until it is closer to root than
				# the other, or they match
				try:
				while True:
				if gx[0] == gy[0]:
				for v in gx[1]:
				if v in gy[1]:
				return v
				gy = y.next()
				gx = x.next()
				elif gx[0] > gy[0]:
				gy = y.next()
				else:
				gx = x.next()
				except StopIteration:
				return None