← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/weave.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2009-03-17 07:05:37 UTC
  • mfrom: (4152.1.2 branch.stacked.streams)
  • Revision ID: pqm@pqm.ubuntu.com-20090317070537-zaud24vjs2szna87
(robertc) Add client-side streaming from stacked branches (over
        bzr:// protocols) when the sort order is compatible with doing
        that. (Robert Collins, Andrew Bennetts)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/weave.py
1
 
# Copyright (C) 2005, 2009 Canonical Ltd
 
1
#! /usr/bin/python
 
2
 
 
3
# Copyright (C) 2005 Canonical Ltd
2
4
#
3
5
# This program is free software; you can redistribute it and/or modify
4
6
# it under the terms of the GNU General Public License as published by
12
14
#
13
15
# You should have received a copy of the GNU General Public License
14
16
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
17
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
18
 
17
19
# Author: Martin Pool <mbp@canonical.com>
18
20
 
69
71
from copy import copy
70
72
from cStringIO import StringIO
71
73
import os
 
74
import time
 
75
import warnings
72
76
 
73
77
from bzrlib.lazy_import import lazy_import
74
78
lazy_import(globals(), """
77
81
from bzrlib import (
78
82
    errors,
79
83
    osutils,
 
84
    progress,
80
85
    )
81
86
from bzrlib.errors import (WeaveError, WeaveFormatError, WeaveParentMismatch,
82
87
        RevisionAlreadyPresent,
83
88
        RevisionNotPresent,
84
89
        UnavailableRepresentation,
 
90
        WeaveRevisionAlreadyPresent,
 
91
        WeaveRevisionNotPresent,
85
92
        )
86
93
from bzrlib.osutils import dirname, sha, sha_strings, split_lines
87
94
import bzrlib.patiencediff
403
410
        version_id
404
411
            Symbolic name for this version.
405
412
            (Typically the revision-id of the revision that added it.)
406
 
            If None, a name will be allocated based on the hash. (sha1:SHAHASH)
407
413
 
408
414
        parents
409
415
            List or set of direct parent version numbers.
419
425
            sha1 = sha_strings(lines)
420
426
        if sha1 == nostore_sha:
421
427
            raise errors.ExistingContent
422
 
        if version_id is None:
423
 
            version_id = "sha1:" + sha1
424
428
        if version_id in self._name_map:
425
429
            return self._check_repeated_add(version_id, parents, lines, sha1)
426
430
 
968
972
        super(WeaveFile, self).insert_record_stream(stream)
969
973
        self._save()
970
974
 
 
975
    @deprecated_method(one_five)
 
976
    def join(self, other, pb=None, msg=None, version_ids=None,
 
977
             ignore_missing=False):
 
978
        """Join other into self and save."""
 
979
        super(WeaveFile, self).join(other, pb, msg, version_ids, ignore_missing)
 
980
        self._save()
 
981
 
971
982
 
972
983
def _reweave(wa, wb, pb=None, msg=None):
973
984
    """Combine two weaves and return the result.
1018
1029
        wr._add(name, lines, [wr._lookup(i) for i in combined_parents[name]])
1019
1030
    return wr
1020
1031
 
1021
 
 
1022
1032
def _reweave_parent_graphs(wa, wb):
1023
1033
    """Return combined parent ancestry for two weaves.
1024
1034
 
1029
1039
            p = combined.setdefault(name, set())
1030
1040
            p.update(map(weave._idx_to_name, weave._parents[idx]))
1031
1041
    return combined
 
1042
 
 
1043
 
 
1044
def weave_toc(w):
 
1045
    """Show the weave's table-of-contents"""
 
1046
    print '%6s %50s %10s %10s' % ('ver', 'name', 'sha1', 'parents')
 
1047
    for i in (6, 50, 10, 10):
 
1048
        print '-' * i,
 
1049
    print
 
1050
    for i in range(w.num_versions()):
 
1051
        sha1 = w._sha1s[i]
 
1052
        name = w._names[i]
 
1053
        parent_str = ' '.join(map(str, w._parents[i]))
 
1054
        print '%6d %-50.50s %10.10s %s' % (i, name, sha1, parent_str)
 
1055
 
 
1056
 
 
1057
 
 
1058
def weave_stats(weave_file, pb):
 
1059
    from bzrlib.weavefile import read_weave
 
1060
 
 
1061
    wf = file(weave_file, 'rb')
 
1062
    w = read_weave(wf)
 
1063
    # FIXME: doesn't work on pipes
 
1064
    weave_size = wf.tell()
 
1065
 
 
1066
    total = 0
 
1067
    vers = len(w)
 
1068
    for i in range(vers):
 
1069
        pb.update('checking sizes', i, vers)
 
1070
        for origin, lineno, line in w._extract([i]):
 
1071
            total += len(line)
 
1072
 
 
1073
    pb.clear()
 
1074
 
 
1075
    print 'versions          %9d' % vers
 
1076
    print 'weave file        %9d bytes' % weave_size
 
1077
    print 'total contents    %9d bytes' % total
 
1078
    print 'compression ratio %9.2fx' % (float(total) / float(weave_size))
 
1079
    if vers:
 
1080
        avg = total/vers
 
1081
        print 'average size      %9d bytes' % avg
 
1082
        print 'relative size     %9.2fx' % (float(weave_size) / float(avg))
 
1083
 
 
1084
 
 
1085
def usage():
 
1086
    print """bzr weave tool
 
1087
 
 
1088
Experimental tool for weave algorithm.
 
1089
 
 
1090
usage:
 
1091
    weave init WEAVEFILE
 
1092
        Create an empty weave file
 
1093
    weave get WEAVEFILE VERSION
 
1094
        Write out specified version.
 
1095
    weave check WEAVEFILE
 
1096
        Check consistency of all versions.
 
1097
    weave toc WEAVEFILE
 
1098
        Display table of contents.
 
1099
    weave add WEAVEFILE NAME [BASE...] < NEWTEXT
 
1100
        Add NEWTEXT, with specified parent versions.
 
1101
    weave annotate WEAVEFILE VERSION
 
1102
        Display origin of each line.
 
1103
    weave merge WEAVEFILE VERSION1 VERSION2 > OUT
 
1104
        Auto-merge two versions and display conflicts.
 
1105
    weave diff WEAVEFILE VERSION1 VERSION2
 
1106
        Show differences between two versions.
 
1107
 
 
1108
example:
 
1109
 
 
1110
    % weave init foo.weave
 
1111
    % vi foo.txt
 
1112
    % weave add foo.weave ver0 < foo.txt
 
1113
    added version 0
 
1114
 
 
1115
    (create updated version)
 
1116
    % vi foo.txt
 
1117
    % weave get foo.weave 0 | diff -u - foo.txt
 
1118
    % weave add foo.weave ver1 0 < foo.txt
 
1119
    added version 1
 
1120
 
 
1121
    % weave get foo.weave 0 > foo.txt       (create forked version)
 
1122
    % vi foo.txt
 
1123
    % weave add foo.weave ver2 0 < foo.txt
 
1124
    added version 2
 
1125
 
 
1126
    % weave merge foo.weave 1 2 > foo.txt   (merge them)
 
1127
    % vi foo.txt                            (resolve conflicts)
 
1128
    % weave add foo.weave merged 1 2 < foo.txt     (commit merged version)
 
1129
 
 
1130
"""
 
1131
 
 
1132
 
 
1133
 
 
1134
def main(argv):
 
1135
    import sys
 
1136
    import os
 
1137
    try:
 
1138
        import bzrlib
 
1139
    except ImportError:
 
1140
        # in case we're run directly from the subdirectory
 
1141
        sys.path.append('..')
 
1142
        import bzrlib
 
1143
    from bzrlib.weavefile import write_weave, read_weave
 
1144
    from bzrlib.progress import ProgressBar
 
1145
 
 
1146
    try:
 
1147
        import psyco
 
1148
        psyco.full()
 
1149
    except ImportError:
 
1150
        pass
 
1151
 
 
1152
    if len(argv) < 2:
 
1153
        usage()
 
1154
        return 0
 
1155
 
 
1156
    cmd = argv[1]
 
1157
 
 
1158
    def readit():
 
1159
        return read_weave(file(argv[2], 'rb'))
 
1160
 
 
1161
    if cmd == 'help':
 
1162
        usage()
 
1163
    elif cmd == 'add':
 
1164
        w = readit()
 
1165
        # at the moment, based on everything in the file
 
1166
        name = argv[3]
 
1167
        parents = map(int, argv[4:])
 
1168
        lines = sys.stdin.readlines()
 
1169
        ver = w.add(name, parents, lines)
 
1170
        write_weave(w, file(argv[2], 'wb'))
 
1171
        print 'added version %r %d' % (name, ver)
 
1172
    elif cmd == 'init':
 
1173
        fn = argv[2]
 
1174
        if os.path.exists(fn):
 
1175
            raise IOError("file exists")
 
1176
        w = Weave()
 
1177
        write_weave(w, file(fn, 'wb'))
 
1178
    elif cmd == 'get': # get one version
 
1179
        w = readit()
 
1180
        sys.stdout.writelines(w.get_iter(int(argv[3])))
 
1181
 
 
1182
    elif cmd == 'diff':
 
1183
        w = readit()
 
1184
        fn = argv[2]
 
1185
        v1, v2 = map(int, argv[3:5])
 
1186
        lines1 = w.get(v1)
 
1187
        lines2 = w.get(v2)
 
1188
        diff_gen = bzrlib.patiencediff.unified_diff(lines1, lines2,
 
1189
                                '%s version %d' % (fn, v1),
 
1190
                                '%s version %d' % (fn, v2))
 
1191
        sys.stdout.writelines(diff_gen)
 
1192
 
 
1193
    elif cmd == 'annotate':
 
1194
        w = readit()
 
1195
        # newline is added to all lines regardless; too hard to get
 
1196
        # reasonable formatting otherwise
 
1197
        lasto = None
 
1198
        for origin, text in w.annotate(int(argv[3])):
 
1199
            text = text.rstrip('\r\n')
 
1200
            if origin == lasto:
 
1201
                print '      | %s' % (text)
 
1202
            else:
 
1203
                print '%5d | %s' % (origin, text)
 
1204
                lasto = origin
 
1205
 
 
1206
    elif cmd == 'toc':
 
1207
        weave_toc(readit())
 
1208
 
 
1209
    elif cmd == 'stats':
 
1210
        weave_stats(argv[2], ProgressBar())
 
1211
 
 
1212
    elif cmd == 'check':
 
1213
        w = readit()
 
1214
        pb = ProgressBar()
 
1215
        w.check(pb)
 
1216
        pb.clear()
 
1217
        print '%d versions ok' % w.num_versions()
 
1218
 
 
1219
    elif cmd == 'inclusions':
 
1220
        w = readit()
 
1221
        print ' '.join(map(str, w.inclusions([int(argv[3])])))
 
1222
 
 
1223
    elif cmd == 'parents':
 
1224
        w = readit()
 
1225
        print ' '.join(map(str, w._parents[int(argv[3])]))
 
1226
 
 
1227
    elif cmd == 'plan-merge':
 
1228
        # replaced by 'bzr weave-plan-merge'
 
1229
        w = readit()
 
1230
        for state, line in w.plan_merge(int(argv[3]), int(argv[4])):
 
1231
            if line:
 
1232
                print '%14s | %s' % (state, line),
 
1233
    elif cmd == 'merge':
 
1234
        # replaced by 'bzr weave-merge-text'
 
1235
        w = readit()
 
1236
        p = w.plan_merge(int(argv[3]), int(argv[4]))
 
1237
        sys.stdout.writelines(w.weave_merge(p))
 
1238
    else:
 
1239
        raise ValueError('unknown command %r' % cmd)
 
1240
 
 
1241
 
 
1242
if __name__ == '__main__':
 
1243
    import sys
 
1244
    sys.exit(main(sys.argv))