upstream/mercurial-mirror Files · mercurial/revlogutils/concurrency_checker.py

typing: hide the interface version of `dirstate` during type checking...

typing: hide the interface version of `dirstate` during type checking As noted in the previous commit, the `dirstate` type is still inferred as `Any` by pytype, including where it is used as a base class for the largefiles dirstate. That effectively disables most type checking. The problems fixed two commits ago were flagged by this change. I'm not at all clear what the benefit of the original type is, but that was what was used at runtime, so I don't want to change the largefiles base class to the raw class. Having both a lowercase and camelcase name for the same thing isn't great, but given that this trivially finds problems without worrying about which symbol clients may be using, and the non-raw type is useless to pytype anyway, I'm not going to worry about it.

Kyle Lippincott - - Load All Authors

File last commit:

r47349:e9901d01 default


                r52702:45270e28

default

Download file

             concurrency_checker.py
        
                    38 lines
            
             | 1.5 KiB
            
                | text/x-python
            
             |
                PythonLexer
            
             / mercurial / revlogutils / concurrency_checker.py
          
                    History
                
                 |
                  Annotation
                 | Raw
                 |Copy content
                 |Copy permalink

      from ..i18n import _

      from .. import error

      def get_checker(ui, revlog_name=b'changelog'):

          """Get a function that checks file handle position is as expected.

          This is used to ensure that files haven't been modified outside of our

          knowledge (such as on a networked filesystem, if `hg debuglocks` was used,

          or writes to .hg that ignored locks happened).

          Due to revlogs supporting a concept of buffered, delayed, or diverted

          writes, we're allowing the files to be shorter than expected (the data may

          not have been written yet), but they can't be longer.

          Please note that this check is not perfect; it can't detect all cases (there

          may be false-negatives/false-OKs), but it should never claim there's an

          issue when there isn't (false-positives/false-failures).

          """

          vpos = ui.config(b'debug', b'revlog.verifyposition.' + revlog_name)

          # Avoid any `fh.tell` cost if this isn't enabled.

          if not vpos or vpos not in [b'log', b'warn', b'fail']:

              return None

          def _checker(fh, fn, expected):

              if fh.tell() <= expected:

                  return

              msg = _(b'%s: file cursor at position %d, expected %d')

              # Always log if we're going to warn or fail.

              ui.log(b'debug', msg + b'\n', fn, fh.tell(), expected)

              if vpos == b'warn':

                  ui.warn((msg + b'\n') % (fn, fh.tell(), expected))

              elif vpos == b'fail':

                  raise error.RevlogError(msg % (fn, fh.tell(), expected))

          return _checker

	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

				from ..i18n import _
				from .. import error


				def get_checker(ui, revlog_name=b'changelog'):
				"""Get a function that checks file handle position is as expected.

				This is used to ensure that files haven't been modified outside of our
				knowledge (such as on a networked filesystem, if `hg debuglocks` was used,
				or writes to .hg that ignored locks happened).

				Due to revlogs supporting a concept of buffered, delayed, or diverted
				writes, we're allowing the files to be shorter than expected (the data may
				not have been written yet), but they can't be longer.

				Please note that this check is not perfect; it can't detect all cases (there
				may be false-negatives/false-OKs), but it should never claim there's an
				issue when there isn't (false-positives/false-failures).
				"""

				vpos = ui.config(b'debug', b'revlog.verifyposition.' + revlog_name)
				# Avoid any `fh.tell` cost if this isn't enabled.
				if not vpos or vpos not in [b'log', b'warn', b'fail']:
				return None

				def _checker(fh, fn, expected):
				if fh.tell() <= expected:
				return

				msg = _(b'%s: file cursor at position %d, expected %d')
				# Always log if we're going to warn or fail.
				ui.log(b'debug', msg + b'\n', fn, fh.tell(), expected)
				if vpos == b'warn':
				ui.warn((msg + b'\n') % (fn, fh.tell(), expected))
				elif vpos == b'fail':
				raise error.RevlogError(msg % (fn, fh.tell(), expected))

				return _checker