wireprotov2: let clients drive delta behavior

Previously, the "manifestdata" and "filedata" commands assumed the
receiver had all parent revisions for requested nodes. Unless the
revision had no parents, they emitted a delta instead of a fulltext.

This strategy isn't appropriate for shallow clones and for clients
that only want to access fulltext revision data for a single node
without fetching their parent revisions.

This commit adds an "haveparents" argument to the "manifestdata"
and "filedata" commands that controls delta generation behavior.

Unless "haveparents" is set, the server assumes that the client
doesn't have parent revisions unless they were previously sent
as part of the current group of revisions.

This change allows the fulltext revision data of any individual
revision to be obtained. This will facilitate shallow clones
and other data retrieval strategies that don't require all previous
revisions of an entity to be fetched.

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

mercurial/exchangev2.py

@@ -1,394 +1,396
 # exchangev2.py - repository exchange for wire protocol version 2
 #
 # Copyright 2018 Gregory Szorc <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import collections
 import weakref
 
 from .i18n import _
 from .node import (
     nullid,
     short,
 )
 from . import (
     bookmarks,
     error,
     mdiff,
     phases,
     pycompat,
     setdiscovery,
 )
 
 def pull(pullop):
     """Pull using wire protocol version 2."""
     repo = pullop.repo
     remote = pullop.remote
     tr = pullop.trmanager.transaction()
 
     # Figure out what needs to be fetched.
     common, fetch, remoteheads = _pullchangesetdiscovery(
         repo, remote, pullop.heads, abortwhenunrelated=pullop.force)
 
     # And fetch the data.
     pullheads = pullop.heads or remoteheads
     csetres = _fetchchangesets(repo, tr, remote, common, fetch, pullheads)
 
     # New revisions are written to the changelog. But all other updates
     # are deferred. Do those now.
 
     # Ensure all new changesets are draft by default. If the repo is
     # publishing, the phase will be adjusted by the loop below.
     if csetres['added']:
         phases.registernew(repo, tr, phases.draft, csetres['added'])
 
     # And adjust the phase of all changesets accordingly.
     for phase in phases.phasenames:
         if phase == b'secret' or not csetres['nodesbyphase'][phase]:
             continue
 
         phases.advanceboundary(repo, tr, phases.phasenames.index(phase),
                                csetres['nodesbyphase'][phase])
 
     # Write bookmark updates.
     bookmarks.updatefromremote(repo.ui, repo, csetres['bookmarks'],
                                remote.url(), pullop.gettransaction,
                                explicit=pullop.explicitbookmarks)
 
     manres = _fetchmanifests(repo, tr, remote, csetres['manifestnodes'])
 
     # Find all file nodes referenced by added manifests and fetch those
     # revisions.
     fnodes = _derivefilesfrommanifests(repo, manres['added'])
     _fetchfiles(repo, tr, remote, fnodes, manres['linkrevs'])
 
 def _pullchangesetdiscovery(repo, remote, heads, abortwhenunrelated=True):
     """Determine which changesets need to be pulled."""
 
     if heads:
         knownnode = repo.changelog.hasnode
         if all(knownnode(head) for head in heads):
             return heads, False, heads
 
     # TODO wire protocol version 2 is capable of more efficient discovery
     # than setdiscovery. Consider implementing something better.
     common, fetch, remoteheads = setdiscovery.findcommonheads(
         repo.ui, repo, remote, abortwhenunrelated=abortwhenunrelated)
 
     common = set(common)
     remoteheads = set(remoteheads)
 
     # If a remote head is filtered locally, put it back in the common set.
     # See the comment in exchange._pulldiscoverychangegroup() for more.
 
     if fetch and remoteheads:
         nodemap = repo.unfiltered().changelog.nodemap
 
         common |= {head for head in remoteheads if head in nodemap}
 
         if set(remoteheads).issubset(common):
             fetch = []
 
     common.discard(nullid)
 
     return common, fetch, remoteheads
 
 def _fetchchangesets(repo, tr, remote, common, fetch, remoteheads):
     # TODO consider adding a step here where we obtain the DAG shape first
     # (or ask the server to slice changesets into chunks for us) so that
     # we can perform multiple fetches in batches. This will facilitate
     # resuming interrupted clones, higher server-side cache hit rates due
     # to smaller segments, etc.
     with remote.commandexecutor() as e:
         objs = e.callcommand(b'changesetdata', {
             b'noderange': [sorted(common), sorted(remoteheads)],
             b'fields': {b'bookmarks', b'parents', b'phase', b'revision'},
         }).result()
 
         # The context manager waits on all response data when exiting. So
         # we need to remain in the context manager in order to stream data.
         return _processchangesetdata(repo, tr, objs)
 
 def _processchangesetdata(repo, tr, objs):
     repo.hook('prechangegroup', throw=True,
               **pycompat.strkwargs(tr.hookargs))
 
     urepo = repo.unfiltered()
     cl = urepo.changelog
 
     cl.delayupdate(tr)
 
     # The first emitted object is a header describing the data that
     # follows.
     meta = next(objs)
 
     progress = repo.ui.makeprogress(_('changesets'),
                                     unit=_('chunks'),
                                     total=meta.get(b'totalitems'))
 
     manifestnodes = {}
 
     def linkrev(node):
         repo.ui.debug('add changeset %s\n' % short(node))
         # Linkrev for changelog is always self.
         return len(cl)
 
     def onchangeset(cl, node):
         progress.increment()
 
         revision = cl.changelogrevision(node)
 
         # We need to preserve the mapping of changelog revision to node
         # so we can set the linkrev accordingly when manifests are added.
         manifestnodes[cl.rev(node)] = revision.manifest
 
     nodesbyphase = {phase: set() for phase in phases.phasenames}
     remotebookmarks = {}
 
     # addgroup() expects a 7-tuple describing revisions. This normalizes
     # the wire data to that format.
     #
     # This loop also aggregates non-revision metadata, such as phase
     # data.
     def iterrevisions():
         for cset in objs:
             node = cset[b'node']
 
             if b'phase' in cset:
                 nodesbyphase[cset[b'phase']].add(node)
 
             for mark in cset.get(b'bookmarks', []):
                 remotebookmarks[mark] = node
 
             # TODO add mechanism for extensions to examine records so they
             # can siphon off custom data fields.
 
             # Some entries might only be metadata only updates.
             if b'revisionsize' not in cset:
                 continue
 
             data = next(objs)
 
             yield (
                 node,
                 cset[b'parents'][0],
                 cset[b'parents'][1],
                 # Linknode is always itself for changesets.
                 cset[b'node'],
                 # We always send full revisions. So delta base is not set.
                 nullid,
                 mdiff.trivialdiffheader(len(data)) + data,
                 # Flags not yet supported.
                 0,
             )
 
     added = cl.addgroup(iterrevisions(), linkrev, weakref.proxy(tr),
                         addrevisioncb=onchangeset)
 
     progress.complete()
 
     return {
         'added': added,
         'nodesbyphase': nodesbyphase,
         'bookmarks': remotebookmarks,
         'manifestnodes': manifestnodes,
     }
 
 def _fetchmanifests(repo, tr, remote, manifestnodes):
     rootmanifest = repo.manifestlog.getstorage(b'')
 
     # Some manifests can be shared between changesets. Filter out revisions
     # we already know about.
     fetchnodes = []
     linkrevs = {}
     seen = set()
 
     for clrev, node in sorted(manifestnodes.iteritems()):
         if node in seen:
             continue
 
         try:
             rootmanifest.rev(node)
         except error.LookupError:
             fetchnodes.append(node)
             linkrevs[node] = clrev
 
         seen.add(node)
 
     # TODO handle tree manifests
 
     # addgroup() expects 7-tuple describing revisions. This normalizes
     # the wire data to that format.
     def iterrevisions(objs, progress):
         for manifest in objs:
             node = manifest[b'node']
 
             if b'deltasize' in manifest:
                 basenode = manifest[b'deltabasenode']
                 delta = next(objs)
             elif b'revisionsize' in manifest:
                 basenode = nullid
                 revision = next(objs)
                 delta = mdiff.trivialdiffheader(len(revision)) + revision
             else:
                 continue
 
             yield (
                 node,
                 manifest[b'parents'][0],
                 manifest[b'parents'][1],
                 # The value passed in is passed to the lookup function passed
                 # to addgroup(). We already have a map of manifest node to
                 # changelog revision number. So we just pass in the
                 # manifest node here and use linkrevs.__getitem__ as the
                 # resolution function.
                 node,
                 basenode,
                 delta,
                 # Flags not yet supported.
                 0
             )
 
             progress.increment()
 
     progress = repo.ui.makeprogress(_('manifests'), unit=_('chunks'),
                                     total=len(fetchnodes))
 
     # Fetch manifests 10,000 per command.
     # TODO have server advertise preferences?
     # TODO make size configurable on client?
     batchsize = 10000
 
     # We send commands 1 at a time to the remote. This is not the most
     # efficient because we incur a round trip at the end of each batch.
     # However, the existing frame-based reactor keeps consuming server
     # data in the background. And this results in response data buffering
     # in memory. This can consume gigabytes of memory.
     # TODO send multiple commands in a request once background buffering
     # issues are resolved.
 
     added = []
 
     for i in pycompat.xrange(0, len(fetchnodes), batchsize):
         batch = [node for node in fetchnodes[i:i + batchsize]]
         if not batch:
             continue
 
         with remote.commandexecutor() as e:
             objs = e.callcommand(b'manifestdata', {
                 b'tree': b'',
                 b'nodes': batch,
                 b'fields': {b'parents', b'revision'},
+                b'haveparents': True,
             }).result()
 
             # Chomp off header object.
             next(objs)
 
             added.extend(rootmanifest.addgroup(
                 iterrevisions(objs, progress),
                 linkrevs.__getitem__,
                 weakref.proxy(tr)))
 
     progress.complete()
 
     return {
         'added': added,
         'linkrevs': linkrevs,
     }
 
 def _derivefilesfrommanifests(repo, manifestnodes):
     """Determine what file nodes are relevant given a set of manifest nodes.
 
     Returns a dict mapping file paths to dicts of file node to first manifest
     node.
     """
     ml = repo.manifestlog
     fnodes = collections.defaultdict(dict)
 
     for manifestnode in manifestnodes:
         m = ml.get(b'', manifestnode)
 
         # TODO this will pull in unwanted nodes because it takes the storage
         # delta into consideration. What we really want is something that takes
         # the delta between the manifest's parents. And ideally we would
         # ignore file nodes that are known locally. For now, ignore both
         # these limitations. This will result in incremental fetches requesting
         # data we already have. So this is far from ideal.
         md = m.readfast()
 
         for path, fnode in md.items():
             fnodes[path].setdefault(fnode, manifestnode)
 
     return fnodes
 
 def _fetchfiles(repo, tr, remote, fnodes, linkrevs):
     def iterrevisions(objs, progress):
         for filerevision in objs:
             node = filerevision[b'node']
 
             if b'deltasize' in filerevision:
                 basenode = filerevision[b'deltabasenode']
                 delta = next(objs)
             elif b'revisionsize' in filerevision:
                 basenode = nullid
                 revision = next(objs)
                 delta = mdiff.trivialdiffheader(len(revision)) + revision
             else:
                 continue
 
             yield (
                 node,
                 filerevision[b'parents'][0],
                 filerevision[b'parents'][1],
                 node,
                 basenode,
                 delta,
                 # Flags not yet supported.
                 0,
             )
 
             progress.increment()
 
     progress = repo.ui.makeprogress(
         _('files'), unit=_('chunks'),
          total=sum(len(v) for v in fnodes.itervalues()))
 
     # TODO make batch size configurable
     batchsize = 10000
     fnodeslist = [x for x in sorted(fnodes.items())]
 
     for i in pycompat.xrange(0, len(fnodeslist), batchsize):
         batch = [x for x in fnodeslist[i:i + batchsize]]
         if not batch:
             continue
 
         with remote.commandexecutor() as e:
             fs = []
             locallinkrevs = {}
 
             for path, nodes in batch:
                 fs.append((path, e.callcommand(b'filedata', {
                     b'path': path,
                     b'nodes': sorted(nodes),
-                    b'fields': {b'parents', b'revision'}
+                    b'fields': {b'parents', b'revision'},
+                    b'haveparents': True,
                 })))
 
                 locallinkrevs[path] = {
                     node: linkrevs[manifestnode]
                     for node, manifestnode in nodes.iteritems()}
 
             for path, f in fs:
                 objs = f.result()
 
                 # Chomp off header objects.
                 next(objs)
 
                 store = repo.file(path)
                 store.addgroup(
                     iterrevisions(objs, progress),
                     locallinkrevs[path].__getitem__,
                     weakref.proxy(tr))

mercurial/help/internals/wireprotocolv2.txt

@@ -1,425 +1,440
 **Experimental and under active development**
 
 This section documents the wire protocol commands exposed to transports
 using the frame-based protocol. The set of commands exposed through
 these transports is distinct from the set of commands exposed to legacy
 transports.
 
 The frame-based protocol uses CBOR to encode command execution requests.
 All command arguments must be mapped to a specific or set of CBOR data
 types.
 
 The response to many commands is also CBOR. There is no common response
 format: each command defines its own response format.
 
 TODOs
 =====
 
 * Add "node namespace" support to each command. In order to support
   SHA-1 hash transition, we want servers to be able to expose different
   "node namespaces" for the same data. Every command operating on nodes
   should specify which "node namespace" it is operating on and responses
   should encode the "node namespace" accordingly.
 
 Commands
 ========
 
 The sections below detail all commands available to wire protocol version
 2.
 
 branchmap
 ---------
 
 Obtain heads in named branches.
 
 Receives no arguments.
 
 The response is a map with bytestring keys defining the branch name.
 Values are arrays of bytestring defining raw changeset nodes.
 
 capabilities
 ------------
 
 Obtain the server's capabilities.
 
 Receives no arguments.
 
 This command is typically called only as part of the handshake during
 initial connection establishment.
 
 The response is a map with bytestring keys defining server information.
 
 The defined keys are:
 
 commands
    A map defining available wire protocol commands on this server.
 
    Keys in the map are the names of commands that can be invoked. Values
    are maps defining information about that command. The bytestring keys
    are:
 
       args
          A map of argument names and their expected types.
 
          Types are defined as a representative value for the expected type.
          e.g. an argument expecting a boolean type will have its value
          set to true. An integer type will have its value set to 42. The
          actual values are arbitrary and may not have meaning.
       permissions
          An array of permissions required to execute this command.
 
 compression
    An array of maps defining available compression format support.
 
    The array is sorted from most preferred to least preferred.
 
    Each entry has the following bytestring keys:
 
       name
          Name of the compression engine. e.g. ``zstd`` or ``zlib``.
 
 framingmediatypes
    An array of bytestrings defining the supported framing protocol
    media types. Servers will not accept media types not in this list.
 
 rawrepoformats
    An array of storage formats the repository is using. This set of
    requirements can be used to determine whether a client can read a
    *raw* copy of file data available.
 
 changesetdata
 -------------
 
 Obtain various data related to changesets.
 
 The command accepts the following arguments:
 
 noderange
    (array of arrays of bytestrings) An array of 2 elements, each being an
    array of node bytestrings. The first array denotes the changelog revisions
    that are already known to the client. The second array denotes the changelog
    revision DAG heads to fetch. The argument essentially defines a DAG range
    bounded by root and head nodes to fetch.
 
    The roots array may be empty. The heads array must be defined.
 
 nodes
    (array of bytestrings) Changelog revisions to request explicitly.
 
 fields
    (set of bytestring) Which data associated with changelog revisions to
    fetch. The following values are recognized:
 
    bookmarks
       Bookmarks associated with a revision.
 
    parents
       Parent revisions.
 
    phase
       The phase state of a revision.
 
    revision
       The raw, revision data for the changelog entry. The hash of this data
       will match the revision's node value.
 
 The server resolves the set of revisions relevant to the request by taking
 the union of the ``noderange`` and ``nodes`` arguments. At least one of these
 arguments must be defined.
 
 The response bytestream starts with a CBOR map describing the data that follows.
 This map has the following bytestring keys:
 
 totalitems
    (unsigned integer) Total number of changelog revisions whose data is being
    transferred. This maps to the set of revisions in the requested node
    range, not the total number of records that follow (see below for why).
 
 Following the map header is a series of 0 or more CBOR values. If values
 are present, the first value will always be a map describing a single changeset
 revision. If revision data is requested, the raw revision data (encoded as
 a CBOR bytestring) will follow the map describing it. Otherwise, another CBOR
 map describing the next changeset revision will occur.
 
 Each map has the following bytestring keys:
 
 node
    (bytestring) The node value for this revision. This is the SHA-1 hash of
    the raw revision data.
 
 bookmarks (optional)
    (array of bytestrings) Bookmarks attached to this revision. Only present
    if ``bookmarks`` data is being requested and the revision has bookmarks
    attached.
 
 parents (optional)
    (array of bytestrings) The nodes representing the parent revisions of this
    revision. Only present if ``parents`` data is being requested.
 
 phase (optional)
    (bytestring) The phase that a revision is in. Recognized values are
    ``secret``, ``draft``, and ``public``. Only present if ``phase`` data
    is being requested.
 
 revisionsize (optional)
    (unsigned integer) Indicates the size of raw revision data that follows this
    map. The following data contains a serialized form of the changeset data,
    including the author, date, commit message, set of changed files, manifest
    node, and other metadata.
 
    Only present if ``revision`` data was requested and the data follows this
    map.
 
 If nodes are requested via ``noderange``, they will be emitted in DAG order,
 parents always before children.
 
 If nodes are requested via ``nodes``, they will be emitted in requested order.
 
 Nodes from ``nodes`` are emitted before nodes from ``noderange``.
 
 The set of changeset revisions emitted may not match the exact set of
 changesets requested. Furthermore, the set of keys present on each
 map may vary. This is to facilitate emitting changeset updates as well
 as new revisions.
 
 For example, if the request wants ``phase`` and ``revision`` data,
 the response may contain entries for each changeset in the common nodes
 set with the ``phase`` key and without the ``revision`` key in order
 to reflect a phase-only update.
 
 TODO support different revision selection mechanisms (e.g. non-public, specific
 revisions)
 TODO support different hash "namespaces" for revisions (e.g. sha-1 versus other)
 TODO support emitting obsolescence data
 TODO support filtering based on relevant paths (narrow clone)
 TODO support depth limiting
 TODO support hgtagsfnodes cache / tags data
 TODO support branch heads cache
 
 filedata
 --------
 
 Obtain various data related to an individual tracked file.
 
 The command accepts the following arguments:
 
 fields
    (set of bytestring) Which data associated with a file to fetch.
    The following values are recognized:
 
    parents
       Parent nodes for the revision.
 
    revision
       The raw revision data for a file.
 
+haveparents
+   (bool) Whether the client has the parent revisions of all requested
+   nodes. If set, the server may emit revision data as deltas against
+   any parent revision. If not set, the server MUST only emit deltas for
+   revisions previously emitted by this command.
+
+   False is assumed in the absence of any value.
+
 nodes
    (array of bytestrings) File nodes whose data to retrieve.
 
 path
    (bytestring) Path of the tracked file whose data to retrieve.
 
 TODO allow specifying revisions via alternate means (such as from
 changeset revisions or ranges)
 
 The response bytestream starts with a CBOR map describing the data that
 follows. It has the following bytestream keys:
 
 totalitems
    (unsigned integer) Total number of file revisions whose data is
    being returned.
 
 Following the header map is a series of 0 or more CBOR values. The first
 value is always a map describing a file revision. If this map has the
 ``deltasize`` or ``revisionsize`` keys, a bytestring containing the delta
 or revision, respectively, will immediately follow the map. Otherwise
 the next value will be a map describing the next file revision.
 
 Each map has the following bytestring keys:
 
 node
    (bytestring) The node of the file revision whose data is represented.
 
 deltabasenode
    (bytestring) Node of the file revision the following delta is against.
 
    Only present if the ``revision`` field is requested and delta data
    follows this map.
 
 deltasize
    (unsigned integer) The size of the delta data that follows this map.
 
    Only present if the ``revision`` field is requested and delta data
    follows this map.
 
 parents
    (array of bytestring) The nodes of the parents of this file revision.
 
    Only present if the ``parents`` field is requested.
 
 revisionsize
    (unsigned integer) The size of the fulltext revision data that follows
    this map.
 
    Only present if the ``revision`` field is requested and fulltext revision
    data follows this map.
 
 When ``revision`` data is requested, the server chooses to emit either fulltext
 revision data or a delta. What the server decides can be inferred by looking
 for the presence of the ``deltasize`` or ``revisionsize`` keys in the map.
 Servers MUST NOT define both keys.
 
 heads
 -----
 
 Obtain DAG heads in the repository.
 
 The command accepts the following arguments:
 
 publiconly (optional)
    (boolean) If set, operate on the DAG for public phase changesets only.
    Non-public (i.e. draft) phase DAG heads will not be returned.
 
 The response is a CBOR array of bytestrings defining changeset nodes
 of DAG heads. The array can be empty if the repository is empty or no
 changesets satisfied the request.
 
 TODO consider exposing phase of heads in response
 
 known
 -----
 
 Determine whether a series of changeset nodes is known to the server.
 
 The command accepts the following arguments:
 
 nodes
    (array of bytestrings) List of changeset nodes whose presence to
    query.
 
 The response is a bytestring where each byte contains a 0 or 1 for the
 corresponding requested node at the same index.
 
 TODO use a bit array for even more compact response
 
 listkeys
 --------
 
 List values in a specified ``pushkey`` namespace.
 
 The command receives the following arguments:
 
 namespace
    (bytestring) Pushkey namespace to query.
 
 The response is a map with bytestring keys and values.
 
 TODO consider using binary to represent nodes in certain pushkey namespaces.
 
 lookup
 ------
 
 Try to resolve a value to a changeset revision.
 
 Unlike ``known`` which operates on changeset nodes, lookup operates on
 node fragments and other names that a user may use.
 
 The command receives the following arguments:
 
 key
    (bytestring) Value to try to resolve.
 
 On success, returns a bytestring containing the resolved node.
 
 manifestdata
 ------------
 
 Obtain various data related to manifests (which are lists of files in
 a revision).
 
 The command accepts the following arguments:
 
 fields
    (set of bytestring) Which data associated with manifests to fetch.
    The following values are recognized:
 
    parents
       Parent nodes for the manifest.
 
    revision
       The raw revision data for the manifest.
 
+haveparents
+   (bool) Whether the client has the parent revisions of all requested
+   nodes. If set, the server may emit revision data as deltas against
+   any parent revision. If not set, the server MUST only emit deltas for
+   revisions previously emitted by this command.
+
+   False is assumed in the absence of any value.
+
 nodes
    (array of bytestring) Manifest nodes whose data to retrieve.
 
 tree
    (bytestring) Path to manifest to retrieve. The empty bytestring represents
    the root manifest. All other values represent directories/trees within
    the repository.
 
 TODO allow specifying revisions via alternate means (such as from changeset
 revisions or ranges)
 TODO consider recursive expansion of manifests (with path filtering for
 narrow use cases)
-TODO more control over whether to emit fulltexts or deltas
 
 The response bytestream starts with a CBOR map describing the data that
 follows. It has the following bytestring keys:
 
 totalitems
    (unsigned integer) Total number of manifest revisions whose data is
    being returned.
 
 Following the header map is a series of 0 or more CBOR values. The first
 value is always a map describing a manifest revision. If this map has the
 ``deltasize`` or ``revisionsize`` keys, a bytestring containing the delta
 or revision, respectively, will immediately follow the map. Otherwise
 the next value will be a map describing the next manifest revision.
 
 Each map has the following bytestring keys:
 
 node
    (bytestring) The node of the manifest revision whose data is represented.
 
 deltabasenode
    (bytestring) The node that the delta representation of this revision is
    computed against. Only present if the ``revision`` field is requested and
    a delta is being emitted.
 
 deltasize
    (unsigned integer) The size of the delta data that follows this map.
    Only present if the ``revision`` field is requested and a delta is
    being emitted.
 
 parents
    (array of bytestring) The nodes of the parents of this manifest revision.
    Only present if the ``parents`` field is requested.
 
 revisionsize
    (unsigned integer) The size of the fulltext revision data that follows
    this map. Only present if the ``revision`` field is requested and a fulltext
    revision is being emitted.
 
 When ``revision`` data is requested, the server chooses to emit either fulltext
 revision data or a delta. What the server decides can be inferred by looking
 for the presence of the ``deltasize`` or ``revisionsize`` keys in the map.
 Servers MUST NOT define both keys.
 
 pushkey
 -------
 
 Set a value using the ``pushkey`` protocol.
 
 The command receives the following arguments:
 
 namespace
    (bytestring) Pushkey namespace to operate on.
 key
    (bytestring) The pushkey key to set.
 old
    (bytestring) Old value for this key.
 new
    (bytestring) New value for this key.
 
 TODO consider using binary to represent nodes is certain pushkey namespaces.
 TODO better define response type and meaning.

mercurial/wireprotov2server.py

