Create an extension to test bundle2 API

  $ cat > bundle2.py << EOF

  > """A small extension to test bundle2 implementation

  > 

  > Current bundle2 implementation is far too limited to be used in any core

  > code. We still need to be able to test it while it grow up.

  > """

  > 

  > try:

  >     import msvcrt

  >     msvcrt.setmode(sys.stdin.fileno(), os.O_BINARY)

  >     msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)

  >     msvcrt.setmode(sys.stderr.fileno(), os.O_BINARY)

  > except ImportError:

  >     pass

  > 

  > import sys

  > from mercurial import cmdutil

  > from mercurial import util

  > from mercurial import bundle2

  > from mercurial import scmutil

  > from mercurial import discovery

  > from mercurial import changegroup

  > from mercurial import error

  > cmdtable = {}

  > command = cmdutil.command(cmdtable)

  > 

  > ELEPHANTSSONG = """Patali Dirapata, Cromda Cromda Ripalo, Pata Pata, Ko Ko Ko

  > Bokoro Dipoulito, Rondi Rondi Pepino, Pata Pata, Ko Ko Ko

  > Emana Karassoli, Loucra Loucra Ponponto, Pata Pata, Ko Ko Ko."""

  > assert len(ELEPHANTSSONG) == 178 # future test say 178 bytes, trust it.

  > 

  > @bundle2.parthandler('test:song')

  > def songhandler(op, part):

  >     """handle a "test:song" bundle2 part, printing the lyrics on stdin"""

  >     op.ui.write('The choir starts singing:\n')

  >     verses = 0

  >     for line in part.read().split('\n'):

  >         op.ui.write('    %s\n' % line)

  >         verses += 1

  >     op.records.add('song', {'verses': verses})

  > 

  > @bundle2.parthandler('test:ping')

  > def pinghandler(op, part):

  >     op.ui.write('received ping request (id %i)\n' % part.id)

  >     if op.reply is not None and 'ping-pong' in op.reply.capabilities:

  >         op.ui.write_err('replying to ping request (id %i)\n' % part.id)

  >         rpart = bundle2.bundlepart('test:pong',

  >                                    [('in-reply-to', str(part.id))])

  >         op.reply.addpart(rpart)

  > 

  > @bundle2.parthandler('test:debugreply')

  > def debugreply(op, part):

  >     """print data about the capacity of the bundle reply"""

  >     if op.reply is None:

  >         op.ui.write('debugreply: no reply\n')

  >     else:

  >         op.ui.write('debugreply: capabilities:\n')

  >         for cap in sorted(op.reply.capabilities):

  >             op.ui.write('debugreply:     %r\n' % cap)

  >             for val in op.reply.capabilities[cap]:

  >                 op.ui.write('debugreply:         %r\n' % val)

  > 

  > @command('bundle2',

  >          [('', 'param', [], 'stream level parameter'),

  >           ('', 'unknown', False, 'include an unknown mandatory part in the bundle'),

  >           ('', 'parts', False, 'include some arbitrary parts to the bundle'),

  >           ('', 'reply', False, 'produce a reply bundle'),

  >           ('', 'pushrace', False, 'includes a check:head part with unknown nodes'),

  >           ('r', 'rev', [], 'includes those changeset in the bundle'),],

  >          '[OUTPUTFILE]')

  > def cmdbundle2(ui, repo, path=None, **opts):

  >     """write a bundle2 container on standard ouput"""

  >     bundler = bundle2.bundle20(ui)

  >     for p in opts['param']:

  >         p = p.split('=', 1)

  >         try:

  >             bundler.addparam(*p)

  >         except ValueError, exc:

  >             raise util.Abort('%s' % exc)

  > 

  >     if opts['reply']:

  >         capsstring = 'ping-pong\nelephants=babar,celeste\ncity%3D%21=celeste%2Cville'

  >         bundler.addpart(bundle2.bundlepart('b2x:replycaps', data=capsstring))

  > 

  >     if opts['pushrace']:

  >         dummynode = '01234567890123456789'

  >         bundler.addpart(bundle2.bundlepart('b2x:check:heads', data=dummynode))

  > 

  >     revs = opts['rev']

  >     if 'rev' in opts:

  >         revs = scmutil.revrange(repo, opts['rev'])

  >         if revs:

  >             # very crude version of a changegroup part creation

  >             bundled = repo.revs('%ld::%ld', revs, revs)

  >             headmissing = [c.node() for c in repo.set('heads(%ld)', revs)]

  >             headcommon  = [c.node() for c in repo.set('parents(%ld) - %ld', revs, revs)]

  >             outgoing = discovery.outgoing(repo.changelog, headcommon, headmissing)

  >             cg = changegroup.getlocalbundle(repo, 'test:bundle2', outgoing, None)

  >             part = bundle2.bundlepart('b2x:changegroup', data=cg.getchunks())

  >             bundler.addpart(part)

  > 

  >     if opts['parts']:

  >        part = bundle2.bundlepart('test:empty')

  >        bundler.addpart(part)

  >        # add a second one to make sure we handle multiple parts

  >        part = bundle2.bundlepart('test:empty')

  >        bundler.addpart(part)

  >        part = bundle2.bundlepart('test:song', data=ELEPHANTSSONG)

  >        bundler.addpart(part)

  >        part = bundle2.bundlepart('test:debugreply')

  >        bundler.addpart(part)

  >        part = bundle2.bundlepart('test:math',

  >                                  [('pi', '3.14'), ('e', '2.72')],

  >                                  [('cooking', 'raw')],

  >                                  '42')

  >        bundler.addpart(part)

  >     if opts['unknown']:

  >        part = bundle2.bundlepart('test:UNKNOWN',

  >                                  data='some random content')

  >        bundler.addpart(part)

  >     if opts['parts']:

  >        part = bundle2.bundlepart('test:ping')

  >        bundler.addpart(part)

  > 

  >     if path is None:

  >        file = sys.stdout

  >     else:

  >         file = open(path, 'w')

  > 

  >     for chunk in bundler.getchunks():

  >         file.write(chunk)

  > 

  > @command('unbundle2', [], '')

  > def cmdunbundle2(ui, repo, replypath=None):

  >     """process a bundle2 stream from stdin on the current repo"""

  >     try:

  >         tr = None

  >         lock = repo.lock()

  >         tr = repo.transaction('processbundle')

  >         try:

  >             unbundler = bundle2.unbundle20(ui, sys.stdin)

  >             op = bundle2.processbundle(repo, unbundler, lambda: tr)

  >             tr.close()

  >         except KeyError, exc:

  >             raise util.Abort('missing support for %s' % exc)

  >         except error.PushRaced, exc:

  >             raise util.Abort('push race: %s' % exc)

  >     finally:

  >         if tr is not None:

  >             tr.release()

  >         lock.release()

  >         remains = sys.stdin.read()

  >         ui.write('%i unread bytes\n' % len(remains))

  >     if op.records['song']:

  >         totalverses = sum(r['verses'] for r in op.records['song'])

  >         ui.write('%i total verses sung\n' % totalverses)

  >     for rec in op.records['changegroup']:

  >         ui.write('addchangegroup return: %i\n' % rec['return'])

  >     if op.reply is not None and replypath is not None:

  >         file = open(replypath, 'w')

  >         for chunk in op.reply.getchunks():

  >             file.write(chunk)

  > 

  > @command('statbundle2', [], '')

  > def cmdstatbundle2(ui, repo):

  >     """print statistic on the bundle2 container read from stdin"""

  >     unbundler = bundle2.unbundle20(ui, sys.stdin)

  >     try:

  >         params = unbundler.params

  >     except KeyError, exc:

  >        raise util.Abort('unknown parameters: %s' % exc)

  >     ui.write('options count: %i\n' % len(params))

  >     for key in sorted(params):

  >         ui.write('- %s\n' % key)

  >         value = params[key]

  >         if value is not None:

  >             ui.write('    %s\n' % value)

  >     count = 0

  >     for p in unbundler.iterparts():

  >         count += 1

  >         ui.write('  :%s:\n' % p.type)

  >         ui.write('    mandatory: %i\n' % len(p.mandatoryparams))

  >         ui.write('    advisory: %i\n' % len(p.advisoryparams))

  >         ui.write('    payload: %i bytes\n' % len(p.read()))

  >     ui.write('parts count:   %i\n' % count)

  > EOF

  $ cat >> $HGRCPATH << EOF

  > [extensions]

  > bundle2=$TESTTMP/bundle2.py

  > [experimental]

  > bundle2-exp=True

  > [ui]

  > ssh=python "$TESTDIR/dummyssh"

  > [web]

  > push_ssl = false

  > allow_push = *

  > EOF

