remotefilelog: cast division result to an int

Otherwise mid is a float and this confuses __slice__ on Python 3.

Differential Revision: https://phab.mercurial-scm.org/D5760

contrib/python3-whitelist

@@ -1,745 +1,746 b''
 test-abort-checkin.t
 test-absorb-edit-lines.t
 test-absorb-filefixupstate.py
 test-absorb-phase.t
 test-absorb-rename.t
 test-absorb-strip.t
 test-absorb.t
 test-add.t
 test-addremove-similar.t
 test-addremove.t
 test-alias.t
 test-amend-subrepo.t
 test-amend.t
 test-ancestor.py
 test-annotate.py
 test-annotate.t
 test-arbitraryfilectx.t
 test-archive-symlinks.t
 test-archive.t
 test-atomictempfile.py
 test-audit-path.t
 test-audit-subrepo.t
 test-automv.t
 test-backout.t
 test-backwards-remove.t
 test-bad-extension.t
 test-bad-pull.t
 test-basic.t
 test-batching.py
 test-bdiff.py
 test-bheads.t
 test-bisect.t
 test-bisect2.t
 test-bisect3.t
 test-blackbox.t
 test-bookflow.t
 test-bookmarks-current.t
 test-bookmarks-merge.t
 test-bookmarks-pushpull.t
 test-bookmarks-rebase.t
 test-bookmarks-strip.t
 test-bookmarks.t
 test-branch-change.t
 test-branch-option.t
 test-branch-tag-confict.t
 test-branches.t
 test-bugzilla.t
 test-bundle-phases.t
 test-bundle-r.t
 test-bundle-type.t
 test-bundle-vs-outgoing.t
 test-bundle.t
 test-bundle2-exchange.t
 test-bundle2-format.t
 test-bundle2-multiple-changegroups.t
 test-bundle2-pushback.t
 test-bundle2-remote-changegroup.t
 test-cache-abuse.t
 test-cappedreader.py
 test-casecollision-merge.t
 test-casecollision.t
 test-casefolding.t
 test-cat.t
 test-cbor.py
 test-censor.t
 test-changelog-exec.t
 test-check-code.t
 test-check-commit.t
 test-check-config.py
 test-check-config.t
 test-check-execute.t
 test-check-help.t
 test-check-interfaces.py
 test-check-module-imports.t
 test-check-py3-compat.t
 test-check-pyflakes.t
 test-check-pylint.t
 test-check-shbang.t
 test-children.t
 test-churn.t
 test-clone-cgi.t
 test-clone-pull-corruption.t
 test-clone-r.t
 test-clone-uncompressed.t
 test-clone-update-order.t
 test-clone.t
 test-clonebundles.t
 test-close-head.t
 test-commandserver.t
 test-commit-amend.t
 test-commit-interactive.t
 test-commit-multiple.t
 test-commit-unresolved.t
 test-commit.t
 test-committer.t
 test-completion.t
 test-config-env.py
 test-config.t
 test-conflict.t
 test-confused-revert.t
 test-context-metadata.t
 test-context.py
 test-contrib-check-code.t
 test-contrib-check-commit.t
 test-contrib-dumprevlog.t
 test-contrib-perf.t
 test-contrib-relnotes.t
 test-contrib-testparseutil.t
 test-contrib.t
 test-convert-authormap.t
 test-convert-clonebranches.t
 test-convert-cvs-branch.t
 test-convert-cvs-detectmerge.t
 test-convert-cvs-synthetic.t
 test-convert-cvs.t
 test-convert-cvsnt-mergepoints.t
 test-convert-datesort.t
 test-convert-filemap.t
 test-convert-hg-sink.t
 test-convert-hg-source.t
 test-convert-hg-startrev.t
 test-convert-splicemap.t
 test-convert-svn-sink.t
 test-convert-tagsbranch-topology.t
 test-convert.t
 test-copy-move-merge.t
 test-copy.t
 test-copytrace-heuristics.t
 test-custom-filters.t
 test-debugbuilddag.t
 test-debugbundle.t
 test-debugcommands.t
 test-debugextensions.t
 test-debugindexdot.t
 test-debugrename.t
 test-default-push.t
 test-diff-antipatience.t
 test-diff-binary-file.t
 test-diff-change.t
 test-diff-color.t
 test-diff-copy-depth.t
 test-diff-hashes.t
 test-diff-ignore-whitespace.t
 test-diff-indent-heuristic.t
 test-diff-issue2761.t
 test-diff-newlines.t
 test-diff-reverse.t
 test-diff-subdir.t
 test-diff-unified.t
 test-diff-upgrade.t
 test-diffdir.t
 test-diffstat.t
 test-directaccess.t
 test-dirstate-backup.t
 test-dirstate-nonnormalset.t
 test-dirstate-race.t
 test-dirstate.t
 test-dispatch.py
 test-dispatch.t
 test-doctest.py
 test-double-merge.t
 test-drawdag.t
 test-duplicateoptions.py
 test-editor-filename.t
 test-empty-dir.t
 test-empty-file.t
 test-empty-group.t
 test-empty.t
 test-encode.t
 test-encoding-align.t
 test-encoding-func.py
 test-encoding-textwrap.t
 test-encoding.t
 test-eol-add.t
 test-eol-clone.t
 test-eol-hook.t
 test-eol-patch.t
 test-eol-tag.t
 test-eol-update.t
 test-eol.t
 test-eolfilename.t
 test-excessive-merge.t
 test-exchange-obsmarkers-case-A1.t
 test-exchange-obsmarkers-case-A2.t
 test-exchange-obsmarkers-case-A3.t
 test-exchange-obsmarkers-case-A4.t
 test-exchange-obsmarkers-case-A5.t
 test-exchange-obsmarkers-case-A6.t
 test-exchange-obsmarkers-case-A7.t
 test-exchange-obsmarkers-case-B1.t
 test-exchange-obsmarkers-case-B2.t
 test-exchange-obsmarkers-case-B3.t
 test-exchange-obsmarkers-case-B4.t
 test-exchange-obsmarkers-case-B5.t
 test-exchange-obsmarkers-case-B6.t
 test-exchange-obsmarkers-case-B7.t
 test-exchange-obsmarkers-case-C1.t
 test-exchange-obsmarkers-case-C2.t
 test-exchange-obsmarkers-case-C3.t
 test-exchange-obsmarkers-case-C4.t
 test-exchange-obsmarkers-case-D1.t
 test-exchange-obsmarkers-case-D2.t
 test-exchange-obsmarkers-case-D3.t
 test-exchange-obsmarkers-case-D4.t
 test-execute-bit.t
 test-export.t
 test-extdata.t
 test-extdiff.t
 test-extension-timing.t
 test-extensions-afterloaded.t
 test-extensions-wrapfunction.py
 test-extra-filelog-entry.t
 test-fastannotate-corrupt.t
 test-fastannotate-diffopts.t
 test-fastannotate-hg.t
 test-fastannotate-perfhack.t
 test-fastannotate-protocol.t
 test-fastannotate-renames.t
 test-fastannotate-revmap.py
 test-fastannotate.t
 test-fetch.t
 test-filebranch.t
 test-filecache.py
 test-filelog.py
 test-fileset-generated.t
 test-fileset.t
 test-fix-topology.t
 test-fix.t
 test-flags.t
 test-fncache.t
 test-gendoc-da.t
 test-gendoc-de.t
 test-gendoc-el.t
 test-gendoc-fr.t
 test-gendoc-it.t
 test-gendoc-ja.t
 test-gendoc-pt_BR.t
 test-gendoc-ro.t
 test-gendoc-ru.t
 test-gendoc-sv.t
 test-gendoc-zh_CN.t
 test-gendoc-zh_TW.t
 test-gendoc.t
 test-generaldelta.t
 test-getbundle.t
 test-git-export.t
 test-githelp.t
 test-globalopts.t
 test-glog-beautifygraph.t
 test-glog-topological.t
 test-glog.t
 test-gpg.t
 test-graft.t
 test-grep.t
 test-hardlinks.t
 test-help-hide.t
 test-help.t
 test-hg-parseurl.py
 test-hghave.t
 test-hgignore.t
 test-hgk.t
 test-hgrc.t
 test-hgweb-annotate-whitespace.t
 test-hgweb-auth.py
 test-hgweb-bundle.t
 test-hgweb-commands.t
 test-hgweb-csp.t
 test-hgweb-descend-empties.t
 test-hgweb-diffs.t
 test-hgweb-empty.t
 test-hgweb-filelog.t
 test-hgweb-no-path-info.t
 test-hgweb-no-request-uri.t
 test-hgweb-non-interactive.t
 test-hgweb-raw.t
 test-hgweb-removed.t
 test-hgweb-symrev.t
 test-hgweb.t
 test-hgwebdir-paths.py
 test-hgwebdir.t
 test-hgwebdirsym.t
 test-histedit-arguments.t
 test-histedit-base.t
 test-histedit-bookmark-motion.t
 test-histedit-commute.t
 test-histedit-drop.t
 test-histedit-edit.t
 test-histedit-fold-non-commute.t
 test-histedit-fold.t
 test-histedit-no-backup.t
 test-histedit-no-change.t
 test-histedit-non-commute-abort.t
 test-histedit-non-commute.t
 test-histedit-obsolete.t
 test-histedit-outgoing.t
 test-histedit-templates.t
 test-http-api-httpv2.t
 test-http-api.t
 test-http-bad-server.t
 test-http-branchmap.t
 test-http-bundle1.t
 test-http-clone-r.t
 test-http-permissions.t
 test-http-protocol.t
 test-http.t
 test-hybridencode.py
 test-i18n.t
 test-identify.t
 test-impexp-branch.t
 test-import-bypass.t
 test-import-context.t
 test-import-eol.t
 test-import-merge.t
 test-import-unknown.t
 test-import.t
 test-imports-checker.t
 test-incoming-outgoing.t
 test-infinitepush-bundlestore.t
 test-infinitepush-ci.t
 test-infinitepush.t
 test-inherit-mode.t
 test-init.t
 test-install.t
 test-issue1089.t
 test-issue1102.t
 test-issue1175.t
 test-issue1306.t
 test-issue1438.t
 test-issue1502.t
 test-issue1802.t
 test-issue1877.t
 test-issue1993.t
 test-issue2137.t
 test-issue3084.t
 test-issue4074.t
 test-issue522.t
 test-issue586.t
 test-issue5979.t
 test-issue612.t
 test-issue619.t
 test-issue660.t
 test-issue672.t
 test-issue842.t
 test-journal-exists.t
 test-journal-share.t
 test-journal.t
 test-keyword.t
 test-known.t
 test-largefiles-cache.t
 test-largefiles-misc.t
 test-largefiles-small-disk.t
 test-largefiles-update.t
 test-largefiles-wireproto.t
 test-largefiles.t
 test-lfconvert.t
 test-lfs-bundle.t
 test-lfs-largefiles.t
 test-lfs-pointer.py
 test-lfs-test-server.t
 test-lfs.t
 test-linelog.py
 test-linerange.py
 test-locate.t
 test-lock-badness.t
 test-log-exthook.t
 test-log-linerange.t
 test-log.t
 test-logexchange.t
 test-logtoprocess.t
 test-lrucachedict.py
 test-mactext.t
 test-mailmap.t
 test-manifest-merging.t
 test-manifest.py
 test-manifest.t
 test-match.py
 test-mdiff.py
 test-merge-changedelete.t
 test-merge-closedheads.t
 test-merge-commit.t
 test-merge-criss-cross.t
 test-merge-default.t
 test-merge-force.t
 test-merge-halt.t
 test-merge-internal-tools-pattern.t
 test-merge-local.t
 test-merge-no-file-change.t
 test-merge-remove.t
 test-merge-revert.t
 test-merge-revert2.t
 test-merge-subrepos.t
 test-merge-symlinks.t
 test-merge-tools.t
 test-merge-types.t
 test-merge1.t
 test-merge10.t
 test-merge2.t
 test-merge4.t
 test-merge5.t
 test-merge6.t
 test-merge7.t
 test-merge8.t
 test-merge9.t
 test-minifileset.py
 test-minirst.py
 test-missing-capability.t
 test-mq-eol.t
 test-mq-git.t
 test-mq-guards.t
 test-mq-header-date.t
 test-mq-header-from.t
 test-mq-merge.t
 test-mq-missingfiles.t
 test-mq-pull-from-bundle.t
 test-mq-qclone-http.t
 test-mq-qdelete.t
 test-mq-qdiff.t
 test-mq-qfold.t
 test-mq-qgoto.t
 test-mq-qimport-fail-cleanup.t
 test-mq-qimport.t
 test-mq-qnew.t
 test-mq-qpush-exact.t
 test-mq-qpush-fail.t
 test-mq-qqueue.t
 test-mq-qrefresh-interactive.t
 test-mq-qrefresh-replace-log-message.t
 test-mq-qrefresh.t
 test-mq-qrename.t
 test-mq-qsave.t
 test-mq-safety.t
 test-mq-subrepo.t
 test-mq-symlinks.t
 test-mq.t
 test-mv-cp-st-diff.t
 test-narrow-acl.t
 test-narrow-archive.t
 test-narrow-clone-no-ellipsis.t
 test-narrow-clone-non-narrow-server.t
 test-narrow-clone-nonlinear.t
 test-narrow-clone-stream.t
 test-narrow-clone.t
 test-narrow-commit.t
 test-narrow-copies.t
 test-narrow-debugcommands.t
 test-narrow-debugrebuilddirstate.t
 test-narrow-exchange-merges.t
 test-narrow-exchange.t
 test-narrow-expanddirstate.t
 test-narrow-merge.t
 test-narrow-patch.t
 test-narrow-patterns.t
 test-narrow-pull.t
 test-narrow-rebase.t
 test-narrow-shallow-merges.t
 test-narrow-shallow.t
 test-narrow-share.t
 test-narrow-sparse.t
 test-narrow-strip.t
 test-narrow-trackedcmd.t
 test-narrow-update.t
 test-narrow-widen-no-ellipsis.t
 test-narrow-widen.t
 test-narrow.t
 test-nested-repo.t
 test-newbranch.t
 test-newcgi.t
 test-newercgi.t
 test-nointerrupt.t
 test-notify-changegroup.t
 test-obshistory.t
 test-obsmarker-template.t
 test-obsmarkers-effectflag.t
 test-obsolete-bounds-checking.t
 test-obsolete-bundle-strip.t
 test-obsolete-changeset-exchange.t
 test-obsolete-checkheads.t
 test-obsolete-distributed.t
 test-obsolete-divergent.t
 test-obsolete-tag-cache.t
 test-obsolete.t
 test-oldcgi.t
 test-origbackup-conflict.t
 test-pager-legacy.t
 test-pager.t
 test-parents.t
 test-parse-date.t
 test-parseindex.t
 test-parseindex2.py
 test-patch-offset.t
 test-patch.t
 test-patchbomb-bookmark.t
 test-patchbomb-tls.t
 test-patchbomb.t
 test-pathconflicts-basic.t
 test-pathconflicts-merge.t
 test-pathconflicts-update.t
 test-pathencode.py
 test-pending.t
 test-permissions.t
 test-phases-exchange.t
 test-phases.t
 test-profile.t
 test-progress.t
 test-propertycache.py
 test-pull-branch.t
 test-pull-bundle.t
 test-pull-http.t
 test-pull-permission.t
 test-pull-pull-corruption.t
 test-pull-r.t
 test-pull-update.t
 test-pull.t
 test-purge.t
 test-push-cgi.t
 test-push-checkheads-partial-C1.t
 test-push-checkheads-partial-C2.t
 test-push-checkheads-partial-C3.t
 test-push-checkheads-partial-C4.t
 test-push-checkheads-pruned-B1.t
 test-push-checkheads-pruned-B2.t
 test-push-checkheads-pruned-B3.t
 test-push-checkheads-pruned-B4.t
 test-push-checkheads-pruned-B5.t
 test-push-checkheads-pruned-B6.t
 test-push-checkheads-pruned-B7.t
 test-push-checkheads-pruned-B8.t
 test-push-checkheads-superceed-A1.t
 test-push-checkheads-superceed-A2.t
 test-push-checkheads-superceed-A3.t
 test-push-checkheads-superceed-A4.t
 test-push-checkheads-superceed-A5.t
 test-push-checkheads-superceed-A6.t
 test-push-checkheads-superceed-A7.t
 test-push-checkheads-superceed-A8.t
 test-push-checkheads-unpushed-D1.t
 test-push-checkheads-unpushed-D2.t
 test-push-checkheads-unpushed-D3.t
 test-push-checkheads-unpushed-D4.t
 test-push-checkheads-unpushed-D5.t
 test-push-checkheads-unpushed-D6.t
 test-push-checkheads-unpushed-D7.t
 test-push-http.t
 test-push-race.t
 test-push-warn.t
 test-push.t
 test-pushvars.t
 test-qrecord.t
 test-rebase-abort.t
 test-rebase-backup.t
 test-rebase-base-flag.t
 test-rebase-bookmarks.t
 test-rebase-brute-force.t
 test-rebase-cache.t
 test-rebase-check-restore.t
 test-rebase-collapse.t
 test-rebase-conflicts.t
 test-rebase-dest.t
 test-rebase-detach.t
 test-rebase-emptycommit.t
 test-rebase-inmemory.t
 test-rebase-interruptions.t
 test-rebase-issue-noparam-single-rev.t
 test-rebase-legacy.t
 test-rebase-mq-skip.t
 test-rebase-mq.t
 test-rebase-named-branches.t
 test-rebase-newancestor.t
 test-rebase-obsolete.t
 test-rebase-parameters.t
 test-rebase-partial.t
 test-rebase-pull.t
 test-rebase-rename.t
 test-rebase-scenario-global.t
 test-rebase-templates.t
 test-rebase-transaction.t
 test-rebuildstate.t
 test-record.t
 test-releasenotes-formatting.t
 test-releasenotes-merging.t
 test-releasenotes-parsing.t
 test-relink.t
 test-remotefilelog-bad-configs.t
 test-remotefilelog-bgprefetch.t
 test-remotefilelog-blame.t
 test-remotefilelog-bundle2.t
 test-remotefilelog-bundles.t
 test-remotefilelog-cacheprocess.t
 test-remotefilelog-clone-tree.t
 test-remotefilelog-clone.t
