upstream/mercurial-mirror Files · mercurial/pure/parsers.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.

Mads Kiilerich - - Load All Authors

File last commit:

r17425:e95ec38f default


                r17878:d1d01402

stable

Download file

             parsers.py
        
                    89 lines
            
             | 2.2 KiB
            
                | text/x-python
            
             |
                PythonLexer
            
             / mercurial / pure / parsers.py
          
                    History
                
                 |
                  Annotation
                 | Raw
                 |Copy content
                 |Copy permalink

      # parsers.py - Python implementation of parsers.c

      #

      # Copyright 2009 Matt Mackall <mpm@selenic.com> and others

      #

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

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

      from mercurial.node import bin, nullid

      from mercurial import util

      import struct, zlib

      _pack = struct.pack

      _unpack = struct.unpack

      _compress = zlib.compress

      _decompress = zlib.decompress

      _sha = util.sha1

      def parse_manifest(mfdict, fdict, lines):

          for l in lines.splitlines():

              f, n = l.split('\0')

              if len(n) > 40:

                  fdict[f] = n[40:]

                  mfdict[f] = bin(n[:40])

              else:

                  mfdict[f] = bin(n)

      def parse_index2(data, inline):

          def gettype(q):

              return int(q & 0xFFFF)

          def offset_type(offset, type):

              return long(long(offset) << 16 | type)

          indexformatng = ">Qiiiiii20s12x"

          s = struct.calcsize(indexformatng)

          index = []

          cache = None

          off = 0

          l = len(data) - s

          append = index.append

          if inline:

              cache = (0, data)

              while off <= l:

                  e = _unpack(indexformatng, data[off:off + s])

                  append(e)

                  if e[1] < 0:

                      break

                  off += e[1] + s

          else:

              while off <= l:

                  e = _unpack(indexformatng, data[off:off + s])

                  append(e)

                  off += s

          if off != len(data):

              raise ValueError('corrupt index file')

          if index:

              e = list(index[0])

              type = gettype(e[0])

              e[0] = offset_type(0, type)

              index[0] = tuple(e)

          # add the magic null revision at -1

          index.append((0, 0, 0, -1, -1, -1, -1, nullid))

          return index, cache

      def parse_dirstate(dmap, copymap, st):

          parents = [st[:20], st[20: 40]]

          # dereference fields so they will be local in loop

          format = ">cllll"

          e_size = struct.calcsize(format)

          pos1 = 40

          l = len(st)

          # the inner loop

          while pos1 < l:

              pos2 = pos1 + e_size

              e = _unpack(">cllll", st[pos1:pos2]) # a literal here is faster

              pos1 = pos2 + e[4]

              f = st[pos2:pos1]

              if '\0' in f:

                  f, c = f.split('\0')

                  copymap[f] = c

              dmap[f] = e[:4]

          return parents

	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

				# parsers.py - Python implementation of parsers.c
				#
				# Copyright 2009 Matt Mackall <mpm@selenic.com> and others
				#
				# This software may be used and distributed according to the terms of the
				# GNU General Public License version 2 or any later version.

				from mercurial.node import bin, nullid
				from mercurial import util
				import struct, zlib

				_pack = struct.pack
				_unpack = struct.unpack
				_compress = zlib.compress
				_decompress = zlib.decompress
				_sha = util.sha1

				def parse_manifest(mfdict, fdict, lines):
				for l in lines.splitlines():
				f, n = l.split('\0')
				if len(n) > 40:
				fdict[f] = n[40:]
				mfdict[f] = bin(n[:40])
				else:
				mfdict[f] = bin(n)

				def parse_index2(data, inline):
				def gettype(q):
				return int(q & 0xFFFF)

				def offset_type(offset, type):
				return long(long(offset) << 16 \| type)

				indexformatng = ">Qiiiiii20s12x"

				s = struct.calcsize(indexformatng)
				index = []
				cache = None
				off = 0

				l = len(data) - s
				append = index.append
				if inline:
				cache = (0, data)
				while off <= l:
				e = _unpack(indexformatng, data[off:off + s])
				append(e)
				if e[1] < 0:
				break
				off += e[1] + s
				else:
				while off <= l:
				e = _unpack(indexformatng, data[off:off + s])
				append(e)
				off += s

				if off != len(data):
				raise ValueError('corrupt index file')

				if index:
				e = list(index[0])
				type = gettype(e[0])
				e[0] = offset_type(0, type)
				index[0] = tuple(e)

				# add the magic null revision at -1
				index.append((0, 0, 0, -1, -1, -1, -1, nullid))

				return index, cache

				def parse_dirstate(dmap, copymap, st):
				parents = [st[:20], st[20: 40]]
				# dereference fields so they will be local in loop
				format = ">cllll"
				e_size = struct.calcsize(format)
				pos1 = 40
				l = len(st)

				# the inner loop
				while pos1 < l:
				pos2 = pos1 + e_size
				e = _unpack(">cllll", st[pos1:pos2]) # a literal here is faster
				pos1 = pos2 + e[4]
				f = st[pos2:pos1]
				if '\0' in f:
				f, c = f.split('\0')
				copymap[f] = c
				dmap[f] = e[:4]
				return parents