mercurial/sshserver.py

templates: add 'bisect' keyword to return a cset's bisect status

This new 'bisect' template expands to a cset's bisection status (good,
bad and so on...). There is also a new 'shortbisect' filter that yields
a single char representing the cset's bisection status.

It uses the two recently-added hbisect.label() and .shortlabel() functions.

Example output using the repository in test-bisect2.t, and some made-up
state of the 'end at merge' test (with graphlog, it's so explicit):

  $ hg glog --template '{rev}:{node|short} {bisect}\n'  \
            -r 'bisect(range)|bisect(ignored)'
  o  17:228c06deef46: bad
  |
  o  16:609d82a7ebae: bad (implicit)
  |
  o    15:857b178a7cf3: bad
  |\
  | o  13:b0a32c86eb31: good
  | |
  | o  12:9f259202bbe7: good (implicit)
  | |
  | o  11:82ca6f06eccd: good
  | |
  @ |    10:429fcd26f52d: untested
  |\ \
  | o |  9:3c77083deb4a: skipped
  | |/
  | o  8:dab8161ac8fc: good
  | |
  o |    6:a214d5d3811a: ignored
  |\ \
  | o |  5:385a529b6670: ignored
  | | |
  o | |  4:5c668c22234f: ignored
  | | |
  o | |  3:0950834f0a9c: ignored
  |/ /
  o /  2:051e12f87bf1: ignored
  |/

And now the same with the short label:

  $ hg log --template '{bisect|shortbisect} {rev}:{node|short}\n'
    18:d42e18c7bc9b
  B 17:228c06deef46
  B 16:609d82a7ebae
  B 15:857b178a7cf3
    14:faa450606157
  G 13:b0a32c86eb31
  G 12:9f259202bbe7
  G 11:82ca6f06eccd
  U 10:429fcd26f52d
  S 9:3c77083deb4a
  G 8:dab8161ac8fc
    7:50c76098bbf2
  I 6:a214d5d3811a
  I 5:385a529b6670
  I 4:5c668c22234f
  I 3:0950834f0a9c
  I 2:051e12f87bf1
    1:4ca5088da217
    0:33b1f9bc8bc5

Signed-off-by: "Yann E. MORIN" <[e-mail]>

# sshserver.py - ssh protocol server support for mercurial
#
# Copyright 2005-2007 Matt Mackall <[e-mail]>
# Copyright 2006 Vadim Gelfer <[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.

import util, hook, wireproto, changegroup
import os, sys

class sshserver(object):
    def __init__(self, ui, repo):
        self.ui = ui
        self.repo = repo
        self.lock = None
        self.fin = ui.fin
        self.fout = ui.fout

        hook.redirect(True)
        ui.fout = repo.ui.fout = ui.ferr

        # Prevent insertion/deletion of CRs
        util.setbinary(self.fin)
        util.setbinary(self.fout)

    def getargs(self, args):
        data = {}
        keys = args.split()
        for n in xrange(len(keys)):
            argline = self.fin.readline()[:-1]
            arg, l = argline.split()
            if arg not in keys:
                raise util.Abort("unexpected parameter %r" % arg)
            if arg == '*':
                star = {}
                for k in xrange(int(l)):
                    argline = self.fin.readline()[:-1]
                    arg, l = argline.split()
                    val = self.fin.read(int(l))
                    star[arg] = val
                data['*'] = star
            else:
                val = self.fin.read(int(l))
                data[arg] = val
        return [data[k] for k in keys]

    def getarg(self, name):
        return self.getargs(name)[0]

    def getfile(self, fpout):
        self.sendresponse('')
        count = int(self.fin.readline())
        while count:
            fpout.write(self.fin.read(count))
            count = int(self.fin.readline())

    def redirect(self):
        pass

    def groupchunks(self, changegroup):
        while True:
            d = changegroup.read(4096)
            if not d:
                break
            yield d

    def sendresponse(self, v):
        self.fout.write("%d\n" % len(v))
        self.fout.write(v)
        self.fout.flush()

    def sendstream(self, source):
        for chunk in source.gen:
            self.fout.write(chunk)
        self.fout.flush()

    def sendpushresponse(self, rsp):
        self.sendresponse('')
        self.sendresponse(str(rsp.res))

    def sendpusherror(self, rsp):
        self.sendresponse(rsp.res)

    def sendooberror(self, rsp):
        self.ui.ferr.write('%s\n-\n' % rsp.message)
        self.ui.ferr.flush()
        self.fout.write('\n')
        self.fout.flush()

    def serve_forever(self):
        try:
            while self.serve_one():
                pass
        finally:
            if self.lock is not None:
                self.lock.release()
        sys.exit(0)

    handlers = {
        str: sendresponse,
        wireproto.streamres: sendstream,
        wireproto.pushres: sendpushresponse,
        wireproto.pusherr: sendpusherror,
        wireproto.ooberror: sendooberror,
    }

    def serve_one(self):
        cmd = self.fin.readline()[:-1]
        if cmd and cmd in wireproto.commands:
            rsp = wireproto.dispatch(self.repo, self, cmd)
            self.handlers[rsp.__class__](self, rsp)
        elif cmd:
            impl = getattr(self, 'do_' + cmd, None)
            if impl:
                r = impl()
                if r is not None:
                    self.sendresponse(r)
            else: self.sendresponse("")
        return cmd != ''

    def do_lock(self):
        '''DEPRECATED - allowing remote client to lock repo is not safe'''

        self.lock = self.repo.lock()
        return ""

    def do_unlock(self):
        '''DEPRECATED'''

        if self.lock:
            self.lock.release()
        self.lock = None
        return ""

    def do_addchangegroup(self):
        '''DEPRECATED'''

        if not self.lock:
            self.sendresponse("not locked")
            return

        self.sendresponse("")
        cg = changegroup.unbundle10(self.fin, "UN")
        r = self.repo.addchangegroup(cg, 'serve', self._client(),
                                     lock=self.lock)
        return str(r)

    def _client(self):
        client = os.environ.get('SSH_CLIENT', '').split(' ', 1)[0]
        return 'remote:ssh:' + client