#!/usr/bin/python## This is a pretty-printer for subversion BDB repository databases.#import sys, os, re, codecs, textwrapimport skel, svnfs# Parse argumentsif len(sys.argv) == 2:  dbhome = os.path.join(sys.argv[1], 'db')  if not os.path.exists(dbhome):    sys.stderr.write("%s: '%s' is not a valid svn repository\n" %        (sys.argv[0], dbhome))    sys.exit(1)else:  sys.stderr.write("Usage: %s <svn-repository>\n" % sys.argv[0])  sys.exit(1)# Helper Classesclass RepositoryProblem(Exception):  pass# Helper Functionsdef ok(bool, comment):  if not bool:    raise RepositoryProblem(text)# Helper Dataopmap = {  'add': 'A',  'modify': 'M',  'delete': 'D',  'replace': 'R',  'reset': 'X',}# Analysis Modulesdef am_uuid(ctx):  "uuids"  db = ctx.uuids_db  ok(db.keys() == [1], 'uuid Table Structure')  ok(re.match(r'^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$',    db[1]), 'UUID format')  print "Repos UUID: %s" % db[1]def am_revisions(ctx):  "revisions"  cur = ctx.revs_db.cursor()  try:    rec = cur.first()    ctx.txn2rev = txn2rev = {}    prevrevnum = -1    while rec:      rev = skel.Rev(rec[1])      revnum = rec[0] - 1      print "r%d: txn %s%s" % (revnum, rev.txn,          (not ctx.txns_db.has_key(rev.txn)) and "*** MISSING TXN ***" or "")      ok(not txn2rev.has_key(rev.txn), 'Multiple revs bound to same txn')      txn2rev[rev.txn] = revnum      rec = cur.next()  finally:    cur.close()def am_changes(ctx):  "changes"  cur = ctx.changes_db.cursor()  try:    current_txnid_len = 0    maximum_txnid_len = 0    while current_txnid_len <= maximum_txnid_len:      current_txnid_len += 1      rec = cur.first()      prevtxn = None      while rec:        if len(rec[0]) != current_txnid_len:          rec = cur.next()          continue        ch = skel.Change(rec[1])        lead = "txn %s:" % rec[0]        if prevtxn == rec[0]:          lead = " " * len(lead)        print "%s %s %s %s %s %s%s" % (lead, opmap[ch.kind], ch.path, ch.node,            ch.textmod and "T" or "-", ch.propmod and "P" or "-",            (not ctx.nodes_db.has_key(ch.node)) \                and "*** MISSING NODE ***" or "")        prevtxn = rec[0]        if len(rec[0]) > maximum_txnid_len:          maximum_txnid_len = len(rec[0])        rec = cur.next()  finally:    cur.close()def am_copies(ctx):  "copies"  cur = ctx.copies_db.cursor()  try:    print "next-key: %s" % ctx.copies_db['next-key']    rec = cur.first()    while rec:      if rec[0] != 'next-key':        cp = skel.Copy(rec[1])        destnode = ctx.nodes_db.get(cp.destnode)        if not destnode:          destpath = "*** MISSING NODE ***"        else:          destpath = skel.Node(destnode).createpath        print "cpy %s: %s %s @txn %s to %s (%s)" % (rec[0],            {'copy':'C','soft-copy':'S'}[cp.kind], cp.srcpath or "-",            cp.srctxn or "-", cp.destnode, destpath)      rec = cur.next()  finally:    cur.close()def am_txns(ctx):  "transactions"  cur = ctx.txns_db.cursor()  try:    print "next-key: %s" % ctx.txns_db['next-key']    length = 1    found_some = True    while found_some:      found_some = False      rec = cur.first()      while rec:        if rec[0] != 'next-key' and len(rec[0]) == length:          found_some = True          txn = skel.Txn(rec[1])          if txn.kind == "committed":            label = "r%s" % txn.rev            ok(ctx.txn2rev[rec[0]] == int(txn.rev), 'Txn->rev not <-txn')          else:            label = "%s based-on %s" % (txn.kind, txn.basenode)          print "txn %s: %s root-node %s props %d copies %s" % (rec[0],              label, txn.rootnode, len(txn.proplist) / 2, ",".join(txn.copies))        rec = cur.next()      length += 1  finally:    cur.close()def am_nodes(ctx):  "nodes"  cur = ctx.nodes_db.cursor()  try:    print "next-key: %s" % ctx.txns_db['next-key']    rec = cur.first()    data = {}    while rec:      if rec[0] == 'next-key':        rec = cur.next()        continue      nd = skel.Node(rec[1])      nid,cid,tid = rec[0].split(".")      data[tid.rjust(20)+nd.createpath] = (rec[0], nd)      rec = cur.next()    k = data.keys()    k.sort()    reptype = {"fulltext":"F", "delta":"D"}    for i in k:      nd = data[i][1]      prkind = drkind = " "      if nd.proprep:        try:          rep = skel.Rep(ctx.reps_db[nd.proprep])          prkind = reptype[rep.kind]          if ctx.bad_reps.has_key(nd.proprep):            prkind += " *** BAD ***"        except KeyError:          prkind = "*** MISSING ***"      if nd.datarep:        try:          rep = skel.Rep(ctx.reps_db[nd.datarep])          drkind = reptype[rep.kind]          if ctx.bad_reps.has_key(nd.datarep):            drkind += " *** BAD ***"        except KeyError:          drkind = "*** MISSING ***"      stringdata = "%s: %s %s pred %s count %s prop %s %s data %s %s edit %s" \          % ( data[i][0], {"file":"F", "dir":"D"}[nd.kind], nd.createpath,          nd.prednode or "-", nd.predcount, prkind, nd.proprep or "-",          drkind, nd.datarep or "-", nd.editrep or "-")      if nd.createpath == "/":        print      print stringdata  finally:    cur.close()def get_string(ctx, id):  try:    return ctx.get_whole_string(id)  except DbNotFoundError:    return "*** MISSING STRING ***"def am_reps(ctx):  "representations"  ctx.bad_reps = {}  cur = ctx.reps_db.cursor()  try:    print "next-key: %s" % ctx.txns_db['next-key']    rec = cur.first()    while rec:      if rec[0] != 'next-key':        rep = skel.Rep(rec[1])        lead = "rep %s: txn %s: %s %s " % (rec[0], rep.txn, rep.cksumtype,            codecs.getencoder('hex_codec')(rep.cksum)[0])        if rep.kind == "fulltext":          note = ""          if not ctx.strings_db.has_key(rep.str):            note = " *MISS*"            ctx.bad_reps[rec[0]] = None          print lead+("fulltext str %s%s" % (rep.str, note))          if ctx.verbose:            print textwrap.fill(get_string(ctx, rep.str), initial_indent="  ",                subsequent_indent="  ", width=78)        elif rep.kind == "delta":          print lead+("delta of %s window%s" % (len(rep.windows),            len(rep.windows) != 1 and "s" or ""))          for window in rep.windows:            noterep = notestr = ""            if not ctx.reps_db.has_key(window.vs_rep):              noterep = " *MISS*"              ctx.bad_reps[rec[0]] = None            if not ctx.strings_db.has_key(window.str):              notestr = " *MISS*"              ctx.bad_reps[rec[0]] = None            print "\toff %s len %s vs-rep %s%s str %s%s" % (window.offset,                window.size, window.vs_rep, noterep, window.str, notestr)        else:          print lead+"*** UNKNOWN REPRESENTATION TYPE ***"      rec = cur.next()  finally:    cur.close()def am_stringsize(ctx):  "string size"  if not ctx.verbose:    return  cur = ctx.strings_db.cursor()  try:    rec = cur.first()    size = 0    while rec:      size = size + len(rec[1] or "")      rec = cur.next()    print size, size/1024.0, size/1024.0/1024.0  finally:    cur.close()modules = (    am_uuid,    am_revisions,    am_changes,    am_copies,    am_txns,    am_reps,    am_nodes,    # Takes too long: am_stringsize,    )def main():  print "Repository View for '%s'" % dbhome  print  ctx = svnfs.Ctx(dbhome, readonly=1)  # Stash process state in a library data structure. Yuck!  ctx.verbose = 0  try:    for am in modules:      print "MODULE: %s" % am.__doc__      am(ctx)      print  finally:    ctx.close()if __name__ == '__main__':  main()