@@ -1,898 +1,921
 # Copyright 21 May 2005 - (c) 2005 Jake Edge <[e-mail]>
 # Copyright 2005-2007 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import contextlib
 
 from .i18n import _
 from .node import (
     hex,
     nullid,
     nullrev,
 )
 from . import (
     changegroup,
     dagop,
     discovery,
     encoding,
     error,
     pycompat,
     streamclone,
     util,
     wireprotoframing,
     wireprototypes,
 )
 from .utils import (
     interfaceutil,
 )
 
 FRAMINGTYPE = b'application/mercurial-exp-framing-0005'
 
 HTTP_WIREPROTO_V2 = wireprototypes.HTTP_WIREPROTO_V2
 
 COMMANDS = wireprototypes.commanddict()
 
 def handlehttpv2request(rctx, req, res, checkperm, urlparts):
     from .hgweb import common as hgwebcommon
 
     # URL space looks like: <permissions>/<command>, where <permission> can
     # be ``ro`` or ``rw`` to signal read-only or read-write, respectively.
 
     # Root URL does nothing meaningful... yet.
     if not urlparts:
         res.status = b'200 OK'
         res.headers[b'Content-Type'] = b'text/plain'
         res.setbodybytes(_('HTTP version 2 API handler'))
         return
 
     if len(urlparts) == 1:
         res.status = b'404 Not Found'
         res.headers[b'Content-Type'] = b'text/plain'
         res.setbodybytes(_('do not know how to process %s\n') %
                          req.dispatchpath)
         return
 
     permission, command = urlparts[0:2]
 
     if permission not in (b'ro', b'rw'):
         res.status = b'404 Not Found'
         res.headers[b'Content-Type'] = b'text/plain'
         res.setbodybytes(_('unknown permission: %s') % permission)
         return
 
     if req.method != 'POST':
         res.status = b'405 Method Not Allowed'
         res.headers[b'Allow'] = b'POST'
         res.setbodybytes(_('commands require POST requests'))
         return
 
     # At some point we'll want to use our own API instead of recycling the
     # behavior of version 1 of the wire protocol...
     # TODO return reasonable responses - not responses that overload the
     # HTTP status line message for error reporting.
     try:
         checkperm(rctx, req, 'pull' if permission == b'ro' else 'push')
     except hgwebcommon.ErrorResponse as e:
         res.status = hgwebcommon.statusmessage(e.code, pycompat.bytestr(e))
         for k, v in e.headers:
             res.headers[k] = v
         res.setbodybytes('permission denied')
         return
 
     # We have a special endpoint to reflect the request back at the client.
     if command == b'debugreflect':
         _processhttpv2reflectrequest(rctx.repo.ui, rctx.repo, req, res)
         return
 
     # Extra commands that we handle that aren't really wire protocol
     # commands. Think extra hard before making this hackery available to
     # extension.
     extracommands = {'multirequest'}
 
     if command not in COMMANDS and command not in extracommands:
         res.status = b'404 Not Found'
         res.headers[b'Content-Type'] = b'text/plain'
         res.setbodybytes(_('unknown wire protocol command: %s\n') % command)
         return
 
     repo = rctx.repo
     ui = repo.ui
 
     proto = httpv2protocolhandler(req, ui)
 
     if (not COMMANDS.commandavailable(command, proto)
         and command not in extracommands):
         res.status = b'404 Not Found'
         res.headers[b'Content-Type'] = b'text/plain'
         res.setbodybytes(_('invalid wire protocol command: %s') % command)
         return
 
     # TODO consider cases where proxies may add additional Accept headers.
     if req.headers.get(b'Accept') != FRAMINGTYPE:
         res.status = b'406 Not Acceptable'
         res.headers[b'Content-Type'] = b'text/plain'
         res.setbodybytes(_('client MUST specify Accept header with value: %s\n')
                            % FRAMINGTYPE)
         return
 
     if req.headers.get(b'Content-Type') != FRAMINGTYPE:
         res.status = b'415 Unsupported Media Type'
         # TODO we should send a response with appropriate media type,
         # since client does Accept it.
         res.headers[b'Content-Type'] = b'text/plain'
         res.setbodybytes(_('client MUST send Content-Type header with '
                            'value: %s\n') % FRAMINGTYPE)
         return
 
     _processhttpv2request(ui, repo, req, res, permission, command, proto)
 
 def _processhttpv2reflectrequest(ui, repo, req, res):
     """Reads unified frame protocol request and dumps out state to client.
 
     This special endpoint can be used to help debug the wire protocol.
 
     Instead of routing the request through the normal dispatch mechanism,
     we instead read all frames, decode them, and feed them into our state
     tracker. We then dump the log of all that activity back out to the
     client.
     """
     import json
 
     # Reflection APIs have a history of being abused, accidentally disclosing
     # sensitive data, etc. So we have a config knob.
     if not ui.configbool('experimental', 'web.api.debugreflect'):
         res.status = b'404 Not Found'
         res.headers[b'Content-Type'] = b'text/plain'
         res.setbodybytes(_('debugreflect service not available'))
         return
 
     # We assume we have a unified framing protocol request body.
 
     reactor = wireprotoframing.serverreactor()
     states = []
 
     while True:
         frame = wireprotoframing.readframe(req.bodyfh)
 
         if not frame:
             states.append(b'received: <no frame>')
             break
 
         states.append(b'received: %d %d %d %s' % (frame.typeid, frame.flags,
                                                   frame.requestid,
                                                   frame.payload))
 
         action, meta = reactor.onframerecv(frame)
         states.append(json.dumps((action, meta), sort_keys=True,
                                  separators=(', ', ': ')))
 
     action, meta = reactor.oninputeof()
     meta['action'] = action
     states.append(json.dumps(meta, sort_keys=True, separators=(', ',': ')))
 
     res.status = b'200 OK'
     res.headers[b'Content-Type'] = b'text/plain'
     res.setbodybytes(b'\n'.join(states))
 
 def _processhttpv2request(ui, repo, req, res, authedperm, reqcommand, proto):
     """Post-validation handler for HTTPv2 requests.
 
     Called when the HTTP request contains unified frame-based protocol
     frames for evaluation.
     """
     # TODO Some HTTP clients are full duplex and can receive data before
     # the entire request is transmitted. Figure out a way to indicate support
     # for that so we can opt into full duplex mode.
     reactor = wireprotoframing.serverreactor(deferoutput=True)
     seencommand = False
 
     outstream = reactor.makeoutputstream()
 
     while True:
         frame = wireprotoframing.readframe(req.bodyfh)
         if not frame:
             break
 
         action, meta = reactor.onframerecv(frame)
 
         if action == 'wantframe':
             # Need more data before we can do anything.
             continue
         elif action == 'runcommand':
             sentoutput = _httpv2runcommand(ui, repo, req, res, authedperm,
                                            reqcommand, reactor, outstream,
                                            meta, issubsequent=seencommand)
 
             if sentoutput:
                 return
 
             seencommand = True
 
         elif action == 'error':
             # TODO define proper error mechanism.
             res.status = b'200 OK'
             res.headers[b'Content-Type'] = b'text/plain'
             res.setbodybytes(meta['message'] + b'\n')
             return
         else:
             raise error.ProgrammingError(
                 'unhandled action from frame processor: %s' % action)
 
     action, meta = reactor.oninputeof()
     if action == 'sendframes':
         # We assume we haven't started sending the response yet. If we're
         # wrong, the response type will raise an exception.
         res.status = b'200 OK'
         res.headers[b'Content-Type'] = FRAMINGTYPE
         res.setbodygen(meta['framegen'])
     elif action == 'noop':
         pass
     else:
         raise error.ProgrammingError('unhandled action from frame processor: %s'
                                      % action)
 
 def _httpv2runcommand(ui, repo, req, res, authedperm, reqcommand, reactor,
                       outstream, command, issubsequent):
     """Dispatch a wire protocol command made from HTTPv2 requests.
 
     The authenticated permission (``authedperm``) along with the original
     command from the URL (``reqcommand``) are passed in.
     """
     # We already validated that the session has permissions to perform the
     # actions in ``authedperm``. In the unified frame protocol, the canonical
     # command to run is expressed in a frame. However, the URL also requested
     # to run a specific command. We need to be careful that the command we
     # run doesn't have permissions requirements greater than what was granted
     # by ``authedperm``.
     #
     # Our rule for this is we only allow one command per HTTP request and
     # that command must match the command in the URL. However, we make
     # an exception for the ``multirequest`` URL. This URL is allowed to
     # execute multiple commands. We double check permissions of each command
     # as it is invoked to ensure there is no privilege escalation.
     # TODO consider allowing multiple commands to regular command URLs
     # iff each command is the same.
 
     proto = httpv2protocolhandler(req, ui, args=command['args'])
 
     if reqcommand == b'multirequest':
         if not COMMANDS.commandavailable(command['command'], proto):
             # TODO proper error mechanism
             res.status = b'200 OK'
             res.headers[b'Content-Type'] = b'text/plain'
             res.setbodybytes(_('wire protocol command not available: %s') %
                              command['command'])
             return True
 
         # TODO don't use assert here, since it may be elided by -O.
         assert authedperm in (b'ro', b'rw')
         wirecommand = COMMANDS[command['command']]
         assert wirecommand.permission in ('push', 'pull')
 
         if authedperm == b'ro' and wirecommand.permission != 'pull':
             # TODO proper error mechanism
             res.status = b'403 Forbidden'
             res.headers[b'Content-Type'] = b'text/plain'
             res.setbodybytes(_('insufficient permissions to execute '
                                'command: %s') % command['command'])
             return True
 
         # TODO should we also call checkperm() here? Maybe not if we're going
         # to overhaul that API. The granted scope from the URL check should
         # be good enough.
 
     else:
         # Don't allow multiple commands outside of ``multirequest`` URL.
         if issubsequent:
             # TODO proper error mechanism
             res.status = b'200 OK'
             res.headers[b'Content-Type'] = b'text/plain'
             res.setbodybytes(_('multiple commands cannot be issued to this '
                                'URL'))
             return True
 
         if reqcommand != command['command']:
             # TODO define proper error mechanism
             res.status = b'200 OK'
             res.headers[b'Content-Type'] = b'text/plain'
             res.setbodybytes(_('command in frame must match command in URL'))
             return True
 
     res.status = b'200 OK'
     res.headers[b'Content-Type'] = FRAMINGTYPE
 
     try:
         objs = dispatch(repo, proto, command['command'])
 
         action, meta = reactor.oncommandresponsereadyobjects(
             outstream, command['requestid'], objs)
 
     except Exception as e:
         action, meta = reactor.onservererror(
             outstream, command['requestid'],
             _('exception when invoking command: %s') % e)
 
     if action == 'sendframes':
         res.setbodygen(meta['framegen'])
         return True
     elif action == 'noop':
         return False
     else:
         raise error.ProgrammingError('unhandled event from reactor: %s' %
                                      action)
 
 def getdispatchrepo(repo, proto, command):
     return repo.filtered('served')
 
 def dispatch(repo, proto, command):
     repo = getdispatchrepo(repo, proto, command)
 
     func, spec = COMMANDS[command]
     args = proto.getargs(spec)
 
     return func(repo, proto, **args)
 
 @interfaceutil.implementer(wireprototypes.baseprotocolhandler)
 class httpv2protocolhandler(object):
     def __init__(self, req, ui, args=None):
         self._req = req
         self._ui = ui
         self._args = args
 
     @property
     def name(self):
         return HTTP_WIREPROTO_V2
 
     def getargs(self, args):
         data = {}
         for k, typ in args.items():
             if k == '*':
                 raise NotImplementedError('do not support * args')
             elif k in self._args:
                 # TODO consider validating value types.
                 data[k] = self._args[k]
 
         return data
 
     def getprotocaps(self):
         # Protocol capabilities are currently not implemented for HTTP V2.
         return set()
 
     def getpayload(self):
         raise NotImplementedError
 
     @contextlib.contextmanager
     def mayberedirectstdio(self):
         raise NotImplementedError
 
     def client(self):
         raise NotImplementedError
 
     def addcapabilities(self, repo, caps):
         return caps
 
     def checkperm(self, perm):
         raise NotImplementedError
 
 def httpv2apidescriptor(req, repo):
     proto = httpv2protocolhandler(req, repo.ui)
 
     return _capabilitiesv2(repo, proto)
 
 def _capabilitiesv2(repo, proto):
     """Obtain the set of capabilities for version 2 transports.
 
     These capabilities are distinct from the capabilities for version 1
     transports.
     """
     compression = []
     for engine in wireprototypes.supportedcompengines(repo.ui, util.SERVERROLE):
         compression.append({
             b'name': engine.wireprotosupport().name,
         })
 
     caps = {
         'commands': {},
         'compression': compression,
         'framingmediatypes': [FRAMINGTYPE],
     }
 
     # TODO expose available changesetdata fields.
 
     for command, entry in COMMANDS.items():
         caps['commands'][command] = {
             'args': entry.args,
             'permissions': [entry.permission],
         }
 
     if streamclone.allowservergeneration(repo):
         caps['rawrepoformats'] = sorted(repo.requirements &
                                         repo.supportedformats)
 
     return proto.addcapabilities(repo, caps)
 
-def builddeltarequests(store, nodes):
+def builddeltarequests(store, nodes, haveparents):
     """Build a series of revision delta requests against a backend store.
 
     Returns a list of revision numbers in the order they should be sent
     and a list of ``irevisiondeltarequest`` instances to be made against
     the backend store.
     """
     # We sort and send nodes in DAG order because this is optimal for
     # storage emission.
     # TODO we may want a better storage API here - one where we can throw
     # a list of nodes and delta preconditions over a figurative wall and
     # have the storage backend figure it out for us.
     revs = dagop.linearize({store.rev(n) for n in nodes}, store.parentrevs)
 
     requests = []
+    seenrevs = set()
 
     for rev in revs:
         node = store.node(rev)
-        parents = store.parents(node)
-        deltaparent = store.node(store.deltaparent(rev))
+        parentnodes = store.parents(node)
+        parentrevs = [store.rev(n) for n in parentnodes]
+        deltabaserev = store.deltaparent(rev)
+        deltabasenode = store.node(deltabaserev)
 
-        # There is a delta in storage. That means we can send the delta
-        # efficiently.
+        # The choice of whether to send a fulltext revision or a delta and
+        # what delta to send is governed by a few factors.
         #
-        # But, the delta may be against a revision the receiver doesn't
-        # have (e.g. shallow clone or when the delta isn't against a parent
-        # revision). For now, we ignore the problem of shallow clone. As
-        # long as a delta exists against a parent, we send it.
-        # TODO allow arguments to control this behavior, as the receiver
-        # may not have the base revision in some scenarios.
-        if deltaparent != nullid and deltaparent in parents:
-            basenode = deltaparent
+        # To send a delta, we need to ensure the receiver is capable of
+        # decoding it. And that requires the receiver to have the base
+        # revision the delta is against.
+        #
+        # We can only guarantee the receiver has the base revision if
+        # a) we've already sent the revision as part of this group
+        # b) the receiver has indicated they already have the revision.
+        # And the mechanism for "b" is the client indicating they have
+        # parent revisions. So this means we can only send the delta if
+        # it is sent before or it is against a delta and the receiver says
+        # they have a parent.
 
-        # Else there is no delta parent in storage or the delta that is
-        # # there isn't suitable. Let's use a delta against a parent
-        # revision, if possible.
-        #
-        # There is room to check if the delta parent is in the ancestry of
-        # this node. But there isn't an API on the manifest storage object
-        # for that. So ignore this case for now.
+        # We can send storage delta if it is against a revision we've sent
+        # in this group.
+        if deltabaserev != nullrev and deltabaserev in seenrevs:
+            basenode = deltabasenode
+
+        # We can send storage delta if it is against a parent revision and
+        # the receiver indicates they have the parents.
+        elif (deltabaserev != nullrev and deltabaserev in parentrevs
+              and haveparents):
+            basenode = deltabasenode
 
-        elif parents[0] != nullid:
-            basenode = parents[0]
-        elif parents[1] != nullid:
-            basenode = parents[1]
+        # Otherwise the storage delta isn't appropriate. Fall back to
+        # using another delta, if possible.
 
-        # No potential bases to delta against. Send a full revision.
+        # Use p1 if we've emitted it or receiver says they have it.
+        elif parentrevs[0] != nullrev and (
+            parentrevs[0] in seenrevs or haveparents):
+            basenode = parentnodes[0]
+
+        # Use p2 if we've emitted it or receiver says they have it.
+        elif parentrevs[1] != nullrev and (
+            parentrevs[1] in seenrevs or haveparents):
+            basenode = parentnodes[1]
+
+        # Nothing appropriate to delta against. Send the full revision.
         else:
             basenode = nullid
 
         requests.append(changegroup.revisiondeltarequest(
             node=node,
-            p1node=parents[0],
-            p2node=parents[1],
+            p1node=parentnodes[0],
+            p2node=parentnodes[1],
             # Receiver deals with linknode resolution.
             linknode=nullid,
             basenode=basenode,
         ))
 
+        seenrevs.add(rev)
+
     return revs, requests
 
 def wireprotocommand(name, args=None, permission='push'):
     """Decorator to declare a wire protocol command.
 
     ``name`` is the name of the wire protocol command being provided.
 
     ``args`` is a dict of argument names to example values.
 
     ``permission`` defines the permission type needed to run this command.
     Can be ``push`` or ``pull``. These roughly map to read-write and read-only,
     respectively. Default is to assume command requires ``push`` permissions
     because otherwise commands not declaring their permissions could modify
     a repository that is supposed to be read-only.
 
     Wire protocol commands are generators of objects to be serialized and
     sent to the client.
 
     If a command raises an uncaught exception, this will be translated into
     a command error.
     """
     transports = {k for k, v in wireprototypes.TRANSPORTS.items()
                   if v['version'] == 2}
 
     if permission not in ('push', 'pull'):
         raise error.ProgrammingError('invalid wire protocol permission; '
                                      'got %s; expected "push" or "pull"' %
                                      permission)
 
     if args is None:
         args = {}
 
     if not isinstance(args, dict):
         raise error.ProgrammingError('arguments for version 2 commands '
                                      'must be declared as dicts')
 
     def register(func):
         if name in COMMANDS:
             raise error.ProgrammingError('%s command already registered '
                                          'for version 2' % name)
 
         COMMANDS[name] = wireprototypes.commandentry(
             func, args=args, transports=transports, permission=permission)
 
         return func
 
     return register
 
 @wireprotocommand('branchmap', permission='pull')
 def branchmapv2(repo, proto):
     yield {encoding.fromlocal(k): v
            for k, v in repo.branchmap().iteritems()}
 
 @wireprotocommand('capabilities', permission='pull')
 def capabilitiesv2(repo, proto):
     yield _capabilitiesv2(repo, proto)
 
 @wireprotocommand('changesetdata',
                   args={
                       'noderange': [[b'0123456...'], [b'abcdef...']],
                       'nodes': [b'0123456...'],
                       'fields': {b'parents', b'revision'},
                   },
                   permission='pull')
 def changesetdata(repo, proto, noderange=None, nodes=None, fields=None):
     fields = fields or set()
 
     # TODO look for unknown fields and abort when they can't be serviced.
 
     if noderange is None and nodes is None:
         raise error.WireprotoCommandError(
             'noderange or nodes must be defined')
 
     if noderange is not None:
         if len(noderange) != 2:
             raise error.WireprotoCommandError(
                 'noderange must consist of 2 elements')
 
         if not noderange[1]:
             raise error.WireprotoCommandError(
                 'heads in noderange request cannot be empty')
 
     cl = repo.changelog
     hasnode = cl.hasnode
 
     seen = set()
     outgoing = []
 
     if nodes is not None:
         outgoing.extend(n for n in nodes if hasnode(n))
         seen |= set(outgoing)
 
     if noderange is not None:
         if noderange[0]:
             common = [n for n in noderange[0] if hasnode(n)]
         else:
             common = [nullid]
 
         for n in discovery.outgoing(repo, common, noderange[1]).missing:
             if n not in seen:
                 outgoing.append(n)
             # Don't need to add to seen here because this is the final
             # source of nodes and there should be no duplicates in this
             # list.
 
     seen.clear()
     publishing = repo.publishing()
 
     if outgoing:
         repo.hook('preoutgoing', throw=True, source='serve')
 
     yield {
         b'totalitems': len(outgoing),
     }
 
     # The phases of nodes already transferred to the client may have changed
     # since the client last requested data. We send phase-only records
     # for these revisions, if requested.
     if b'phase' in fields and noderange is not None:
         # TODO skip nodes whose phase will be reflected by a node in the
         # outgoing set. This is purely an optimization to reduce data
         # size.
         for node in noderange[0]:
             yield {
                 b'node': node,
                 b'phase': b'public' if publishing else repo[node].phasestr()
             }
 
     nodebookmarks = {}
     for mark, node in repo._bookmarks.items():
         nodebookmarks.setdefault(node, set()).add(mark)
 
     # It is already topologically sorted by revision number.
     for node in outgoing:
         d = {
             b'node': node,
         }
 
         if b'parents' in fields:
             d[b'parents'] = cl.parents(node)
 
         if b'phase' in fields:
             if publishing:
                 d[b'phase'] = b'public'
             else:
                 ctx = repo[node]
                 d[b'phase'] = ctx.phasestr()
 
         if b'bookmarks' in fields and node in nodebookmarks:
             d[b'bookmarks'] = sorted(nodebookmarks[node])
             del nodebookmarks[node]
 
         revisiondata = None
 
         if b'revision' in fields:
             revisiondata = cl.revision(node, raw=True)
             d[b'revisionsize'] = len(revisiondata)
 
         # TODO make it possible for extensions to wrap a function or register
         # a handler to service custom fields.
 
         yield d
 
         if revisiondata is not None:
             yield revisiondata
 
     # If requested, send bookmarks from nodes that didn't have revision
     # data sent so receiver is aware of any bookmark updates.
     if b'bookmarks' in fields:
         for node, marks in sorted(nodebookmarks.iteritems()):
             yield {
                 b'node': node,
                 b'bookmarks': sorted(marks),
             }
 
 class FileAccessError(Exception):
     """Represents an error accessing a specific file."""
 
     def __init__(self, path, msg, args):
         self.path = path
         self.msg = msg
         self.args = args
 
 def getfilestore(repo, proto, path):
     """Obtain a file storage object for use with wire protocol.
 
     Exists as a standalone function so extensions can monkeypatch to add
     access control.
     """
     # This seems to work even if the file doesn't exist. So catch
     # "empty" files and return an error.
     fl = repo.file(path)
 
     if not len(fl):
         raise FileAccessError(path, 'unknown file: %s', (path,))
 
     return fl
 
 @wireprotocommand('filedata',
                   args={
+                      'haveparents': True,
                       'nodes': [b'0123456...'],
                       'fields': [b'parents', b'revision'],
                       'path': b'foo.txt',
                   },
                   permission='pull')
-def filedata(repo, proto, nodes=None, fields=None, path=None):
+def filedata(repo, proto, haveparents=False, nodes=None, fields=None,
+             path=None):
     fields = fields or set()
 
     if nodes is None:
         raise error.WireprotoCommandError('nodes argument must be defined')
 
     if path is None:
         raise error.WireprotoCommandError('path argument must be defined')
 
     try:
         # Extensions may wish to access the protocol handler.
         store = getfilestore(repo, proto, path)
     except FileAccessError as e:
         raise error.WireprotoCommandError(e.msg, e.args)
 
     # Validate requested nodes.
     for node in nodes:
         try:
             store.rev(node)
         except error.LookupError:
             raise error.WireprotoCommandError('unknown file node: %s',
                                               (hex(node),))
 
-    revs, requests = builddeltarequests(store, nodes)
+    revs, requests = builddeltarequests(store, nodes, haveparents)
 
     yield {
         b'totalitems': len(revs),
     }
 
     if b'revision' in fields:
         deltas = store.emitrevisiondeltas(requests)
     else:
         deltas = None
 
     for rev in revs:
         node = store.node(rev)
 
         if deltas is not None:
             delta = next(deltas)
         else:
             delta = None
 
         d = {
             b'node': node,
         }
 
         if b'parents' in fields:
             d[b'parents'] = store.parents(node)
 
         if b'revision' in fields:
             assert delta is not None
             assert delta.flags == 0
             assert d[b'node'] == delta.node
 
             if delta.revision is not None:
                 revisiondata = delta.revision
                 d[b'revisionsize'] = len(revisiondata)
             else:
                 d[b'deltabasenode'] = delta.basenode
                 revisiondata = delta.delta
                 d[b'deltasize'] = len(revisiondata)
         else:
             revisiondata = None
 
         yield d
 
         if revisiondata is not None:
             yield revisiondata
 
     if deltas is not None:
         try:
             next(deltas)
             raise error.ProgrammingError('should not have more deltas')
         except GeneratorExit:
             pass
 
 @wireprotocommand('heads',
                   args={
                       'publiconly': False,
                   },
                   permission='pull')
 def headsv2(repo, proto, publiconly=False):
     if publiconly:
         repo = repo.filtered('immutable')
 
     yield repo.heads()
 
 @wireprotocommand('known',
                   args={
                       'nodes': [b'deadbeef'],
                   },
                   permission='pull')
 def knownv2(repo, proto, nodes=None):
     nodes = nodes or []
     result = b''.join(b'1' if n else b'0' for n in repo.known(nodes))
     yield result
 
 @wireprotocommand('listkeys',
                   args={
                       'namespace': b'ns',
                   },
                   permission='pull')
 def listkeysv2(repo, proto, namespace=None):
     keys = repo.listkeys(encoding.tolocal(namespace))
     keys = {encoding.fromlocal(k): encoding.fromlocal(v)
             for k, v in keys.iteritems()}
 
     yield keys
 
 @wireprotocommand('lookup',
                   args={
                       'key': b'foo',
                   },
                   permission='pull')
 def lookupv2(repo, proto, key):
     key = encoding.tolocal(key)
 
     # TODO handle exception.
     node = repo.lookup(key)
 
     yield node
 
 @wireprotocommand('manifestdata',
                   args={
                       'nodes': [b'0123456...'],
+                      'haveparents': True,
                       'fields': [b'parents', b'revision'],
                       'tree': b'',
                   },
                   permission='pull')
-def manifestdata(repo, proto, nodes=None, fields=None, tree=None):
+def manifestdata(repo, proto, haveparents=False, nodes=None, fields=None,
+                 tree=None):
     fields = fields or set()
 
     if nodes is None:
         raise error.WireprotoCommandError(
             'nodes argument must be defined')
 
     if tree is None:
         raise error.WireprotoCommandError(
             'tree argument must be defined')
 
     store = repo.manifestlog.getstorage(tree)
 
     # Validate the node is known and abort on unknown revisions.
     for node in nodes:
         try:
             store.rev(node)
         except error.LookupError:
             raise error.WireprotoCommandError(
                 'unknown node: %s', (node,))
 
-    revs, requests = builddeltarequests(store, nodes)
+    revs, requests = builddeltarequests(store, nodes, haveparents)
 
     yield {
         b'totalitems': len(revs),
     }
 
     if b'revision' in fields:
         deltas = store.emitrevisiondeltas(requests)
     else:
         deltas = None
 
     for rev in revs:
         node = store.node(rev)
 
         if deltas is not None:
             delta = next(deltas)
         else:
             delta = None
 
         d = {
             b'node': node,
         }
 
         if b'parents' in fields:
             d[b'parents'] = store.parents(node)
 
         if b'revision' in fields:
             assert delta is not None
             assert delta.flags == 0
             assert d[b'node'] == delta.node
 
             if delta.revision is not None:
                 revisiondata = delta.revision
                 d[b'revisionsize'] = len(revisiondata)
             else:
                 d[b'deltabasenode'] = delta.basenode
                 revisiondata = delta.delta
                 d[b'deltasize'] = len(revisiondata)
         else:
             revisiondata = None
 
         yield d
 
         if revisiondata is not None:
             yield revisiondata
 
     if deltas is not None:
         try:
             next(deltas)
             raise error.ProgrammingError('should not have more deltas')
         except GeneratorExit:
             pass
 
 @wireprotocommand('pushkey',
                   args={
                       'namespace': b'ns',
                       'key': b'key',
                       'old': b'old',
                       'new': b'new',
                   },
                   permission='push')
 def pushkeyv2(repo, proto, namespace, key, old, new):
     # TODO handle ui output redirection
     yield repo.pushkey(encoding.tolocal(namespace),
                        encoding.tolocal(key),
                        encoding.tolocal(old),
                        encoding.tolocal(new))

tests/test-http-protocol.t

