migrate verify

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

migrate verify

Move the bulk of the verify code into the localrepository class and move
the command into commands.py

manifest hash: 793a8d0094d56ab0a411cd11d7fe7f39c923f209
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.0 (GNU/Linux)

iD8DBQFCog33ywK+sNU5EO8RApfBAJ4mCmiMmZE1fEfbR6sA+aP1csPvqQCfXHzY
3XK7yc19AivXf5HGKEOL3eM=
=GISf
-----END PGP SIGNATURE-----

hg

@@ -1,244 +1,121 b''
 #!/usr/bin/env python
 #
 # mercurial - a minimal scalable distributed SCM
 # v0.5b "katje"
 #
 # Copyright 2005 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
 
 # the psyco compiler makes commits a bit faster
 # and makes changegroup merge about 20 times slower!
 # try:
 #    import psyco
 #    psyco.full()
 # except:
 #    pass
 
 import sys
-from mercurial import hg, mdiff, fancyopts, ui, commands
+from mercurial import hg, fancyopts, ui, commands
 
 try:
     sys.exit(commands.dispatch(sys.argv[1:]))
 except commands.UnknownCommand:
     # fall through
     pass
 
 options = {}
 opts = [('v', 'verbose', None, 'verbose'),
         ('d', 'debug', None, 'debug'),
         ('q', 'quiet', None, 'quiet'),
         ('y', 'noninteractive', None, 'run non-interactively'),
         ]
 
 args = fancyopts.fancyopts(sys.argv[1:], opts, options,
                            'hg [options] <command> [command options] [files]')
 
 try:
     cmd = args[0]
     args = args[1:]
 except:
     cmd = "help"
 
 ui = ui.ui(options["verbose"], options["debug"], options["quiet"],
            not options["noninteractive"])
     
 try:
     repo = hg.repository(ui=ui)
 except IOError:
     ui.warn("Unable to open repository\n")
     sys.exit(0)
 
 if cmd == "debugchangegroup":
     newer = repo.newer(map(repo.lookup, args))
     for chunk in repo.changegroup(newer):
         sys.stdout.write(chunk)
 
 elif cmd == "debugaddchangegroup":
     data = sys.stdin.read()
     repo.addchangegroup(data)
 
 elif cmd == "dump":
     if args:
         r = repo.file(args[0])
         n = r.tip()
         if len(args) > 1: n = r.lookup(args[1])
         sys.stdout.write(r.read(n))
     else:
         print "missing filename"
 
 elif cmd == "dumpmanifest":
     n = repo.manifest.tip()
     if len(args) > 0:
         n = repo.manifest.lookup(args[0])
     m = repo.manifest.read(n)
     files = m.keys()
     files.sort()
 
     for f in files:
         print hg.hex(m[f]), f
 
 elif cmd == "debugindex":
     if ".hg" not in args[0]:
         args[0] = ".hg/data/" + repo.file(args[0]).encodepath(args[0]) + "i"
     
     r = hg.revlog(open, args[0], "")
     print "   rev    offset  length   base linkrev"+\
           " p1           p2           nodeid"
     for i in range(r.count()):
         e = r.index[i]
         print "% 6d % 9d % 7d % 6d % 7d %s.. %s.. %s.." % (
             i, e[0], e[1], e[2], e[3],
             hg.hex(e[4][:5]), hg.hex(e[5][:5]), hg.hex(e[6][:5]))
 
 elif cmd == "debugindexdot":
     if ".hg" not in args[0]:
         args[0] = ".hg/data/" + repo.file(args[0]).encodepath(args[0]) + "i"
 
     r = hg.revlog(open, args[0], "")
     print "digraph G {"
     for i in range(r.count()):
         e = r.index[i]
         print "\t%d -> %d" % (r.rev(e[4]), i)
         if e[5] != hg.nullid:
             print "\t%d -> %d" % (r.rev(e[5]), i)
     print "}"
 
 elif cmd == "tags":
     repo.lookup(0) # prime the cache
     i = repo.tags.items()
     i.sort()
     for k, n in i:
         try:
             r = repo.changelog.rev(n)
         except KeyError:
             r = "?"
         print "%-30s %5d:%s" % (k, repo.changelog.rev(n), hg.hex(n))
 
-elif cmd == "verify":
-    filelinkrevs = {}
-    filenodes = {}
-    manifestchangeset = {}
-    changesets = revisions = files = 0
-    errors = 0
-
-    ui.status("checking changesets\n")
-    for i in range(repo.changelog.count()):
-        changesets += 1
-        n = repo.changelog.node(i)
-        for p in repo.changelog.parents(n):
-            if p not in repo.changelog.nodemap:
-                ui.warn("changeset %s has unknown parent %s\n" %
-                        (hg.short(n), hg.short(p)))
-                errors += 1
-        try:
-            changes = repo.changelog.read(n)
-        except Exception, inst:
-            ui.warn("unpacking changeset %s: %s\n" % (short(n), inst))
-            errors += 1
-            
-        manifestchangeset[changes[0]] = n
-        for f in changes[3]:
-            filelinkrevs.setdefault(f, []).append(i)
-
-    ui.status("checking manifests\n")
-    for i in range(repo.manifest.count()):
-        n = repo.manifest.node(i)
-        for p in repo.manifest.parents(n):
-            if p not in repo.manifest.nodemap:
-                ui.warn("manifest %s has unknown parent %s\n" %
-                        (hg.short(n), hg.short(p)))
-                errors += 1
-        ca = repo.changelog.node(repo.manifest.linkrev(n))
-        cc = manifestchangeset[n]
-        if ca != cc:
-            ui.warn("manifest %s points to %s, not %s\n" %
-                    (hg.hex(n), hg.hex(ca), hg.hex(cc)))
-            errors += 1
-
-        try:
-            delta = mdiff.patchtext(repo.manifest.delta(n))
-        except KeyboardInterrupt:
-            print "aborted"
-            sys.exit(0)
-        except Exception, inst:
-            ui.warn("unpacking manifest %s: %s\n" % (hg.short(n), inst))
-            errors += 1
-
-        ff = [ l.split('\0') for l in delta.splitlines() ]
-        for f, fn in ff:
-            filenodes.setdefault(f, {})[hg.bin(fn)] = 1
-
-    ui.status("crosschecking files in changesets and manifests\n")
-    for f in filenodes:
-        if f not in filelinkrevs:
-            ui.warn("file %s in manifest but not in changesets\n" % f)
-            errors += 1
-
-    for f in filelinkrevs:
-        if f not in filenodes:
-            ui.warn("file %s in changeset but not in manifest\n" % f)
-            errors += 1
-
-    ui.status("checking files\n")
-    ff = filenodes.keys()
-    ff.sort()
-    for f in ff:
-        if f == "/dev/null": continue
-        files += 1
-        fl = repo.file(f)
-        nodes = { hg.nullid: 1 }
-        for i in range(fl.count()):
-            revisions += 1
-            n = fl.node(i)
-
-            if n not in filenodes[f]:
-                ui.warn("%s: %d:%s not in manifests\n" % (f, i, hg.short(n)))
-                print len(filenodes[f].keys()), fl.count(), f
-                errors += 1
-            else:
-                del filenodes[f][n]
-
-            flr = fl.linkrev(n)
-            if flr not in filelinkrevs[f]:
-                ui.warn("%s:%s points to unexpected changeset rev %d\n"
-                        % (f, hg.short(n), fl.linkrev(n)))
-                errors += 1
-            else:
-                filelinkrevs[f].remove(flr)
-
-            # verify contents
-            try:
-                t = fl.read(n)
-            except Exception, inst:
-                ui.warn("unpacking file %s %s: %s\n" % (f, hg.short(n), inst))
-                errors += 1
-            
-            # verify parents
-            (p1, p2) = fl.parents(n)
-            if p1 not in nodes:
-                ui.warn("file %s:%s unknown parent 1 %s" %
-                        (f, hg.short(n), hg.short(p1)))
-                errors += 1
-            if p2 not in nodes:
-                ui.warn("file %s:%s unknown parent 2 %s" %
-                        (f, hg.short(n), hg.short(p1)))
-                errors += 1
-            nodes[n] = 1
-
-        # cross-check
-        for node in filenodes[f]:
-            ui.warn("node %s in manifests not in %s\n" % (hg.hex(n), f))
-            errors += 1
-
-    ui.status("%d files, %d changesets, %d total revisions\n" %
-              (files, changesets, revisions))
-    
-    if errors:
-        ui.warn("%d integrity errors encountered!\n" % errors)
-        sys.exit(1)
-
 else:
     if cmd: ui.warn("unknown command\n\n")
     sys.exit(1)