+test-remotefilelog-datapack.py
 test-remotefilelog-gcrepack.t
 test-remotefilelog-histpack.py
 test-remotefilelog-http.t
 test-remotefilelog-keepset.t
 test-remotefilelog-local.t
 test-remotefilelog-log.t
 test-remotefilelog-partial-shallow.t
 test-remotefilelog-permissions.t
 test-remotefilelog-permisssions.t
 test-remotefilelog-prefetch.t
 test-remotefilelog-pull-noshallow.t
 test-remotefilelog-share.t
 test-remotefilelog-sparse.t
 test-remotefilelog-tags.t
 test-remotefilelog-wireproto.t
 test-remove.t
 test-removeemptydirs.t
 test-rename-after-merge.t
 test-rename-dir-merge.t
 test-rename-merge1.t
 test-rename-merge2.t
 test-rename.t
 test-repair-strip.t
 test-repo-compengines.t
 test-requires.t
 test-resolve.t
 test-revert-flags.t
 test-revert-interactive.t
 test-revert-unknown.t
 test-revert.t
 test-revisions.t
 test-revlog-ancestry.py
 test-revlog-group-emptyiter.t
 test-revlog-mmapindex.t
 test-revlog-packentry.t
 test-revlog-raw.py
 test-revlog-v2.t
 test-revlog.t
 test-revset-dirstate-parents.t
 test-revset-legacy-lookup.t
 test-revset-outgoing.t
 test-rollback.t
 test-run-tests.py
 test-run-tests.t
 test-rust-ancestor.py
 test-schemes.t
 test-serve.t
 test-setdiscovery.t
 test-share.t
 test-shelve.t
 test-shelve2.t
 test-show-stack.t
 test-show-work.t
 test-show.t
 test-simple-update.t
 test-simplekeyvaluefile.py
 test-simplemerge.py
 test-single-head.t
 test-sparse-clear.t
 test-sparse-clone.t
 test-sparse-import.t
 test-sparse-merges.t
 test-sparse-profiles.t
 test-sparse-requirement.t
 test-sparse-verbose-json.t
 test-sparse.t
 test-split.t
 test-ssh-bundle1.t
 test-ssh-clone-r.t
 test-ssh-proto-unbundle.t
 test-ssh-proto.t
 test-ssh-repoerror.t
 test-ssh.t
 test-sshserver.py
 test-stack.t
 test-static-http.t
 test-status-color.t
 test-status-inprocess.py
 test-status-rev.t
 test-status-terse.t
 test-status.t
 test-storage.py
 test-stream-bundle-v2.t
 test-strict.t
 test-strip-cross.t
 test-strip.t
 test-subrepo-deep-nested-change.t
 test-subrepo-missing.t
 test-subrepo-paths.t
 test-subrepo-recursion.t
 test-subrepo-relative-path.t
 test-subrepo.t
 test-symlink-os-yes-fs-no.py
 test-symlink-placeholder.t
 test-symlinks.t
 test-tag.t
 test-tags.t
 test-template-basic.t
 test-template-functions.t
 test-template-keywords.t
 test-template-map.t
 test-tools.t
 test-transplant.t
 test-treediscovery-legacy.t
 test-treediscovery.t
 test-treemanifest.t
 test-ui-color.py
 test-ui-config.py
 test-ui-verbosity.py
 test-unamend.t
 test-unbundlehash.t
 test-uncommit.t
 test-unified-test.t
 test-unionrepo.t
 test-unrelated-pull.t
 test-up-local-change.t
 test-update-atomic.t
 test-update-branches.t
 test-update-dest.t
 test-update-issue1456.t
 test-update-names.t
 test-update-reverse.t
 test-upgrade-repo.t
 test-url-download.t
 test-url-rev.t
 test-url.py
 test-username-newline.t
 test-util.py
 test-verify.t
 test-walk.t
 test-walkrepo.py
 test-websub.t
 test-win32text.t
 test-wireproto-caching.t
 test-wireproto-clientreactor.py
 test-wireproto-command-branchmap.t
 test-wireproto-command-capabilities.t
 test-wireproto-command-changesetdata.t
 test-wireproto-command-filedata.t
 test-wireproto-command-filesdata.t
 test-wireproto-command-heads.t
 test-wireproto-command-known.t
 test-wireproto-command-listkeys.t
 test-wireproto-command-lookup.t
 test-wireproto-command-manifestdata.t
 test-wireproto-command-pushkey.t
 test-wireproto-command-rawstorefiledata.t
 test-wireproto-content-redirects.t
 test-wireproto-exchangev2.t
 test-wireproto-framing.py
 test-wireproto-serverreactor.py
 test-wireproto.py
 test-wireproto.t
 test-wsgirequest.py
 test-xdg.t