The extension requires a repo (currently unused)

  $ hg init main

  $ cd main

  $ touch a

  $ hg add a

  $ hg commit -m 'a'

Empty bundle

=================

- no option

- no parts

Test bundling

  $ hg bundle2

  HG2X\x00\x00\x00\x00 (no-eol) (esc)

Test unbundling

  $ hg bundle2 | hg statbundle2

  options count: 0

  parts count:   0

Test old style bundle are detected and refused

  $ hg bundle --all ../bundle.hg

  1 changesets found

  $ hg statbundle2 < ../bundle.hg

  abort: unknown bundle version 10

  [255]

Test parameters

=================

- some options

- no parts

advisory parameters, no value

-------------------------------

Simplest possible parameters form

Test generation simple option

  $ hg bundle2 --param 'caution'

  HG2X\x00\x07caution\x00\x00 (no-eol) (esc)

Test unbundling

  $ hg bundle2 --param 'caution' | hg statbundle2

  options count: 1

  - caution

  parts count:   0

Test generation multiple option

  $ hg bundle2 --param 'caution' --param 'meal'

  HG2X\x00\x0ccaution meal\x00\x00 (no-eol) (esc)

Test unbundling

  $ hg bundle2 --param 'caution' --param 'meal' | hg statbundle2

  options count: 2

  - caution

  - meal

  parts count:   0