mercurial/commands.py

@@ -1,502 +1,507 b''
 import os, re, traceback, sys, signal, time, mdiff
 from mercurial import fancyopts, ui, hg
 
 class UnknownCommand(Exception): pass
 
 def filterfiles(filters, files):
     l = [ x for x in files if x in filters ]
 
     for t in filters:
         if t and t[-1] != os.sep: t += os.sep
         l += [ x for x in files if x.startswith(t) ]
     return l
 
 def relfilter(repo, files):
     if os.getcwd() != repo.root:
         p = os.getcwd()[len(repo.root) + 1: ]
         return filterfiles(p, files)
     return files
 
 def relpath(repo, args):
     if os.getcwd() != repo.root:
         p = os.getcwd()[len(repo.root) + 1: ]
         return [ os.path.normpath(os.path.join(p, x)) for x in args ]
     return args
 
 def dodiff(repo, files = None, node1 = None, node2 = None):
     def date(c):
         return time.asctime(time.gmtime(float(c[2].split(' ')[0])))
 
     if node2:
         change = repo.changelog.read(node2)
         mmap2 = repo.manifest.read(change[0])
         (c, a, d) = repo.diffrevs(node1, node2)
         def read(f): return repo.file(f).read(mmap2[f])
         date2 = date(change)
     else:
         date2 = time.asctime()
         (c, a, d, u) = repo.diffdir(repo.root, node1)
         if not node1:
             node1 = repo.dirstate.parents()[0]
         def read(f): return file(os.path.join(repo.root, f)).read()
 
     change = repo.changelog.read(node1)
     mmap = repo.manifest.read(change[0])
     date1 = date(change)
 
     if files:
         c, a, d = map(lambda x: filterfiles(files, x), (c, a, d))
 
     for f in c:
         to = repo.file(f).read(mmap[f])
         tn = read(f)
         sys.stdout.write(mdiff.unidiff(to, date1, tn, date2, f))
     for f in a:
         to = ""
         tn = read(f)
         sys.stdout.write(mdiff.unidiff(to, date1, tn, date2, f))
     for f in d:
         to = repo.file(f).read(mmap[f])
         tn = ""
         sys.stdout.write(mdiff.unidiff(to, date1, tn, date2, f))
     
 def help(ui, cmd=None):
     '''show help'''
     if cmd:
         try:
             i = find(cmd)
             ui.write("%s\n\n" % i[2])
             ui.write(i[0].__doc__, "\n")
         except UnknownCommand:
             ui.warn("unknown command %s", cmd)
         sys.exit(0)
     
     ui.status("""\
  hg commands:
 
  add [files...]        add the given files in the next commit
  addremove             add all new files, delete all missing files
  annotate [files...]   show changeset number per file line
  branch <path>         create a branch of <path> in this directory
  checkout [changeset]  checkout the latest or given changeset
  commit                commit all changes to the repository
  diff [files...]       diff working directory (or selected files)
  dump <file> [rev]     dump the latest or given revision of a file
  dumpmanifest [rev]    dump the latest or given revision of the manifest
  export <rev>          dump the changeset header and diffs for a revision
  history               show changeset history
  init                  create a new repository in this directory
  log <file>            show revision history of a single file
  merge <path>          merge changes from <path> into local repository
  recover               rollback an interrupted transaction
  remove [files...]     remove the given files in the next commit
  serve                 export the repository via HTTP
  status                show new, missing, and changed files in working dir
  tags                  show current changeset tags
  undo                  undo the last transaction
 """)
 
 def add(ui, repo, file, *files):
     '''add the specified files on the next commit'''
     repo.add(relpath(repo, (file,) + files))
 
 def addremove(ui, repo):
     (c, a, d, u) = repo.diffdir(repo.root)
     repo.add(a)
     repo.remove(d)
 
 def annotate(u, repo, file, *files, **ops):
     def getnode(rev):
         return hg.short(repo.changelog.node(rev))
 
     def getname(rev):
         try:
             return bcache[rev]
         except KeyError:
             cl = repo.changelog.read(repo.changelog.node(rev))
             name = cl[1]
             f = name.find('@')
             if f >= 0:
                 name = name[:f]
             bcache[rev] = name
             return name
     
     bcache = {}
     opmap = [['user', getname], ['number', str], ['changeset', getnode]]
     if not ops['user'] and not ops['changeset']:
         ops['number'] = 1
 
     node = repo.dirstate.parents()[0]
     if ops['revision']:
         node = repo.changelog.lookup(ops['revision'])
     change = repo.changelog.read(node)
     mmap = repo.manifest.read(change[0])
     maxuserlen = 0
     maxchangelen = 0
     for f in relpath(repo, (file,) + files):
         lines = repo.file(f).annotate(mmap[f])
         pieces = []
 
         for o, f in opmap:
             if ops[o]:
                 l = [ f(n) for n,t in lines ]
                 m = max(map(len, l))
                 pieces.append([ "%*s" % (m, x) for x in l])
 
         for p,l in zip(zip(*pieces), lines):
             u.write(" ".join(p) + ": " + l[1])
 
 def branch(ui, path):
     '''branch from a local repository'''
     # this should eventually support remote repos
     os.system("cp -al %s/.hg .hg" % path)
 
 def checkout(ui, repo, changeset=None):
     '''checkout a given changeset or the current tip'''
     (c, a, d, u) = repo.diffdir(repo.root)
     if c or a or d:
         ui.warn("aborting (outstanding changes in working directory)\n")
         sys.exit(1)
 
     node = repo.changelog.tip()
     if changeset:
         node = repo.lookup(changeset)
     repo.checkout(node)
 
 def commit(ui, repo, *files):
     """commit the specified files or all outstanding changes"""
     repo.commit(relpath(repo, files))
 
 def diff(ui, repo, *files, **opts):
     revs = []
     if opts['rev']:
         revs = map(lambda x: repo.lookup(x), opts['rev'])
     
     if len(revs) > 2:
         self.ui.warn("too many revisions to diff\n")
         sys.exit(1)
 
     if files:
         files = relpath(repo, files)
     else:
         files = relpath(repo, [""])
 
     dodiff(repo, files, *revs)
 
 def export(ui, repo, changeset):
     node = repo.lookup(changeset)
     prev, other = repo.changelog.parents(node)
     change = repo.changelog.read(node)
     print "# HG changeset patch"
     print "# User %s" % change[1]
     print "# Node ID %s" % hg.hex(node)
     print "# Parent  %s" % hg.hex(prev)
     print
     if other != hg.nullid:
         print "# Parent  %s" % hg.hex(other)
     print change[4].rstrip()
     print
     
     dodiff(repo, None, prev, node)
 
 def forget(ui, repo, file, *files):
     """don't add the specified files on the next commit"""
     repo.forget(relpath(repo, (file,) + files))
 
 def heads(ui, repo):
     '''show current repository heads'''
     for n in repo.changelog.heads():
         i = repo.changelog.rev(n)
         changes = repo.changelog.read(n)
         (p1, p2) = repo.changelog.parents(n)
         (h, h1, h2) = map(hg.hex, (n, p1, p2))
         (i1, i2) = map(repo.changelog.rev, (p1, p2))
         print "rev:      %4d:%s" % (i, h)
         print "parents:  %4d:%s" % (i1, h1)
         if i2: print "          %4d:%s" % (i2, h2)
         print "manifest: %4d:%s" % (repo.manifest.rev(changes[0]),
                                     hg.hex(changes[0]))
         print "user:", changes[1]
         print "date:", time.asctime(
             time.localtime(float(changes[2].split(' ')[0])))
         if ui.verbose: print "files:", " ".join(changes[3])
         print "description:"
         print changes[4]
 
 def history(ui, repo):
     """show the changelog history"""
     for i in range(repo.changelog.count()):
         n = repo.changelog.node(i)
         changes = repo.changelog.read(n)
         (p1, p2) = repo.changelog.parents(n)
         (h, h1, h2) = map(hg.hex, (n, p1, p2))
         (i1, i2) = map(repo.changelog.rev, (p1, p2))
         print "rev:      %4d:%s" % (i, h)
         print "parents:  %4d:%s" % (i1, h1)
         if i2: print "          %4d:%s" % (i2, h2)
         print "manifest: %4d:%s" % (repo.manifest.rev(changes[0]),
                                     hg.hex(changes[0]))
         print "user:", changes[1]
         print "date:", time.asctime(
             time.localtime(float(changes[2].split(' ')[0])))
         if ui.verbose: print "files:", " ".join(changes[3])
         print "description:"
         print changes[4]
 
 def patch(ui, repo, patches, opts):
     """import an ordered set of patches"""
     try:
         import psyco
         psyco.full()
     except:
         pass
     
     d = opts["base"]
     strip = opts["strip"]
     quiet = opts["quiet"] and "> /dev/null" or ""
 
     for patch in patches:
         ui.status("applying %s\n" % patch)
         pf = os.path.join(d, patch)
 
         text = ""
         for l in file(pf):
             if l[:4] == "--- ": break
             text += l
 
         f = os.popen("lsdiff --strip %d %s" % (strip, pf))
         files = filter(None, map(lambda x: x.rstrip(), f.read().splitlines()))
         f.close()
 
         if files:
             if os.system("patch -p%d < %s %s" % (strip, pf, quiet)):
                 raise "patch failed!"
         repo.commit(files, text)
 
 def init(ui):
     """create a repository"""
     hg.repository(ui, ".", create=1)
 
 def log(ui, repo, f):
     f = relpath(repo, [f])[0]
 
     r = repo.file(f)
     for i in range(r.count()):
         n = r.node(i)
         (p1, p2) = r.parents(n)
         (h, h1, h2) = map(hg.hex, (n, p1, p2))
         (i1, i2) = map(r.rev, (p1, p2))
         cr = r.linkrev(n)
         cn = hg.hex(repo.changelog.node(cr))
         print "rev:       %4d:%s" % (i, h)
         print "changeset: %4d:%s" % (cr, cn)
         print "parents:   %4d:%s" % (i1, h1)
         if i2: print "           %4d:%s" % (i2, h2)
         changes = repo.changelog.read(repo.changelog.node(cr))
         print "user: %s" % changes[1]
         print "date: %s" % time.asctime(
             time.localtime(float(changes[2].split(' ')[0])))
         print "description:"
         print changes[4].rstrip()
         print
 
 def parents(ui, repo, node = None):
     '''show the parents of the current working dir'''
     if node:
         p = repo.changelog.parents(repo.lookup(hg.bin(node)))
     else:
         p = repo.dirstate.parents()
 
     for n in p:
         if n != hg.nullid:
             ui.write("%d:%s\n" % (repo.changelog.rev(n), hg.hex(n)))
 
 def pull(ui, repo, source):
     """pull changes from the specified source"""
     paths = {}
     try:
         pf = os.path.expanduser("~/.hgpaths")
         for l in file(pf):
             name, path = l.split()
             paths[name] = path
     except IOError:
         pass
 
     if source in paths: source = paths[source]
     
     other = hg.repository(ui, source)
     cg = repo.getchangegroup(other)
     repo.addchangegroup(cg)
 
 def rawcommit(ui, repo, files, rc):
     "raw commit interface"
 
     text = rc['text']
     if not text and rc['logfile']:
         try: text = open(rc['logfile']).read()
         except IOError: pass
     if not text and not rc['logfile']:
         print "missing commit text"
         return 1
 
     files = relpath(repo, files)
     if rc['files']:
         files += open(rc['files']).read().splitlines()
         
     repo.rawcommit(files, text, rc['user'], rc['date'], *rc['parent'])
  
 def recover(ui, repo):
     repo.recover()
 
 def remove(ui, repo, file, *files):
     """remove the specified files on the next commit"""
     repo.remove(relpath(repo, (file,) + files))
 
 def resolve(ui, repo, node=None):
     '''merge a given node or the current tip into the working dir'''
     if not node:
         node = repo.changelog.tip()
     else:
         node = repo.lookup(node)
     repo.resolve(node)
 
 def serve(ui, repo, **opts):
     from mercurial import hgweb
     hgweb.server(repo.root, opts["name"], opts["templates"],
                  opts["address"], opts["port"])
     
 def status(ui, repo):
     '''show changed files in the working directory
 
     C = changed
     A = added
     R = removed
     ? = not tracked'''
     
     (c, a, d, u) = repo.diffdir(repo.root)
     (c, a, d, u) = map(lambda x: relfilter(repo, x), (c, a, d, u))
 
     for f in c: print "C", f
     for f in a: print "A", f
     for f in d: print "R", f
     for f in u: print "?", f
 
 def tip(ui, repo):
     n = repo.changelog.tip()
     t = repo.changelog.rev(n)
     ui.status("%d:%s\n" % (t, hg.hex(n)))
 
 def undo(ui, repo):
     repo.undo()
 