hgext/remotefilelog/datapack.py

@@ -1,458 +1,458 b''
 from __future__ import absolute_import
 
 import struct
 import zlib
 
 from mercurial.node import hex, nullid
 from mercurial.i18n import _
 from mercurial import (
     pycompat,
     util,
 )
 from . import (
     basepack,
     constants,
     shallowutil,
 )
 
 NODELENGTH = 20
 
 # The indicator value in the index for a fulltext entry.
 FULLTEXTINDEXMARK = -1
 NOBASEINDEXMARK = -2
 
 INDEXSUFFIX = '.dataidx'
 PACKSUFFIX = '.datapack'
 
 class datapackstore(basepack.basepackstore):
     INDEXSUFFIX = INDEXSUFFIX
     PACKSUFFIX = PACKSUFFIX
 
     def __init__(self, ui, path):
         super(datapackstore, self).__init__(ui, path)
 
     def getpack(self, path):
         return datapack(path)
 
     def get(self, name, node):
         raise RuntimeError("must use getdeltachain with datapackstore")
 
     def getmeta(self, name, node):
         for pack in self.packs:
             try:
                 return pack.getmeta(name, node)
             except KeyError:
                 pass
 
         for pack in self.refresh():
             try:
                 return pack.getmeta(name, node)
             except KeyError:
                 pass
 
         raise KeyError((name, hex(node)))
 
     def getdelta(self, name, node):
         for pack in self.packs:
             try:
                 return pack.getdelta(name, node)
             except KeyError:
                 pass
 
         for pack in self.refresh():
             try:
                 return pack.getdelta(name, node)
             except KeyError:
                 pass
 
         raise KeyError((name, hex(node)))
 
     def getdeltachain(self, name, node):
         for pack in self.packs:
             try:
                 return pack.getdeltachain(name, node)
             except KeyError:
                 pass
 
         for pack in self.refresh():
             try:
                 return pack.getdeltachain(name, node)
             except KeyError:
                 pass
 
         raise KeyError((name, hex(node)))
 
     def add(self, name, node, data):
         raise RuntimeError("cannot add to datapackstore")
 
 class datapack(basepack.basepack):
     INDEXSUFFIX = INDEXSUFFIX
     PACKSUFFIX = PACKSUFFIX
 
     # Format is <node><delta offset><pack data offset><pack data size>
     # See the mutabledatapack doccomment for more details.
     INDEXFORMAT = '!20siQQ'
     INDEXENTRYLENGTH = 40
 
     SUPPORTED_VERSIONS = [2]
 
     def getmissing(self, keys):
         missing = []
         for name, node in keys:
             value = self._find(node)
             if not value:
                 missing.append((name, node))
 
         return missing
 
     def get(self, name, node):
         raise RuntimeError("must use getdeltachain with datapack (%s:%s)"
                            % (name, hex(node)))
 
     def getmeta(self, name, node):
         value = self._find(node)
         if value is None:
             raise KeyError((name, hex(node)))
 
         node, deltabaseoffset, offset, size = value
         rawentry = self._data[offset:offset + size]
 
         # see docstring of mutabledatapack for the format
         offset = 0
         offset += struct.unpack_from('!H', rawentry, offset)[0] + 2 # filename
         offset += 40 # node, deltabase node
         offset += struct.unpack_from('!Q', rawentry, offset)[0] + 8 # delta
 
         metalen = struct.unpack_from('!I', rawentry, offset)[0]
         offset += 4
 
         meta = shallowutil.parsepackmeta(rawentry[offset:offset + metalen])
 
         return meta
 
     def getdelta(self, name, node):
         value = self._find(node)
         if value is None:
             raise KeyError((name, hex(node)))
 
         node, deltabaseoffset, offset, size = value
         entry = self._readentry(offset, size, getmeta=True)
         filename, node, deltabasenode, delta, meta = entry
 
         # If we've read a lot of data from the mmap, free some memory.
         self.freememory()
 
         return delta, filename, deltabasenode, meta
 
     def getdeltachain(self, name, node):
         value = self._find(node)
         if value is None:
             raise KeyError((name, hex(node)))
 
         params = self.params
 
         # Precompute chains
         chain = [value]
         deltabaseoffset = value[1]
         entrylen = self.INDEXENTRYLENGTH
         while (deltabaseoffset != FULLTEXTINDEXMARK
                and deltabaseoffset != NOBASEINDEXMARK):
             loc = params.indexstart + deltabaseoffset
             value = struct.unpack(self.INDEXFORMAT,
                                   self._index[loc:loc + entrylen])
             deltabaseoffset = value[1]
             chain.append(value)
 
         # Read chain data
         deltachain = []
         for node, deltabaseoffset, offset, size in chain:
             filename, node, deltabasenode, delta = self._readentry(offset, size)
             deltachain.append((filename, node, filename, deltabasenode, delta))
 
         # If we've read a lot of data from the mmap, free some memory.
         self.freememory()
 
         return deltachain
 
     def _readentry(self, offset, size, getmeta=False):
         rawentry = self._data[offset:offset + size]
         self._pagedin += len(rawentry)
 
         # <2 byte len> + <filename>
         lengthsize = 2
         filenamelen = struct.unpack('!H', rawentry[:2])[0]
         filename = rawentry[lengthsize:lengthsize + filenamelen]
 
         # <20 byte node> + <20 byte deltabase>
         nodestart = lengthsize + filenamelen
         deltabasestart = nodestart + NODELENGTH
         node = rawentry[nodestart:deltabasestart]
         deltabasenode = rawentry[deltabasestart:deltabasestart + NODELENGTH]
 
         # <8 byte len> + <delta>
         deltastart = deltabasestart + NODELENGTH
         rawdeltalen = rawentry[deltastart:deltastart + 8]
         deltalen = struct.unpack('!Q', rawdeltalen)[0]
 
         delta = rawentry[deltastart + 8:deltastart + 8 + deltalen]
         delta = self._decompress(delta)
 
         if getmeta:
             metastart = deltastart + 8 + deltalen
             metalen = struct.unpack_from('!I', rawentry, metastart)[0]
 
             rawmeta = rawentry[metastart + 4:metastart + 4 + metalen]
             meta = shallowutil.parsepackmeta(rawmeta)
             return filename, node, deltabasenode, delta, meta
         else:
             return filename, node, deltabasenode, delta
 
     def _decompress(self, data):
         return zlib.decompress(data)
 
     def add(self, name, node, data):
         raise RuntimeError("cannot add to datapack (%s:%s)" % (name, node))
 
     def _find(self, node):
         params = self.params
         fanoutkey = struct.unpack(params.fanoutstruct,
                                   node[:params.fanoutprefix])[0]
         fanout = self._fanouttable
 
         start = fanout[fanoutkey] + params.indexstart
         indexend = self._indexend
 
         # Scan forward to find the first non-same entry, which is the upper
         # bound.
         for i in pycompat.xrange(fanoutkey + 1, params.fanoutcount):
             end = fanout[i] + params.indexstart
             if end != start:
                 break
         else:
             end = indexend
 
         # Bisect between start and end to find node
         index = self._index
         startnode = index[start:start + NODELENGTH]
         endnode = index[end:end + NODELENGTH]
         entrylen = self.INDEXENTRYLENGTH
         if startnode == node:
             entry = index[start:start + entrylen]
         elif endnode == node:
             entry = index[end:end + entrylen]
         else:
             while start < end - entrylen:
                 mid = start  + (end - start) / 2