@@ -1,749 +1,749
 #require no-chg
 
   $ . $TESTDIR/wireprotohelpers.sh
 
   $ cat >> $HGRCPATH << EOF
   > [web]
   > push_ssl = false
   > allow_push = *
   > EOF
 
   $ hg init server
   $ cd server
   $ touch a
   $ hg -q commit -A -m initial
   $ cd ..
 
   $ hg serve -R server -p $HGPORT -d --pid-file hg.pid
   $ cat hg.pid >> $DAEMON_PIDS
 
 compression formats are advertised in compression capability
 
 #if zstd
   $ get-with-headers.py $LOCALIP:$HGPORT '?cmd=capabilities' | tr ' ' '\n' | grep '^compression=zstd,zlib$' > /dev/null
 #else
   $ get-with-headers.py $LOCALIP:$HGPORT '?cmd=capabilities' | tr ' ' '\n' | grep '^compression=zlib$' > /dev/null
 #endif
 
   $ killdaemons.py
 
 server.compressionengines can replace engines list wholesale
 
   $ hg serve --config server.compressionengines=none -R server -p $HGPORT -d --pid-file hg.pid
   $ cat hg.pid > $DAEMON_PIDS
   $ get-with-headers.py $LOCALIP:$HGPORT '?cmd=capabilities' | tr ' ' '\n' | grep '^compression=none$' > /dev/null
 
   $ killdaemons.py
 
 Order of engines can also change
 
   $ hg serve --config server.compressionengines=none,zlib -R server -p $HGPORT -d --pid-file hg.pid
   $ cat hg.pid > $DAEMON_PIDS
   $ get-with-headers.py $LOCALIP:$HGPORT '?cmd=capabilities' | tr ' ' '\n' | grep '^compression=none,zlib$' > /dev/null
 
   $ killdaemons.py
 
 Start a default server again
 
   $ hg serve -R server -p $HGPORT -d --pid-file hg.pid
   $ cat hg.pid > $DAEMON_PIDS
 
 Server should send application/mercurial-0.1 to clients if no Accept is used
 
   $ get-with-headers.py --headeronly $LOCALIP:$HGPORT '?cmd=getbundle&heads=e93700bd72895c5addab234c56d4024b487a362f&common=0000000000000000000000000000000000000000' -
   200 Script output follows
   content-type: application/mercurial-0.1
   date: $HTTP_DATE$
   server: testing stub value
   transfer-encoding: chunked
 
 Server should send application/mercurial-0.1 when client says it wants it
 
   $ get-with-headers.py --hgproto '0.1' --headeronly $LOCALIP:$HGPORT '?cmd=getbundle&heads=e93700bd72895c5addab234c56d4024b487a362f&common=0000000000000000000000000000000000000000' -
   200 Script output follows
   content-type: application/mercurial-0.1
   date: $HTTP_DATE$
   server: testing stub value
   transfer-encoding: chunked
 
 Server should send application/mercurial-0.2 when client says it wants it
 
   $ get-with-headers.py --hgproto '0.2' --headeronly $LOCALIP:$HGPORT '?cmd=getbundle&heads=e93700bd72895c5addab234c56d4024b487a362f&common=0000000000000000000000000000000000000000' -
   200 Script output follows
   content-type: application/mercurial-0.2
   date: $HTTP_DATE$
   server: testing stub value
   transfer-encoding: chunked
 
   $ get-with-headers.py --hgproto '0.1 0.2' --headeronly $LOCALIP:$HGPORT '?cmd=getbundle&heads=e93700bd72895c5addab234c56d4024b487a362f&common=0000000000000000000000000000000000000000' -
   200 Script output follows
   content-type: application/mercurial-0.2
   date: $HTTP_DATE$
   server: testing stub value
   transfer-encoding: chunked
 
 Requesting a compression format that server doesn't support results will fall back to 0.1
 
   $ get-with-headers.py --hgproto '0.2 comp=aa' --headeronly $LOCALIP:$HGPORT '?cmd=getbundle&heads=e93700bd72895c5addab234c56d4024b487a362f&common=0000000000000000000000000000000000000000' -
   200 Script output follows
   content-type: application/mercurial-0.1
   date: $HTTP_DATE$
   server: testing stub value
   transfer-encoding: chunked
 
 #if zstd
 zstd is used if available
 
   $ get-with-headers.py --hgproto '0.2 comp=zstd' $LOCALIP:$HGPORT '?cmd=getbundle&heads=e93700bd72895c5addab234c56d4024b487a362f&common=0000000000000000000000000000000000000000' > resp
   $ f --size --hexdump --bytes 36 --sha1 resp
   resp: size=248, sha1=4d8d8f87fb82bd542ce52881fdc94f850748
   0000: 32 30 30 20 53 63 72 69 70 74 20 6f 75 74 70 75 |200 Script outpu|
   0010: 74 20 66 6f 6c 6c 6f 77 73 0a 0a 04 7a 73 74 64 |t follows...zstd|
   0020: 28 b5 2f fd                                     |(./.|
 
 #endif
 
 application/mercurial-0.2 is not yet used on non-streaming responses
 
   $ get-with-headers.py --hgproto '0.2' $LOCALIP:$HGPORT '?cmd=heads' -
   200 Script output follows
   content-length: 41
   content-type: application/mercurial-0.1
   date: $HTTP_DATE$
   server: testing stub value
   
   e93700bd72895c5addab234c56d4024b487a362f
 
 Now test protocol preference usage
 
   $ killdaemons.py
   $ hg serve --config server.compressionengines=none,zlib -R server -p $HGPORT -d --pid-file hg.pid
   $ cat hg.pid > $DAEMON_PIDS
 
 No Accept will send 0.1+zlib, even though "none" is preferred b/c "none" isn't supported on 0.1
 
   $ get-with-headers.py --headeronly $LOCALIP:$HGPORT '?cmd=getbundle&heads=e93700bd72895c5addab234c56d4024b487a362f&common=0000000000000000000000000000000000000000' Content-Type
   200 Script output follows
   content-type: application/mercurial-0.1
 
   $ get-with-headers.py $LOCALIP:$HGPORT '?cmd=getbundle&heads=e93700bd72895c5addab234c56d4024b487a362f&common=0000000000000000000000000000000000000000'  > resp
   $ f --size --hexdump --bytes 28 --sha1 resp
   resp: size=227, sha1=35a4c074da74f32f5440da3cbf04
   0000: 32 30 30 20 53 63 72 69 70 74 20 6f 75 74 70 75 |200 Script outpu|
   0010: 74 20 66 6f 6c 6c 6f 77 73 0a 0a 78             |t follows..x|
 
 Explicit 0.1 will send zlib because "none" isn't supported on 0.1
 
   $ get-with-headers.py --hgproto '0.1' $LOCALIP:$HGPORT '?cmd=getbundle&heads=e93700bd72895c5addab234c56d4024b487a362f&common=0000000000000000000000000000000000000000'  > resp
   $ f --size --hexdump --bytes 28 --sha1 resp
   resp: size=227, sha1=35a4c074da74f32f5440da3cbf04
   0000: 32 30 30 20 53 63 72 69 70 74 20 6f 75 74 70 75 |200 Script outpu|
   0010: 74 20 66 6f 6c 6c 6f 77 73 0a 0a 78             |t follows..x|
 
 0.2 with no compression will get "none" because that is server's preference
 (spec says ZL and UN are implicitly supported)
 
   $ get-with-headers.py --hgproto '0.2' $LOCALIP:$HGPORT '?cmd=getbundle&heads=e93700bd72895c5addab234c56d4024b487a362f&common=0000000000000000000000000000000000000000'  > resp
   $ f --size --hexdump --bytes 32 --sha1 resp
   resp: size=432, sha1=ac931b412ec185a02e0e5bcff98dac83
   0000: 32 30 30 20 53 63 72 69 70 74 20 6f 75 74 70 75 |200 Script outpu|
   0010: 74 20 66 6f 6c 6c 6f 77 73 0a 0a 04 6e 6f 6e 65 |t follows...none|
 
 Client receives server preference even if local order doesn't match
 
   $ get-with-headers.py --hgproto '0.2 comp=zlib,none' $LOCALIP:$HGPORT '?cmd=getbundle&heads=e93700bd72895c5addab234c56d4024b487a362f&common=0000000000000000000000000000000000000000'  > resp
   $ f --size --hexdump --bytes 32 --sha1 resp
   resp: size=432, sha1=ac931b412ec185a02e0e5bcff98dac83
   0000: 32 30 30 20 53 63 72 69 70 74 20 6f 75 74 70 75 |200 Script outpu|
   0010: 74 20 66 6f 6c 6c 6f 77 73 0a 0a 04 6e 6f 6e 65 |t follows...none|
 
 Client receives only supported format even if not server preferred format
 
   $ get-with-headers.py --hgproto '0.2 comp=zlib' $LOCALIP:$HGPORT '?cmd=getbundle&heads=e93700bd72895c5addab234c56d4024b487a362f&common=0000000000000000000000000000000000000000'  > resp
   $ f --size --hexdump --bytes 33 --sha1 resp
   resp: size=232, sha1=a1c727f0c9693ca15742a75c30419bc36
   0000: 32 30 30 20 53 63 72 69 70 74 20 6f 75 74 70 75 |200 Script outpu|
   0010: 74 20 66 6f 6c 6c 6f 77 73 0a 0a 04 7a 6c 69 62 |t follows...zlib|
   0020: 78                                              |x|
 
   $ killdaemons.py
   $ cd ..
 
 Test listkeys for listing namespaces
 
   $ hg init empty
   $ hg -R empty serve -p $HGPORT -d --pid-file hg.pid
   $ cat hg.pid > $DAEMON_PIDS
 
   $ hg --verbose debugwireproto http://$LOCALIP:$HGPORT << EOF
   > command listkeys
   >     namespace namespaces
   > EOF
   s>     GET /?cmd=capabilities HTTP/1.1\r\n
   s>     Accept-Encoding: identity\r\n
   s>     accept: application/mercurial-0.1\r\n
   s>     host: $LOCALIP:$HGPORT\r\n (glob)
   s>     user-agent: Mercurial debugwireproto\r\n
   s>     \r\n
   s> makefile('rb', None)
   s>     HTTP/1.1 200 Script output follows\r\n
   s>     Server: testing stub value\r\n
   s>     Date: $HTTP_DATE$\r\n
   s>     Content-Type: application/mercurial-0.1\r\n
   s>     Content-Length: *\r\n (glob)
   s>     \r\n
   s>     batch branchmap $USUAL_BUNDLE2_CAPS_SERVER$ changegroupsubset compression=$BUNDLE2_COMPRESSIONS$ getbundle httpheader=1024 httpmediatype=0.1rx,0.1tx,0.2tx known lookup pushkey streamreqs=generaldelta,revlogv1 unbundle=HG10GZ,HG10BZ,HG10UN unbundlehash
   sending listkeys command
   s>     GET /?cmd=listkeys HTTP/1.1\r\n
   s>     Accept-Encoding: identity\r\n
   s>     vary: X-HgArg-1,X-HgProto-1\r\n
   s>     x-hgarg-1: namespace=namespaces\r\n
   s>     x-hgproto-1: 0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull\r\n
   s>     accept: application/mercurial-0.1\r\n
   s>     host: $LOCALIP:$HGPORT\r\n (glob)
   s>     user-agent: Mercurial debugwireproto\r\n
   s>     \r\n
   s> makefile('rb', None)
   s>     HTTP/1.1 200 Script output follows\r\n
   s>     Server: testing stub value\r\n
   s>     Date: $HTTP_DATE$\r\n
   s>     Content-Type: application/mercurial-0.1\r\n
   s>     Content-Length: 30\r\n
   s>     \r\n
   s>     bookmarks\t\n
   s>     namespaces\t\n
   s>     phases\t
   response: {
     b'bookmarks': b'',
     b'namespaces': b'',
     b'phases': b''
   }
 
 Same thing, but with "httprequest" command
 
   $ hg --verbose debugwireproto --peer raw http://$LOCALIP:$HGPORT << EOF
   > httprequest GET ?cmd=listkeys
   >     user-agent: test
   >     x-hgarg-1: namespace=namespaces
   > EOF
   using raw connection to peer
   s>     GET /?cmd=listkeys HTTP/1.1\r\n
   s>     Accept-Encoding: identity\r\n
   s>     user-agent: test\r\n
   s>     x-hgarg-1: namespace=namespaces\r\n
   s>     host: $LOCALIP:$HGPORT\r\n (glob)
   s>     \r\n
   s> makefile('rb', None)
   s>     HTTP/1.1 200 Script output follows\r\n
   s>     Server: testing stub value\r\n
   s>     Date: $HTTP_DATE$\r\n
   s>     Content-Type: application/mercurial-0.1\r\n
   s>     Content-Length: 30\r\n
   s>     \r\n
   s>     bookmarks\t\n
   s>     namespaces\t\n
   s>     phases\t
 
 Client with HTTPv2 enabled advertises that and gets old capabilities response from old server
 
   $ hg --config experimental.httppeer.advertise-v2=true --verbose debugwireproto http://$LOCALIP:$HGPORT << EOF
   > command heads
   > EOF
   s>     GET /?cmd=capabilities HTTP/1.1\r\n
   s>     Accept-Encoding: identity\r\n
   s>     vary: X-HgProto-1,X-HgUpgrade-1\r\n
   s>     x-hgproto-1: cbor\r\n
   s>     x-hgupgrade-1: exp-http-v2-0001\r\n
   s>     accept: application/mercurial-0.1\r\n
   s>     host: $LOCALIP:$HGPORT\r\n (glob)
   s>     user-agent: Mercurial debugwireproto\r\n
   s>     \r\n
   s> makefile('rb', None)
   s>     HTTP/1.1 200 Script output follows\r\n
   s>     Server: testing stub value\r\n
   s>     Date: $HTTP_DATE$\r\n
   s>     Content-Type: application/mercurial-0.1\r\n
   s>     Content-Length: *\r\n (glob)
   s>     \r\n
   s>     batch branchmap $USUAL_BUNDLE2_CAPS_SERVER$ changegroupsubset compression=$BUNDLE2_COMPRESSIONS$ getbundle httpheader=1024 httpmediatype=0.1rx,0.1tx,0.2tx known lookup pushkey streamreqs=generaldelta,revlogv1 unbundle=HG10GZ,HG10BZ,HG10UN unbundlehash
   sending heads command
   s>     GET /?cmd=heads HTTP/1.1\r\n
   s>     Accept-Encoding: identity\r\n
   s>     vary: X-HgProto-1\r\n
   s>     x-hgproto-1: 0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull\r\n
   s>     accept: application/mercurial-0.1\r\n
   s>     host: $LOCALIP:$HGPORT\r\n (glob)
   s>     user-agent: Mercurial debugwireproto\r\n
   s>     \r\n
   s> makefile('rb', None)
   s>     HTTP/1.1 200 Script output follows\r\n
   s>     Server: testing stub value\r\n
   s>     Date: $HTTP_DATE$\r\n
   s>     Content-Type: application/mercurial-0.1\r\n
   s>     Content-Length: 41\r\n
   s>     \r\n
   s>     0000000000000000000000000000000000000000\n
   response: [
     b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
   ]
 
   $ killdaemons.py
   $ enablehttpv2 empty
   $ hg --config server.compressionengines=zlib -R empty serve -p $HGPORT -d --pid-file hg.pid
   $ cat hg.pid > $DAEMON_PIDS
 
 Client with HTTPv2 enabled automatically upgrades if the server supports it
 
   $ hg --config experimental.httppeer.advertise-v2=true --verbose debugwireproto http://$LOCALIP:$HGPORT << EOF
   > command heads
   > EOF
   s>     GET /?cmd=capabilities HTTP/1.1\r\n
   s>     Accept-Encoding: identity\r\n
   s>     vary: X-HgProto-1,X-HgUpgrade-1\r\n
   s>     x-hgproto-1: cbor\r\n
   s>     x-hgupgrade-1: exp-http-v2-0001\r\n
   s>     accept: application/mercurial-0.1\r\n
   s>     host: $LOCALIP:$HGPORT\r\n (glob)
   s>     user-agent: Mercurial debugwireproto\r\n
   s>     \r\n
   s> makefile('rb', None)
   s>     HTTP/1.1 200 OK\r\n
   s>     Server: testing stub value\r\n
   s>     Date: $HTTP_DATE$\r\n
   s>     Content-Type: application/mercurial-cbor\r\n
   s>     Content-Length: *\r\n (glob)
   s>     \r\n
-  s>     \xa3GapibaseDapi/Dapis\xa1Pexp-http-v2-0001\xa4Hcommands\xaaIbranchmap\xa2Dargs\xa0Kpermissions\x81DpullLcapabilities\xa2Dargs\xa0Kpermissions\x81DpullMchangesetdata\xa2Dargs\xa3Ffields\xd9\x01\x02\x82GparentsHrevisionInoderange\x82\x81J0123456...\x81Iabcdef...Enodes\x81J0123456...Kpermissions\x81DpullHfiledata\xa2Dargs\xa3Ffields\x82GparentsHrevisionEnodes\x81J0123456...DpathGfoo.txtKpermissions\x81DpullEheads\xa2Dargs\xa1Jpubliconly\xf4Kpermissions\x81DpullEknown\xa2Dargs\xa1Enodes\x81HdeadbeefKpermissions\x81DpullHlistkeys\xa2Dargs\xa1InamespaceBnsKpermissions\x81DpullFlookup\xa2Dargs\xa1CkeyCfooKpermissions\x81DpullLmanifestdata\xa2Dargs\xa3Ffields\x82GparentsHrevisionEnodes\x81J0123456...Dtree@Kpermissions\x81DpullGpushkey\xa2Dargs\xa4CkeyCkeyInamespaceBnsCnewCnewColdColdKpermissions\x81DpushKcompression\x81\xa1DnameDzlibQframingmediatypes\x81X&application/mercurial-exp-framing-0005Nrawrepoformats\x82LgeneraldeltaHrevlogv1Nv1capabilitiesY\x01\xc5batch branchmap $USUAL_BUNDLE2_CAPS_SERVER$ changegroupsubset compression=$BUNDLE2_COMPRESSIONS$ getbundle httpheader=1024 httpmediatype=0.1rx,0.1tx,0.2tx known lookup pushkey streamreqs=generaldelta,revlogv1 unbundle=HG10GZ,HG10BZ,HG10UN unbundlehash
+  s>     \xa3GapibaseDapi/Dapis\xa1Pexp-http-v2-0001\xa4Hcommands\xaaIbranchmap\xa2Dargs\xa0Kpermissions\x81DpullLcapabilities\xa2Dargs\xa0Kpermissions\x81DpullMchangesetdata\xa2Dargs\xa3Ffields\xd9\x01\x02\x82GparentsHrevisionInoderange\x82\x81J0123456...\x81Iabcdef...Enodes\x81J0123456...Kpermissions\x81DpullHfiledata\xa2Dargs\xa4Ffields\x82GparentsHrevisionKhaveparents\xf5Enodes\x81J0123456...DpathGfoo.txtKpermissions\x81DpullEheads\xa2Dargs\xa1Jpubliconly\xf4Kpermissions\x81DpullEknown\xa2Dargs\xa1Enodes\x81HdeadbeefKpermissions\x81DpullHlistkeys\xa2Dargs\xa1InamespaceBnsKpermissions\x81DpullFlookup\xa2Dargs\xa1CkeyCfooKpermissions\x81DpullLmanifestdata\xa2Dargs\xa4Ffields\x82GparentsHrevisionKhaveparents\xf5Enodes\x81J0123456...Dtree@Kpermissions\x81DpullGpushkey\xa2Dargs\xa4CkeyCkeyInamespaceBnsCnewCnewColdColdKpermissions\x81DpushKcompression\x81\xa1DnameDzlibQframingmediatypes\x81X&application/mercurial-exp-framing-0005Nrawrepoformats\x82LgeneraldeltaHrevlogv1Nv1capabilitiesY\x01\xc5batch branchmap $USUAL_BUNDLE2_CAPS_SERVER$ changegroupsubset compression=$BUNDLE2_COMPRESSIONS$ getbundle httpheader=1024 httpmediatype=0.1rx,0.1tx,0.2tx known lookup pushkey streamreqs=generaldelta,revlogv1 unbundle=HG10GZ,HG10BZ,HG10UN unbundlehash
   sending heads command
   s>     POST /api/exp-http-v2-0001/ro/heads HTTP/1.1\r\n
   s>     Accept-Encoding: identity\r\n
   s>     accept: application/mercurial-exp-framing-0005\r\n
   s>     content-type: application/mercurial-exp-framing-0005\r\n
   s>     content-length: 20\r\n
   s>     host: $LOCALIP:$HGPORT\r\n (glob)
   s>     user-agent: Mercurial debugwireproto\r\n
   s>     \r\n
   s>     \x0c\x00\x00\x01\x00\x01\x01\x11\xa1DnameEheads
   s> makefile('rb', None)
   s>     HTTP/1.1 200 OK\r\n
   s>     Server: testing stub value\r\n
   s>     Date: $HTTP_DATE$\r\n
   s>     Content-Type: application/mercurial-exp-framing-0005\r\n
   s>     Transfer-Encoding: chunked\r\n
   s>     \r\n
   s>     13\r\n
   s>     \x0b\x00\x00\x01\x00\x02\x011
   s>     \xa1FstatusBok
   s>     \r\n
   received frame(size=11; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=continuation)
   s>     1e\r\n
   s>     \x16\x00\x00\x01\x00\x02\x001
   s>     \x81T\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00
   s>     \r\n
   received frame(size=22; request=1; stream=2; streamflags=; type=command-response; flags=continuation)
   s>     8\r\n
   s>     \x00\x00\x00\x01\x00\x02\x002
   s>     \r\n
   s>     0\r\n
   s>     \r\n
   received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos)
   response: [
     b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
   ]
 
   $ killdaemons.py
 
 HTTP client follows HTTP redirect on handshake to new repo
 
   $ cd $TESTTMP
 
   $ hg init redirector
   $ hg init redirected
   $ cd redirected
   $ touch foo
   $ hg -q commit -A -m initial
   $ cd ..
 
   $ cat > paths.conf << EOF
   > [paths]
   > / = $TESTTMP/*
   > EOF
 
   $ cat > redirectext.py << EOF
   > from mercurial import extensions, wireprotoserver
   > def wrappedcallhttp(orig, repo, req, res, proto, cmd):
   >     path = req.advertisedurl[len(req.advertisedbaseurl):]
   >     if not path.startswith(b'/redirector'):
   >         return orig(repo, req, res, proto, cmd)
   >     relpath = path[len(b'/redirector'):]
   >     res.status = b'301 Redirect'
   >     newurl = b'%s/redirected%s' % (req.baseurl, relpath)
   >     if not repo.ui.configbool('testing', 'redirectqs', True) and b'?' in newurl:
   >         newurl = newurl[0:newurl.index(b'?')]
   >     res.headers[b'Location'] = newurl
   >     res.headers[b'Content-Type'] = b'text/plain'
   >     res.setbodybytes(b'redirected')
   >     return True
   > 
   > extensions.wrapfunction(wireprotoserver, '_callhttp', wrappedcallhttp)
   > EOF
 
   $ hg --config extensions.redirect=$TESTTMP/redirectext.py \
   >    --config server.compressionengines=zlib \
   >     serve --web-conf paths.conf --pid-file hg.pid -p $HGPORT -d
   $ cat hg.pid > $DAEMON_PIDS
 
 Verify our HTTP 301 is served properly
 
   $ hg --verbose debugwireproto --peer raw http://$LOCALIP:$HGPORT << EOF
   > httprequest GET /redirector?cmd=capabilities
   >     user-agent: test
   > EOF
   using raw connection to peer
   s>     GET /redirector?cmd=capabilities HTTP/1.1\r\n
   s>     Accept-Encoding: identity\r\n
   s>     user-agent: test\r\n
   s>     host: $LOCALIP:$HGPORT\r\n (glob)
   s>     \r\n
   s> makefile('rb', None)
   s>     HTTP/1.1 301 Redirect\r\n
   s>     Server: testing stub value\r\n
   s>     Date: $HTTP_DATE$\r\n
   s>     Location: http://$LOCALIP:$HGPORT/redirected?cmd=capabilities\r\n (glob)
   s>     Content-Type: text/plain\r\n
   s>     Content-Length: 10\r\n
   s>     \r\n
   s>     redirected
   s>     GET /redirected?cmd=capabilities HTTP/1.1\r\n
   s>     Accept-Encoding: identity\r\n
   s>     user-agent: test\r\n
   s>     host: $LOCALIP:$HGPORT\r\n (glob)
   s>     \r\n
   s> makefile('rb', None)
   s>     HTTP/1.1 200 Script output follows\r\n
   s>     Server: testing stub value\r\n
   s>     Date: $HTTP_DATE$\r\n
   s>     Content-Type: application/mercurial-0.1\r\n
   s>     Content-Length: 453\r\n
   s>     \r\n
   s>     batch branchmap $USUAL_BUNDLE2_CAPS_SERVER$ changegroupsubset compression=$BUNDLE2_COMPRESSIONS$ getbundle httpheader=1024 httpmediatype=0.1rx,0.1tx,0.2tx known lookup pushkey streamreqs=generaldelta,revlogv1 unbundle=HG10GZ,HG10BZ,HG10UN unbundlehash
 
 Test with the HTTP peer
 
   $ hg --verbose debugwireproto http://$LOCALIP:$HGPORT/redirector << EOF
   > command heads
   > EOF
   s>     GET /redirector?cmd=capabilities HTTP/1.1\r\n
   s>     Accept-Encoding: identity\r\n
   s>     accept: application/mercurial-0.1\r\n
   s>     host: $LOCALIP:$HGPORT\r\n (glob)
   s>     user-agent: Mercurial debugwireproto\r\n
   s>     \r\n
   s> makefile('rb', None)
   s>     HTTP/1.1 301 Redirect\r\n
   s>     Server: testing stub value\r\n
   s>     Date: $HTTP_DATE$\r\n
   s>     Location: http://$LOCALIP:$HGPORT/redirected?cmd=capabilities\r\n (glob)
   s>     Content-Type: text/plain\r\n
   s>     Content-Length: 10\r\n
   s>     \r\n
   s>     redirected
   s>     GET /redirected?cmd=capabilities HTTP/1.1\r\n
   s>     Accept-Encoding: identity\r\n
   s>     accept: application/mercurial-0.1\r\n
   s>     host: $LOCALIP:$HGPORT\r\n (glob)
   s>     user-agent: Mercurial debugwireproto\r\n
   s>     \r\n
   s> makefile('rb', None)
   s>     HTTP/1.1 200 Script output follows\r\n
   s>     Server: testing stub value\r\n
   s>     Date: $HTTP_DATE$\r\n
   s>     Content-Type: application/mercurial-0.1\r\n
   s>     Content-Length: 453\r\n
   s>     \r\n
   real URL is http://$LOCALIP:$HGPORT/redirected (glob)
   s>     batch branchmap $USUAL_BUNDLE2_CAPS_SERVER$ changegroupsubset compression=$BUNDLE2_COMPRESSIONS$ getbundle httpheader=1024 httpmediatype=0.1rx,0.1tx,0.2tx known lookup pushkey streamreqs=generaldelta,revlogv1 unbundle=HG10GZ,HG10BZ,HG10UN unbundlehash
   sending heads command
   s>     GET /redirected?cmd=heads HTTP/1.1\r\n
   s>     Accept-Encoding: identity\r\n
   s>     vary: X-HgProto-1\r\n
   s>     x-hgproto-1: 0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull\r\n
   s>     accept: application/mercurial-0.1\r\n
   s>     host: $LOCALIP:$HGPORT\r\n (glob)
   s>     user-agent: Mercurial debugwireproto\r\n
   s>     \r\n
   s> makefile('rb', None)
   s>     HTTP/1.1 200 Script output follows\r\n
   s>     Server: testing stub value\r\n
   s>     Date: $HTTP_DATE$\r\n
   s>     Content-Type: application/mercurial-0.1\r\n
   s>     Content-Length: 41\r\n
   s>     \r\n
   s>     96ee1d7354c4ad7372047672c36a1f561e3a6a4c\n
   response: [
     b'\x96\xee\x1dsT\xc4\xadsr\x04vr\xc3j\x1fV\x1e:jL'
   ]
 
   $ killdaemons.py
 
 Now test a variation where we strip the query string from the redirect URL.
 (SCM Manager apparently did this and clients would recover from it)
 
   $ hg --config extensions.redirect=$TESTTMP/redirectext.py \
   >    --config server.compressionengines=zlib \
   >    --config testing.redirectqs=false \
   >     serve --web-conf paths.conf --pid-file hg.pid -p $HGPORT -d
   $ cat hg.pid > $DAEMON_PIDS
 
   $ hg --verbose debugwireproto --peer raw http://$LOCALIP:$HGPORT << EOF
   > httprequest GET /redirector?cmd=capabilities
   >     user-agent: test
   > EOF
   using raw connection to peer
   s>     GET /redirector?cmd=capabilities HTTP/1.1\r\n
   s>     Accept-Encoding: identity\r\n
   s>     user-agent: test\r\n
   s>     host: $LOCALIP:$HGPORT\r\n (glob)
   s>     \r\n
   s> makefile('rb', None)
   s>     HTTP/1.1 301 Redirect\r\n
   s>     Server: testing stub value\r\n
   s>     Date: $HTTP_DATE$\r\n
   s>     Location: http://$LOCALIP:$HGPORT/redirected\r\n (glob)
   s>     Content-Type: text/plain\r\n
   s>     Content-Length: 10\r\n
   s>     \r\n
   s>     redirected
   s>     GET /redirected HTTP/1.1\r\n
   s>     Accept-Encoding: identity\r\n
   s>     user-agent: test\r\n
   s>     host: $LOCALIP:$HGPORT\r\n (glob)
   s>     \r\n
   s> makefile('rb', None)
   s>     HTTP/1.1 200 Script output follows\r\n
   s>     Server: testing stub value\r\n
   s>     Date: $HTTP_DATE$\r\n
   s>     ETag: W/"*"\r\n (glob)
   s>     Content-Type: text/html; charset=ascii\r\n
   s>     Transfer-Encoding: chunked\r\n
   s>     \r\n
   s>     414\r\n
   s>     <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">\n
   s>     <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en-US">\n
   s>     <head>\n
   s>     <link rel="icon" href="/redirected/static/hgicon.png" type="image/png" />\n
   s>     <meta name="robots" content="index, nofollow" />\n
   s>     <link rel="stylesheet" href="/redirected/static/style-paper.css" type="text/css" />\n
   s>     <script type="text/javascript" src="/redirected/static/mercurial.js"></script>\n
   s>     \n
   s>     <title>redirected: log</title>\n
   s>     <link rel="alternate" type="application/atom+xml"\n
   s>        href="/redirected/atom-log" title="Atom feed for redirected" />\n
   s>     <link rel="alternate" type="application/rss+xml"\n
   s>        href="/redirected/rss-log" title="RSS feed for redirected" />\n
   s>     </head>\n
   s>     <body>\n
   s>     \n
   s>     <div class="container">\n
   s>     <div class="menu">\n
   s>     <div class="logo">\n
   s>     <a href="https://mercurial-scm.org/">\n
   s>     <img src="/redirected/static/hglogo.png" alt="mercurial" /></a>\n
   s>     </div>\n
   s>     <ul>\n
   s>     <li class="active">log</li>\n
   s>     <li><a href="/redirected/graph/tip">graph</a></li>\n
   s>     <li><a href="/redirected/tags">tags</a></li>\n
   s>     <li><a href="
   s>     \r\n
   s>     810\r\n
   s>     /redirected/bookmarks">bookmarks</a></li>\n
   s>     <li><a href="/redirected/branches">branches</a></li>\n
   s>     </ul>\n
   s>     <ul>\n
   s>     <li><a href="/redirected/rev/tip">changeset</a></li>\n
   s>     <li><a href="/redirected/file/tip">browse</a></li>\n
   s>     </ul>\n
   s>     <ul>\n
   s>     \n
   s>     </ul>\n
   s>     <ul>\n
   s>      <li><a href="/redirected/help">help</a></li>\n
   s>     </ul>\n
   s>     <div class="atom-logo">\n
   s>     <a href="/redirected/atom-log" title="subscribe to atom feed">\n
   s>     <img class="atom-logo" src="/redirected/static/feed-icon-14x14.png" alt="atom feed" />\n
   s>     </a>\n
   s>     </div>\n
   s>     </div>\n
   s>     \n
   s>     <div class="main">\n
   s>     <h2 class="breadcrumb"><a href="/">Mercurial</a> &gt; <a href="/redirected">redirected</a> </h2>\n
   s>     <h3>log</h3>\n
   s>     \n
   s>     \n
   s>     <form class="search" action="/redirected/log">\n
   s>     \n
   s>     <p><input name="rev" id="search1" type="text" size="30" value="" /></p>\n
   s>     <div id="hint">Find changesets by keywords (author, files, the commit message), revision\n
   s>     number or hash, or <a href="/redirected/help/revsets">revset expression</a>.</div>\n
   s>     </form>\n
   s>     \n
   s>     <div class="navigate">\n
   s>     <a href="/redirected/shortlog/tip?revcount=30">less</a>\n
   s>     <a href="/redirected/shortlog/tip?revcount=120">more</a>\n
   s>     | rev 0: <a href="/redirected/shortlog/96ee1d7354c4">(0)</a> <a href="/redirected/shortlog/tip">tip</a> \n
   s>     </div>\n
   s>     \n
   s>     <table class="bigtable">\n
   s>     <thead>\n
   s>      <tr>\n
   s>       <th class="age">age</th>\n
   s>       <th class="author">author</th>\n
   s>       <th class="description">description</th>\n
   s>      </tr>\n
   s>     </thead>\n
   s>     <tbody class="stripes2">\n
   s>      <tr>\n
   s>       <td class="age">Thu, 01 Jan 1970 00:00:00 +0000</td>\n
   s>       <td class="author">test</td>\n
   s>       <td class="description">\n
   s>        <a href="/redirected/rev/96ee1d7354c4">initial</a>\n
   s>        <span class="phase">draft</span> <span class="branchhead">default</span> <span class="tag">tip</span> \n
   s>       </td>\n
   s>      </tr>\n
   s>     \n
   s>     </tbody>\n
   s>     </table>\n
   s>     \n
   s>     <div class="navigate">\n
   s>     <a href="/redirected/shortlog/tip?revcount=30">less</a>\n
   s>     <a href="/redirected/shortlog/tip?revcount=120">more</a>\n
   s>     | rev 0: <a href="/redirected/shortlog/96ee1d7354c4">(0)</a> <a href="/redirected/shortlog/tip">tip</a> \n
   s>     </div>\n
   s>     \n
   s>     <script type="text/javascript">\n
   s>         ajaxScrollInit(\n
   s>                 \'/redirected/shortlog/%next%\',\n
   s>                 \'\', <!-- NEXTHASH\n
   s>                 function (htmlText) {
   s>     \r\n
   s>     14a\r\n
   s>     \n
   s>                     var m = htmlText.match(/\'(\\w+)\', <!-- NEXTHASH/);\n
   s>                     return m ? m[1] : null;\n
   s>                 },\n
   s>                 \'.bigtable > tbody\',\n
   s>                 \'<tr class="%class%">\\\n
   s>                 <td colspan="3" style="text-align: center;">%text%</td>\\\n
   s>                 </tr>\'\n
   s>         );\n
   s>     </script>\n
   s>     \n
   s>     </div>\n
   s>     </div>\n
   s>     \n
   s>     \n
   s>     \n
   s>     </body>\n
   s>     </html>\n
   s>     \n
   s>     \r\n
   s>     0\r\n
   s>     \r\n
 
   $ hg --verbose debugwireproto http://$LOCALIP:$HGPORT/redirector << EOF
   > command heads
   > EOF
   s>     GET /redirector?cmd=capabilities HTTP/1.1\r\n
   s>     Accept-Encoding: identity\r\n
   s>     accept: application/mercurial-0.1\r\n
   s>     host: $LOCALIP:$HGPORT\r\n (glob)
   s>     user-agent: Mercurial debugwireproto\r\n
   s>     \r\n
   s> makefile('rb', None)
   s>     HTTP/1.1 301 Redirect\r\n
   s>     Server: testing stub value\r\n
   s>     Date: $HTTP_DATE$\r\n
   s>     Location: http://$LOCALIP:$HGPORT/redirected\r\n (glob)
   s>     Content-Type: text/plain\r\n
   s>     Content-Length: 10\r\n
   s>     \r\n
   s>     redirected
   s>     GET /redirected HTTP/1.1\r\n
   s>     Accept-Encoding: identity\r\n
   s>     accept: application/mercurial-0.1\r\n
   s>     host: $LOCALIP:$HGPORT\r\n (glob)
   s>     user-agent: Mercurial debugwireproto\r\n
   s>     \r\n
   s> makefile('rb', None)
   s>     HTTP/1.1 200 Script output follows\r\n
   s>     Server: testing stub value\r\n
   s>     Date: $HTTP_DATE$\r\n
   s>     ETag: W/"*"\r\n (glob)
   s>     Content-Type: text/html; charset=ascii\r\n
   s>     Transfer-Encoding: chunked\r\n
   s>     \r\n
   real URL is http://$LOCALIP:$HGPORT/redirected (glob)
   s>     414\r\n
   s>     <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">\n
   s>     <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en-US">\n
   s>     <head>\n
   s>     <link rel="icon" href="/redirected/static/hgicon.png" type="image/png" />\n
   s>     <meta name="robots" content="index, nofollow" />\n
   s>     <link rel="stylesheet" href="/redirected/static/style-paper.css" type="text/css" />\n
   s>     <script type="text/javascript" src="/redirected/static/mercurial.js"></script>\n
   s>     \n
   s>     <title>redirected: log</title>\n
   s>     <link rel="alternate" type="application/atom+xml"\n
   s>        href="/redirected/atom-log" title="Atom feed for redirected" />\n
   s>     <link rel="alternate" type="application/rss+xml"\n
   s>        href="/redirected/rss-log" title="RSS feed for redirected" />\n
   s>     </head>\n
   s>     <body>\n
   s>     \n
   s>     <div class="container">\n
   s>     <div class="menu">\n
   s>     <div class="logo">\n
   s>     <a href="https://mercurial-scm.org/">\n
   s>     <img src="/redirected/static/hglogo.png" alt="mercurial" /></a>\n
   s>     </div>\n
   s>     <ul>\n
   s>     <li class="active">log</li>\n
   s>     <li><a href="/redirected/graph/tip">graph</a></li>\n
   s>     <li><a href="/redirected/tags">tags</a
   s>     GET /redirected?cmd=capabilities HTTP/1.1\r\n
   s>     Accept-Encoding: identity\r\n
   s>     accept: application/mercurial-0.1\r\n
   s>     host: $LOCALIP:$HGPORT\r\n (glob)
   s>     user-agent: Mercurial debugwireproto\r\n
   s>     \r\n
   s> makefile('rb', None)
   s>     HTTP/1.1 200 Script output follows\r\n
   s>     Server: testing stub value\r\n
   s>     Date: $HTTP_DATE$\r\n
   s>     Content-Type: application/mercurial-0.1\r\n
   s>     Content-Length: 453\r\n
   s>     \r\n
   real URL is http://$LOCALIP:$HGPORT/redirected (glob)
   s>     batch branchmap $USUAL_BUNDLE2_CAPS_SERVER$ changegroupsubset compression=$BUNDLE2_COMPRESSIONS$ getbundle httpheader=1024 httpmediatype=0.1rx,0.1tx,0.2tx known lookup pushkey streamreqs=generaldelta,revlogv1 unbundle=HG10GZ,HG10BZ,HG10UN unbundlehash
   sending heads command
   s>     GET /redirected?cmd=heads HTTP/1.1\r\n
   s>     Accept-Encoding: identity\r\n
   s>     vary: X-HgProto-1\r\n
   s>     x-hgproto-1: 0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull\r\n
   s>     accept: application/mercurial-0.1\r\n
   s>     host: $LOCALIP:$HGPORT\r\n (glob)
   s>     user-agent: Mercurial debugwireproto\r\n
   s>     \r\n
   s> makefile('rb', None)
   s>     HTTP/1.1 200 Script output follows\r\n
   s>     Server: testing stub value\r\n
   s>     Date: $HTTP_DATE$\r\n
   s>     Content-Type: application/mercurial-0.1\r\n
   s>     Content-Length: 41\r\n
   s>     \r\n
   s>     96ee1d7354c4ad7372047672c36a1f561e3a6a4c\n
   response: [
     b'\x96\xee\x1dsT\xc4\xadsr\x04vr\xc3j\x1fV\x1e:jL'
   ]

tests/test-wireproto-command-capabilities.t

@@ -1,532 +1,536
 #require no-chg
 
   $ . $TESTDIR/wireprotohelpers.sh
 
   $ hg init server
 
 zstd isn't present in plain builds. Make tests easier by removing
 zstd from the equation.
 
   $ cat >> server/.hg/hgrc << EOF
   > [server]
   > compressionengines = zlib
   > EOF
 
   $ hg -R server serve -p $HGPORT -d --pid-file hg.pid -E error.log
   $ cat hg.pid > $DAEMON_PIDS
 
 A normal capabilities request is serviced for version 1
 
   $ sendhttpraw << EOF
   > httprequest GET ?cmd=capabilities
   >     user-agent: test
   > EOF
   using raw connection to peer
   s>     GET /?cmd=capabilities HTTP/1.1\r\n
   s>     Accept-Encoding: identity\r\n
   s>     user-agent: test\r\n
   s>     host: $LOCALIP:$HGPORT\r\n (glob)
   s>     \r\n
   s> makefile('rb', None)
   s>     HTTP/1.1 200 Script output follows\r\n
   s>     Server: testing stub value\r\n
   s>     Date: $HTTP_DATE$\r\n
   s>     Content-Type: application/mercurial-0.1\r\n
   s>     Content-Length: *\r\n (glob)
   s>     \r\n
   s>     batch branchmap $USUAL_BUNDLE2_CAPS_SERVER$ changegroupsubset compression=$BUNDLE2_COMPRESSIONS$ getbundle httpheader=1024 httpmediatype=0.1rx,0.1tx,0.2tx known lookup pushkey streamreqs=generaldelta,revlogv1 unbundle=HG10GZ,HG10BZ,HG10UN unbundlehash
 
 A proper request without the API server enabled returns the legacy response
 
   $ sendhttpraw << EOF
   > httprequest GET ?cmd=capabilities
   >    user-agent: test
   >    x-hgupgrade-1: foo
   >    x-hgproto-1: cbor
   > EOF
   using raw connection to peer
   s>     GET /?cmd=capabilities HTTP/1.1\r\n
   s>     Accept-Encoding: identity\r\n
   s>     user-agent: test\r\n
   s>     x-hgproto-1: cbor\r\n
   s>     x-hgupgrade-1: foo\r\n
   s>     host: $LOCALIP:$HGPORT\r\n (glob)
   s>     \r\n
   s> makefile('rb', None)
   s>     HTTP/1.1 200 Script output follows\r\n
   s>     Server: testing stub value\r\n
   s>     Date: $HTTP_DATE$\r\n
   s>     Content-Type: application/mercurial-0.1\r\n
   s>     Content-Length: *\r\n (glob)
   s>     \r\n
   s>     batch branchmap $USUAL_BUNDLE2_CAPS_SERVER$ changegroupsubset compression=$BUNDLE2_COMPRESSIONS$ getbundle httpheader=1024 httpmediatype=0.1rx,0.1tx,0.2tx known lookup pushkey streamreqs=generaldelta,revlogv1 unbundle=HG10GZ,HG10BZ,HG10UN unbundlehash
 
 Restart with just API server enabled. This enables serving the new format.
 
   $ killdaemons.py
   $ cat error.log
 
   $ cat >> server/.hg/hgrc << EOF
   > [experimental]
   > web.apiserver = true
   > EOF
 
   $ hg -R server serve -p $HGPORT -d --pid-file hg.pid -E error.log
   $ cat hg.pid > $DAEMON_PIDS
 
 X-HgUpgrade-<N> without CBOR advertisement uses legacy response
 
   $ sendhttpraw << EOF
   > httprequest GET ?cmd=capabilities
   >    user-agent: test
   >    x-hgupgrade-1: foo bar
   > EOF
   using raw connection to peer
   s>     GET /?cmd=capabilities HTTP/1.1\r\n
   s>     Accept-Encoding: identity\r\n
   s>     user-agent: test\r\n
   s>     x-hgupgrade-1: foo bar\r\n
   s>     host: $LOCALIP:$HGPORT\r\n (glob)
   s>     \r\n
   s> makefile('rb', None)
   s>     HTTP/1.1 200 Script output follows\r\n
   s>     Server: testing stub value\r\n
   s>     Date: $HTTP_DATE$\r\n
   s>     Content-Type: application/mercurial-0.1\r\n
   s>     Content-Length: *\r\n (glob)
   s>     \r\n
   s>     batch branchmap $USUAL_BUNDLE2_CAPS_SERVER$ changegroupsubset compression=$BUNDLE2_COMPRESSIONS$ getbundle httpheader=1024 httpmediatype=0.1rx,0.1tx,0.2tx known lookup pushkey streamreqs=generaldelta,revlogv1 unbundle=HG10GZ,HG10BZ,HG10UN unbundlehash
 
 X-HgUpgrade-<N> without known serialization in X-HgProto-<N> uses legacy response
 
   $ sendhttpraw << EOF
   > httprequest GET ?cmd=capabilities
   >    user-agent: test
   >    x-hgupgrade-1: foo bar
   >    x-hgproto-1: some value
   > EOF
   using raw connection to peer
   s>     GET /?cmd=capabilities HTTP/1.1\r\n
   s>     Accept-Encoding: identity\r\n
   s>     user-agent: test\r\n
   s>     x-hgproto-1: some value\r\n
   s>     x-hgupgrade-1: foo bar\r\n
   s>     host: $LOCALIP:$HGPORT\r\n (glob)
   s>     \r\n
   s> makefile('rb', None)
   s>     HTTP/1.1 200 Script output follows\r\n
   s>     Server: testing stub value\r\n
   s>     Date: $HTTP_DATE$\r\n
   s>     Content-Type: application/mercurial-0.1\r\n
   s>     Content-Length: *\r\n (glob)
   s>     \r\n
   s>     batch branchmap $USUAL_BUNDLE2_CAPS_SERVER$ changegroupsubset compression=$BUNDLE2_COMPRESSIONS$ getbundle httpheader=1024 httpmediatype=0.1rx,0.1tx,0.2tx known lookup pushkey streamreqs=generaldelta,revlogv1 unbundle=HG10GZ,HG10BZ,HG10UN unbundlehash
 
 X-HgUpgrade-<N> + X-HgProto-<N> headers trigger new response format
 
   $ sendhttpraw << EOF
   > httprequest GET ?cmd=capabilities
   >    user-agent: test
   >    x-hgupgrade-1: foo bar
   >    x-hgproto-1: cbor
   > EOF
   using raw connection to peer
   s>     GET /?cmd=capabilities HTTP/1.1\r\n
   s>     Accept-Encoding: identity\r\n
   s>     user-agent: test\r\n
   s>     x-hgproto-1: cbor\r\n
   s>     x-hgupgrade-1: foo bar\r\n
   s>     host: $LOCALIP:$HGPORT\r\n (glob)
   s>     \r\n
   s> makefile('rb', None)
   s>     HTTP/1.1 200 OK\r\n
   s>     Server: testing stub value\r\n
   s>     Date: $HTTP_DATE$\r\n
   s>     Content-Type: application/mercurial-cbor\r\n
   s>     Content-Length: *\r\n (glob)
   s>     \r\n
   s>     \xa3GapibaseDapi/Dapis\xa0Nv1capabilitiesY\x01\xc5batch branchmap $USUAL_BUNDLE2_CAPS_SERVER$ changegroupsubset compression=$BUNDLE2_COMPRESSIONS$ getbundle httpheader=1024 httpmediatype=0.1rx,0.1tx,0.2tx known lookup pushkey streamreqs=generaldelta,revlogv1 unbundle=HG10GZ,HG10BZ,HG10UN unbundlehash
   cbor> {
     b'apibase': b'api/',
     b'apis': {},
     b'v1capabilities': b'batch branchmap $USUAL_BUNDLE2_CAPS_SERVER$ changegroupsubset compression=$BUNDLE2_COMPRESSIONS$ getbundle httpheader=1024 httpmediatype=0.1rx,0.1tx,0.2tx known lookup pushkey streamreqs=generaldelta,revlogv1 unbundle=HG10GZ,HG10BZ,HG10UN unbundlehash'
   }
 
 Restart server to enable HTTPv2
 
   $ killdaemons.py
   $ enablehttpv2 server
   $ hg -R server serve -p $HGPORT -d --pid-file hg.pid -E error.log
   $ cat hg.pid > $DAEMON_PIDS
 
 Only requested API services are returned
 
   $ sendhttpraw << EOF
   > httprequest GET ?cmd=capabilities
   >    user-agent: test
   >    x-hgupgrade-1: foo bar
   >    x-hgproto-1: cbor
   > EOF
   using raw connection to peer
   s>     GET /?cmd=capabilities HTTP/1.1\r\n
   s>     Accept-Encoding: identity\r\n
   s>     user-agent: test\r\n
   s>     x-hgproto-1: cbor\r\n
   s>     x-hgupgrade-1: foo bar\r\n
   s>     host: $LOCALIP:$HGPORT\r\n (glob)
   s>     \r\n
   s> makefile('rb', None)
   s>     HTTP/1.1 200 OK\r\n
   s>     Server: testing stub value\r\n
   s>     Date: $HTTP_DATE$\r\n
   s>     Content-Type: application/mercurial-cbor\r\n
   s>     Content-Length: *\r\n (glob)
   s>     \r\n
   s>     \xa3GapibaseDapi/Dapis\xa0Nv1capabilitiesY\x01\xc5batch branchmap $USUAL_BUNDLE2_CAPS_SERVER$ changegroupsubset compression=$BUNDLE2_COMPRESSIONS$ getbundle httpheader=1024 httpmediatype=0.1rx,0.1tx,0.2tx known lookup pushkey streamreqs=generaldelta,revlogv1 unbundle=HG10GZ,HG10BZ,HG10UN unbundlehash
   cbor> {
     b'apibase': b'api/',
     b'apis': {},
     b'v1capabilities': b'batch branchmap $USUAL_BUNDLE2_CAPS_SERVER$ changegroupsubset compression=$BUNDLE2_COMPRESSIONS$ getbundle httpheader=1024 httpmediatype=0.1rx,0.1tx,0.2tx known lookup pushkey streamreqs=generaldelta,revlogv1 unbundle=HG10GZ,HG10BZ,HG10UN unbundlehash'
   }
 
 Request for HTTPv2 service returns information about it
 
   $ sendhttpraw << EOF
   > httprequest GET ?cmd=capabilities
   >    user-agent: test
   >    x-hgupgrade-1: exp-http-v2-0001 foo bar
   >    x-hgproto-1: cbor
   > EOF
   using raw connection to peer
   s>     GET /?cmd=capabilities HTTP/1.1\r\n
   s>     Accept-Encoding: identity\r\n
   s>     user-agent: test\r\n
   s>     x-hgproto-1: cbor\r\n
   s>     x-hgupgrade-1: exp-http-v2-0001 foo bar\r\n
   s>     host: $LOCALIP:$HGPORT\r\n (glob)
   s>     \r\n
   s> makefile('rb', None)
   s>     HTTP/1.1 200 OK\r\n
   s>     Server: testing stub value\r\n
   s>     Date: $HTTP_DATE$\r\n
   s>     Content-Type: application/mercurial-cbor\r\n
   s>     Content-Length: *\r\n (glob)
   s>     \r\n
-  s>     \xa3GapibaseDapi/Dapis\xa1Pexp-http-v2-0001\xa4Hcommands\xaaIbranchmap\xa2Dargs\xa0Kpermissions\x81DpullLcapabilities\xa2Dargs\xa0Kpermissions\x81DpullMchangesetdata\xa2Dargs\xa3Ffields\xd9\x01\x02\x82GparentsHrevisionInoderange\x82\x81J0123456...\x81Iabcdef...Enodes\x81J0123456...Kpermissions\x81DpullHfiledata\xa2Dargs\xa3Ffields\x82GparentsHrevisionEnodes\x81J0123456...DpathGfoo.txtKpermissions\x81DpullEheads\xa2Dargs\xa1Jpubliconly\xf4Kpermissions\x81DpullEknown\xa2Dargs\xa1Enodes\x81HdeadbeefKpermissions\x81DpullHlistkeys\xa2Dargs\xa1InamespaceBnsKpermissions\x81DpullFlookup\xa2Dargs\xa1CkeyCfooKpermissions\x81DpullLmanifestdata\xa2Dargs\xa3Ffields\x82GparentsHrevisionEnodes\x81J0123456...Dtree@Kpermissions\x81DpullGpushkey\xa2Dargs\xa4CkeyCkeyInamespaceBnsCnewCnewColdColdKpermissions\x81DpushKcompression\x81\xa1DnameDzlibQframingmediatypes\x81X&application/mercurial-exp-framing-0005Nrawrepoformats\x82LgeneraldeltaHrevlogv1Nv1capabilitiesY\x01\xc5batch branchmap $USUAL_BUNDLE2_CAPS_SERVER$ changegroupsubset compression=$BUNDLE2_COMPRESSIONS$ getbundle httpheader=1024 httpmediatype=0.1rx,0.1tx,0.2tx known lookup pushkey streamreqs=generaldelta,revlogv1 unbundle=HG10GZ,HG10BZ,HG10UN unbundlehash
+  s>     \xa3GapibaseDapi/Dapis\xa1Pexp-http-v2-0001\xa4Hcommands\xaaIbranchmap\xa2Dargs\xa0Kpermissions\x81DpullLcapabilities\xa2Dargs\xa0Kpermissions\x81DpullMchangesetdata\xa2Dargs\xa3Ffields\xd9\x01\x02\x82GparentsHrevisionInoderange\x82\x81J0123456...\x81Iabcdef...Enodes\x81J0123456...Kpermissions\x81DpullHfiledata\xa2Dargs\xa4Ffields\x82GparentsHrevisionKhaveparents\xf5Enodes\x81J0123456...DpathGfoo.txtKpermissions\x81DpullEheads\xa2Dargs\xa1Jpubliconly\xf4Kpermissions\x81DpullEknown\xa2Dargs\xa1Enodes\x81HdeadbeefKpermissions\x81DpullHlistkeys\xa2Dargs\xa1InamespaceBnsKpermissions\x81DpullFlookup\xa2Dargs\xa1CkeyCfooKpermissions\x81DpullLmanifestdata\xa2Dargs\xa4Ffields\x82GparentsHrevisionKhaveparents\xf5Enodes\x81J0123456...Dtree@Kpermissions\x81DpullGpushkey\xa2Dargs\xa4CkeyCkeyInamespaceBnsCnewCnewColdColdKpermissions\x81DpushKcompression\x81\xa1DnameDzlibQframingmediatypes\x81X&application/mercurial-exp-framing-0005Nrawrepoformats\x82LgeneraldeltaHrevlogv1Nv1capabilitiesY\x01\xc5batch branchmap $USUAL_BUNDLE2_CAPS_SERVER$ changegroupsubset compression=$BUNDLE2_COMPRESSIONS$ getbundle httpheader=1024 httpmediatype=0.1rx,0.1tx,0.2tx known lookup pushkey streamreqs=generaldelta,revlogv1 unbundle=HG10GZ,HG10BZ,HG10UN unbundlehash
   cbor> {
     b'apibase': b'api/',
     b'apis': {
       b'exp-http-v2-0001': {
         b'commands': {
           b'branchmap': {
             b'args': {},
             b'permissions': [
               b'pull'
             ]
           },
           b'capabilities': {
             b'args': {},
             b'permissions': [
               b'pull'
             ]
           },
           b'changesetdata': {
             b'args': {
               b'fields': set([
                 b'parents',
                 b'revision'
               ]),
               b'noderange': [
                 [
                   b'0123456...'
                 ],
                 [
                   b'abcdef...'
                 ]
               ],
               b'nodes': [
                 b'0123456...'
               ]
             },
             b'permissions': [
               b'pull'
             ]
           },
           b'filedata': {
             b'args': {
               b'fields': [
                 b'parents',
                 b'revision'
               ],
+              b'haveparents': True,
               b'nodes': [
                 b'0123456...'
               ],
               b'path': b'foo.txt'
             },
             b'permissions': [
               b'pull'
             ]
           },
           b'heads': {
             b'args': {
               b'publiconly': False
             },
             b'permissions': [
               b'pull'
             ]
           },
           b'known': {
             b'args': {
               b'nodes': [
                 b'deadbeef'
               ]
             },
             b'permissions': [
               b'pull'
             ]
           },
           b'listkeys': {
             b'args': {
               b'namespace': b'ns'
             },
             b'permissions': [
               b'pull'
             ]
           },
           b'lookup': {
             b'args': {
               b'key': b'foo'
             },
             b'permissions': [
               b'pull'
             ]
           },
           b'manifestdata': {
             b'args': {
               b'fields': [
                 b'parents',
                 b'revision'
               ],
+              b'haveparents': True,
               b'nodes': [
                 b'0123456...'
               ],
               b'tree': b''
             },
             b'permissions': [
               b'pull'
             ]
           },
           b'pushkey': {
             b'args': {
               b'key': b'key',
               b'namespace': b'ns',
               b'new': b'new',
               b'old': b'old'
             },
             b'permissions': [
               b'push'
             ]
           }
         },
         b'compression': [
           {
             b'name': b'zlib'
           }
         ],
         b'framingmediatypes': [
           b'application/mercurial-exp-framing-0005'
         ],
         b'rawrepoformats': [
           b'generaldelta',
           b'revlogv1'
         ]
       }
     },
     b'v1capabilities': b'batch branchmap $USUAL_BUNDLE2_CAPS_SERVER$ changegroupsubset compression=$BUNDLE2_COMPRESSIONS$ getbundle httpheader=1024 httpmediatype=0.1rx,0.1tx,0.2tx known lookup pushkey streamreqs=generaldelta,revlogv1 unbundle=HG10GZ,HG10BZ,HG10UN unbundlehash'
   }
 
 capabilities command returns expected info
 
   $ sendhttpv2peerhandshake << EOF
   > command capabilities
   > EOF
   creating http peer for wire protocol version 2
   s>     GET /?cmd=capabilities HTTP/1.1\r\n
   s>     Accept-Encoding: identity\r\n
   s>     vary: X-HgProto-1,X-HgUpgrade-1\r\n
   s>     x-hgproto-1: cbor\r\n
   s>     x-hgupgrade-1: exp-http-v2-0001\r\n
   s>     accept: application/mercurial-0.1\r\n
   s>     host: $LOCALIP:$HGPORT\r\n (glob)
   s>     user-agent: Mercurial debugwireproto\r\n
   s>     \r\n
   s> makefile('rb', None)
   s>     HTTP/1.1 200 OK\r\n
   s>     Server: testing stub value\r\n
   s>     Date: $HTTP_DATE$\r\n
   s>     Content-Type: application/mercurial-cbor\r\n
   s>     Content-Length: *\r\n (glob)
   s>     \r\n
-  s>     \xa3GapibaseDapi/Dapis\xa1Pexp-http-v2-0001\xa4Hcommands\xaaIbranchmap\xa2Dargs\xa0Kpermissions\x81DpullLcapabilities\xa2Dargs\xa0Kpermissions\x81DpullMchangesetdata\xa2Dargs\xa3Ffields\xd9\x01\x02\x82GparentsHrevisionInoderange\x82\x81J0123456...\x81Iabcdef...Enodes\x81J0123456...Kpermissions\x81DpullHfiledata\xa2Dargs\xa3Ffields\x82GparentsHrevisionEnodes\x81J0123456...DpathGfoo.txtKpermissions\x81DpullEheads\xa2Dargs\xa1Jpubliconly\xf4Kpermissions\x81DpullEknown\xa2Dargs\xa1Enodes\x81HdeadbeefKpermissions\x81DpullHlistkeys\xa2Dargs\xa1InamespaceBnsKpermissions\x81DpullFlookup\xa2Dargs\xa1CkeyCfooKpermissions\x81DpullLmanifestdata\xa2Dargs\xa3Ffields\x82GparentsHrevisionEnodes\x81J0123456...Dtree@Kpermissions\x81DpullGpushkey\xa2Dargs\xa4CkeyCkeyInamespaceBnsCnewCnewColdColdKpermissions\x81DpushKcompression\x81\xa1DnameDzlibQframingmediatypes\x81X&application/mercurial-exp-framing-0005Nrawrepoformats\x82LgeneraldeltaHrevlogv1Nv1capabilitiesY\x01\xc5batch branchmap $USUAL_BUNDLE2_CAPS_SERVER$ changegroupsubset compression=$BUNDLE2_COMPRESSIONS$ getbundle httpheader=1024 httpmediatype=0.1rx,0.1tx,0.2tx known lookup pushkey streamreqs=generaldelta,revlogv1 unbundle=HG10GZ,HG10BZ,HG10UN unbundlehash
+  s>     \xa3GapibaseDapi/Dapis\xa1Pexp-http-v2-0001\xa4Hcommands\xaaIbranchmap\xa2Dargs\xa0Kpermissions\x81DpullLcapabilities\xa2Dargs\xa0Kpermissions\x81DpullMchangesetdata\xa2Dargs\xa3Ffields\xd9\x01\x02\x82GparentsHrevisionInoderange\x82\x81J0123456...\x81Iabcdef...Enodes\x81J0123456...Kpermissions\x81DpullHfiledata\xa2Dargs\xa4Ffields\x82GparentsHrevisionKhaveparents\xf5Enodes\x81J0123456...DpathGfoo.txtKpermissions\x81DpullEheads\xa2Dargs\xa1Jpubliconly\xf4Kpermissions\x81DpullEknown\xa2Dargs\xa1Enodes\x81HdeadbeefKpermissions\x81DpullHlistkeys\xa2Dargs\xa1InamespaceBnsKpermissions\x81DpullFlookup\xa2Dargs\xa1CkeyCfooKpermissions\x81DpullLmanifestdata\xa2Dargs\xa4Ffields\x82GparentsHrevisionKhaveparents\xf5Enodes\x81J0123456...Dtree@Kpermissions\x81DpullGpushkey\xa2Dargs\xa4CkeyCkeyInamespaceBnsCnewCnewColdColdKpermissions\x81DpushKcompression\x81\xa1DnameDzlibQframingmediatypes\x81X&application/mercurial-exp-framing-0005Nrawrepoformats\x82LgeneraldeltaHrevlogv1Nv1capabilitiesY\x01\xc5batch branchmap $USUAL_BUNDLE2_CAPS_SERVER$ changegroupsubset compression=$BUNDLE2_COMPRESSIONS$ getbundle httpheader=1024 httpmediatype=0.1rx,0.1tx,0.2tx known lookup pushkey streamreqs=generaldelta,revlogv1 unbundle=HG10GZ,HG10BZ,HG10UN unbundlehash
   sending capabilities command
   s>     POST /api/exp-http-v2-0001/ro/capabilities HTTP/1.1\r\n
   s>     Accept-Encoding: identity\r\n
   s>     accept: application/mercurial-exp-framing-0005\r\n
   s>     content-type: application/mercurial-exp-framing-0005\r\n
   s>     content-length: 27\r\n
   s>     host: $LOCALIP:$HGPORT\r\n (glob)
   s>     user-agent: Mercurial debugwireproto\r\n
   s>     \r\n
   s>     \x13\x00\x00\x01\x00\x01\x01\x11\xa1DnameLcapabilities
   s> makefile('rb', None)
   s>     HTTP/1.1 200 OK\r\n
   s>     Server: testing stub value\r\n
   s>     Date: $HTTP_DATE$\r\n
   s>     Content-Type: application/mercurial-exp-framing-0005\r\n
   s>     Transfer-Encoding: chunked\r\n
   s>     \r\n
   s>     13\r\n
   s>     \x0b\x00\x00\x01\x00\x02\x011
   s>     \xa1FstatusBok
   s>     \r\n
   received frame(size=11; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=continuation)
-  s>     2f4\r\n
-  s>     \xec\x02\x00\x01\x00\x02\x001
-  s>     \xa4Hcommands\xaaIbranchmap\xa2Dargs\xa0Kpermissions\x81DpullLcapabilities\xa2Dargs\xa0Kpermissions\x81DpullMchangesetdata\xa2Dargs\xa3Ffields\xd9\x01\x02\x82GparentsHrevisionInoderange\x82\x81J0123456...\x81Iabcdef...Enodes\x81J0123456...Kpermissions\x81DpullHfiledata\xa2Dargs\xa3Ffields\x82GparentsHrevisionEnodes\x81J0123456...DpathGfoo.txtKpermissions\x81DpullEheads\xa2Dargs\xa1Jpubliconly\xf4Kpermissions\x81DpullEknown\xa2Dargs\xa1Enodes\x81HdeadbeefKpermissions\x81DpullHlistkeys\xa2Dargs\xa1InamespaceBnsKpermissions\x81DpullFlookup\xa2Dargs\xa1CkeyCfooKpermissions\x81DpullLmanifestdata\xa2Dargs\xa3Ffields\x82GparentsHrevisionEnodes\x81J0123456...Dtree@Kpermissions\x81DpullGpushkey\xa2Dargs\xa4CkeyCkeyInamespaceBnsCnewCnewColdColdKpermissions\x81DpushKcompression\x81\xa1DnameDzlibQframingmediatypes\x81X&application/mercurial-exp-framing-0005Nrawrepoformats\x82LgeneraldeltaHrevlogv1
+  s>     30e\r\n
+  s>     \x06\x03\x00\x01\x00\x02\x001
+  s>     \xa4Hcommands\xaaIbranchmap\xa2Dargs\xa0Kpermissions\x81DpullLcapabilities\xa2Dargs\xa0Kpermissions\x81DpullMchangesetdata\xa2Dargs\xa3Ffields\xd9\x01\x02\x82GparentsHrevisionInoderange\x82\x81J0123456...\x81Iabcdef...Enodes\x81J0123456...Kpermissions\x81DpullHfiledata\xa2Dargs\xa4Ffields\x82GparentsHrevisionKhaveparents\xf5Enodes\x81J0123456...DpathGfoo.txtKpermissions\x81DpullEheads\xa2Dargs\xa1Jpubliconly\xf4Kpermissions\x81DpullEknown\xa2Dargs\xa1Enodes\x81HdeadbeefKpermissions\x81DpullHlistkeys\xa2Dargs\xa1InamespaceBnsKpermissions\x81DpullFlookup\xa2Dargs\xa1CkeyCfooKpermissions\x81DpullLmanifestdata\xa2Dargs\xa4Ffields\x82GparentsHrevisionKhaveparents\xf5Enodes\x81J0123456...Dtree@Kpermissions\x81DpullGpushkey\xa2Dargs\xa4CkeyCkeyInamespaceBnsCnewCnewColdColdKpermissions\x81DpushKcompression\x81\xa1DnameDzlibQframingmediatypes\x81X&application/mercurial-exp-framing-0005Nrawrepoformats\x82LgeneraldeltaHrevlogv1
   s>     \r\n
-  received frame(size=748; request=1; stream=2; streamflags=; type=command-response; flags=continuation)
+  received frame(size=774; request=1; stream=2; streamflags=; type=command-response; flags=continuation)
   s>     8\r\n
   s>     \x00\x00\x00\x01\x00\x02\x002
   s>     \r\n
   s>     0\r\n
   s>     \r\n
   received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos)
   response: gen[
     {
       b'commands': {
         b'branchmap': {
           b'args': {},
           b'permissions': [
             b'pull'
           ]
         },
         b'capabilities': {
           b'args': {},
           b'permissions': [
             b'pull'
           ]
         },
         b'changesetdata': {
           b'args': {
             b'fields': set([
               b'parents',
               b'revision'
             ]),
             b'noderange': [
               [
                 b'0123456...'
               ],
               [
                 b'abcdef...'
               ]
             ],
             b'nodes': [
               b'0123456...'
             ]
           },
           b'permissions': [
             b'pull'
           ]
         },
         b'filedata': {
           b'args': {
             b'fields': [
               b'parents',
               b'revision'
             ],
+            b'haveparents': True,
             b'nodes': [
               b'0123456...'
             ],
             b'path': b'foo.txt'
           },
           b'permissions': [
             b'pull'
           ]
         },
         b'heads': {
           b'args': {
             b'publiconly': False
           },
           b'permissions': [
             b'pull'
           ]
         },
         b'known': {
           b'args': {
             b'nodes': [
               b'deadbeef'
             ]
           },
           b'permissions': [
             b'pull'
           ]
         },
         b'listkeys': {
           b'args': {
             b'namespace': b'ns'
           },
           b'permissions': [
             b'pull'
           ]
         },
         b'lookup': {
           b'args': {
             b'key': b'foo'
           },
           b'permissions': [
             b'pull'
           ]
         },
         b'manifestdata': {
           b'args': {
             b'fields': [
               b'parents',
               b'revision'
             ],
+            b'haveparents': True,
             b'nodes': [
               b'0123456...'
             ],
             b'tree': b''
           },
           b'permissions': [
             b'pull'
           ]
         },
         b'pushkey': {
           b'args': {
             b'key': b'key',
             b'namespace': b'ns',
             b'new': b'new',
             b'old': b'old'
           },
           b'permissions': [
             b'push'
           ]
         }
       },
       b'compression': [
         {
           b'name': b'zlib'
         }
       ],
       b'framingmediatypes': [
         b'application/mercurial-exp-framing-0005'
       ],
       b'rawrepoformats': [
         b'generaldelta',
         b'revlogv1'
       ]
     }
   ]
 
   $ cat error.log

tests/test-wireproto-command-filedata.t

@@ -1,497 +1,604
   $ . $TESTDIR/wireprotohelpers.sh
 
   $ hg init server
   $ enablehttpv2 server
   $ cd server
   $ echo a0 > a
   $ echo b0 > b
   $ mkdir -p dir0/child0 dir0/child1 dir1
   $ echo c0 > dir0/c
   $ echo d0 > dir0/d
   $ echo e0 > dir0/child0/e
   $ echo f0 > dir0/child1/f
   $ hg -q commit -A -m 'commit 0'
 
   $ echo a1 > a
   $ echo d1 > dir0/d
   $ hg commit -m 'commit 1'
   $ echo f0 > dir0/child1/f
   $ hg commit -m 'commit 2'
   nothing changed
   [1]
 
   $ hg -q up -r 0
   $ echo a2 > a
   $ hg commit -m 'commit 3'
   created new head
 
   $ hg log -G -T '{rev}:{node} {desc}\n'
   @  2:c8757a2ffe552850d1e0dfe60d295ebf64c196d9 commit 3
   |
   | o  1:650165e803375748a94df471e5b58d85763e0b29 commit 1
   |/
   o  0:6d85ca1270b377d320098556ba5bfad34a9ee12d commit 0
   
 
   $ hg --debug debugindex a
      rev linkrev nodeid                                   p1                                       p2
        0       0 2b4eb07319bfa077a40a2f04913659aef0da42da 0000000000000000000000000000000000000000 0000000000000000000000000000000000000000
        1       1 9a38122997b3ac97be2a9aa2e556838341fdf2cc 2b4eb07319bfa077a40a2f04913659aef0da42da 0000000000000000000000000000000000000000
        2       2 0879345e39377229634b420c639454156726c6b6 2b4eb07319bfa077a40a2f04913659aef0da42da 0000000000000000000000000000000000000000
 
   $ hg --debug debugindex dir0/child0/e
      rev linkrev nodeid                                   p1                                       p2
        0       0 bbba6c06b30f443d34ff841bc985c4d0827c6be4 0000000000000000000000000000000000000000 0000000000000000000000000000000000000000
 
   $ hg serve -p $HGPORT -d --pid-file hg.pid -E error.log
   $ cat hg.pid > $DAEMON_PIDS
 
 Missing arguments is an error
 
   $ sendhttpv2peer << EOF
   > command filedata
   > EOF
   creating http peer for wire protocol version 2
   sending filedata command
   s>     POST /api/exp-http-v2-0001/ro/filedata HTTP/1.1\r\n
   s>     Accept-Encoding: identity\r\n
   s>     accept: application/mercurial-exp-framing-0005\r\n
   s>     content-type: application/mercurial-exp-framing-0005\r\n
   s>     content-length: 23\r\n
   s>     host: $LOCALIP:$HGPORT\r\n (glob)
   s>     user-agent: Mercurial debugwireproto\r\n
   s>     \r\n
   s>     \x0f\x00\x00\x01\x00\x01\x01\x11\xa1DnameHfiledata
   s> makefile('rb', None)
   s>     HTTP/1.1 200 OK\r\n
   s>     Server: testing stub value\r\n
   s>     Date: $HTTP_DATE$\r\n
   s>     Content-Type: application/mercurial-exp-framing-0005\r\n
   s>     Transfer-Encoding: chunked\r\n
   s>     \r\n
   s>     45\r\n
   s>     =\x00\x00\x01\x00\x02\x012
   s>     \xa2Eerror\xa1GmessageX\x1enodes argument must be definedFstatusEerror
   s>     \r\n
   received frame(size=61; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=eos)
   s>     0\r\n
   s>     \r\n
   abort: nodes argument must be defined!
   [255]
 
   $ sendhttpv2peer << EOF
   > command filedata
   >     nodes eval:[]
   > EOF
   creating http peer for wire protocol version 2
   sending filedata command
   s>     POST /api/exp-http-v2-0001/ro/filedata HTTP/1.1\r\n
   s>     Accept-Encoding: identity\r\n
   s>     accept: application/mercurial-exp-framing-0005\r\n
   s>     content-type: application/mercurial-exp-framing-0005\r\n
   s>     content-length: 36\r\n
   s>     host: $LOCALIP:$HGPORT\r\n (glob)
   s>     user-agent: Mercurial debugwireproto\r\n
   s>     \r\n
   s>     \x1c\x00\x00\x01\x00\x01\x01\x11\xa2Dargs\xa1Enodes\x80DnameHfiledata
   s> makefile('rb', None)
   s>     HTTP/1.1 200 OK\r\n
   s>     Server: testing stub value\r\n
   s>     Date: $HTTP_DATE$\r\n
   s>     Content-Type: application/mercurial-exp-framing-0005\r\n
   s>     Transfer-Encoding: chunked\r\n
   s>     \r\n
   s>     44\r\n
   s>     <\x00\x00\x01\x00\x02\x012
   s>     \xa2Eerror\xa1GmessageX\x1dpath argument must be definedFstatusEerror
   s>     \r\n
   received frame(size=60; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=eos)
   s>     0\r\n
   s>     \r\n
   abort: path argument must be defined!
   [255]
 
 Unknown node is an error
 
   $ sendhttpv2peer << EOF
   > command filedata
   >     nodes eval:[b'\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa']
   >     path eval:b'a'
   > EOF
   creating http peer for wire protocol version 2
   sending filedata command
   s>     POST /api/exp-http-v2-0001/ro/filedata HTTP/1.1\r\n
   s>     Accept-Encoding: identity\r\n
   s>     accept: application/mercurial-exp-framing-0005\r\n
   s>     content-type: application/mercurial-exp-framing-0005\r\n
   s>     content-length: 64\r\n
   s>     host: $LOCALIP:$HGPORT\r\n (glob)
   s>     user-agent: Mercurial debugwireproto\r\n
   s>     \r\n
   s>     8\x00\x00\x01\x00\x01\x01\x11\xa2Dargs\xa2Enodes\x81T\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaaDpathAaDnameHfiledata
   s> makefile('rb', None)
   s>     HTTP/1.1 200 OK\r\n
   s>     Server: testing stub value\r\n
   s>     Date: $HTTP_DATE$\r\n
   s>     Content-Type: application/mercurial-exp-framing-0005\r\n
   s>     Transfer-Encoding: chunked\r\n
   s>     \r\n
   s>     6b\r\n
   s>     c\x00\x00\x01\x00\x02\x012
   s>     \xa2Eerror\xa2Dargs\x81X(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaGmessageUunknown file node: %sFstatusEerror
   s>     \r\n
   received frame(size=99; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=eos)
   s>     0\r\n
   s>     \r\n
   abort: unknown file node: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa!
   [255]
 
 Fetching a single revision returns just metadata by default
 
   $ sendhttpv2peer << EOF
   > command filedata
   >     nodes eval:[b'\x9a\x38\x12\x29\x97\xb3\xac\x97\xbe\x2a\x9a\xa2\xe5\x56\x83\x83\x41\xfd\xf2\xcc']
   >     path eval:b'a'
   > EOF
   creating http peer for wire protocol version 2
   sending filedata command
   s>     POST /api/exp-http-v2-0001/ro/filedata HTTP/1.1\r\n
   s>     Accept-Encoding: identity\r\n
   s>     accept: application/mercurial-exp-framing-0005\r\n
   s>     content-type: application/mercurial-exp-framing-0005\r\n
   s>     content-length: 64\r\n
   s>     host: $LOCALIP:$HGPORT\r\n (glob)
   s>     user-agent: Mercurial debugwireproto\r\n
   s>     \r\n
   s>     8\x00\x00\x01\x00\x01\x01\x11\xa2Dargs\xa2Enodes\x81T\x9a8\x12)\x97\xb3\xac\x97\xbe*\x9a\xa2\xe5V\x83\x83A\xfd\xf2\xccDpathAaDnameHfiledata
   s> makefile('rb', None)
   s>     HTTP/1.1 200 OK\r\n
   s>     Server: testing stub value\r\n
   s>     Date: $HTTP_DATE$\r\n
   s>     Content-Type: application/mercurial-exp-framing-0005\r\n
   s>     Transfer-Encoding: chunked\r\n
   s>     \r\n
   s>     13\r\n
   s>     \x0b\x00\x00\x01\x00\x02\x011
   s>     \xa1FstatusBok
   s>     \r\n
   received frame(size=11; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=continuation)
   s>     30\r\n
   s>     (\x00\x00\x01\x00\x02\x001
   s>     \xa1Jtotalitems\x01\xa1DnodeT\x9a8\x12)\x97\xb3\xac\x97\xbe*\x9a\xa2\xe5V\x83\x83A\xfd\xf2\xcc
   s>     \r\n
   received frame(size=40; request=1; stream=2; streamflags=; type=command-response; flags=continuation)
   s>     8\r\n
   s>     \x00\x00\x00\x01\x00\x02\x002
   s>     \r\n
   s>     0\r\n
   s>     \r\n
   received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos)
   response: gen[
     {
       b'totalitems': 1
     },
     {
       b'node': b'\x9a8\x12)\x97\xb3\xac\x97\xbe*\x9a\xa2\xe5V\x83\x83A\xfd\xf2\xcc'
     }
   ]
 
 Requesting parents works
 
   $ sendhttpv2peer << EOF
   > command filedata
   >     nodes eval:[b'\x9a\x38\x12\x29\x97\xb3\xac\x97\xbe\x2a\x9a\xa2\xe5\x56\x83\x83\x41\xfd\xf2\xcc']
   >     path eval:b'a'
   >     fields eval:[b'parents']
   > EOF
   creating http peer for wire protocol version 2
   sending filedata command
   s>     POST /api/exp-http-v2-0001/ro/filedata HTTP/1.1\r\n
   s>     Accept-Encoding: identity\r\n
   s>     accept: application/mercurial-exp-framing-0005\r\n
   s>     content-type: application/mercurial-exp-framing-0005\r\n
   s>     content-length: 80\r\n
   s>     host: $LOCALIP:$HGPORT\r\n (glob)
   s>     user-agent: Mercurial debugwireproto\r\n
   s>     \r\n
   s>     H\x00\x00\x01\x00\x01\x01\x11\xa2Dargs\xa3Ffields\x81GparentsEnodes\x81T\x9a8\x12)\x97\xb3\xac\x97\xbe*\x9a\xa2\xe5V\x83\x83A\xfd\xf2\xccDpathAaDnameHfiledata
   s> makefile('rb', None)
   s>     HTTP/1.1 200 OK\r\n
   s>     Server: testing stub value\r\n
   s>     Date: $HTTP_DATE$\r\n
   s>     Content-Type: application/mercurial-exp-framing-0005\r\n
   s>     Transfer-Encoding: chunked\r\n
   s>     \r\n
   s>     13\r\n
   s>     \x0b\x00\x00\x01\x00\x02\x011
   s>     \xa1FstatusBok
   s>     \r\n
   received frame(size=11; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=continuation)
   s>     63\r\n
   s>     [\x00\x00\x01\x00\x02\x001
   s>     \xa1Jtotalitems\x01\xa2DnodeT\x9a8\x12)\x97\xb3\xac\x97\xbe*\x9a\xa2\xe5V\x83\x83A\xfd\xf2\xccGparents\x82T+N\xb0s\x19\xbf\xa0w\xa4\n
   s>     /\x04\x916Y\xae\xf0\xdaB\xdaT\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00
   s>     \r\n
   received frame(size=91; request=1; stream=2; streamflags=; type=command-response; flags=continuation)
   s>     8\r\n
   s>     \x00\x00\x00\x01\x00\x02\x002
   s>     \r\n
   s>     0\r\n
   s>     \r\n
   received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos)
   response: gen[
     {
       b'totalitems': 1
     },
     {
       b'node': b'\x9a8\x12)\x97\xb3\xac\x97\xbe*\x9a\xa2\xe5V\x83\x83A\xfd\xf2\xcc',
       b'parents': [
         b'+N\xb0s\x19\xbf\xa0w\xa4\n/\x04\x916Y\xae\xf0\xdaB\xda',
         b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
       ]
     }
   ]
 
 Requesting revision data works
+(haveparents defaults to False, so fulltext is emitted)
 
   $ sendhttpv2peer << EOF
   > command filedata
   >     nodes eval:[b'\x9a\x38\x12\x29\x97\xb3\xac\x97\xbe\x2a\x9a\xa2\xe5\x56\x83\x83\x41\xfd\xf2\xcc']
   >     path eval:b'a'
   >     fields eval:[b'revision']
   > EOF
   creating http peer for wire protocol version 2
   sending filedata command
   s>     POST /api/exp-http-v2-0001/ro/filedata HTTP/1.1\r\n
   s>     Accept-Encoding: identity\r\n
   s>     accept: application/mercurial-exp-framing-0005\r\n
   s>     content-type: application/mercurial-exp-framing-0005\r\n
   s>     content-length: 81\r\n
   s>     host: $LOCALIP:$HGPORT\r\n (glob)
   s>     user-agent: Mercurial debugwireproto\r\n
   s>     \r\n
   s>     I\x00\x00\x01\x00\x01\x01\x11\xa2Dargs\xa3Ffields\x81HrevisionEnodes\x81T\x9a8\x12)\x97\xb3\xac\x97\xbe*\x9a\xa2\xe5V\x83\x83A\xfd\xf2\xccDpathAaDnameHfiledata
   s> makefile('rb', None)
   s>     HTTP/1.1 200 OK\r\n
   s>     Server: testing stub value\r\n
   s>     Date: $HTTP_DATE$\r\n
   s>     Content-Type: application/mercurial-exp-framing-0005\r\n
   s>     Transfer-Encoding: chunked\r\n
   s>     \r\n
   s>     13\r\n
   s>     \x0b\x00\x00\x01\x00\x02\x011
   s>     \xa1FstatusBok
   s>     \r\n
   received frame(size=11; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=continuation)
+  s>     42\r\n
+  s>     :\x00\x00\x01\x00\x02\x001
+  s>     \xa1Jtotalitems\x01\xa2DnodeT\x9a8\x12)\x97\xb3\xac\x97\xbe*\x9a\xa2\xe5V\x83\x83A\xfd\xf2\xccLrevisionsize\x03Ca1\n
+  s>     \r\n
+  received frame(size=58; request=1; stream=2; streamflags=; type=command-response; flags=continuation)
+  s>     8\r\n
+  s>     \x00\x00\x00\x01\x00\x02\x002
+  s>     \r\n
+  s>     0\r\n
+  s>     \r\n
+  received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos)
+  response: gen[
+    {
+      b'totalitems': 1
+    },
+    {
+      b'node': b'\x9a8\x12)\x97\xb3\xac\x97\xbe*\x9a\xa2\xe5V\x83\x83A\xfd\xf2\xcc',
+      b'revisionsize': 3
+    },
+    b'a1\n'
+  ]
+
+haveparents=False should be same as above
+
+  $ sendhttpv2peer << EOF
+  > command filedata
+  >     nodes eval:[b'\x9a\x38\x12\x29\x97\xb3\xac\x97\xbe\x2a\x9a\xa2\xe5\x56\x83\x83\x41\xfd\xf2\xcc']
+  >     path eval:b'a'
+  >     fields eval:[b'revision']
+  >     haveparents eval:False
+  > EOF
+  creating http peer for wire protocol version 2
+  sending filedata command
+  s>     POST /api/exp-http-v2-0001/ro/filedata HTTP/1.1\r\n
+  s>     Accept-Encoding: identity\r\n
+  s>     accept: application/mercurial-exp-framing-0005\r\n
+  s>     content-type: application/mercurial-exp-framing-0005\r\n
+  s>     content-length: 94\r\n
+  s>     host: $LOCALIP:$HGPORT\r\n (glob)
+  s>     user-agent: Mercurial debugwireproto\r\n
+  s>     \r\n
+  s>     V\x00\x00\x01\x00\x01\x01\x11\xa2Dargs\xa4Ffields\x81HrevisionKhaveparents\xf4Enodes\x81T\x9a8\x12)\x97\xb3\xac\x97\xbe*\x9a\xa2\xe5V\x83\x83A\xfd\xf2\xccDpathAaDnameHfiledata
+  s> makefile('rb', None)
+  s>     HTTP/1.1 200 OK\r\n
+  s>     Server: testing stub value\r\n
+  s>     Date: $HTTP_DATE$\r\n
+  s>     Content-Type: application/mercurial-exp-framing-0005\r\n
+  s>     Transfer-Encoding: chunked\r\n
+  s>     \r\n
+  s>     13\r\n
+  s>     \x0b\x00\x00\x01\x00\x02\x011
+  s>     \xa1FstatusBok
+  s>     \r\n
+  received frame(size=11; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=continuation)
+  s>     42\r\n
+  s>     :\x00\x00\x01\x00\x02\x001
+  s>     \xa1Jtotalitems\x01\xa2DnodeT\x9a8\x12)\x97\xb3\xac\x97\xbe*\x9a\xa2\xe5V\x83\x83A\xfd\xf2\xccLrevisionsize\x03Ca1\n
+  s>     \r\n
+  received frame(size=58; request=1; stream=2; streamflags=; type=command-response; flags=continuation)
+  s>     8\r\n
+  s>     \x00\x00\x00\x01\x00\x02\x002
+  s>     \r\n
+  s>     0\r\n
+  s>     \r\n
+  received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos)
+  response: gen[
+    {
+      b'totalitems': 1
+    },
+    {
+      b'node': b'\x9a8\x12)\x97\xb3\xac\x97\xbe*\x9a\xa2\xe5V\x83\x83A\xfd\xf2\xcc',
+      b'revisionsize': 3
+    },
+    b'a1\n'
+  ]
+
+haveparents=True should emit a delta
+
+  $ sendhttpv2peer << EOF
+  > command filedata
+  >     nodes eval:[b'\x9a\x38\x12\x29\x97\xb3\xac\x97\xbe\x2a\x9a\xa2\xe5\x56\x83\x83\x41\xfd\xf2\xcc']
+  >     path eval:b'a'
+  >     fields eval:[b'revision']
+  >     haveparents eval:True
+  > EOF
+  creating http peer for wire protocol version 2
+  sending filedata command
+  s>     POST /api/exp-http-v2-0001/ro/filedata HTTP/1.1\r\n
+  s>     Accept-Encoding: identity\r\n
+  s>     accept: application/mercurial-exp-framing-0005\r\n
+  s>     content-type: application/mercurial-exp-framing-0005\r\n
+  s>     content-length: 94\r\n
+  s>     host: $LOCALIP:$HGPORT\r\n (glob)
+  s>     user-agent: Mercurial debugwireproto\r\n
+  s>     \r\n
+  s>     V\x00\x00\x01\x00\x01\x01\x11\xa2Dargs\xa4Ffields\x81HrevisionKhaveparents\xf5Enodes\x81T\x9a8\x12)\x97\xb3\xac\x97\xbe*\x9a\xa2\xe5V\x83\x83A\xfd\xf2\xccDpathAaDnameHfiledata
+  s> makefile('rb', None)
+  s>     HTTP/1.1 200 OK\r\n
+  s>     Server: testing stub value\r\n
+  s>     Date: $HTTP_DATE$\r\n
+  s>     Content-Type: application/mercurial-exp-framing-0005\r\n
+  s>     Transfer-Encoding: chunked\r\n
+  s>     \r\n
+  s>     13\r\n
+  s>     \x0b\x00\x00\x01\x00\x02\x011
+  s>     \xa1FstatusBok
+  s>     \r\n
+  received frame(size=11; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=continuation)
   s>     6e\r\n
   s>     f\x00\x00\x01\x00\x02\x001
   s>     \xa1Jtotalitems\x01\xa3MdeltabasenodeT+N\xb0s\x19\xbf\xa0w\xa4\n
   s>     /\x04\x916Y\xae\xf0\xdaB\xdaIdeltasize\x0fDnodeT\x9a8\x12)\x97\xb3\xac\x97\xbe*\x9a\xa2\xe5V\x83\x83A\xfd\xf2\xccO\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x03a1\n
   s>     \r\n
   received frame(size=102; request=1; stream=2; streamflags=; type=command-response; flags=continuation)
   s>     8\r\n
   s>     \x00\x00\x00\x01\x00\x02\x002
   s>     \r\n
   s>     0\r\n
   s>     \r\n
   received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos)
   response: gen[
     {
       b'totalitems': 1
     },
     {
       b'deltabasenode': b'+N\xb0s\x19\xbf\xa0w\xa4\n/\x04\x916Y\xae\xf0\xdaB\xda',
       b'deltasize': 15,
       b'node': b'\x9a8\x12)\x97\xb3\xac\x97\xbe*\x9a\xa2\xe5V\x83\x83A\xfd\xf2\xcc'
     },
     b'\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x03a1\n'
   ]
 
 Requesting multiple revisions works
-(first revision should be fulltext, subsequents are deltas)
+(first revision is a fulltext since haveparents=False by default)
 
   $ sendhttpv2peer << EOF
   > command filedata
   >     nodes eval:['\x2b\x4e\xb0\x73\x19\xbf\xa0\x77\xa4\x0a\x2f\x04\x91\x36\x59\xae\xf0\xda\x42\xda', '\x9a\x38\x12\x29\x97\xb3\xac\x97\xbe\x2a\x9a\xa2\xe5\x56\x83\x83\x41\xfd\xf2\xcc']
   >     path eval:b'a'
   >     fields eval:[b'revision']
   > EOF
   creating http peer for wire protocol version 2
   sending filedata command
   s>     POST /api/exp-http-v2-0001/ro/filedata HTTP/1.1\r\n
   s>     Accept-Encoding: identity\r\n
   s>     accept: application/mercurial-exp-framing-0005\r\n
   s>     content-type: application/mercurial-exp-framing-0005\r\n
   s>     content-length: 102\r\n
   s>     host: $LOCALIP:$HGPORT\r\n (glob)
   s>     user-agent: Mercurial debugwireproto\r\n
   s>     \r\n
   s>     ^\x00\x00\x01\x00\x01\x01\x11\xa2Dargs\xa3Ffields\x81HrevisionEnodes\x82T+N\xb0s\x19\xbf\xa0w\xa4\n
   s>     /\x04\x916Y\xae\xf0\xdaB\xdaT\x9a8\x12)\x97\xb3\xac\x97\xbe*\x9a\xa2\xe5V\x83\x83A\xfd\xf2\xccDpathAaDnameHfiledata
   s> makefile('rb', None)
   s>     HTTP/1.1 200 OK\r\n
   s>     Server: testing stub value\r\n
   s>     Date: $HTTP_DATE$\r\n
   s>     Content-Type: application/mercurial-exp-framing-0005\r\n
   s>     Transfer-Encoding: chunked\r\n
   s>     \r\n
   s>     13\r\n
   s>     \x0b\x00\x00\x01\x00\x02\x011
   s>     \xa1FstatusBok
   s>     \r\n
   received frame(size=11; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=continuation)
   s>     9b\r\n
   s>     \x93\x00\x00\x01\x00\x02\x001
   s>     \xa1Jtotalitems\x02\xa2DnodeT+N\xb0s\x19\xbf\xa0w\xa4\n
   s>     /\x04\x916Y\xae\xf0\xdaB\xdaLrevisionsize\x03Ca0\n
   s>     \xa3MdeltabasenodeT+N\xb0s\x19\xbf\xa0w\xa4\n
   s>     /\x04\x916Y\xae\xf0\xdaB\xdaIdeltasize\x0fDnodeT\x9a8\x12)\x97\xb3\xac\x97\xbe*\x9a\xa2\xe5V\x83\x83A\xfd\xf2\xccO\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x03a1\n
   s>     \r\n
   received frame(size=147; request=1; stream=2; streamflags=; type=command-response; flags=continuation)
   s>     8\r\n
   s>     \x00\x00\x00\x01\x00\x02\x002
   s>     \r\n
   s>     0\r\n
   s>     \r\n
   received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos)
   response: gen[
     {
       b'totalitems': 2
     },
     {
       b'node': b'+N\xb0s\x19\xbf\xa0w\xa4\n/\x04\x916Y\xae\xf0\xdaB\xda',
       b'revisionsize': 3
     },
     b'a0\n',
     {
       b'deltabasenode': b'+N\xb0s\x19\xbf\xa0w\xa4\n/\x04\x916Y\xae\xf0\xdaB\xda',
       b'deltasize': 15,
       b'node': b'\x9a8\x12)\x97\xb3\xac\x97\xbe*\x9a\xa2\xe5V\x83\x83A\xfd\xf2\xcc'
     },
     b'\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x03a1\n'
   ]
 
 Revisions are sorted by DAG order, parents first
 
   $ sendhttpv2peer << EOF
   > command filedata
   >     nodes eval:['\x9a\x38\x12\x29\x97\xb3\xac\x97\xbe\x2a\x9a\xa2\xe5\x56\x83\x83\x41\xfd\xf2\xcc', '\x2b\x4e\xb0\x73\x19\xbf\xa0\x77\xa4\x0a\x2f\x04\x91\x36\x59\xae\xf0\xda\x42\xda']
   >     path eval:b'a'
   >     fields eval:[b'revision']
   > EOF
   creating http peer for wire protocol version 2
   sending filedata command
   s>     POST /api/exp-http-v2-0001/ro/filedata HTTP/1.1\r\n
   s>     Accept-Encoding: identity\r\n
   s>     accept: application/mercurial-exp-framing-0005\r\n
   s>     content-type: application/mercurial-exp-framing-0005\r\n
   s>     content-length: 102\r\n
   s>     host: $LOCALIP:$HGPORT\r\n (glob)
   s>     user-agent: Mercurial debugwireproto\r\n
   s>     \r\n
   s>     ^\x00\x00\x01\x00\x01\x01\x11\xa2Dargs\xa3Ffields\x81HrevisionEnodes\x82T\x9a8\x12)\x97\xb3\xac\x97\xbe*\x9a\xa2\xe5V\x83\x83A\xfd\xf2\xccT+N\xb0s\x19\xbf\xa0w\xa4\n
   s>     /\x04\x916Y\xae\xf0\xdaB\xdaDpathAaDnameHfiledata
   s> makefile('rb', None)
   s>     HTTP/1.1 200 OK\r\n
   s>     Server: testing stub value\r\n
   s>     Date: $HTTP_DATE$\r\n
   s>     Content-Type: application/mercurial-exp-framing-0005\r\n
   s>     Transfer-Encoding: chunked\r\n
   s>     \r\n
   s>     13\r\n
   s>     \x0b\x00\x00\x01\x00\x02\x011
   s>     \xa1FstatusBok
   s>     \r\n
   received frame(size=11; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=continuation)
   s>     9b\r\n
   s>     \x93\x00\x00\x01\x00\x02\x001
   s>     \xa1Jtotalitems\x02\xa2DnodeT+N\xb0s\x19\xbf\xa0w\xa4\n
   s>     /\x04\x916Y\xae\xf0\xdaB\xdaLrevisionsize\x03Ca0\n
   s>     \xa3MdeltabasenodeT+N\xb0s\x19\xbf\xa0w\xa4\n
   s>     /\x04\x916Y\xae\xf0\xdaB\xdaIdeltasize\x0fDnodeT\x9a8\x12)\x97\xb3\xac\x97\xbe*\x9a\xa2\xe5V\x83\x83A\xfd\xf2\xccO\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x03a1\n
   s>     \r\n
   received frame(size=147; request=1; stream=2; streamflags=; type=command-response; flags=continuation)
   s>     8\r\n
   s>     \x00\x00\x00\x01\x00\x02\x002
   s>     \r\n
   s>     0\r\n
   s>     \r\n
   received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos)
   response: gen[
     {
       b'totalitems': 2
     },
     {
       b'node': b'+N\xb0s\x19\xbf\xa0w\xa4\n/\x04\x916Y\xae\xf0\xdaB\xda',
       b'revisionsize': 3
     },
     b'a0\n',
     {
       b'deltabasenode': b'+N\xb0s\x19\xbf\xa0w\xa4\n/\x04\x916Y\xae\xf0\xdaB\xda',
       b'deltasize': 15,
       b'node': b'\x9a8\x12)\x97\xb3\xac\x97\xbe*\x9a\xa2\xe5V\x83\x83A\xfd\xf2\xcc'
     },
     b'\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x03a1\n'
   ]
 
 Requesting parents and revision data works
 
   $ sendhttpv2peer << EOF
   > command filedata
   >     nodes eval:['\x08\x79\x34\x5e\x39\x37\x72\x29\x63\x4b\x42\x0c\x63\x94\x54\x15\x67\x26\xc6\xb6']
   >     path eval:b'a'
   >     fields eval:[b'parents', b'revision']
   > EOF
   creating http peer for wire protocol version 2
   sending filedata command
   s>     POST /api/exp-http-v2-0001/ro/filedata HTTP/1.1\r\n
   s>     Accept-Encoding: identity\r\n
   s>     accept: application/mercurial-exp-framing-0005\r\n
   s>     content-type: application/mercurial-exp-framing-0005\r\n
   s>     content-length: 89\r\n
   s>     host: $LOCALIP:$HGPORT\r\n (glob)
   s>     user-agent: Mercurial debugwireproto\r\n
   s>     \r\n
   s>     Q\x00\x00\x01\x00\x01\x01\x11\xa2Dargs\xa3Ffields\x82GparentsHrevisionEnodes\x81T\x08y4^97r)cKB\x0cc\x94T\x15g&\xc6\xb6DpathAaDnameHfiledata
   s> makefile('rb', None)
   s>     HTTP/1.1 200 OK\r\n
   s>     Server: testing stub value\r\n
   s>     Date: $HTTP_DATE$\r\n
   s>     Content-Type: application/mercurial-exp-framing-0005\r\n
   s>     Transfer-Encoding: chunked\r\n
   s>     \r\n
   s>     13\r\n
   s>     \x0b\x00\x00\x01\x00\x02\x011
   s>     \xa1FstatusBok
   s>     \r\n
   received frame(size=11; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=continuation)
-  s>     a1\r\n
-  s>     \x99\x00\x00\x01\x00\x02\x001
-  s>     \xa1Jtotalitems\x01\xa4MdeltabasenodeT+N\xb0s\x19\xbf\xa0w\xa4\n
-  s>     /\x04\x916Y\xae\xf0\xdaB\xdaIdeltasize\x0fDnodeT\x08y4^97r)cKB\x0cc\x94T\x15g&\xc6\xb6Gparents\x82T+N\xb0s\x19\xbf\xa0w\xa4\n
-  s>     /\x04\x916Y\xae\xf0\xdaB\xdaT\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00O\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x03a2\n
+  s>     75\r\n
+  s>     m\x00\x00\x01\x00\x02\x001
+  s>     \xa1Jtotalitems\x01\xa3DnodeT\x08y4^97r)cKB\x0cc\x94T\x15g&\xc6\xb6Gparents\x82T+N\xb0s\x19\xbf\xa0w\xa4\n
+  s>     /\x04\x916Y\xae\xf0\xdaB\xdaT\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00Lrevisionsize\x03Ca2\n
   s>     \r\n
-  received frame(size=153; request=1; stream=2; streamflags=; type=command-response; flags=continuation)
+  received frame(size=109; request=1; stream=2; streamflags=; type=command-response; flags=continuation)
   s>     8\r\n
   s>     \x00\x00\x00\x01\x00\x02\x002
   s>     \r\n
   s>     0\r\n
   s>     \r\n
   received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos)
   response: gen[
     {
       b'totalitems': 1
     },
     {
-      b'deltabasenode': b'+N\xb0s\x19\xbf\xa0w\xa4\n/\x04\x916Y\xae\xf0\xdaB\xda',
-      b'deltasize': 15,
       b'node': b'\x08y4^97r)cKB\x0cc\x94T\x15g&\xc6\xb6',
       b'parents': [
         b'+N\xb0s\x19\xbf\xa0w\xa4\n/\x04\x916Y\xae\xf0\xdaB\xda',
         b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
-      ]
+      ],
+      b'revisionsize': 3
     },
-    b'\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x03a2\n'
+    b'a2\n'
   ]
 
   $ cat error.log

tests/test-wireproto-command-manifestdata.t

@@ -1,507 +1,694
   $ . $TESTDIR/wireprotohelpers.sh
 
   $ hg init server
   $ enablehttpv2 server
   $ cd server
   $ echo a0 > a
   $ echo b0 > b
   $ mkdir -p dir0/child0 dir0/child1 dir1
   $ echo c0 > dir0/c
   $ echo d0 > dir0/d
   $ echo e0 > dir0/child0/e
   $ echo f0 > dir0/child1/f
   $ hg -q commit -A -m 'commit 0'
 
   $ echo a1 > a
   $ echo d1 > dir0/d
   $ hg commit -m 'commit 1'
   $ echo f0 > dir0/child1/f
   $ hg commit -m 'commit 2'
   nothing changed
   [1]
 
   $ hg -q up -r 0
   $ echo a2 > a
   $ hg commit -m 'commit 3'
   created new head
 
   $ hg log -G -T '{rev}:{node} {desc}\n'
   @  2:c8757a2ffe552850d1e0dfe60d295ebf64c196d9 commit 3
   |
   | o  1:650165e803375748a94df471e5b58d85763e0b29 commit 1
   |/
   o  0:6d85ca1270b377d320098556ba5bfad34a9ee12d commit 0
   
 
   $ hg --debug debugindex -m
      rev linkrev nodeid                                   p1                                       p2
        0       0 1b175b595f022cfab5b809cc0ed551bd0b3ff5e4 0000000000000000000000000000000000000000 0000000000000000000000000000000000000000
        1       1 91e0bdbfb0dde0023fa063edc1445f207a22eac7 1b175b595f022cfab5b809cc0ed551bd0b3ff5e4 0000000000000000000000000000000000000000
        2       2 46a6721b5edaf0ea04b79a5cb3218854a4d2aba0 1b175b595f022cfab5b809cc0ed551bd0b3ff5e4 0000000000000000000000000000000000000000
 
   $ hg serve -p $HGPORT -d --pid-file hg.pid -E error.log
   $ cat hg.pid > $DAEMON_PIDS
 
 Missing arguments is an error
 
   $ sendhttpv2peer << EOF
   > command manifestdata
   > EOF
   creating http peer for wire protocol version 2
   sending manifestdata command
   s>     POST /api/exp-http-v2-0001/ro/manifestdata HTTP/1.1\r\n
   s>     Accept-Encoding: identity\r\n
   s>     accept: application/mercurial-exp-framing-0005\r\n
   s>     content-type: application/mercurial-exp-framing-0005\r\n
   s>     content-length: 27\r\n
   s>     host: $LOCALIP:$HGPORT\r\n (glob)
   s>     user-agent: Mercurial debugwireproto\r\n
   s>     \r\n
   s>     \x13\x00\x00\x01\x00\x01\x01\x11\xa1DnameLmanifestdata
   s> makefile('rb', None)
   s>     HTTP/1.1 200 OK\r\n
   s>     Server: testing stub value\r\n
   s>     Date: $HTTP_DATE$\r\n
   s>     Content-Type: application/mercurial-exp-framing-0005\r\n
   s>     Transfer-Encoding: chunked\r\n
   s>     \r\n
   s>     45\r\n
   s>     =\x00\x00\x01\x00\x02\x012
   s>     \xa2Eerror\xa1GmessageX\x1enodes argument must be definedFstatusEerror
   s>     \r\n
   received frame(size=61; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=eos)
   s>     0\r\n
   s>     \r\n
   abort: nodes argument must be defined!
   [255]
 
   $ sendhttpv2peer << EOF
   > command manifestdata
   >     nodes eval:[]
   > EOF
   creating http peer for wire protocol version 2
   sending manifestdata command
   s>     POST /api/exp-http-v2-0001/ro/manifestdata HTTP/1.1\r\n
   s>     Accept-Encoding: identity\r\n
   s>     accept: application/mercurial-exp-framing-0005\r\n
   s>     content-type: application/mercurial-exp-framing-0005\r\n
   s>     content-length: 40\r\n
   s>     host: $LOCALIP:$HGPORT\r\n (glob)
   s>     user-agent: Mercurial debugwireproto\r\n
   s>     \r\n
   s>      \x00\x00\x01\x00\x01\x01\x11\xa2Dargs\xa1Enodes\x80DnameLmanifestdata
   s> makefile('rb', None)
   s>     HTTP/1.1 200 OK\r\n
   s>     Server: testing stub value\r\n
   s>     Date: $HTTP_DATE$\r\n
   s>     Content-Type: application/mercurial-exp-framing-0005\r\n
   s>     Transfer-Encoding: chunked\r\n
   s>     \r\n
   s>     44\r\n
   s>     <\x00\x00\x01\x00\x02\x012
   s>     \xa2Eerror\xa1GmessageX\x1dtree argument must be definedFstatusEerror
   s>     \r\n
   received frame(size=60; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=eos)
   s>     0\r\n
   s>     \r\n
   abort: tree argument must be defined!
   [255]
 
 Unknown node is an error
 
   $ sendhttpv2peer << EOF
   > command manifestdata
   >     nodes eval:[b'\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa']
   >     tree eval:b''
   > EOF
   creating http peer for wire protocol version 2
   sending manifestdata command
   s>     POST /api/exp-http-v2-0001/ro/manifestdata HTTP/1.1\r\n
   s>     Accept-Encoding: identity\r\n
   s>     accept: application/mercurial-exp-framing-0005\r\n
   s>     content-type: application/mercurial-exp-framing-0005\r\n
   s>     content-length: 67\r\n
   s>     host: $LOCALIP:$HGPORT\r\n (glob)
   s>     user-agent: Mercurial debugwireproto\r\n
   s>     \r\n
   s>     ;\x00\x00\x01\x00\x01\x01\x11\xa2Dargs\xa2Enodes\x81T\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaaDtree@DnameLmanifestdata
   s> makefile('rb', None)
   s>     HTTP/1.1 200 OK\r\n
   s>     Server: testing stub value\r\n
   s>     Date: $HTTP_DATE$\r\n
   s>     Content-Type: application/mercurial-exp-framing-0005\r\n
   s>     Transfer-Encoding: chunked\r\n
   s>     \r\n
   s>     51\r\n
   s>     I\x00\x00\x01\x00\x02\x012
   s>     \xa2Eerror\xa2Dargs\x81T\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaaGmessagePunknown node: %sFstatusEerror
   s>     \r\n
   received frame(size=73; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=eos)
   s>     0\r\n
   s>     \r\n
   abort: unknown node: \xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa! (esc)
   [255]
 
 Fetching a single revision returns just metadata by default
 
   $ sendhttpv2peer << EOF
   > command manifestdata
   >     nodes eval:[b'\x46\xa6\x72\x1b\x5e\xda\xf0\xea\x04\xb7\x9a\x5c\xb3\x21\x88\x54\xa4\xd2\xab\xa0']
   >     tree eval:b''
   > EOF
   creating http peer for wire protocol version 2
   sending manifestdata command
   s>     POST /api/exp-http-v2-0001/ro/manifestdata HTTP/1.1\r\n
   s>     Accept-Encoding: identity\r\n
   s>     accept: application/mercurial-exp-framing-0005\r\n
   s>     content-type: application/mercurial-exp-framing-0005\r\n
   s>     content-length: 67\r\n
   s>     host: $LOCALIP:$HGPORT\r\n (glob)
   s>     user-agent: Mercurial debugwireproto\r\n
   s>     \r\n
   s>     ;\x00\x00\x01\x00\x01\x01\x11\xa2Dargs\xa2Enodes\x81TF\xa6r\x1b^\xda\xf0\xea\x04\xb7\x9a\\\xb3!\x88T\xa4\xd2\xab\xa0Dtree@DnameLmanifestdata
   s> makefile('rb', None)
   s>     HTTP/1.1 200 OK\r\n
   s>     Server: testing stub value\r\n
   s>     Date: $HTTP_DATE$\r\n
   s>     Content-Type: application/mercurial-exp-framing-0005\r\n
   s>     Transfer-Encoding: chunked\r\n
   s>     \r\n
   s>     13\r\n
   s>     \x0b\x00\x00\x01\x00\x02\x011
   s>     \xa1FstatusBok
   s>     \r\n
   received frame(size=11; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=continuation)
   s>     30\r\n
   s>     (\x00\x00\x01\x00\x02\x001
   s>     \xa1Jtotalitems\x01\xa1DnodeTF\xa6r\x1b^\xda\xf0\xea\x04\xb7\x9a\\\xb3!\x88T\xa4\xd2\xab\xa0
   s>     \r\n
   received frame(size=40; request=1; stream=2; streamflags=; type=command-response; flags=continuation)
   s>     8\r\n
   s>     \x00\x00\x00\x01\x00\x02\x002
   s>     \r\n
   s>     0\r\n
   s>     \r\n
   received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos)
   response: gen[
     {
       b'totalitems': 1
     },
     {
       b'node': b'F\xa6r\x1b^\xda\xf0\xea\x04\xb7\x9a\\\xb3!\x88T\xa4\xd2\xab\xa0'
     }
   ]
 
 Requesting parents works
 
   $ sendhttpv2peer << EOF
   > command manifestdata
   >     nodes eval:[b'\x46\xa6\x72\x1b\x5e\xda\xf0\xea\x04\xb7\x9a\x5c\xb3\x21\x88\x54\xa4\xd2\xab\xa0']
   >     tree eval:b''
   >     fields eval:[b'parents']
   > EOF
   creating http peer for wire protocol version 2
   sending manifestdata command
   s>     POST /api/exp-http-v2-0001/ro/manifestdata HTTP/1.1\r\n
   s>     Accept-Encoding: identity\r\n
   s>     accept: application/mercurial-exp-framing-0005\r\n
   s>     content-type: application/mercurial-exp-framing-0005\r\n
   s>     content-length: 83\r\n
   s>     host: $LOCALIP:$HGPORT\r\n (glob)
   s>     user-agent: Mercurial debugwireproto\r\n
   s>     \r\n
   s>     K\x00\x00\x01\x00\x01\x01\x11\xa2Dargs\xa3Ffields\x81GparentsEnodes\x81TF\xa6r\x1b^\xda\xf0\xea\x04\xb7\x9a\\\xb3!\x88T\xa4\xd2\xab\xa0Dtree@DnameLmanifestdata
   s> makefile('rb', None)
   s>     HTTP/1.1 200 OK\r\n
   s>     Server: testing stub value\r\n
   s>     Date: $HTTP_DATE$\r\n
   s>     Content-Type: application/mercurial-exp-framing-0005\r\n
   s>     Transfer-Encoding: chunked\r\n
   s>     \r\n
   s>     13\r\n
   s>     \x0b\x00\x00\x01\x00\x02\x011
   s>     \xa1FstatusBok
   s>     \r\n
   received frame(size=11; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=continuation)
   s>     63\r\n
   s>     [\x00\x00\x01\x00\x02\x001
   s>     \xa1Jtotalitems\x01\xa2DnodeTF\xa6r\x1b^\xda\xf0\xea\x04\xb7\x9a\\\xb3!\x88T\xa4\xd2\xab\xa0Gparents\x82T\x1b\x17[Y_\x02,\xfa\xb5\xb8\t\xcc\x0e\xd5Q\xbd\x0b?\xf5\xe4T\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00
   s>     \r\n
   received frame(size=91; request=1; stream=2; streamflags=; type=command-response; flags=continuation)
   s>     8\r\n
   s>     \x00\x00\x00\x01\x00\x02\x002
   s>     \r\n
   s>     0\r\n
   s>     \r\n
   received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos)
   response: gen[
     {
       b'totalitems': 1
     },
     {
       b'node': b'F\xa6r\x1b^\xda\xf0\xea\x04\xb7\x9a\\\xb3!\x88T\xa4\xd2\xab\xa0',
       b'parents': [
         b'\x1b\x17[Y_\x02,\xfa\xb5\xb8\t\xcc\x0e\xd5Q\xbd\x0b?\xf5\xe4',
         b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
       ]
     }
   ]
 
 Requesting revision data works
+(haveparents defaults to false, so fulltext is emitted)
 
   $ sendhttpv2peer << EOF
   > command manifestdata
   >     nodes eval:[b'\x46\xa6\x72\x1b\x5e\xda\xf0\xea\x04\xb7\x9a\x5c\xb3\x21\x88\x54\xa4\xd2\xab\xa0']
   >     tree eval:b''
   >     fields eval:[b'revision']
   > EOF
   creating http peer for wire protocol version 2
   sending manifestdata command
   s>     POST /api/exp-http-v2-0001/ro/manifestdata HTTP/1.1\r\n
   s>     Accept-Encoding: identity\r\n
   s>     accept: application/mercurial-exp-framing-0005\r\n
   s>     content-type: application/mercurial-exp-framing-0005\r\n
   s>     content-length: 84\r\n
   s>     host: $LOCALIP:$HGPORT\r\n (glob)
   s>     user-agent: Mercurial debugwireproto\r\n
   s>     \r\n
   s>     L\x00\x00\x01\x00\x01\x01\x11\xa2Dargs\xa3Ffields\x81HrevisionEnodes\x81TF\xa6r\x1b^\xda\xf0\xea\x04\xb7\x9a\\\xb3!\x88T\xa4\xd2\xab\xa0Dtree@DnameLmanifestdata
   s> makefile('rb', None)
   s>     HTTP/1.1 200 OK\r\n
   s>     Server: testing stub value\r\n
   s>     Date: $HTTP_DATE$\r\n
   s>     Content-Type: application/mercurial-exp-framing-0005\r\n
   s>     Transfer-Encoding: chunked\r\n
   s>     \r\n
   s>     13\r\n
   s>     \x0b\x00\x00\x01\x00\x02\x011
   s>     \xa1FstatusBok
   s>     \r\n
   received frame(size=11; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=continuation)
+  s>     167\r\n
+  s>     _\x01\x00\x01\x00\x02\x001
+  s>     \xa1Jtotalitems\x01\xa2DnodeTF\xa6r\x1b^\xda\xf0\xea\x04\xb7\x9a\\\xb3!\x88T\xa4\xd2\xab\xa0Lrevisionsize\x19\x01$Y\x01$a\x000879345e39377229634b420c639454156726c6b6\n
+  s>     b\x00819e258d31a5e1606629f365bb902a1b21ee4216\n
+  s>     dir0/c\x00914445346a0ca0629bd47ceb5dfe07e4d4cf2501\n
+  s>     dir0/child0/e\x00bbba6c06b30f443d34ff841bc985c4d0827c6be4\n
+  s>     dir0/child1/f\x0012fc7dcd773b5a0a929ce195228083c6ddc9cec4\n
+  s>     dir0/d\x00538206dc971e521540d6843abfe6d16032f6d426\n
+  s>     \r\n
+  received frame(size=351; request=1; stream=2; streamflags=; type=command-response; flags=continuation)
+  s>     8\r\n
+  s>     \x00\x00\x00\x01\x00\x02\x002
+  s>     \r\n
+  s>     0\r\n
+  s>     \r\n
+  received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos)
+  response: gen[
+    {
+      b'totalitems': 1
+    },
+    {
+      b'node': b'F\xa6r\x1b^\xda\xf0\xea\x04\xb7\x9a\\\xb3!\x88T\xa4\xd2\xab\xa0',
+      b'revisionsize': 292
+    },
+    b'a\x000879345e39377229634b420c639454156726c6b6\nb\x00819e258d31a5e1606629f365bb902a1b21ee4216\ndir0/c\x00914445346a0ca0629bd47ceb5dfe07e4d4cf2501\ndir0/child0/e\x00bbba6c06b30f443d34ff841bc985c4d0827c6be4\ndir0/child1/f\x0012fc7dcd773b5a0a929ce195228083c6ddc9cec4\ndir0/d\x00538206dc971e521540d6843abfe6d16032f6d426\n'
+  ]
+
+haveparents=False yields same output
+
+  $ sendhttpv2peer << EOF
+  > command manifestdata
+  >     nodes eval:[b'\x46\xa6\x72\x1b\x5e\xda\xf0\xea\x04\xb7\x9a\x5c\xb3\x21\x88\x54\xa4\xd2\xab\xa0']
+  >     tree eval:b''
+  >     fields eval:[b'revision']
+  >     haveparents eval:False
+  > EOF
+  creating http peer for wire protocol version 2
+  sending manifestdata command
+  s>     POST /api/exp-http-v2-0001/ro/manifestdata HTTP/1.1\r\n
+  s>     Accept-Encoding: identity\r\n
+  s>     accept: application/mercurial-exp-framing-0005\r\n
+  s>     content-type: application/mercurial-exp-framing-0005\r\n
+  s>     content-length: 97\r\n
+  s>     host: $LOCALIP:$HGPORT\r\n (glob)
+  s>     user-agent: Mercurial debugwireproto\r\n
+  s>     \r\n
+  s>     Y\x00\x00\x01\x00\x01\x01\x11\xa2Dargs\xa4Ffields\x81HrevisionKhaveparents\xf4Enodes\x81TF\xa6r\x1b^\xda\xf0\xea\x04\xb7\x9a\\\xb3!\x88T\xa4\xd2\xab\xa0Dtree@DnameLmanifestdata
+  s> makefile('rb', None)
+  s>     HTTP/1.1 200 OK\r\n
+  s>     Server: testing stub value\r\n
+  s>     Date: $HTTP_DATE$\r\n
+  s>     Content-Type: application/mercurial-exp-framing-0005\r\n
+  s>     Transfer-Encoding: chunked\r\n
+  s>     \r\n
+  s>     13\r\n
+  s>     \x0b\x00\x00\x01\x00\x02\x011
+  s>     \xa1FstatusBok
+  s>     \r\n
+  received frame(size=11; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=continuation)
+  s>     167\r\n
+  s>     _\x01\x00\x01\x00\x02\x001
+  s>     \xa1Jtotalitems\x01\xa2DnodeTF\xa6r\x1b^\xda\xf0\xea\x04\xb7\x9a\\\xb3!\x88T\xa4\xd2\xab\xa0Lrevisionsize\x19\x01$Y\x01$a\x000879345e39377229634b420c639454156726c6b6\n
+  s>     b\x00819e258d31a5e1606629f365bb902a1b21ee4216\n
+  s>     dir0/c\x00914445346a0ca0629bd47ceb5dfe07e4d4cf2501\n
+  s>     dir0/child0/e\x00bbba6c06b30f443d34ff841bc985c4d0827c6be4\n
+  s>     dir0/child1/f\x0012fc7dcd773b5a0a929ce195228083c6ddc9cec4\n
+  s>     dir0/d\x00538206dc971e521540d6843abfe6d16032f6d426\n
+  s>     \r\n
+  received frame(size=351; request=1; stream=2; streamflags=; type=command-response; flags=continuation)
+  s>     8\r\n
+  s>     \x00\x00\x00\x01\x00\x02\x002
+  s>     \r\n
+  s>     0\r\n
+  s>     \r\n
+  received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos)
+  response: gen[
+    {
+      b'totalitems': 1
+    },
+    {
+      b'node': b'F\xa6r\x1b^\xda\xf0\xea\x04\xb7\x9a\\\xb3!\x88T\xa4\xd2\xab\xa0',
+      b'revisionsize': 292
+    },
+    b'a\x000879345e39377229634b420c639454156726c6b6\nb\x00819e258d31a5e1606629f365bb902a1b21ee4216\ndir0/c\x00914445346a0ca0629bd47ceb5dfe07e4d4cf2501\ndir0/child0/e\x00bbba6c06b30f443d34ff841bc985c4d0827c6be4\ndir0/child1/f\x0012fc7dcd773b5a0a929ce195228083c6ddc9cec4\ndir0/d\x00538206dc971e521540d6843abfe6d16032f6d426\n'
+  ]
+
+haveparents=True will emit delta
+
+  $ sendhttpv2peer << EOF
+  > command manifestdata
+  >     nodes eval:[b'\x46\xa6\x72\x1b\x5e\xda\xf0\xea\x04\xb7\x9a\x5c\xb3\x21\x88\x54\xa4\xd2\xab\xa0']
+  >     tree eval:b''
+  >     fields eval:[b'revision']
+  >     haveparents eval:True
+  > EOF
+  creating http peer for wire protocol version 2
+  sending manifestdata command
+  s>     POST /api/exp-http-v2-0001/ro/manifestdata HTTP/1.1\r\n
+  s>     Accept-Encoding: identity\r\n
+  s>     accept: application/mercurial-exp-framing-0005\r\n
+  s>     content-type: application/mercurial-exp-framing-0005\r\n
+  s>     content-length: 97\r\n
+  s>     host: $LOCALIP:$HGPORT\r\n (glob)
+  s>     user-agent: Mercurial debugwireproto\r\n
+  s>     \r\n
+  s>     Y\x00\x00\x01\x00\x01\x01\x11\xa2Dargs\xa4Ffields\x81HrevisionKhaveparents\xf5Enodes\x81TF\xa6r\x1b^\xda\xf0\xea\x04\xb7\x9a\\\xb3!\x88T\xa4\xd2\xab\xa0Dtree@DnameLmanifestdata
+  s> makefile('rb', None)
+  s>     HTTP/1.1 200 OK\r\n
+  s>     Server: testing stub value\r\n
+  s>     Date: $HTTP_DATE$\r\n
+  s>     Content-Type: application/mercurial-exp-framing-0005\r\n
+  s>     Transfer-Encoding: chunked\r\n
+  s>     \r\n
+  s>     13\r\n
+  s>     \x0b\x00\x00\x01\x00\x02\x011
+  s>     \xa1FstatusBok
+  s>     \r\n
+  received frame(size=11; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=continuation)
   s>     98\r\n
   s>     \x90\x00\x00\x01\x00\x02\x001
   s>     \xa1Jtotalitems\x01\xa3MdeltabasenodeT\x1b\x17[Y_\x02,\xfa\xb5\xb8\t\xcc\x0e\xd5Q\xbd\x0b?\xf5\xe4Ideltasize\x187DnodeTF\xa6r\x1b^\xda\xf0\xea\x04\xb7\x9a\\\xb3!\x88T\xa4\xd2\xab\xa0X7\x00\x00\x00\x00\x00\x00\x00+\x00\x00\x00+a\x000879345e39377229634b420c639454156726c6b6\n
   s>     \r\n
   received frame(size=144; request=1; stream=2; streamflags=; type=command-response; flags=continuation)
   s>     8\r\n
   s>     \x00\x00\x00\x01\x00\x02\x002
   s>     \r\n
   s>     0\r\n
   s>     \r\n
   received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos)
   response: gen[
     {
       b'totalitems': 1
     },
     {
       b'deltabasenode': b'\x1b\x17[Y_\x02,\xfa\xb5\xb8\t\xcc\x0e\xd5Q\xbd\x0b?\xf5\xe4',
       b'deltasize': 55,
       b'node': b'F\xa6r\x1b^\xda\xf0\xea\x04\xb7\x9a\\\xb3!\x88T\xa4\xd2\xab\xa0'
     },
     b'\x00\x00\x00\x00\x00\x00\x00+\x00\x00\x00+a\x000879345e39377229634b420c639454156726c6b6\n'
   ]
 
 Requesting multiple revisions works
+(haveparents defaults to false, so fulltext is emitted unless a parent
+has been emitted)
 
   $ sendhttpv2peer << EOF
   > command manifestdata
   >     nodes eval:[b'\x1b\x17\x5b\x59\x5f\x02\x2c\xfa\xb5\xb8\x09\xcc\x0e\xd5\x51\xbd\x0b\x3f\xf5\xe4', b'\x46\xa6\x72\x1b\x5e\xda\xf0\xea\x04\xb7\x9a\x5c\xb3\x21\x88\x54\xa4\xd2\xab\xa0']
   >     tree eval:b''
   >     fields eval:[b'revision']
   > EOF
   creating http peer for wire protocol version 2
   sending manifestdata command
   s>     POST /api/exp-http-v2-0001/ro/manifestdata HTTP/1.1\r\n
   s>     Accept-Encoding: identity\r\n
   s>     accept: application/mercurial-exp-framing-0005\r\n
   s>     content-type: application/mercurial-exp-framing-0005\r\n
   s>     content-length: 105\r\n
   s>     host: $LOCALIP:$HGPORT\r\n (glob)
   s>     user-agent: Mercurial debugwireproto\r\n
   s>     \r\n
   s>     a\x00\x00\x01\x00\x01\x01\x11\xa2Dargs\xa3Ffields\x81HrevisionEnodes\x82T\x1b\x17[Y_\x02,\xfa\xb5\xb8\t\xcc\x0e\xd5Q\xbd\x0b?\xf5\xe4TF\xa6r\x1b^\xda\xf0\xea\x04\xb7\x9a\\\xb3!\x88T\xa4\xd2\xab\xa0Dtree@DnameLmanifestdata
   s> makefile('rb', None)
   s>     HTTP/1.1 200 OK\r\n
   s>     Server: testing stub value\r\n
   s>     Date: $HTTP_DATE$\r\n
   s>     Content-Type: application/mercurial-exp-framing-0005\r\n
   s>     Transfer-Encoding: chunked\r\n
   s>     \r\n
   s>     13\r\n
   s>     \x0b\x00\x00\x01\x00\x02\x011
   s>     \xa1FstatusBok
   s>     \r\n
   received frame(size=11; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=continuation)
   s>     1ea\r\n
   s>     \xe2\x01\x00\x01\x00\x02\x001
   s>     \xa1Jtotalitems\x02\xa2DnodeT\x1b\x17[Y_\x02,\xfa\xb5\xb8\t\xcc\x0e\xd5Q\xbd\x0b?\xf5\xe4Lrevisionsize\x19\x01$Y\x01$a\x002b4eb07319bfa077a40a2f04913659aef0da42da\n
   s>     b\x00819e258d31a5e1606629f365bb902a1b21ee4216\n
   s>     dir0/c\x00914445346a0ca0629bd47ceb5dfe07e4d4cf2501\n
   s>     dir0/child0/e\x00bbba6c06b30f443d34ff841bc985c4d0827c6be4\n
   s>     dir0/child1/f\x0012fc7dcd773b5a0a929ce195228083c6ddc9cec4\n
   s>     dir0/d\x00538206dc971e521540d6843abfe6d16032f6d426\n
   s>     \xa3MdeltabasenodeT\x1b\x17[Y_\x02,\xfa\xb5\xb8\t\xcc\x0e\xd5Q\xbd\x0b?\xf5\xe4Ideltasize\x187DnodeTF\xa6r\x1b^\xda\xf0\xea\x04\xb7\x9a\\\xb3!\x88T\xa4\xd2\xab\xa0X7\x00\x00\x00\x00\x00\x00\x00+\x00\x00\x00+a\x000879345e39377229634b420c639454156726c6b6\n
   s>     \r\n
   received frame(size=482; request=1; stream=2; streamflags=; type=command-response; flags=continuation)
   s>     8\r\n
   s>     \x00\x00\x00\x01\x00\x02\x002
   s>     \r\n
   s>     0\r\n
   s>     \r\n
   received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos)
   response: gen[
     {
       b'totalitems': 2
     },
     {
       b'node': b'\x1b\x17[Y_\x02,\xfa\xb5\xb8\t\xcc\x0e\xd5Q\xbd\x0b?\xf5\xe4',
       b'revisionsize': 292
     },
     b'a\x002b4eb07319bfa077a40a2f04913659aef0da42da\nb\x00819e258d31a5e1606629f365bb902a1b21ee4216\ndir0/c\x00914445346a0ca0629bd47ceb5dfe07e4d4cf2501\ndir0/child0/e\x00bbba6c06b30f443d34ff841bc985c4d0827c6be4\ndir0/child1/f\x0012fc7dcd773b5a0a929ce195228083c6ddc9cec4\ndir0/d\x00538206dc971e521540d6843abfe6d16032f6d426\n',
     {
       b'deltabasenode': b'\x1b\x17[Y_\x02,\xfa\xb5\xb8\t\xcc\x0e\xd5Q\xbd\x0b?\xf5\xe4',
       b'deltasize': 55,
       b'node': b'F\xa6r\x1b^\xda\xf0\xea\x04\xb7\x9a\\\xb3!\x88T\xa4\xd2\xab\xa0'
     },
     b'\x00\x00\x00\x00\x00\x00\x00+\x00\x00\x00+a\x000879345e39377229634b420c639454156726c6b6\n'
   ]
 
+With haveparents=True, first revision is a delta instead of fulltext
+
+  $ sendhttpv2peer << EOF
+  > command manifestdata
+  >     nodes eval:[b'\x1b\x17\x5b\x59\x5f\x02\x2c\xfa\xb5\xb8\x09\xcc\x0e\xd5\x51\xbd\x0b\x3f\xf5\xe4', b'\x46\xa6\x72\x1b\x5e\xda\xf0\xea\x04\xb7\x9a\x5c\xb3\x21\x88\x54\xa4\xd2\xab\xa0']
+  >     tree eval:b''
+  >     fields eval:[b'revision']
+  >     haveparents eval:True
+  > EOF
+  creating http peer for wire protocol version 2
+  sending manifestdata command
+  s>     POST /api/exp-http-v2-0001/ro/manifestdata HTTP/1.1\r\n
+  s>     Accept-Encoding: identity\r\n
+  s>     accept: application/mercurial-exp-framing-0005\r\n
+  s>     content-type: application/mercurial-exp-framing-0005\r\n
+  s>     content-length: 118\r\n
+  s>     host: $LOCALIP:$HGPORT\r\n (glob)
+  s>     user-agent: Mercurial debugwireproto\r\n
+  s>     \r\n
+  s>     n\x00\x00\x01\x00\x01\x01\x11\xa2Dargs\xa4Ffields\x81HrevisionKhaveparents\xf5Enodes\x82T\x1b\x17[Y_\x02,\xfa\xb5\xb8\t\xcc\x0e\xd5Q\xbd\x0b?\xf5\xe4TF\xa6r\x1b^\xda\xf0\xea\x04\xb7\x9a\\\xb3!\x88T\xa4\xd2\xab\xa0Dtree@DnameLmanifestdata
+  s> makefile('rb', None)
+  s>     HTTP/1.1 200 OK\r\n
+  s>     Server: testing stub value\r\n
+  s>     Date: $HTTP_DATE$\r\n
+  s>     Content-Type: application/mercurial-exp-framing-0005\r\n
+  s>     Transfer-Encoding: chunked\r\n
+  s>     \r\n
+  s>     13\r\n
+  s>     \x0b\x00\x00\x01\x00\x02\x011
+  s>     \xa1FstatusBok
+  s>     \r\n
+  received frame(size=11; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=continuation)
+  s>     1ea\r\n
+  s>     \xe2\x01\x00\x01\x00\x02\x001
+  s>     \xa1Jtotalitems\x02\xa2DnodeT\x1b\x17[Y_\x02,\xfa\xb5\xb8\t\xcc\x0e\xd5Q\xbd\x0b?\xf5\xe4Lrevisionsize\x19\x01$Y\x01$a\x002b4eb07319bfa077a40a2f04913659aef0da42da\n
+  s>     b\x00819e258d31a5e1606629f365bb902a1b21ee4216\n
+  s>     dir0/c\x00914445346a0ca0629bd47ceb5dfe07e4d4cf2501\n
+  s>     dir0/child0/e\x00bbba6c06b30f443d34ff841bc985c4d0827c6be4\n
+  s>     dir0/child1/f\x0012fc7dcd773b5a0a929ce195228083c6ddc9cec4\n
+  s>     dir0/d\x00538206dc971e521540d6843abfe6d16032f6d426\n
+  s>     \xa3MdeltabasenodeT\x1b\x17[Y_\x02,\xfa\xb5\xb8\t\xcc\x0e\xd5Q\xbd\x0b?\xf5\xe4Ideltasize\x187DnodeTF\xa6r\x1b^\xda\xf0\xea\x04\xb7\x9a\\\xb3!\x88T\xa4\xd2\xab\xa0X7\x00\x00\x00\x00\x00\x00\x00+\x00\x00\x00+a\x000879345e39377229634b420c639454156726c6b6\n
+  s>     \r\n
+  received frame(size=482; request=1; stream=2; streamflags=; type=command-response; flags=continuation)
+  s>     8\r\n
+  s>     \x00\x00\x00\x01\x00\x02\x002
+  s>     \r\n
+  s>     0\r\n
+  s>     \r\n
+  received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos)
+  response: gen[
+    {
+      b'totalitems': 2
+    },
+    {
+      b'node': b'\x1b\x17[Y_\x02,\xfa\xb5\xb8\t\xcc\x0e\xd5Q\xbd\x0b?\xf5\xe4',
+      b'revisionsize': 292
+    },
+    b'a\x002b4eb07319bfa077a40a2f04913659aef0da42da\nb\x00819e258d31a5e1606629f365bb902a1b21ee4216\ndir0/c\x00914445346a0ca0629bd47ceb5dfe07e4d4cf2501\ndir0/child0/e\x00bbba6c06b30f443d34ff841bc985c4d0827c6be4\ndir0/child1/f\x0012fc7dcd773b5a0a929ce195228083c6ddc9cec4\ndir0/d\x00538206dc971e521540d6843abfe6d16032f6d426\n',
+    {
+      b'deltabasenode': b'\x1b\x17[Y_\x02,\xfa\xb5\xb8\t\xcc\x0e\xd5Q\xbd\x0b?\xf5\xe4',
+      b'deltasize': 55,
+      b'node': b'F\xa6r\x1b^\xda\xf0\xea\x04\xb7\x9a\\\xb3!\x88T\xa4\xd2\xab\xa0'
+    },
+    b'\x00\x00\x00\x00\x00\x00\x00+\x00\x00\x00+a\x000879345e39377229634b420c639454156726c6b6\n'
+  ]
+
 Revisions are sorted by DAG order, parents first
 
   $ sendhttpv2peer << EOF
   > command manifestdata
   >     nodes eval:[b'\x46\xa6\x72\x1b\x5e\xda\xf0\xea\x04\xb7\x9a\x5c\xb3\x21\x88\x54\xa4\xd2\xab\xa0', b'\x1b\x17\x5b\x59\x5f\x02\x2c\xfa\xb5\xb8\x09\xcc\x0e\xd5\x51\xbd\x0b\x3f\xf5\xe4']
   >     tree eval:b''
   >     fields eval:[b'revision']
   > EOF
   creating http peer for wire protocol version 2
   sending manifestdata command
   s>     POST /api/exp-http-v2-0001/ro/manifestdata HTTP/1.1\r\n
   s>     Accept-Encoding: identity\r\n
   s>     accept: application/mercurial-exp-framing-0005\r\n
   s>     content-type: application/mercurial-exp-framing-0005\r\n
   s>     content-length: 105\r\n
   s>     host: $LOCALIP:$HGPORT\r\n (glob)
   s>     user-agent: Mercurial debugwireproto\r\n
   s>     \r\n
   s>     a\x00\x00\x01\x00\x01\x01\x11\xa2Dargs\xa3Ffields\x81HrevisionEnodes\x82TF\xa6r\x1b^\xda\xf0\xea\x04\xb7\x9a\\\xb3!\x88T\xa4\xd2\xab\xa0T\x1b\x17[Y_\x02,\xfa\xb5\xb8\t\xcc\x0e\xd5Q\xbd\x0b?\xf5\xe4Dtree@DnameLmanifestdata
   s> makefile('rb', None)
   s>     HTTP/1.1 200 OK\r\n
   s>     Server: testing stub value\r\n
   s>     Date: $HTTP_DATE$\r\n
   s>     Content-Type: application/mercurial-exp-framing-0005\r\n
   s>     Transfer-Encoding: chunked\r\n
   s>     \r\n
   s>     13\r\n
   s>     \x0b\x00\x00\x01\x00\x02\x011
   s>     \xa1FstatusBok
   s>     \r\n
   received frame(size=11; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=continuation)
   s>     1ea\r\n
   s>     \xe2\x01\x00\x01\x00\x02\x001
   s>     \xa1Jtotalitems\x02\xa2DnodeT\x1b\x17[Y_\x02,\xfa\xb5\xb8\t\xcc\x0e\xd5Q\xbd\x0b?\xf5\xe4Lrevisionsize\x19\x01$Y\x01$a\x002b4eb07319bfa077a40a2f04913659aef0da42da\n
   s>     b\x00819e258d31a5e1606629f365bb902a1b21ee4216\n
   s>     dir0/c\x00914445346a0ca0629bd47ceb5dfe07e4d4cf2501\n
   s>     dir0/child0/e\x00bbba6c06b30f443d34ff841bc985c4d0827c6be4\n
   s>     dir0/child1/f\x0012fc7dcd773b5a0a929ce195228083c6ddc9cec4\n
   s>     dir0/d\x00538206dc971e521540d6843abfe6d16032f6d426\n
   s>     \xa3MdeltabasenodeT\x1b\x17[Y_\x02,\xfa\xb5\xb8\t\xcc\x0e\xd5Q\xbd\x0b?\xf5\xe4Ideltasize\x187DnodeTF\xa6r\x1b^\xda\xf0\xea\x04\xb7\x9a\\\xb3!\x88T\xa4\xd2\xab\xa0X7\x00\x00\x00\x00\x00\x00\x00+\x00\x00\x00+a\x000879345e39377229634b420c639454156726c6b6\n
   s>     \r\n
   received frame(size=482; request=1; stream=2; streamflags=; type=command-response; flags=continuation)
   s>     8\r\n
   s>     \x00\x00\x00\x01\x00\x02\x002
   s>     \r\n
   s>     0\r\n
   s>     \r\n
   received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos)
   response: gen[
     {
       b'totalitems': 2
     },
     {
       b'node': b'\x1b\x17[Y_\x02,\xfa\xb5\xb8\t\xcc\x0e\xd5Q\xbd\x0b?\xf5\xe4',
       b'revisionsize': 292
     },
     b'a\x002b4eb07319bfa077a40a2f04913659aef0da42da\nb\x00819e258d31a5e1606629f365bb902a1b21ee4216\ndir0/c\x00914445346a0ca0629bd47ceb5dfe07e4d4cf2501\ndir0/child0/e\x00bbba6c06b30f443d34ff841bc985c4d0827c6be4\ndir0/child1/f\x0012fc7dcd773b5a0a929ce195228083c6ddc9cec4\ndir0/d\x00538206dc971e521540d6843abfe6d16032f6d426\n',
     {
       b'deltabasenode': b'\x1b\x17[Y_\x02,\xfa\xb5\xb8\t\xcc\x0e\xd5Q\xbd\x0b?\xf5\xe4',
       b'deltasize': 55,
       b'node': b'F\xa6r\x1b^\xda\xf0\xea\x04\xb7\x9a\\\xb3!\x88T\xa4\xd2\xab\xa0'
     },
     b'\x00\x00\x00\x00\x00\x00\x00+\x00\x00\x00+a\x000879345e39377229634b420c639454156726c6b6\n'
   ]
 
 Requesting parents and revision data works
 
   $ sendhttpv2peer << EOF
   > command manifestdata
   >     nodes eval:[b'\x1b\x17\x5b\x59\x5f\x02\x2c\xfa\xb5\xb8\x09\xcc\x0e\xd5\x51\xbd\x0b\x3f\xf5\xe4', b'\x46\xa6\x72\x1b\x5e\xda\xf0\xea\x04\xb7\x9a\x5c\xb3\x21\x88\x54\xa4\xd2\xab\xa0']
   >     tree eval:b''
   >     fields eval:[b'parents', b'revision']
   > EOF
   creating http peer for wire protocol version 2
   sending manifestdata command
   s>     POST /api/exp-http-v2-0001/ro/manifestdata HTTP/1.1\r\n
   s>     Accept-Encoding: identity\r\n
   s>     accept: application/mercurial-exp-framing-0005\r\n
   s>     content-type: application/mercurial-exp-framing-0005\r\n
   s>     content-length: 113\r\n
   s>     host: $LOCALIP:$HGPORT\r\n (glob)
   s>     user-agent: Mercurial debugwireproto\r\n
   s>     \r\n
   s>     i\x00\x00\x01\x00\x01\x01\x11\xa2Dargs\xa3Ffields\x82GparentsHrevisionEnodes\x82T\x1b\x17[Y_\x02,\xfa\xb5\xb8\t\xcc\x0e\xd5Q\xbd\x0b?\xf5\xe4TF\xa6r\x1b^\xda\xf0\xea\x04\xb7\x9a\\\xb3!\x88T\xa4\xd2\xab\xa0Dtree@DnameLmanifestdata
   s> makefile('rb', None)
   s>     HTTP/1.1 200 OK\r\n
   s>     Server: testing stub value\r\n
   s>     Date: $HTTP_DATE$\r\n
   s>     Content-Type: application/mercurial-exp-framing-0005\r\n
   s>     Transfer-Encoding: chunked\r\n
   s>     \r\n
   s>     13\r\n
   s>     \x0b\x00\x00\x01\x00\x02\x011
   s>     \xa1FstatusBok
   s>     \r\n
   received frame(size=11; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=continuation)
   s>     250\r\n
   s>     H\x02\x00\x01\x00\x02\x001
   s>     \xa1Jtotalitems\x02\xa3DnodeT\x1b\x17[Y_\x02,\xfa\xb5\xb8\t\xcc\x0e\xd5Q\xbd\x0b?\xf5\xe4Gparents\x82T\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00T\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00Lrevisionsize\x19\x01$Y\x01$a\x002b4eb07319bfa077a40a2f04913659aef0da42da\n
   s>     b\x00819e258d31a5e1606629f365bb902a1b21ee4216\n
   s>     dir0/c\x00914445346a0ca0629bd47ceb5dfe07e4d4cf2501\n
   s>     dir0/child0/e\x00bbba6c06b30f443d34ff841bc985c4d0827c6be4\n
   s>     dir0/child1/f\x0012fc7dcd773b5a0a929ce195228083c6ddc9cec4\n
   s>     dir0/d\x00538206dc971e521540d6843abfe6d16032f6d426\n
   s>     \xa4MdeltabasenodeT\x1b\x17[Y_\x02,\xfa\xb5\xb8\t\xcc\x0e\xd5Q\xbd\x0b?\xf5\xe4Ideltasize\x187DnodeTF\xa6r\x1b^\xda\xf0\xea\x04\xb7\x9a\\\xb3!\x88T\xa4\xd2\xab\xa0Gparents\x82T\x1b\x17[Y_\x02,\xfa\xb5\xb8\t\xcc\x0e\xd5Q\xbd\x0b?\xf5\xe4T\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00X7\x00\x00\x00\x00\x00\x00\x00+\x00\x00\x00+a\x000879345e39377229634b420c639454156726c6b6\n
   s>     \r\n
   received frame(size=584; request=1; stream=2; streamflags=; type=command-response; flags=continuation)
   s>     8\r\n
   s>     \x00\x00\x00\x01\x00\x02\x002
   s>     \r\n
   s>     0\r\n
   s>     \r\n
   received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos)
   response: gen[
     {
       b'totalitems': 2
     },
     {
       b'node': b'\x1b\x17[Y_\x02,\xfa\xb5\xb8\t\xcc\x0e\xd5Q\xbd\x0b?\xf5\xe4',
       b'parents': [
         b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00',
         b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
       ],
       b'revisionsize': 292
     },
     b'a\x002b4eb07319bfa077a40a2f04913659aef0da42da\nb\x00819e258d31a5e1606629f365bb902a1b21ee4216\ndir0/c\x00914445346a0ca0629bd47ceb5dfe07e4d4cf2501\ndir0/child0/e\x00bbba6c06b30f443d34ff841bc985c4d0827c6be4\ndir0/child1/f\x0012fc7dcd773b5a0a929ce195228083c6ddc9cec4\ndir0/d\x00538206dc971e521540d6843abfe6d16032f6d426\n',
     {
       b'deltabasenode': b'\x1b\x17[Y_\x02,\xfa\xb5\xb8\t\xcc\x0e\xd5Q\xbd\x0b?\xf5\xe4',
       b'deltasize': 55,
       b'node': b'F\xa6r\x1b^\xda\xf0\xea\x04\xb7\x9a\\\xb3!\x88T\xa4\xd2\xab\xa0',
       b'parents': [
         b'\x1b\x17[Y_\x02,\xfa\xb5\xb8\t\xcc\x0e\xd5Q\xbd\x0b?\xf5\xe4',
         b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
       ]
     },
     b'\x00\x00\x00\x00\x00\x00\x00+\x00\x00\x00+a\x000879345e39377229634b420c639454156726c6b6\n'
   ]
 
   $ cat error.log

tests/test-wireproto-exchangev2.t

@@ -1,605 +1,617
 Tests for wire protocol version 2 exchange.
 Tests in this file should be folded into existing tests once protocol
 v2 has enough features that it can be enabled via #testcase in existing
 tests.
 
   $ . $TESTDIR/wireprotohelpers.sh
   $ enablehttpv2client
 
   $ hg init server-simple
   $ enablehttpv2 server-simple
   $ cd server-simple
   $ cat >> .hg/hgrc << EOF
   > [phases]
   > publish = false
   > EOF
   $ echo a0 > a
   $ echo b0 > b
   $ hg -q commit -A -m 'commit 0'
 
   $ echo a1 > a
   $ hg commit -m 'commit 1'
   $ hg phase --public -r .
   $ echo a2 > a
   $ hg commit -m 'commit 2'
 
   $ hg -q up -r 0
   $ echo b1 > b
   $ hg -q commit -m 'head 2 commit 1'
   $ echo b2 > b
   $ hg -q commit -m 'head 2 commit 2'
 
   $ hg serve -p $HGPORT -d --pid-file hg.pid -E error.log
   $ cat hg.pid > $DAEMON_PIDS
 
   $ cd ..
 
 Test basic clone
 
   $ hg --debug clone -U http://localhost:$HGPORT client-simple
   using http://localhost:$HGPORT/
   sending capabilities command
   query 1; heads
   sending 2 commands
   sending command heads: {}
   sending command known: {
     'nodes': []
   }
   received frame(size=11; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=continuation)
   received frame(size=43; request=1; stream=2; streamflags=; type=command-response; flags=continuation)
   received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos)
   received frame(size=11; request=3; stream=2; streamflags=; type=command-response; flags=continuation)
   received frame(size=1; request=3; stream=2; streamflags=; type=command-response; flags=continuation)
   received frame(size=0; request=3; stream=2; streamflags=; type=command-response; flags=eos)
   sending 1 commands
   sending command changesetdata: {
     'fields': set([
       'bookmarks',
       'parents',
       'phase',
       'revision'
     ]),
     'noderange': [
       [],
       [
         '\xca\xa2\xa4eE\x1d\xd1\xfa\xcd\xa0\xf5\xb1#\x12\xc3UXA\x88\xa1',
         '\xcd%4vk\xec\xe18\xc7\xc1\xaf\xdch%0/\x0fb\xd8\x1f'
       ]
     ]
   }
   received frame(size=11; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=continuation)
   received frame(size=871; request=1; stream=2; streamflags=; type=command-response; flags=continuation)
   received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos)
   add changeset 3390ef850073
   add changeset 4432d83626e8
   add changeset cd2534766bec
   add changeset e96ae20f4188
   add changeset caa2a465451d
   checking for updated bookmarks
   sending 1 commands
   sending command manifestdata: {
     'fields': set([
       'parents',
       'revision'
     ]),
+    'haveparents': True,
     'nodes': [
       '\x99/Gy\x02\x9a=\xf8\xd0fm\x00\xbb\x92OicN&A',
       '\xa9\x88\xfbCX>\x87\x1d\x1e\xd5u\x0e\xe0t\xc6\xd8@\xbb\xbf\xc8',
       '\xec\x80NH\x8c \x88\xc25\t\x9a\x10 u\x13\xbe\xcd\xc3\xdd\xa5',
       '\x04\\\x7f9\'\xda\x13\xe7Z\xf8\xf0\xe4\xf0HI\xe4a\xa9x\x0f',
       '7\x9c\xb0\xc2\xe6d\\y\xdd\xc5\x9a\x1dG\'\xa9\xfb\x83\n\xeb&'
     ],
     'tree': ''
   }
   received frame(size=11; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=continuation)
   received frame(size=922; request=1; stream=2; streamflags=; type=command-response; flags=continuation)
   received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos)
   sending 2 commands
   sending command filedata: {
     'fields': set([
       'parents',
       'revision'
     ]),
+    'haveparents': True,
     'nodes': [
       '+N\xb0s\x19\xbf\xa0w\xa4\n/\x04\x916Y\xae\xf0\xdaB\xda',
       '\x9a8\x12)\x97\xb3\xac\x97\xbe*\x9a\xa2\xe5V\x83\x83A\xfd\xf2\xcc',
       '\xc2\xa2\x05\xc8\xb2\xad\xe2J\xf2`b\xe5<\xd5\xbc8\x01\xd6`\xda'
     ],
     'path': 'a'
   }
   sending command filedata: {
     'fields': set([
       'parents',
       'revision'
     ]),
+    'haveparents': True,
     'nodes': [
       '\x81\x9e%\x8d1\xa5\xe1`f)\xf3e\xbb\x90*\x1b!\xeeB\x16',
       '\xb1zk\xd3g=\x9a\xb8\xce\xd5\x81\xa2\t\xf6/=\xa5\xccEx',
       '\xc5\xb1\xf9\xd3n\x1c\xc18\xbf\xb6\xef\xb3\xde\xb7]\x8c\xcad\x94\xc3'
     ],
     'path': 'b'
   }
   received frame(size=11; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=continuation)
   received frame(size=389; request=1; stream=2; streamflags=; type=command-response; flags=continuation)
   received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos)
   received frame(size=11; request=3; stream=2; streamflags=; type=command-response; flags=continuation)
   received frame(size=389; request=3; stream=2; streamflags=; type=command-response; flags=continuation)
   received frame(size=0; request=3; stream=2; streamflags=; type=command-response; flags=eos)
   updating the branch cache
   new changesets 3390ef850073:caa2a465451d (3 drafts)
 
 All changesets should have been transferred
 
   $ hg -R client-simple debugindex -c
      rev linkrev nodeid       p1           p2
        0       0 3390ef850073 000000000000 000000000000
        1       1 4432d83626e8 3390ef850073 000000000000
        2       2 cd2534766bec 4432d83626e8 000000000000
        3       3 e96ae20f4188 3390ef850073 000000000000
        4       4 caa2a465451d e96ae20f4188 000000000000
 
   $ hg -R client-simple log -G -T '{rev} {node} {phase}\n'
   o  4 caa2a465451dd1facda0f5b12312c355584188a1 draft
   |
   o  3 e96ae20f4188487b9ae4ef3941c27c81143146e5 draft
   |
   | o  2 cd2534766bece138c7c1afdc6825302f0f62d81f draft
   | |
   | o  1 4432d83626e8a98655f062ec1f2a43b07f7fbbb0 public
   |/
   o  0 3390ef850073fbc2f0dfff2244342c8e9229013a public
   
 
 All manifests should have been transferred
 
   $ hg -R client-simple debugindex -m
      rev linkrev nodeid       p1           p2
        0       0 992f4779029a 000000000000 000000000000
        1       1 a988fb43583e 992f4779029a 000000000000
        2       2 ec804e488c20 a988fb43583e 000000000000
        3       3 045c7f3927da 992f4779029a 000000000000
        4       4 379cb0c2e664 045c7f3927da 000000000000
 
 Cloning only a specific revision works
 
   $ hg --debug clone -U -r 4432d83626e8 http://localhost:$HGPORT client-singlehead
   using http://localhost:$HGPORT/
   sending capabilities command
   sending 1 commands
   sending command lookup: {
     'key': '4432d83626e8'
   }
   received frame(size=11; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=continuation)
   received frame(size=21; request=1; stream=2; streamflags=; type=command-response; flags=continuation)
   received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos)
   query 1; heads
   sending 2 commands
   sending command heads: {}
   sending command known: {
     'nodes': []
   }
   received frame(size=11; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=continuation)
   received frame(size=43; request=1; stream=2; streamflags=; type=command-response; flags=continuation)
   received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos)
   received frame(size=11; request=3; stream=2; streamflags=; type=command-response; flags=continuation)
   received frame(size=1; request=3; stream=2; streamflags=; type=command-response; flags=continuation)
   received frame(size=0; request=3; stream=2; streamflags=; type=command-response; flags=eos)
   sending 1 commands
   sending command changesetdata: {
     'fields': set([
       'bookmarks',
       'parents',
       'phase',
       'revision'
     ]),
     'noderange': [
       [],
       [
         'D2\xd86&\xe8\xa9\x86U\xf0b\xec\x1f*C\xb0\x7f\x7f\xbb\xb0'
       ]
     ]
   }
   received frame(size=11; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=continuation)
   received frame(size=353; request=1; stream=2; streamflags=; type=command-response; flags=continuation)
   received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos)
   add changeset 3390ef850073
   add changeset 4432d83626e8
   checking for updated bookmarks
   sending 1 commands
   sending command manifestdata: {
     'fields': set([
       'parents',
       'revision'
     ]),
+    'haveparents': True,
     'nodes': [
       '\x99/Gy\x02\x9a=\xf8\xd0fm\x00\xbb\x92OicN&A',
       '\xa9\x88\xfbCX>\x87\x1d\x1e\xd5u\x0e\xe0t\xc6\xd8@\xbb\xbf\xc8'
     ],
     'tree': ''
   }
   received frame(size=11; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=continuation)
   received frame(size=376; request=1; stream=2; streamflags=; type=command-response; flags=continuation)
   received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos)
   sending 2 commands
   sending command filedata: {
     'fields': set([
       'parents',
       'revision'
     ]),
+    'haveparents': True,
     'nodes': [
       '+N\xb0s\x19\xbf\xa0w\xa4\n/\x04\x916Y\xae\xf0\xdaB\xda',
       '\x9a8\x12)\x97\xb3\xac\x97\xbe*\x9a\xa2\xe5V\x83\x83A\xfd\xf2\xcc'
     ],
     'path': 'a'
   }
   sending command filedata: {
     'fields': set([
       'parents',
       'revision'
     ]),
+    'haveparents': True,
     'nodes': [
       '\x81\x9e%\x8d1\xa5\xe1`f)\xf3e\xbb\x90*\x1b!\xeeB\x16'
     ],
     'path': 'b'
   }
   received frame(size=11; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=continuation)
   received frame(size=249; request=1; stream=2; streamflags=; type=command-response; flags=continuation)
   received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos)
   received frame(size=11; request=3; stream=2; streamflags=; type=command-response; flags=continuation)
   received frame(size=109; request=3; stream=2; streamflags=; type=command-response; flags=continuation)
   received frame(size=0; request=3; stream=2; streamflags=; type=command-response; flags=eos)
   updating the branch cache
   new changesets 3390ef850073:4432d83626e8
 
   $ cd client-singlehead
 
   $ hg log -G -T '{rev} {node} {phase}\n'
   o  1 4432d83626e8a98655f062ec1f2a43b07f7fbbb0 public
   |
   o  0 3390ef850073fbc2f0dfff2244342c8e9229013a public
   
 
   $ hg debugindex -m
      rev linkrev nodeid       p1           p2
        0       0 992f4779029a 000000000000 000000000000
        1       1 a988fb43583e 992f4779029a 000000000000
 
 Incremental pull works
 
   $ hg --debug pull
   pulling from http://localhost:$HGPORT/
   using http://localhost:$HGPORT/
   sending capabilities command
   query 1; heads
   sending 2 commands
   sending command heads: {}
   sending command known: {
     'nodes': [
       'D2\xd86&\xe8\xa9\x86U\xf0b\xec\x1f*C\xb0\x7f\x7f\xbb\xb0'
     ]
   }
   received frame(size=11; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=continuation)
   received frame(size=43; request=1; stream=2; streamflags=; type=command-response; flags=continuation)
   received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos)
   received frame(size=11; request=3; stream=2; streamflags=; type=command-response; flags=continuation)
   received frame(size=2; request=3; stream=2; streamflags=; type=command-response; flags=continuation)
   received frame(size=0; request=3; stream=2; streamflags=; type=command-response; flags=eos)
   searching for changes
   all local heads known remotely
   sending 1 commands
   sending command changesetdata: {
     'fields': set([
       'bookmarks',
       'parents',
       'phase',
       'revision'
     ]),
     'noderange': [
       [
         'D2\xd86&\xe8\xa9\x86U\xf0b\xec\x1f*C\xb0\x7f\x7f\xbb\xb0'
       ],
       [
         '\xca\xa2\xa4eE\x1d\xd1\xfa\xcd\xa0\xf5\xb1#\x12\xc3UXA\x88\xa1',
         '\xcd%4vk\xec\xe18\xc7\xc1\xaf\xdch%0/\x0fb\xd8\x1f'
       ]
     ]
   }
   received frame(size=11; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=continuation)
   received frame(size=571; request=1; stream=2; streamflags=; type=command-response; flags=continuation)
   received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos)
   add changeset cd2534766bec
   add changeset e96ae20f4188
   add changeset caa2a465451d
   checking for updated bookmarks
   sending 1 commands
   sending command manifestdata: {
     'fields': set([
       'parents',
       'revision'
     ]),
+    'haveparents': True,
     'nodes': [
       '\xec\x80NH\x8c \x88\xc25\t\x9a\x10 u\x13\xbe\xcd\xc3\xdd\xa5',
       '\x04\\\x7f9\'\xda\x13\xe7Z\xf8\xf0\xe4\xf0HI\xe4a\xa9x\x0f',
       '7\x9c\xb0\xc2\xe6d\\y\xdd\xc5\x9a\x1dG\'\xa9\xfb\x83\n\xeb&'
     ],
     'tree': ''
   }
   received frame(size=11; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=continuation)
   received frame(size=559; request=1; stream=2; streamflags=; type=command-response; flags=continuation)
   received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos)
   sending 2 commands
   sending command filedata: {
     'fields': set([
       'parents',
       'revision'
     ]),
+    'haveparents': True,
     'nodes': [
       '+N\xb0s\x19\xbf\xa0w\xa4\n/\x04\x916Y\xae\xf0\xdaB\xda',
       '\xc2\xa2\x05\xc8\xb2\xad\xe2J\xf2`b\xe5<\xd5\xbc8\x01\xd6`\xda'
     ],
     'path': 'a'
   }
   sending command filedata: {
     'fields': set([
       'parents',
       'revision'
     ]),
+    'haveparents': True,
     'nodes': [
       '\x81\x9e%\x8d1\xa5\xe1`f)\xf3e\xbb\x90*\x1b!\xeeB\x16',
       '\xb1zk\xd3g=\x9a\xb8\xce\xd5\x81\xa2\t\xf6/=\xa5\xccEx',
       '\xc5\xb1\xf9\xd3n\x1c\xc18\xbf\xb6\xef\xb3\xde\xb7]\x8c\xcad\x94\xc3'
     ],
     'path': 'b'
   }
   received frame(size=11; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=continuation)
   received frame(size=249; request=1; stream=2; streamflags=; type=command-response; flags=continuation)
   received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos)
   received frame(size=11; request=3; stream=2; streamflags=; type=command-response; flags=continuation)
   received frame(size=389; request=3; stream=2; streamflags=; type=command-response; flags=continuation)
   received frame(size=0; request=3; stream=2; streamflags=; type=command-response; flags=eos)
   updating the branch cache
   new changesets cd2534766bec:caa2a465451d (3 drafts)
   (run 'hg update' to get a working copy)
 
   $ hg log -G -T '{rev} {node} {phase}\n'
   o  4 caa2a465451dd1facda0f5b12312c355584188a1 draft
   |
   o  3 e96ae20f4188487b9ae4ef3941c27c81143146e5 draft
   |
   | o  2 cd2534766bece138c7c1afdc6825302f0f62d81f draft
   | |
   | o  1 4432d83626e8a98655f062ec1f2a43b07f7fbbb0 public
   |/
   o  0 3390ef850073fbc2f0dfff2244342c8e9229013a public
   
 
   $ hg debugindex -m
      rev linkrev nodeid       p1           p2
        0       0 992f4779029a 000000000000 000000000000
        1       1 a988fb43583e 992f4779029a 000000000000
        2       2 ec804e488c20 a988fb43583e 000000000000
        3       3 045c7f3927da 992f4779029a 000000000000
        4       4 379cb0c2e664 045c7f3927da 000000000000
 
 Phase-only update works
 
   $ hg -R ../server-simple phase --public -r caa2a465451dd
   $ hg --debug pull
   pulling from http://localhost:$HGPORT/
   using http://localhost:$HGPORT/
   sending capabilities command
   query 1; heads
   sending 2 commands
   sending command heads: {}
   sending command known: {
     'nodes': [
       '\xcd%4vk\xec\xe18\xc7\xc1\xaf\xdch%0/\x0fb\xd8\x1f',
       '\xca\xa2\xa4eE\x1d\xd1\xfa\xcd\xa0\xf5\xb1#\x12\xc3UXA\x88\xa1'
     ]
   }
   received frame(size=11; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=continuation)
   received frame(size=43; request=1; stream=2; streamflags=; type=command-response; flags=continuation)
   received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos)
   received frame(size=11; request=3; stream=2; streamflags=; type=command-response; flags=continuation)
   received frame(size=3; request=3; stream=2; streamflags=; type=command-response; flags=continuation)
   received frame(size=0; request=3; stream=2; streamflags=; type=command-response; flags=eos)
   searching for changes
   all remote heads known locally
   sending 1 commands
   sending command changesetdata: {
     'fields': set([
       'bookmarks',
       'parents',
       'phase',
       'revision'
     ]),
     'noderange': [
       [
         '\xca\xa2\xa4eE\x1d\xd1\xfa\xcd\xa0\xf5\xb1#\x12\xc3UXA\x88\xa1',
         '\xcd%4vk\xec\xe18\xc7\xc1\xaf\xdch%0/\x0fb\xd8\x1f'
       ],
       [
         '\xca\xa2\xa4eE\x1d\xd1\xfa\xcd\xa0\xf5\xb1#\x12\xc3UXA\x88\xa1',
         '\xcd%4vk\xec\xe18\xc7\xc1\xaf\xdch%0/\x0fb\xd8\x1f'
       ]
     ]
   }
   received frame(size=11; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=continuation)
   received frame(size=92; request=1; stream=2; streamflags=; type=command-response; flags=continuation)
   received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos)
   checking for updated bookmarks
   2 local changesets published
   (run 'hg update' to get a working copy)
 
   $ hg log -G -T '{rev} {node} {phase}\n'
   o  4 caa2a465451dd1facda0f5b12312c355584188a1 public
   |
   o  3 e96ae20f4188487b9ae4ef3941c27c81143146e5 public
   |
   | o  2 cd2534766bece138c7c1afdc6825302f0f62d81f draft
   | |
   | o  1 4432d83626e8a98655f062ec1f2a43b07f7fbbb0 public
   |/
   o  0 3390ef850073fbc2f0dfff2244342c8e9229013a public
   
 
   $ cd ..
 
 Bookmarks are transferred on clone
 
   $ hg -R server-simple bookmark -r 3390ef850073fbc2f0dfff2244342c8e9229013a book-1
   $ hg -R server-simple bookmark -r cd2534766bece138c7c1afdc6825302f0f62d81f book-2
 
   $ hg --debug clone -U http://localhost:$HGPORT/ client-bookmarks
   using http://localhost:$HGPORT/
   sending capabilities command
   query 1; heads
   sending 2 commands
   sending command heads: {}
   sending command known: {
     'nodes': []
   }
   received frame(size=11; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=continuation)
   received frame(size=43; request=1; stream=2; streamflags=; type=command-response; flags=continuation)
   received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos)
   received frame(size=11; request=3; stream=2; streamflags=; type=command-response; flags=continuation)
   received frame(size=1; request=3; stream=2; streamflags=; type=command-response; flags=continuation)
   received frame(size=0; request=3; stream=2; streamflags=; type=command-response; flags=eos)
   sending 1 commands
   sending command changesetdata: {
     'fields': set([
       'bookmarks',
       'parents',
       'phase',
       'revision'
     ]),
     'noderange': [
       [],
       [
         '\xca\xa2\xa4eE\x1d\xd1\xfa\xcd\xa0\xf5\xb1#\x12\xc3UXA\x88\xa1',
         '\xcd%4vk\xec\xe18\xc7\xc1\xaf\xdch%0/\x0fb\xd8\x1f'
       ]
     ]
   }
   received frame(size=11; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=continuation)
   received frame(size=909; request=1; stream=2; streamflags=; type=command-response; flags=continuation)
   received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos)
   add changeset 3390ef850073
   add changeset 4432d83626e8
   add changeset cd2534766bec
   add changeset e96ae20f4188
   add changeset caa2a465451d
   checking for updated bookmarks
   adding remote bookmark book-1
   adding remote bookmark book-2
   sending 1 commands
   sending command manifestdata: {
     'fields': set([
       'parents',
       'revision'
     ]),
+    'haveparents': True,
     'nodes': [
       '\x99/Gy\x02\x9a=\xf8\xd0fm\x00\xbb\x92OicN&A',
       '\xa9\x88\xfbCX>\x87\x1d\x1e\xd5u\x0e\xe0t\xc6\xd8@\xbb\xbf\xc8',
       '\xec\x80NH\x8c \x88\xc25\t\x9a\x10 u\x13\xbe\xcd\xc3\xdd\xa5',
       '\x04\\\x7f9\'\xda\x13\xe7Z\xf8\xf0\xe4\xf0HI\xe4a\xa9x\x0f',
       '7\x9c\xb0\xc2\xe6d\\y\xdd\xc5\x9a\x1dG\'\xa9\xfb\x83\n\xeb&'
     ],
     'tree': ''
   }
   received frame(size=11; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=continuation)
   received frame(size=922; request=1; stream=2; streamflags=; type=command-response; flags=continuation)
   received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos)
   sending 2 commands
   sending command filedata: {
     'fields': set([
       'parents',
       'revision'
     ]),
+    'haveparents': True,
     'nodes': [
       '+N\xb0s\x19\xbf\xa0w\xa4\n/\x04\x916Y\xae\xf0\xdaB\xda',
       '\x9a8\x12)\x97\xb3\xac\x97\xbe*\x9a\xa2\xe5V\x83\x83A\xfd\xf2\xcc',
       '\xc2\xa2\x05\xc8\xb2\xad\xe2J\xf2`b\xe5<\xd5\xbc8\x01\xd6`\xda'
     ],
     'path': 'a'
   }
   sending command filedata: {
     'fields': set([
       'parents',
       'revision'
     ]),
+    'haveparents': True,
     'nodes': [
       '\x81\x9e%\x8d1\xa5\xe1`f)\xf3e\xbb\x90*\x1b!\xeeB\x16',
       '\xb1zk\xd3g=\x9a\xb8\xce\xd5\x81\xa2\t\xf6/=\xa5\xccEx',
       '\xc5\xb1\xf9\xd3n\x1c\xc18\xbf\xb6\xef\xb3\xde\xb7]\x8c\xcad\x94\xc3'
     ],
     'path': 'b'
   }
   received frame(size=11; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=continuation)
   received frame(size=389; request=1; stream=2; streamflags=; type=command-response; flags=continuation)
   received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos)
   received frame(size=11; request=3; stream=2; streamflags=; type=command-response; flags=continuation)
   received frame(size=389; request=3; stream=2; streamflags=; type=command-response; flags=continuation)
   received frame(size=0; request=3; stream=2; streamflags=; type=command-response; flags=eos)
   updating the branch cache
   new changesets 3390ef850073:caa2a465451d (1 drafts)
 
   $ hg -R client-bookmarks bookmarks
      book-1                    0:3390ef850073
      book-2                    2:cd2534766bec
 
 Server-side bookmark moves are reflected during `hg pull`
 
   $ hg -R server-simple bookmark -r cd2534766bece138c7c1afdc6825302f0f62d81f book-1
   moving bookmark 'book-1' forward from 3390ef850073
 
   $ hg -R client-bookmarks --debug pull
   pulling from http://localhost:$HGPORT/
   using http://localhost:$HGPORT/
   sending capabilities command
   query 1; heads
   sending 2 commands
   sending command heads: {}
   sending command known: {
     'nodes': [
       '\xcd%4vk\xec\xe18\xc7\xc1\xaf\xdch%0/\x0fb\xd8\x1f',
       '\xca\xa2\xa4eE\x1d\xd1\xfa\xcd\xa0\xf5\xb1#\x12\xc3UXA\x88\xa1'
     ]
   }
   received frame(size=11; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=continuation)
   received frame(size=43; request=1; stream=2; streamflags=; type=command-response; flags=continuation)
   received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos)
   received frame(size=11; request=3; stream=2; streamflags=; type=command-response; flags=continuation)
   received frame(size=3; request=3; stream=2; streamflags=; type=command-response; flags=continuation)
   received frame(size=0; request=3; stream=2; streamflags=; type=command-response; flags=eos)
   searching for changes
   all remote heads known locally
   sending 1 commands
   sending command changesetdata: {
     'fields': set([
       'bookmarks',
       'parents',
       'phase',
       'revision'
     ]),
     'noderange': [
       [
         '\xca\xa2\xa4eE\x1d\xd1\xfa\xcd\xa0\xf5\xb1#\x12\xc3UXA\x88\xa1',
         '\xcd%4vk\xec\xe18\xc7\xc1\xaf\xdch%0/\x0fb\xd8\x1f'
       ],
       [
         '\xca\xa2\xa4eE\x1d\xd1\xfa\xcd\xa0\xf5\xb1#\x12\xc3UXA\x88\xa1',
         '\xcd%4vk\xec\xe18\xc7\xc1\xaf\xdch%0/\x0fb\xd8\x1f'
       ]
     ]
   }
   received frame(size=11; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=continuation)
   received frame(size=144; request=1; stream=2; streamflags=; type=command-response; flags=continuation)
   received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos)
   checking for updated bookmarks
   updating bookmark book-1
   (run 'hg update' to get a working copy)
 
   $ hg -R client-bookmarks bookmarks
      book-1                    2:cd2534766bec
      book-2                    2:cd2534766bec