+def verify(ui, repo):
+    """verify the integrity of the repository"""
+    return repo.verify()
+
 table = {
     "add": (add, [], "hg add [files]"),
     "addremove": (addremove, [], "hg addremove"),
     "ann|annotate": (annotate,
                      [('r', 'revision', '', 'revision'),
                       ('u', 'user', None, 'show user'),
                       ('n', 'number', None, 'show revision number'),
                       ('c', 'changeset', None, 'show changeset')],
                      'hg annotate [-u] [-c] [-n] [-r id] [files]'),
     "branch|clone": (branch, [], 'hg branch [path]'),
     "checkout|co": (checkout, [], 'hg checkout [changeset]'),
     "commit|ci": (commit, [], 'hg commit [files]'),
     "diff": (diff, [('r', 'rev', [], 'revision')],
              'hg diff [-r A] [-r B] [files]'),
     "export": (export, [], "hg export <changeset>"),
     "forget": (forget, [], "hg forget [files]"),
     "heads": (heads, [], 'hg heads'),
     "history": (history, [], 'hg history'),
     "help": (help, [], 'hg help [command]'),
     "init": (init, [], 'hg init'),
     "log": (log, [], 'hg log <file>'),
     "parents": (parents, [], 'hg parents [node]'),
     "patch|import": (patch,
                      [('p', 'strip', 1, 'path strip'),
                       ('b', 'base', "", 'base path'),
                       ('q', 'quiet', "", 'silence diff')],
                      "hg import [options] patches"),
     "pull|merge": (pull, [], 'hg pull [source]'),
     "rawcommit": (rawcommit,
                   [('p', 'parent', [], 'parent'),
                    ('d', 'date', "", 'data'),
                    ('u', 'user', "", 'user'),
                    ('F', 'files', "", 'file list'),
                    ('t', 'text', "", 'commit text'),
                    ('l', 'logfile', "", 'commit text file')],
                   'hg rawcommit [options] [files]'),
     "recover": (recover, [], "hg recover"),
     "remove": (remove, [], "hg remove [files]"),
     "resolve": (resolve, [], 'hg resolve [node]'),
     "serve": (serve, [('p', 'port', 8000, 'listen port'),
                       ('a', 'address', '', 'interface address'),
                       ('n', 'name', os.getcwd(), 'repository name'),
                       ('t', 'templates', "", 'template map')],
               "hg serve [options]"),
     "status": (status, [], 'hg status'),
     "tip": (tip, [], 'hg tip'),
     "undo": (undo, [], 'hg undo'),
+    "verify": (verify, [], 'hg verify'),
     }
 
 norepo = "init branch help"
 
 def find(cmd):
     i = None
     for e in table.keys():
         if re.match(e + "$", cmd):
             return table[e]
 
     raise UnknownCommand(cmd)
 
 class SignalInterrupt(Exception): pass
 
 def catchterm(*args):
     raise SignalInterrupt
 
 def dispatch(args):
     options = {}
     opts = [('v', 'verbose', None, 'verbose'),
             ('d', 'debug', None, 'debug'),
             ('q', 'quiet', None, 'quiet'),
             ('y', 'noninteractive', None, 'run non-interactively'),
             ]
 
     args = fancyopts.fancyopts(args, opts, options,
                                'hg [options] <command> [options] [files]')
 
     if not args:
         cmd = "help"
     else:
         cmd, args = args[0], args[1:]
 
     u = ui.ui(options["verbose"], options["debug"], options["quiet"],
            not options["noninteractive"])
 
     # deal with unfound commands later
     i = find(cmd)
 
     signal.signal(signal.SIGTERM, catchterm)
 
     cmdoptions = {}
     args = fancyopts.fancyopts(args, i[1], cmdoptions, i[2])
 
     if cmd not in norepo.split():
         repo = hg.repository(ui = u)
         d = lambda: i[0](u, repo, *args, **cmdoptions)
     else:
         d = lambda: i[0](u, *args, **cmdoptions)
 
     try:
         return d()
     except SignalInterrupt:
         u.warn("killed!\n")
     except KeyboardInterrupt:
         u.warn("interrupted!\n")
     except TypeError, inst:
         # was this an argument error?
         tb = traceback.extract_tb(sys.exc_info()[2])
         if len(tb) > 2: # no
             raise
         u.warn("%s: invalid arguments\n" % i[0].__name__)
         u.warn("syntax: %s\n" % i[2])
         sys.exit(-1)