-                mid = mid - ((mid - params.indexstart) % entrylen)
+                mid = int(mid - ((mid - params.indexstart) % entrylen))
                 midnode = index[mid:mid + NODELENGTH]
                 if midnode == node:
                     entry = index[mid:mid + entrylen]
                     break
                 if node > midnode:
                     start = mid
                 elif node < midnode:
                     end = mid
             else:
                 return None
 
         return struct.unpack(self.INDEXFORMAT, entry)
 
     def markledger(self, ledger, options=None):
         for filename, node in self:
             ledger.markdataentry(self, filename, node)
 
     def cleanup(self, ledger):
         entries = ledger.sources.get(self, [])
         allkeys = set(self)
         repackedkeys = set((e.filename, e.node) for e in entries if
                            e.datarepacked or e.gced)
 
         if len(allkeys - repackedkeys) == 0:
             if self.path not in ledger.created:
                 util.unlinkpath(self.indexpath, ignoremissing=True)
                 util.unlinkpath(self.packpath, ignoremissing=True)
 
     def __iter__(self):
         for f, n, deltabase, deltalen in self.iterentries():
             yield f, n
 
     def iterentries(self):
         # Start at 1 to skip the header
         offset = 1
         data = self._data
         while offset < self.datasize:
             oldoffset = offset
 
             # <2 byte len> + <filename>
             filenamelen = struct.unpack('!H', data[offset:offset + 2])[0]
             offset += 2
             filename = data[offset:offset + filenamelen]
             offset += filenamelen
 
             # <20 byte node>
             node = data[offset:offset + constants.NODESIZE]
             offset += constants.NODESIZE
             # <20 byte deltabase>
             deltabase = data[offset:offset + constants.NODESIZE]
             offset += constants.NODESIZE
 
             # <8 byte len> + <delta>
             rawdeltalen = data[offset:offset + 8]
             deltalen = struct.unpack('!Q', rawdeltalen)[0]
             offset += 8
 
             # TODO(augie): we should store a header that is the
             # uncompressed size.
             uncompressedlen = len(self._decompress(
                 data[offset:offset + deltalen]))
             offset += deltalen
 
             # <4 byte len> + <metadata-list>
             metalen = struct.unpack_from('!I', data, offset)[0]
             offset += 4 + metalen
 
             yield (filename, node, deltabase, uncompressedlen)
 
             # If we've read a lot of data from the mmap, free some memory.
             self._pagedin += offset - oldoffset
             if self.freememory():
                 data = self._data
 
 class mutabledatapack(basepack.mutablebasepack):
     """A class for constructing and serializing a datapack file and index.
 
     A datapack is a pair of files that contain the revision contents for various
     file revisions in Mercurial. It contains only revision contents (like file
     contents), not any history information.
 
     It consists of two files, with the following format. All bytes are in
     network byte order (big endian).
 
     .datapack
         The pack itself is a series of revision deltas with some basic header
         information on each. A revision delta may be a fulltext, represented by
         a deltabasenode equal to the nullid.
 
         datapack = <version: 1 byte>
                    [<revision>,...]
         revision = <filename len: 2 byte unsigned int>
                    <filename>
                    <node: 20 byte>
                    <deltabasenode: 20 byte>
                    <delta len: 8 byte unsigned int>
                    <delta>
                    <metadata-list len: 4 byte unsigned int> [1]
                    <metadata-list>                          [1]
         metadata-list = [<metadata-item>, ...]
         metadata-item = <metadata-key: 1 byte>
                         <metadata-value len: 2 byte unsigned>
                         <metadata-value>
 
         metadata-key could be METAKEYFLAG or METAKEYSIZE or other single byte
         value in the future.
 
     .dataidx
         The index file consists of two parts, the fanout and the index.
 
         The index is a list of index entries, sorted by node (one per revision
         in the pack). Each entry has:
 
         - node (The 20 byte node of the entry; i.e. the commit hash, file node
                 hash, etc)
         - deltabase index offset (The location in the index of the deltabase for
                                   this entry. The deltabase is the next delta in
                                   the chain, with the chain eventually
                                   terminating in a full-text, represented by a
                                   deltabase offset of -1. This lets us compute
                                   delta chains from the index, then do
                                   sequential reads from the pack if the revision
                                   are nearby on disk.)
         - pack entry offset (The location of this entry in the datapack)
         - pack content size (The on-disk length of this entry's pack data)
 
         The fanout is a quick lookup table to reduce the number of steps for
         bisecting the index. It is a series of 4 byte pointers to positions
         within the index. It has 2^16 entries, which corresponds to hash
         prefixes [0000, 0001,..., FFFE, FFFF]. Example: the pointer in slot
         4F0A points to the index position of the first revision whose node
         starts with 4F0A. This saves log(2^16)=16 bisect steps.
 
         dataidx = <fanouttable>
                   <index>
         fanouttable = [<index offset: 4 byte unsigned int>,...] (2^16 entries)
         index = [<index entry>,...]
         indexentry = <node: 20 byte>
                      <deltabase location: 4 byte signed int>
                      <pack entry offset: 8 byte unsigned int>
                      <pack entry size: 8 byte unsigned int>
 
     [1]: new in version 1.
     """
     INDEXSUFFIX = INDEXSUFFIX
     PACKSUFFIX = PACKSUFFIX
 
     # v[01] index format: <node><delta offset><pack data offset><pack data size>
     INDEXFORMAT = datapack.INDEXFORMAT
     INDEXENTRYLENGTH = datapack.INDEXENTRYLENGTH
 
     # v1 has metadata support
     SUPPORTED_VERSIONS = [2]
 
     def _compress(self, data):
         return zlib.compress(data)
 
     def add(self, name, node, deltabasenode, delta, metadata=None):
         # metadata is a dict, ex. {METAKEYFLAG: flag}
         if len(name) > 2**16:
             raise RuntimeError(_("name too long %s") % name)
         if len(node) != 20:
             raise RuntimeError(_("node should be 20 bytes %s") % node)
 
         if node in self.entries:
             # The revision has already been added
             return
 
         # TODO: allow configurable compression
         delta = self._compress(delta)
 
         rawdata = ''.join((
             struct.pack('!H', len(name)), # unsigned 2 byte int
             name,
             node,
             deltabasenode,
             struct.pack('!Q', len(delta)), # unsigned 8 byte int
             delta,
         ))
 
         # v1 support metadata
         rawmeta = shallowutil.buildpackmeta(metadata)
         rawdata += struct.pack('!I', len(rawmeta)) # unsigned 4 byte
         rawdata += rawmeta
 
         offset = self.packfp.tell()
 
         size = len(rawdata)
 
         self.entries[node] = (deltabasenode, offset, size)
 
         self.writeraw(rawdata)
 
     def createindex(self, nodelocations, indexoffset):
         entries = sorted((n, db, o, s) for n, (db, o, s)
                          in self.entries.iteritems())
 
         rawindex = ''
         fmt = self.INDEXFORMAT
         for node, deltabase, offset, size in entries:
             if deltabase == nullid:
                 deltabaselocation = FULLTEXTINDEXMARK
             else:
                 # Instead of storing the deltabase node in the index, let's
                 # store a pointer directly to the index entry for the deltabase.
                 deltabaselocation = nodelocations.get(deltabase,
                                                       NOBASEINDEXMARK)
 
             entry = struct.pack(fmt, node, deltabaselocation, offset, size)
             rawindex += entry
 
         return rawindex