advisory parameters, with value

-------------------------------

Test generation

  $ hg bundle2 --param 'caution' --param 'meal=vegan' --param 'elephants'

  HG2X\x00\x1ccaution meal=vegan elephants\x00\x00 (no-eol) (esc)

Test unbundling

  $ hg bundle2 --param 'caution' --param 'meal=vegan' --param 'elephants' | hg statbundle2

  options count: 3

  - caution

  - elephants

  - meal

      vegan

  parts count:   0

parameter with special char in value

---------------------------------------------------

Test generation

  $ hg bundle2 --param 'e|! 7/=babar%#==tutu' --param simple

  HG2X\x00)e%7C%21%207/=babar%25%23%3D%3Dtutu simple\x00\x00 (no-eol) (esc)

Test unbundling

  $ hg bundle2 --param 'e|! 7/=babar%#==tutu' --param simple | hg statbundle2

  options count: 2

  - e|! 7/

      babar%#==tutu

  - simple

  parts count:   0

Test unknown mandatory option

---------------------------------------------------

  $ hg bundle2 --param 'Gravity' | hg statbundle2

  abort: unknown parameters: 'Gravity'

  [255]

Test debug output

---------------------------------------------------

bundling debug

  $ hg bundle2 --debug --param 'e|! 7/=babar%#==tutu' --param simple ../out.hg2

  start emission of HG2X stream

  bundle parameter: e%7C%21%207/=babar%25%23%3D%3Dtutu simple

  start of parts

  end of bundle

file content is ok

  $ cat ../out.hg2

  HG2X\x00)e%7C%21%207/=babar%25%23%3D%3Dtutu simple\x00\x00 (no-eol) (esc)

unbundling debug

  $ hg statbundle2 --debug < ../out.hg2

  start processing of HG2X stream

  reading bundle2 stream parameters

  ignoring unknown parameter 'e|! 7/'

  ignoring unknown parameter 'simple'

  options count: 2

  - e|! 7/

      babar%#==tutu

  - simple

  start extraction of bundle2 parts

  part header size: 0

  end of bundle2 stream

  parts count:   0

Test buggy input

---------------------------------------------------

empty parameter name

  $ hg bundle2 --param '' --quiet

  abort: empty parameter name

  [255]