mercurial/hg.py

@@ -1,1075 +1,1202 b''
 # hg.py - repository classes for mercurial
 #
 # Copyright 2005 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
 
 import sys, struct, sha, socket, os, time, re, urllib2, tempfile
 import urllib
 from mercurial import byterange, lock
 from mercurial.transaction import *
 from mercurial.revlog import *
 from difflib import SequenceMatcher
 
 class filelog(revlog):
     def __init__(self, opener, path):
         revlog.__init__(self, opener,
                         os.path.join("data", path + ".i"),
                         os.path.join("data", path + ".d"))
 
     def read(self, node):
         return self.revision(node)
     def add(self, text, transaction, link, p1=None, p2=None):
         return self.addrevision(text, transaction, link, p1, p2)
 
     def annotate(self, node):
 
         def decorate(text, rev):
             return [(rev, l) for l in text.splitlines(1)]
 
         def strip(annotation):
             return [e[1] for e in annotation]
 
         def pair(parent, child):
             new = []
             sm = SequenceMatcher(None, strip(parent), strip(child))
             for o, m, n, s, t in sm.get_opcodes():
                 if o == 'equal':
                     new += parent[m:n]
                 else:
                     new += child[s:t]
             return new
 
         # find all ancestors
         needed = {node:1}
         visit = [node]
         while visit:
             n = visit.pop(0)
             for p in self.parents(n):
                 if p not in needed:
                     needed[p] = 1
                     visit.append(p)
                 else:
                     # count how many times we'll use this
                     needed[p] += 1
 
         # sort by revision which is a topological order
         visit = needed.keys()
         visit = [ (self.rev(n), n) for n in visit ]
         visit.sort()
         visit = [ p[1] for p in visit ]
         hist = {}
 
         for n in visit:
             curr = decorate(self.read(n), self.linkrev(n))
             for p in self.parents(n):
                 if p != nullid:
                     curr = pair(hist[p], curr)
                     # trim the history of unneeded revs
                     needed[p] -= 1
                     if not needed[p]:
                         del hist[p]
             hist[n] = curr
 
         return hist[n]
 
 class manifest(revlog):
     def __init__(self, opener):
         self.mapcache = None
         self.listcache = None
         self.addlist = None
         revlog.__init__(self, opener, "00manifest.i", "00manifest.d")
 
     def read(self, node):
         if self.mapcache and self.mapcache[0] == node:
             return self.mapcache[1].copy()
         text = self.revision(node)
         map = {}
         self.listcache = (text, text.splitlines(1))
         for l in self.listcache[1]:
             (f, n) = l.split('\0')
             map[f] = bin(n[:40])
         self.mapcache = (node, map)
         return map
 
     def diff(self, a, b):
         # this is sneaky, as we're not actually using a and b
         if self.listcache and self.addlist and self.listcache[0] == a:
             d = mdiff.diff(self.listcache[1], self.addlist, 1)
             if mdiff.patch(a, d) != b:
                 sys.stderr.write("*** sortdiff failed, falling back ***\n")
                 return mdiff.textdiff(a, b)
             return d
         else:
             return mdiff.textdiff(a, b)
 
     def add(self, map, transaction, link, p1=None, p2=None):
         files = map.keys()
         files.sort()
 
         self.addlist = ["%s\000%s\n" % (f, hex(map[f])) for f in files]
         text = "".join(self.addlist)
 
         n = self.addrevision(text, transaction, link, p1, p2)
         self.mapcache = (n, map)
         self.listcache = (text, self.addlist)
         self.addlist = None
 
         return n
 
 class changelog(revlog):
     def __init__(self, opener):
         revlog.__init__(self, opener, "00changelog.i", "00changelog.d")
 
     def extract(self, text):
         if not text:
             return (nullid, "", "0", [], "")
         last = text.index("\n\n")
         desc = text[last + 2:]
         l = text[:last].splitlines()
         manifest = bin(l[0])
         user = l[1]
         date = l[2]
         files = l[3:]
         return (manifest, user, date, files, desc)
 
     def read(self, node):
         return self.extract(self.revision(node))
 
     def add(self, manifest, list, desc, transaction, p1=None, p2=None,
                   user=None, date=None):
         user = (user or
                 os.environ.get("HGUSER") or
                 os.environ.get("EMAIL") or
                 os.environ.get("LOGNAME", "unknown") + '@' + socket.getfqdn())
         date = date or "%d %d" % (time.time(), time.timezone)
         list.sort()
         l = [hex(manifest), user, date] + list + ["", desc]
         text = "\n".join(l)
         return self.addrevision(text, transaction, self.count(), p1, p2)
 
 class dirstate:
     def __init__(self, opener, ui, root):
         self.opener = opener
         self.root = root
         self.dirty = 0
         self.ui = ui
         self.map = None
         self.pl = None
 
     def __del__(self):
         if self.dirty:
             self.write()
 
     def __getitem__(self, key):
         try:
             return self.map[key]
         except TypeError:
             self.read()
             return self[key]
 
     def __contains__(self, key):
         if not self.map: self.read()
         return key in self.map
 
     def parents(self):
         if not self.pl:
             self.read()
         return self.pl
 
     def setparents(self, p1, p2 = nullid):
         self.dirty = 1
         self.pl = p1, p2
 
     def state(self, key):
         try:
             return self[key][0]
         except KeyError:
             return "?"
 
     def read(self):
         if self.map is not None: return self.map
 
         self.map = {}
         self.pl = [nullid, nullid]
         try:
             st = self.opener("dirstate").read()
         except: return
 
         self.pl = [st[:20], st[20: 40]]
 
         pos = 40
         while pos < len(st):
             e = struct.unpack(">cllll", st[pos:pos+17])
             l = e[4]
             pos += 17
             f = st[pos:pos + l]
             self.map[f] = e[:4]
             pos += l
         
     def update(self, files, state):
         ''' current states:
         n  normal
         m  needs merging
         i  invalid
         r  marked for removal
         a  marked for addition'''
 
         if not files: return
         self.read()
         self.dirty = 1
         for f in files:
             if state == "r":
                 self.map[f] = ('r', 0, 0, 0)
             else:
                 try:
                     s = os.stat(os.path.join(self.root, f))
                     self.map[f] = (state, s.st_mode, s.st_size, s.st_mtime)
                 except OSError:
                     if state != "i": raise
                     self.map[f] = ('r', 0, 0, 0)
 
     def forget(self, files):
         if not files: return
         self.read()
         self.dirty = 1
         for f in files:
             try:
                 del self.map[f]
             except KeyError:
                 self.ui.warn("not in dirstate: %s!\n" % f)
                 pass
 
     def clear(self):
         self.map = {}
         self.dirty = 1
 
     def write(self):
         st = self.opener("dirstate", "w")
         st.write("".join(self.pl))
         for f, e in self.map.items():
             e = struct.pack(">cllll", e[0], e[1], e[2], e[3], len(f))
             st.write(e + f)
         self.dirty = 0
 
     def copy(self):
         self.read()
         return self.map.copy()
 
 # used to avoid circular references so destructors work
 def opener(base):
     p = base
     def o(path, mode="r"):
         if p[:7] == "http://":
             f = os.path.join(p, urllib.quote(path))
             return httprangereader(f)
 
         f = os.path.join(p, path)
 
         if mode != "r":
             try:
                 s = os.stat(f)
             except OSError:
                 d = os.path.dirname(f)
                 if not os.path.isdir(d):
                     os.makedirs(d)
             else:
                 if s.st_nlink > 1:
                     file(f + ".tmp", "w").write(file(f).read())
                     os.rename(f+".tmp", f)
 
         return file(f, mode)
 
     return o
 
 class localrepository:
     def __init__(self, ui, path=None, create=0):
         self.remote = 0
         if path and path[:7] == "http://":
             self.remote = 1
             self.path = path
         else:
             if not path:
                 p = os.getcwd()
                 while not os.path.isdir(os.path.join(p, ".hg")):
                     p = os.path.dirname(p)
                     if p == "/": raise "No repo found"
                 path = p
             self.path = os.path.join(path, ".hg")
 
         self.root = path
         self.ui = ui
 
         if create:
             os.mkdir(self.path)  
             os.mkdir(self.join("data"))
 
         self.opener = opener(self.path)
         self.manifest = manifest(self.opener)
         self.changelog = changelog(self.opener)
         self.ignorelist = None
         self.tags = None
 
         if not self.remote:
             self.dirstate = dirstate(self.opener, ui, self.root)
 
     def ignore(self, f):
         if self.ignorelist is None:
             self.ignorelist = []
             try:
                 l = open(os.path.join(self.root, ".hgignore"))
                 for pat in l:
                     if pat != "\n":
                         self.ignorelist.append(re.compile(pat[:-1]))
             except IOError: pass
         for pat in self.ignorelist:
             if pat.search(f): return True
         return False
 
     def lookup(self, key):
         if self.tags is None:
             self.tags = {}
             try:
                 fl = self.file(".hgtags")
                 for l in fl.revision(fl.tip()).splitlines():
                     if l:
                         n, k = l.split(" ")
                         self.tags[k] = bin(n)
             except KeyError: pass
         try:
             return self.tags[key]
         except KeyError:
             return self.changelog.lookup(key)
 
     def join(self, f):
         return os.path.join(self.path, f)
 
     def wjoin(self, f):
         return os.path.join(self.root, f)
 
     def file(self, f):
         if f[0] == '/': f = f[1:]
         return filelog(self.opener, f)
 
     def transaction(self):
         return transaction(self.opener, self.join("journal"),
                            self.join("undo"))
 
     def recover(self):
         lock = self.lock()
         if os.path.exists(self.join("recover")):
             self.ui.status("attempting to rollback interrupted transaction\n")
             return rollback(self.opener, self.join("recover"))
         else:
             self.ui.warn("no interrupted transaction available\n")
 
     def undo(self):
         lock = self.lock()
         if os.path.exists(self.join("undo")):
             f = self.changelog.read(self.changelog.tip())[3]
             self.ui.status("attempting to rollback last transaction\n")
             rollback(self.opener, self.join("undo"))
             self.manifest = manifest(self.opener)
             self.changelog = changelog(self.opener)
 
             self.ui.status("discarding dirstate\n")
             node = self.changelog.tip()
             f.sort()
 
             self.dirstate.setparents(node)
             self.dirstate.update(f, 'i')
         
         else:
             self.ui.warn("no undo information available\n")
 
     def lock(self, wait = 1):
         try:
             return lock.lock(self.join("lock"), 0)
         except lock.LockHeld, inst:
             if wait:
                 self.ui.warn("waiting for lock held by %s\n" % inst.args[0])
                 return lock.lock(self.join("lock"), wait)
             raise inst
 
     def rawcommit(self, files, text, user, date, p1=None, p2=None):
         p1 = p1 or self.dirstate.parents()[0] or nullid
         p2 = p2 or self.dirstate.parents()[1] or nullid
         pchange = self.changelog.read(p1)
         pmmap = self.manifest.read(pchange[0])
         tr = self.transaction()
         mmap = {}
         linkrev = self.changelog.count()
         for f in files:
             try:
                 t = file(f).read()
             except IOError:
                 self.ui.warn("Read file %s error, skipped\n" % f)
                 continue
             r = self.file(f)
             # FIXME - need to find both parents properly
             prev = pmmap.get(f, nullid)
             mmap[f] = r.add(t, tr, linkrev, prev)
 
         mnode = self.manifest.add(mmap, tr, linkrev, pchange[0])
         n = self.changelog.add(mnode, files, text, tr, p1, p2, user ,date, )
         tr.close()
         self.dirstate.setparents(p1, p2)
         self.dirstate.clear()
         self.dirstate.update(mmap.keys(), "n")
 
     def commit(self, files = None, text = ""):
         commit = []
         remove = []
         if files:
             for f in files:
                 s = self.dirstate.state(f)
                 if s in 'nmai':
                     commit.append(f)
                 elif s == 'r':
                     remove.append(f)
                 else:
                     self.ui.warn("%s not tracked!\n" % f)
         else:
             (c, a, d, u) = self.diffdir(self.root)
             commit = c + a
             remove = d
 
         if not commit and not remove:
             self.ui.status("nothing changed\n")
             return
 
         p1, p2 = self.dirstate.parents()
         c1 = self.changelog.read(p1)
         c2 = self.changelog.read(p2)
         m1 = self.manifest.read(c1[0])
         m2 = self.manifest.read(c2[0])
         lock = self.lock()
         tr = self.transaction()
 
         # check in files
         new = {}
         linkrev = self.changelog.count()
         commit.sort()
         for f in commit:
             self.ui.note(f + "\n")
             try:
                 t = file(self.wjoin(f)).read()
             except IOError:
                 self.warn("trouble committing %s!\n" % f)
                 raise
 
             r = self.file(f)
             fp1 = m1.get(f, nullid)
             fp2 = m2.get(f, nullid)
             new[f] = r.add(t, tr, linkrev, fp1, fp2)
 
         # update manifest
         m1.update(new)
         for f in remove: del m1[f]
         mn = self.manifest.add(m1, tr, linkrev, c1[0], c2[0])
 
         # add changeset
         new = new.keys()
         new.sort()
 
         edittext = text + "\n" + "HG: manifest hash %s\n" % hex(mn)
         edittext += "".join(["HG: changed %s\n" % f for f in new])
         edittext += "".join(["HG: removed %s\n" % f for f in remove])
         edittext = self.ui.edit(edittext)
 
         n = self.changelog.add(mn, new, edittext, tr, p1, p2)
         tr.close()
 
         self.dirstate.setparents(n)
         self.dirstate.update(new, "n")
         self.dirstate.forget(remove)
 
     def checkout(self, node):
         # checkout is really dumb at the moment
         # it ought to basically merge
         change = self.changelog.read(node)
         l = self.manifest.read(change[0]).items()
         l.sort()
 
         for f,n in l:
             if f[0] == "/": continue
             self.ui.note(f, "\n")
             t = self.file(f).revision(n)
             try:
                 file(self.wjoin(f), "w").write(t)
             except IOError:
                 os.makedirs(os.path.dirname(f))
                 file(self.wjoin(f), "w").write(t)
 
         self.dirstate.setparents(node)
         self.dirstate.clear()
         self.dirstate.update([f for f,n in l], "n")
 
     def diffdir(self, path, changeset = None):
         changed = []
         added = []
         unknown = []
         mf = {}
 
         if changeset:
             change = self.changelog.read(changeset)
             mf = self.manifest.read(change[0])
             dc = dict.fromkeys(mf)
         else:
             changeset = self.dirstate.parents()[0]
             change = self.changelog.read(changeset)
             mf = self.manifest.read(change[0])
             dc = self.dirstate.copy()
 
         def fcmp(fn):
             t1 = file(self.wjoin(fn)).read()
             t2 = self.file(fn).revision(mf[fn])
             return cmp(t1, t2)
 
         for dir, subdirs, files in os.walk(self.root):
             d = dir[len(self.root)+1:]
             if ".hg" in subdirs: subdirs.remove(".hg")
             
             for f in files:
                 fn = os.path.join(d, f)
                 try: s = os.stat(os.path.join(self.root, fn))
                 except: continue
                 if fn in dc:
                     c = dc[fn]
                     del dc[fn]
                     if not c:
                         if fcmp(fn):
                             changed.append(fn)
                     elif c[0] == 'i':
                         if fn not in mf:
                             added.append(fn)
                         elif fcmp(fn):
                             changed.append(fn)
                     elif c[0] == 'm':
                         changed.append(fn)
                     elif c[0] == 'a':
                         added.append(fn)
                     elif c[0] == 'r':
                         unknown.append(fn)
                     elif c[2] != s.st_size:
                         changed.append(fn)
                     elif c[1] != s.st_mode or c[3] != s.st_mtime:
                         if fcmp(fn):
                             changed.append(fn)
                 else:
                     if self.ignore(fn): continue
                     unknown.append(fn)
 
         deleted = dc.keys()
         deleted.sort()
 
         return (changed, added, deleted, unknown)
 
     def diffrevs(self, node1, node2):
         changed, added = [], []
 
         change = self.changelog.read(node1)
         mf1 = self.manifest.read(change[0])
         change = self.changelog.read(node2)
         mf2 = self.manifest.read(change[0])
 
         for fn in mf2:
             if mf1.has_key(fn):
                 if mf1[fn] != mf2[fn]:
                     changed.append(fn)
                 del mf1[fn]
             else:
                 added.append(fn)
                 
         deleted = mf1.keys()
         deleted.sort()
     
         return (changed, added, deleted)
 
     def add(self, list):
         for f in list:
             p = self.wjoin(f)
             if not os.path.isfile(p):
                 self.ui.warn("%s does not exist!\n" % f)
             elif self.dirstate.state(f) == 'n':
                 self.ui.warn("%s already tracked!\n" % f)
             else:
                 self.dirstate.update([f], "a")
 
     def forget(self, list):
         for f in list:
             if self.dirstate.state(f) not in 'ai':
                 self.ui.warn("%s not added!\n" % f)
             else:
                 self.dirstate.forget([f])
 
     def remove(self, list):
         for f in list:
             p = self.wjoin(f)
             if os.path.isfile(p):
                 self.ui.warn("%s still exists!\n" % f)
             elif f not in self.dirstate:
                 self.ui.warn("%s not tracked!\n" % f)
             else:
                 self.dirstate.update([f], "r")
 
     def heads(self):
         return self.changelog.heads()
 
     def branches(self, nodes):
         if not nodes: nodes = [self.changelog.tip()]
         b = []
         for n in nodes:
             t = n
             while n:
                 p = self.changelog.parents(n)
                 if p[1] != nullid or p[0] == nullid:
                     b.append((t, n, p[0], p[1]))
                     break
                 n = p[0]
         return b
 
     def between(self, pairs):
         r = []
 
         for top, bottom in pairs:
             n, l, i = top, [], 0
             f = 1
 
             while n != bottom:
                 p = self.changelog.parents(n)[0]
                 if i == f:
                     l.append(n) 
                     f = f * 2
                 n = p
                 i += 1
 
             r.append(l)
 
         return r
 
     def newer(self, nodes):
         m = {}
         nl = []
         pm = {}
         cl = self.changelog
         t = l = cl.count()
 
         # find the lowest numbered node
         for n in nodes:
             l = min(l, cl.rev(n))
             m[n] = 1
 
         for i in xrange(l, t):
             n = cl.node(i)
             if n in m: # explicitly listed
                 pm[n] = 1
                 nl.append(n)
                 continue
             for p in cl.parents(n):
                 if p in pm: # parent listed
                     pm[n] = 1
                     nl.append(n)
                     break
 
         return nl
 
     def getchangegroup(self, remote):
         m = self.changelog.nodemap
         search = []
         fetch = []
         seen = {}
         seenbranch = {}
 
         # if we have an empty repo, fetch everything
         if self.changelog.tip() == nullid:
             self.ui.status("requesting all changes\n")
             return remote.changegroup([nullid])
 
         # otherwise, assume we're closer to the tip than the root
         self.ui.status("searching for changes\n")
         heads = remote.heads()
         unknown = []
         for h in heads:
             if h not in m:
                 unknown.append(h)
 
         if not unknown:
             self.ui.status("nothing to do!\n")
             return None
             
         unknown = remote.branches(unknown)
         while unknown:
             n = unknown.pop(0)
             seen[n[0]] = 1
             
             self.ui.debug("examining %s:%s\n" % (short(n[0]), short(n[1])))
             if n == nullid: break
             if n in seenbranch:
                 self.ui.debug("branch already found\n")
                 continue
             if n[1] and n[1] in m: # do we know the base?
                 self.ui.debug("found incomplete branch %s:%s\n"
                               % (short(n[0]), short(n[1])))
                 search.append(n) # schedule branch range for scanning
                 seenbranch[n] = 1
             else:
                 if n[2] in m and n[3] in m:
                     if n[1] not in fetch:
                         self.ui.debug("found new changeset %s\n" %
                                       short(n[1]))
                         fetch.append(n[1]) # earliest unknown
                         continue
 
                 r = []
                 for a in n[2:4]:
                     if a not in seen: r.append(a)
                     
                 if r:
                     self.ui.debug("requesting %s\n" %
                                 " ".join(map(short, r)))
                     for b in remote.branches(r):
                         self.ui.debug("received %s:%s\n" %
                                       (short(b[0]), short(b[1])))
                         if b[0] not in m and b[0] not in seen:
                             unknown.append(b)
   
         while search:
             n = search.pop(0)
             l = remote.between([(n[0], n[1])])[0]
             p = n[0]
             f = 1
             for i in l + [n[1]]:
                 if i in m:
                     if f <= 2:
                         self.ui.debug("found new branch changeset %s\n" %
                                           short(p))
                         fetch.append(p)
                     else:
                         self.ui.debug("narrowed branch search to %s:%s\n"
                                       % (short(p), short(i)))
                         search.append((p, i))
                     break
                 p, f = i, f * 2
 
         for f in fetch:
             if f in m:
                 raise "already have", short(f[:4])
 
         self.ui.note("adding new changesets starting at " +
                      " ".join([short(f) for f in fetch]) + "\n")
 
         return remote.changegroup(fetch)
     
     def changegroup(self, basenodes):
         nodes = self.newer(basenodes)
 
         # construct the link map
         linkmap = {}
         for n in nodes:
             linkmap[self.changelog.rev(n)] = n
 
         # construct a list of all changed files
         changed = {}
         for n in nodes:
             c = self.changelog.read(n)
             for f in c[3]:
                 changed[f] = 1
         changed = changed.keys()
         changed.sort()
 
         # the changegroup is changesets + manifests + all file revs
         revs = [ self.changelog.rev(n) for n in nodes ]
 
         for y in self.changelog.group(linkmap): yield y
         for y in self.manifest.group(linkmap): yield y
         for f in changed:
             yield struct.pack(">l", len(f) + 4) + f
             g = self.file(f).group(linkmap)
             for y in g:
                 yield y
 
     def addchangegroup(self, generator):
 
         class genread:
             def __init__(self, generator):
                 self.g = generator
                 self.buf = ""
             def read(self, l):
                 while l > len(self.buf):
                     try:
                         self.buf += self.g.next()
                     except StopIteration:
                         break
                 d, self.buf = self.buf[:l], self.buf[l:]
                 return d
                 
         def getchunk():
             d = source.read(4)
             if not d: return ""
             l = struct.unpack(">l", d)[0]
             if l <= 4: return ""
             return source.read(l - 4)
 
         def getgroup():
             while 1:
                 c = getchunk()
                 if not c: break
                 yield c
 
         def csmap(x):
             self.ui.debug("add changeset %s\n" % short(x))
             return self.changelog.count()
 
         def revmap(x):
             return self.changelog.rev(x)
 
         if not generator: return
         changesets = files = revisions = 0
 
         source = genread(generator)
         lock = self.lock()
         tr = self.transaction()
 
         # pull off the changeset group
         self.ui.status("adding changesets\n")
         co = self.changelog.tip()
         cn = self.changelog.addgroup(getgroup(), csmap, tr, 1) # unique
         changesets = self.changelog.rev(cn) - self.changelog.rev(co)
 
         # pull off the manifest group
         self.ui.status("adding manifests\n")
         mm = self.manifest.tip()
         mo = self.manifest.addgroup(getgroup(), revmap, tr)
 
         # process the files
         self.ui.status("adding file revisions\n")
         while 1:
             f = getchunk()
             if not f: break
             self.ui.debug("adding %s revisions\n" % f)
             fl = self.file(f)
             o = fl.tip()
             n = fl.addgroup(getgroup(), revmap, tr)
             revisions += fl.rev(n) - fl.rev(o)
             files += 1
 
         self.ui.status(("modified %d files, added %d changesets" +
                         " and %d new revisions\n")
                        % (files, changesets, revisions))
 
         tr.close()
         return
 
     def resolve(self, node):
         pl = self.dirstate.parents()
         if pl[1] != nullid:
             self.ui.warn("last merge not committed")
             return
 
         p1, p2 = pl[0], node
         m1n = self.changelog.read(p1)[0]
         m2n = self.changelog.read(p2)[0]
         man = self.manifest.ancestor(m1n, m2n)
         m1 = self.manifest.read(m1n)
         m2 = self.manifest.read(m2n)
         ma = self.manifest.read(man)
 
         (c, a, d, u) = self.diffdir(self.root)
 
         # resolve the manifest to determine which files
         # we care about merging
         self.ui.status("resolving manifests\n")
         self.ui.debug(" ancestor %s local %s remote %s\n" %
                       (short(man), short(m1n), short(m2n)))
 
         merge = {}
         get = {}
         remove = []
 
         # construct a working dir manifest
         mw = m1.copy()
         for f in a + c:
             mw[f] = nullid
         for f in d:
             del mw[f]
 
         for f, n in mw.iteritems():
             if f in m2:
                 if n != m2[f]:
                     self.ui.debug(" %s versions differ, do resolve\n" % f)
                     merge[f] = (m1.get(f, nullid), m2[f])
                 del m2[f]
             elif f in ma:
                 if n != ma[f]:
                     r = self.ui.prompt(
                         (" local changed %s which remote deleted\n" % f) +
                         "(k)eep or (d)elete?", "[kd]", "k")
                     if r == "d":
                         remove.append(f)
                 else:
                     self.ui.debug("other deleted %s\n" % f)
                     pass # other deleted it
             else:
                 self.ui.debug("local created %s\n" %f)
 
         for f, n in m2.iteritems():
             if f in ma:
                 if n != ma[f]:
                     r = self.ui.prompt(
                         ("remote changed %s which local deleted\n" % f) +
                         "(k)eep or (d)elete?", "[kd]", "k")
                     if r == "d": remove.append(f)
                 else:
                     pass # probably safe
             else:
                 self.ui.debug("remote created %s, do resolve\n" % f)
                 get[f] = n
 
         del mw, m1, m2, ma
 
         self.dirstate.setparents(p1, p2)
 
         # get the files we don't need to change
         files = get.keys()
         files.sort()
         for f in files:
             if f[0] == "/": continue
             self.ui.note(f, "\n")
             t = self.file(f).revision(get[f])
             try:
                 file(self.wjoin(f), "w").write(t)
             except IOError:
                 os.makedirs(os.path.dirname(f))
                 file(self.wjoin(f), "w").write(t)
 
         # we have to remember what files we needed to get/change
         # because any file that's different from either one of its
         # parents must be in the changeset
         self.dirstate.update(files, 'm')
 
         # merge the tricky bits
         files = merge.keys()
         files.sort()
         for f in files:
             m, o = merge[f]
             self.merge3(f, m, o)
 
         # same here
         self.dirstate.update(files, 'm')
 
         for f in remove:
             self.ui.note("removing %s\n" % f)
             #os.unlink(f)
         self.dirstate.update(remove, 'r')
 
     def merge3(self, fn, my, other):
         """perform a 3-way merge in the working directory"""
         
         def temp(prefix, node):
             pre = "%s~%s." % (os.path.basename(fn), prefix)
             (fd, name) = tempfile.mkstemp("", pre)
             f = os.fdopen(fd, "w")
             f.write(fl.revision(node))
             f.close()
             return name
 
         fl = self.file(fn)
         base = fl.ancestor(my, other)
         a = self.wjoin(fn)
         b = temp("other", other)
         c = temp("base", base)
 
         self.ui.note("resolving %s\n" % fn)
         self.ui.debug("file %s: other %s ancestor %s\n" %
                               (fn, short(other), short(base)))
 
         cmd = os.environ.get("HGMERGE", "hgmerge")
         r = os.system("%s %s %s %s" % (cmd, a, b, c))
         if r:
             self.ui.warn("merging %s failed!\n" % f)
 
         os.unlink(b)
         os.unlink(c)
 
+    def verify(self):
+        filelinkrevs = {}
+        filenodes = {}
+        manifestchangeset = {}
+        changesets = revisions = files = 0
+        errors = 0
+
+        self.ui.status("checking changesets\n")
+        for i in range(self.changelog.count()):
+            changesets += 1
+            n = self.changelog.node(i)
+            for p in self.changelog.parents(n):
+                if p not in self.changelog.nodemap:
+                    self.ui.warn("changeset %s has unknown parent %s\n" %
+                                 (short(n), short(p)))
+                    errors += 1
+            try:
+                changes = self.changelog.read(n)
+            except Exception, inst:
+                self.ui.warn("unpacking changeset %s: %s\n" % (short(n), inst))
+                errors += 1
+
+            manifestchangeset[changes[0]] = n
+            for f in changes[3]:
+                filelinkrevs.setdefault(f, []).append(i)
+
+        self.ui.status("checking manifests\n")
+        for i in range(self.manifest.count()):
+            n = self.manifest.node(i)
+            for p in self.manifest.parents(n):
+                if p not in self.manifest.nodemap:
+                    self.ui.warn("manifest %s has unknown parent %s\n" %
+                            (short(n), short(p)))
+                    errors += 1
+            ca = self.changelog.node(self.manifest.linkrev(n))
+            cc = manifestchangeset[n]
+            if ca != cc:
+                self.ui.warn("manifest %s points to %s, not %s\n" %
+                        (hex(n), hex(ca), hex(cc)))
+                errors += 1
+
+            try:
+                delta = mdiff.patchtext(self.manifest.delta(n))
+            except KeyboardInterrupt:
+                print "aborted"
+                sys.exit(0)
+            except Exception, inst:
+                self.ui.warn("unpacking manifest %s: %s\n"
+                             % (short(n), inst))
+                errors += 1
+
+            ff = [ l.split('\0') for l in delta.splitlines() ]
+            for f, fn in ff:
+                filenodes.setdefault(f, {})[bin(fn)] = 1
+
+        self.ui.status("crosschecking files in changesets and manifests\n")
+        for f in filenodes:
+            if f not in filelinkrevs:
+                self.ui.warn("file %s in manifest but not in changesets\n" % f)
+                errors += 1
+
+        for f in filelinkrevs:
+            if f not in filenodes:
+                self.ui.warn("file %s in changeset but not in manifest\n" % f)
+                errors += 1
+
+        self.ui.status("checking files\n")
+        ff = filenodes.keys()
+        ff.sort()
+        for f in ff:
+            if f == "/dev/null": continue
+            files += 1
+            fl = self.file(f)
+            nodes = { nullid: 1 }
+            for i in range(fl.count()):
+                revisions += 1
+                n = fl.node(i)
+
+                if n not in filenodes[f]:
+                    self.ui.warn("%s: %d:%s not in manifests\n"
+                                 % (f, i, short(n)))
+                    print len(filenodes[f].keys()), fl.count(), f
+                    errors += 1
+                else:
+                    del filenodes[f][n]
+
+                flr = fl.linkrev(n)
+                if flr not in filelinkrevs[f]:
+                    self.ui.warn("%s:%s points to unexpected changeset %d\n"
+                            % (f, short(n), fl.linkrev(n)))
+                    errors += 1
+                else:
+                    filelinkrevs[f].remove(flr)
+
+                # verify contents
+                try:
+                    t = fl.read(n)
+                except Exception, inst:
+                    self.ui.warn("unpacking file %s %s: %s\n"
+                                 % (f, short(n), inst))
+                    errors += 1
+
+                # verify parents
+                (p1, p2) = fl.parents(n)
+                if p1 not in nodes:
+                    self.ui.warn("file %s:%s unknown parent 1 %s" %
+                            (f, short(n), short(p1)))
+                    errors += 1
+                if p2 not in nodes:
+                    self.ui.warn("file %s:%s unknown parent 2 %s" %
+                            (f, short(n), short(p1)))
+                    errors += 1
+                nodes[n] = 1
+
+            # cross-check
+            for node in filenodes[f]:
+                self.ui.warn("node %s in manifests not in %s\n"
+                             % (hex(n), f))
+                errors += 1
+
+        self.ui.status("%d files, %d changesets, %d total revisions\n" %
+                       (files, changesets, revisions))
+
+        if errors:
+            self.ui.warn("%d integrity errors encountered!\n" % errors)
+            return 1
+
 class remoterepository:
     def __init__(self, ui, path):
         self.url = path
         self.ui = ui
 
     def do_cmd(self, cmd, **args):
         self.ui.debug("sending %s command\n" % cmd)
         q = {"cmd": cmd}
         q.update(args)
         qs = urllib.urlencode(q)
         cu = "%s?%s" % (self.url, qs)
         return urllib.urlopen(cu)
 
     def heads(self):
         d = self.do_cmd("heads").read()
         try:
             return map(bin, d[:-1].split(" "))
         except:
             self.ui.warn("unexpected response:\n" + d[:400] + "\n...\n")
             raise
 
     def branches(self, nodes):
         n = " ".join(map(hex, nodes))
         d = self.do_cmd("branches", nodes=n).read()
         try:
             br = [ tuple(map(bin, b.split(" "))) for b in d.splitlines() ]
             return br
         except:
             self.ui.warn("unexpected response:\n" + d[:400] + "\n...\n")
             raise
 
     def between(self, pairs):
         n = "\n".join(["-".join(map(hex, p)) for p in pairs])
         d = self.do_cmd("between", pairs=n).read()
         try:
             p = [ l and map(bin, l.split(" ")) or [] for l in d.splitlines() ]
             return p
         except:
             self.ui.warn("unexpected response:\n" + d[:400] + "\n...\n")
             raise
 
     def changegroup(self, nodes):
         n = " ".join(map(hex, nodes))
         zd = zlib.decompressobj()
         f = self.do_cmd("changegroup", roots=n)
         bytes = 0
         while 1:
             d = f.read(4096)
             bytes += len(d)
             if not d:
                 yield zd.flush()
                 break
             yield zd.decompress(d)
         self.ui.note("%d bytes of data transfered\n" % bytes)
 
 def repository(ui, path=None, create=0):
     if path and path[:7] == "http://":
         return remoterepository(ui, path)
     if path and path[:5] == "hg://":
         return remoterepository(ui, path.replace("hg://", "http://"))
     if path and path[:11] == "old-http://":
         return localrepository(ui, path.replace("old-http://", "http://"))
     else:
         return localrepository(ui, path, create)
 
 class httprangereader:
     def __init__(self, url):
         self.url = url
         self.pos = 0
     def seek(self, pos):
         self.pos = pos
     def read(self, bytes=None):
         opener = urllib2.build_opener(byterange.HTTPRangeHandler())
         urllib2.install_opener(opener)
         req = urllib2.Request(self.url)
         end = ''
         if bytes: end = self.pos + bytes
         req.add_header('Range', 'bytes=%d-%s' % (self.pos, end))
         f = urllib2.urlopen(req)
         return f.read()