← Back to branch summary

~abentley/bzrtools/bzrtools.dev

« back to all changes in this revision

Viewing changes to bzrtools.py

adjust tests for the 0.7 diff behavioural change.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrtools.py
1
 
# Copyright (C) 2005, 2006, 2007 Aaron Bentley <aaron@aaronbentley.com>
2
 
# Copyright (C) 2007 John Arbash Meinel
 
1
# Copyright (C) 2005 Aaron Bentley
 
2
# <aaron.bentley@utoronto.ca>
3
3
#
4
4
#    This program is free software; you can redistribute it and/or modify
5
5
#    it under the terms of the GNU General Public License as published by
14
14
#    You should have received a copy of the GNU General Public License
15
15
#    along with this program; if not, write to the Free Software
16
16
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
 
import codecs
18
 
import errno
 
17
import bzrlib
 
18
import bzrlib.errors
19
19
import os
20
 
import re
 
20
import os.path
 
21
import sys
21
22
import tempfile
22
23
import shutil
 
24
import errno
23
25
from subprocess import Popen, PIPE
24
 
import sys
25
 
 
26
 
import bzrlib
27
 
from bzrlib import revision as _mod_revision, trace, urlutils
28
 
import bzrlib.errors
29
 
from bzrlib.errors import (
30
 
    BzrCommandError,
31
 
    BzrError,
32
 
    ConnectionError,
33
 
    NotBranchError,
34
 
    NoSuchFile,
35
 
    NoWorkingTree,
36
 
    PermissionDenied,
37
 
    UnsupportedFormatError,
38
 
    TransportError,
39
 
    )
40
 
from bzrlib.bzrdir import BzrDir, BzrDirFormat
41
 
from bzrlib.transport import get_transport
42
 
 
43
 
def temp_tree():
 
26
import codecs
 
27
 
 
28
def temp_branch():
44
29
    dirname = tempfile.mkdtemp("temp-branch")
45
 
    return BzrDir.create_standalone_workingtree(dirname)
46
 
 
47
 
def rm_tree(tree):
48
 
    shutil.rmtree(tree.basedir)
49
 
 
50
 
def is_clean(cur_tree):
 
30
    return bzrlib.branch.Branch.initialize(dirname)
 
31
 
 
32
def rm_branch(br):
 
33
    shutil.rmtree(br.base)
 
34
 
 
35
def is_clean(cur_branch):
51
36
    """
52
37
    Return true if no files are modifed or unknown
 
38
    >>> import bzrlib.add
 
39
    >>> br = temp_branch()
 
40
    >>> is_clean(br)
 
41
    (True, [])
 
42
    >>> fooname = os.path.join(br.base, "foo")
 
43
    >>> file(fooname, "wb").write("bar")
 
44
    >>> is_clean(br)
 
45
    (True, [u'foo'])
 
46
    >>> bzrlib.add.smart_add_branch(br, [br.base])
 
47
    1
 
48
    >>> is_clean(br)
 
49
    (False, [])
 
50
    >>> br.commit("added file")
 
51
    >>> is_clean(br)
 
52
    (True, [])
 
53
    >>> rm_branch(br)
53
54
    """
54
 
    old_tree = cur_tree.basis_tree()
55
 
    new_tree = cur_tree
 
55
    from bzrlib.diff import compare_trees
 
56
    old_tree = cur_branch.basis_tree()
 
57
    new_tree = cur_branch.working_tree()
56
58
    non_source = []
57
 
    new_tree.lock_read()
58
 
    try:
59
 
        for path, file_class, kind, file_id, entry in new_tree.list_files():
60
 
            if file_class in ('?', 'I'):
61
 
                non_source.append(path)
62
 
        delta = new_tree.changes_from(old_tree, want_unchanged=False)
63
 
    finally:
64
 
        new_tree.unlock()
65
 
    return not delta.has_changed(), non_source
66
 
 
67
 
def set_push_data(tree, location):
68
 
    tree.branch._transport.put_bytes("x-push-data", "%s\n" % location)
69
 
 
70
 
def get_push_data(tree):
71
 
    """
72
 
    >>> tree = temp_tree()
73
 
    >>> get_push_data(tree) is None
 
59
    for path, file_class, kind, file_id, entry in new_tree.list_files():
 
60
        if file_class in ('?', 'I'):
 
61
            non_source.append(path)
 
62
    delta = compare_trees(old_tree, new_tree, want_unchanged=False)
 
63
    if len(delta.added) > 0 or len(delta.removed) > 0 or \
 
64
        len(delta.modified) > 0:
 
65
        return False, non_source
 
66
    return True, non_source 
 
67
 
 
68
def set_pull_data(br, location, rev_id):
 
69
    pull_file = file (br.controlfilename("x-pull-data"), "wb")
 
70
    pull_file.write("%s\n%s\n" % (location, rev_id))
 
71
 
 
72
def get_pull_data(br):
 
73
    """
 
74
    >>> br = temp_branch()
 
75
    >>> get_pull_data(br)
 
76
    (None, None)
 
77
    >>> set_pull_data(br, 'http://somewhere', '888-777')
 
78
    >>> get_pull_data(br)
 
79
    ('http://somewhere', '888-777')
 
80
    >>> rm_branch(br)
 
81
    """
 
82
    filename = br.controlfilename("x-pull-data")
 
83
    if not os.path.exists(filename):
 
84
        return (None, None)
 
85
    pull_file = file (filename, "rb")
 
86
    location, rev_id = [f.rstrip('\n') for f in pull_file]
 
87
    return location, rev_id
 
88
 
 
89
def set_push_data(br, location):
 
90
    push_file = file (br.controlfilename("x-push-data"), "wb")
 
91
    push_file.write("%s\n" % location)
 
92
 
 
93
def get_push_data(br):
 
94
    """
 
95
    >>> br = temp_branch()
 
96
    >>> get_push_data(br) is None
74
97
    True
75
 
    >>> set_push_data(tree, 'http://somewhere')
76
 
    >>> get_push_data(tree)
77
 
    u'http://somewhere'
78
 
    >>> rm_tree(tree)
 
98
    >>> set_push_data(br, 'http://somewhere')
 
99
    >>> get_push_data(br)
 
100
    'http://somewhere'
 
101
    >>> rm_branch(br)
79
102
    """
80
 
    try:
81
 
        location = tree.branch._transport.get('x-push-data').read()
82
 
    except NoSuchFile:
 
103
    filename = br.controlfilename("x-push-data")
 
104
    if not os.path.exists(filename):
83
105
        return None
84
 
    location = location.decode('utf-8')
85
 
    return location.rstrip('\n')
 
106
    push_file = file (filename, "rb")
 
107
    (location,) = [f.rstrip('\n') for f in push_file]
 
108
    return location
86
109
 
87
110
"""
88
111
>>> shell_escape('hello')
110
133
    def __init__(self, rsync_name):
111
134
        Exception.__init__(self, "%s not found." % rsync_name)
112
135
 
113
 
 
114
 
def rsync(source, target, ssh=False, excludes=(), silent=False,
 
136
def rsync(source, target, ssh=False, excludes=(), silent=False, 
115
137
          rsync_name="rsync"):
 
138
    """
 
139
    >>> rsync("a", "b", silent=True)
 
140
    Traceback (most recent call last):
 
141
    RsyncNoFile: No such file a
 
142
    >>> rsync("a", "b", excludes=("*.py",), silent=True)
 
143
    Traceback (most recent call last):
 
144
    RsyncNoFile: No such file a
 
145
    >>> rsync("a", "b", excludes=("*.py",), silent=True, rsync_name="rsyncc")
 
146
    Traceback (most recent call last):
 
147
    NoRsync: rsyncc not found.
 
148
    """
116
149
    cmd = [rsync_name, "-av", "--delete"]
117
150
    if ssh:
118
151
        cmd.extend(('-e', 'ssh'))
130
163
    except OSError, e:
131
164
        if e.errno == errno.ENOENT:
132
165
            raise NoRsync(rsync_name)
133
 
 
 
166
            
134
167
    proc.stdin.write('\n'.join(excludes)+'\n')
135
168
    proc.stdin.close()
136
169
    if silent:
172
205
        raise RsyncUnknownStatus(proc.returncode)
173
206
    return [l.split(' ')[-1].rstrip('\n') for l in result.splitlines(True)]
174
207
 
175
 
exclusions = ('.bzr/x-push-data', '.bzr/branch/x-push/data', '.bzr/parent',
176
 
              '.bzr/branch/parent', '.bzr/x-pull-data', '.bzr/x-pull',
177
 
              '.bzr/pull', '.bzr/stat-cache', '.bzr/x-rsync-data',
178
 
              '.bzr/basis-inventory', '.bzr/inventory.backup.weave')
 
208
exclusions = ('.bzr/x-push-data', '.bzr/parent', '.bzr/x-pull-data', 
 
209
              '.bzr/x-pull', '.bzr/pull', '.bzr/stat-cache',
 
210
              '.bzr/x-rsync-data')
179
211
 
180
212
 
181
213
def read_revision_history(fname):
182
214
    return [l.rstrip('\r\n') for l in
183
215
            codecs.open(fname, 'rb', 'utf-8').readlines()]
184
216
 
185
 
 
186
 
def read_revision_info(path):
187
 
    """Parse a last_revision file to determine revision_info"""
188
 
    line = open(path, 'rb').readlines()[0].strip('\n')
189
 
    revno, revision_id = line.split(' ', 1)
190
 
    revno = int(revno)
191
 
    return revno, revision_id
192
 
 
193
 
 
194
217
class RsyncNoFile(Exception):
195
218
    def __init__(self, path):
196
219
        Exception.__init__(self, "No such file %s" % path)
199
222
    def __init__(self):
200
223
        Exception.__init__(self, "Error in rsync protocol data stream.")
201
224
 
202
 
 
203
 
class NotStandalone(BzrError):
204
 
 
205
 
    _fmt = '%(location)s is not a standalone tree.'
206
 
    _internal = False
207
 
 
208
 
    def __init__(self, location):
209
 
        BzrError.__init__(self, location=location)
210
 
 
211
 
 
212
 
def get_revision_history(location, _rsync):
 
225
def get_revision_history(location):
213
226
    tempdir = tempfile.mkdtemp('push')
214
 
    my_rsync = _rsync
215
 
    if my_rsync is None:
216
 
        my_rsync = rsync
217
227
    try:
218
228
        history_fname = os.path.join(tempdir, 'revision-history')
219
 
        try:
220
 
            cmd = my_rsync(location+'.bzr/revision-history', history_fname,
221
 
                        silent=True)
222
 
        except RsyncNoFile:
223
 
            cmd = rsync(location+'.bzr/branch/revision-history', history_fname,
224
 
                        silent=True)
 
229
        cmd = rsync(location+'.bzr/revision-history', history_fname,
 
230
                    silent=True)
225
231
        history = read_revision_history(history_fname)
226
232
    finally:
227
233
        shutil.rmtree(tempdir)
228
234
    return history
229
235
 
230
 
 
231
 
def get_revision_info(location, _rsync):
232
 
    """Get the revsision_info for an rsync-able branch"""
233
 
    tempdir = tempfile.mkdtemp('push')
234
 
    my_rsync = _rsync
235
 
    if my_rsync is None:
236
 
        my_rsync = rsync
237
 
    try:
238
 
        info_fname = os.path.join(tempdir, 'last-revision')
239
 
        cmd = rsync(location+'.bzr/branch/last-revision', info_fname,
240
 
                    silent=True)
241
 
        return read_revision_info(info_fname)
242
 
    finally:
243
 
        shutil.rmtree(tempdir)
244
 
 
245
 
 
246
 
def history_subset(location, branch, _rsync=None):
 
236
def history_subset(location, branch):
 
237
    remote_history = get_revision_history(location)
247
238
    local_history = branch.revision_history()
248
 
    try:
249
 
        remote_history = get_revision_history(location, _rsync)
250
 
    except RsyncNoFile:
251
 
        revno, revision_id = get_revision_info(location, _rsync)
252
 
        if revision_id == _mod_revision.NULL_REVISION:
253
 
            return True
254
 
        return bool(revision_id.decode('utf-8') in local_history)
255
 
    else:
256
 
        if len(remote_history) > len(local_history):
257
 
            return False
258
 
        for local, remote in zip(remote_history, local_history):
259
 
            if local != remote:
260
 
                return False
261
 
        return True
262
 
 
 
239
    if len(remote_history) > len(local_history):
 
240
        return False
 
241
    for local, remote in zip(remote_history, local_history):
 
242
        if local != remote:
 
243
            return False 
 
244
    return True
263
245
 
264
246
def empty_or_absent(location):
265
247
    try:
268
250
    except RsyncNoFile:
269
251
        return True
270
252
 
271
 
def rspush(tree, location=None, overwrite=False, working_tree=True,
272
 
    _rsync=None):
273
 
    tree.lock_write()
274
 
    try:
275
 
        my_rsync = _rsync
276
 
        if my_rsync is None:
277
 
            my_rsync = rsync
278
 
        if (tree.bzrdir.root_transport.base !=
279
 
            tree.branch.bzrdir.root_transport.base):
280
 
            raise NotStandalone(tree.bzrdir.root_transport.base)
281
 
        if (tree.branch.get_bound_location() is not None):
282
 
            raise NotStandalone(tree.bzrdir.root_transport.base)
283
 
        if (tree.branch.repository.is_shared()):
284
 
            raise NotStandalone(tree.bzrdir.root_transport.base)
285
 
        push_location = get_push_data(tree)
286
 
        if location is not None:
287
 
            if not location.endswith('/'):
288
 
                location += '/'
289
 
            push_location = location
290
 
 
291
 
        if push_location is None:
292
 
            raise BzrCommandError("No rspush location known or specified.")
293
 
 
294
 
        if (push_location.find('::') != -1):
295
 
            usessh=False
296
 
        else:
297
 
            usessh=True
298
 
 
299
 
        if (push_location.find('://') != -1 or
300
 
            push_location.find(':') == -1):
301
 
            raise BzrCommandError("Invalid rsync path %r." % push_location)
302
 
 
303
 
        if working_tree:
304
 
            clean, non_source = is_clean(tree)
305
 
            if not clean:
306
 
                raise bzrlib.errors.BzrCommandError(
307
 
                    'This tree has uncommitted changes or unknown'
308
 
                    ' (?) files.  Use "bzr status" to list them.')
309
 
                sys.exit(1)
310
 
            final_exclusions = non_source[:]
311
 
        else:
312
 
            wt = tree
313
 
            final_exclusions = []
314
 
            for path, status, kind, file_id, entry in wt.list_files():
315
 
                final_exclusions.append(path)
316
 
 
317
 
        final_exclusions.extend(exclusions)
318
 
        if not overwrite:
319
 
            try:
320
 
                if not history_subset(push_location, tree.branch,
321
 
                                      _rsync=my_rsync):
322
 
                    raise bzrlib.errors.BzrCommandError(
323
 
                        "Local branch is not a newer version of remote"
324
 
                        " branch.")
325
 
            except RsyncNoFile:
326
 
                if not empty_or_absent(push_location):
327
 
                    raise bzrlib.errors.BzrCommandError(
328
 
                        "Remote location is not a bzr branch (or empty"
329
 
                        " directory)")
330
 
            except RsyncStreamIO:
331
 
                raise bzrlib.errors.BzrCommandError("Rsync could not use the"
332
 
                    " specified location.  Please ensure that"
333
 
                    ' "%s" is of the form "machine:/path".' % push_location)
334
 
        trace.note("Pushing to %s", push_location)
335
 
        my_rsync(tree.basedir+'/', push_location, ssh=usessh,
336
 
                 excludes=final_exclusions)
337
 
 
338
 
        set_push_data(tree, push_location)
339
 
    finally:
340
 
        tree.unlock()
341
 
 
342
 
 
343
 
def short_committer(committer):
344
 
    new_committer = re.sub('<.*>', '', committer).strip(' ')
345
 
    if len(new_committer) < 2:
346
 
        return committer
347
 
    return new_committer
348
 
 
349
 
 
350
 
def apache_ls(t):
351
 
    """Screen-scrape Apache listings"""
352
 
    apache_dir = '<img border="0" src="/icons/folder.gif" alt="[dir]">'\
353
 
        ' <a href="'
354
 
    t = t.clone()
355
 
    t._remote_path = lambda x: t.base
356
 
    try:
357
 
        lines = t.get('')
358
 
    except bzrlib.errors.NoSuchFile:
359
 
        return
360
 
    expr = re.compile('<a[^>]*href="([^>]*)\/"[^>]*>', flags=re.I)
361
 
    for line in lines:
362
 
        match = expr.search(line)
363
 
        if match is None:
364
 
            continue
365
 
        url = match.group(1)
366
 
        if url.startswith('http://') or url.startswith('/') or '../' in url:
367
 
            continue
368
 
        if '?' in url:
369
 
            continue
370
 
        yield url.rstrip('/')
371
 
 
372
 
 
373
 
def list_branches(t):
374
 
    def is_inside(branch):
375
 
        return bool(branch.base.startswith(t.base))
376
 
 
377
 
    if t.base.startswith('http://'):
378
 
        def evaluate(bzrdir):
379
 
            try:
380
 
                branch = bzrdir.open_branch()
381
 
                if is_inside(branch):
382
 
                    return True, branch
383
 
                else:
384
 
                    return True, None
385
 
            except NotBranchError:
386
 
                return True, None
387
 
        return [b for b in BzrDir.find_bzrdirs(t, list_current=apache_ls,
388
 
                evaluate=evaluate) if b is not None]
389
 
    elif not t.listable():
390
 
        raise BzrCommandError("Can't list this type of location.")
391
 
    return [b for b in BzrDir.find_branches(t) if is_inside(b)]
392
 
 
393
 
 
394
 
def evaluate_branch_tree(bzrdir):
395
 
    try:
396
 
        tree, branch = bzrdir._get_tree_branch()
397
 
    except NotBranchError:
398
 
        return True, None
399
 
    else:
400
 
        return True, (branch, tree)
401
 
 
402
 
 
403
 
def iter_branch_tree(t, lister=None):
404
 
    return (x for x in BzrDir.find_bzrdirs(t, evaluate=evaluate_branch_tree,
405
 
            list_current=lister) if x is not None)
406
 
 
407
 
 
408
 
def open_from_url(location):
409
 
    location = urlutils.normalize_url(location)
410
 
    dirname, basename = urlutils.split(location)
411
 
    if location.endswith('/') and not basename.endswith('/'):
412
 
        basename += '/'
413
 
    return get_transport(dirname).get(basename)
414
 
 
 
253
def push(cur_branch, location=None, overwrite=False):
 
254
    push_location = get_push_data(cur_branch)
 
255
    if location is not None:
 
256
        if not location.endswith('/'):
 
257
            location += '/'
 
258
        push_location = location
 
259
    
 
260
    if push_location is None:
 
261
        print "No push location saved.  Please specify one on the command line."
 
262
        sys.exit(1)
 
263
 
 
264
    clean, non_source = is_clean(cur_branch)
 
265
    if not clean:
 
266
        print """Error: This tree has uncommitted changes or unknown (?) files.
 
267
Use "bzr status" to list them."""
 
268
        sys.exit(1)
 
269
    non_source.extend(exclusions)
 
270
    if not overwrite:
 
271
        try:
 
272
            if not history_subset(push_location, cur_branch):
 
273
                raise bzrlib.errors.BzrCommandError("Local branch is not a"
 
274
                                                    " newer version of remote"
 
275
                                                    " branch.")
 
276
        except RsyncNoFile:
 
277
            if not empty_or_absent(push_location):
 
278
                raise bzrlib.errors.BzrCommandError("Remote location is not a"
 
279
                                                    " bzr branch (or empty"
 
280
                                                    " directory)")
 
281
        except RsyncStreamIO:
 
282
            raise bzrlib.errors.BzrCommandError("Rsync could not use the"
 
283
                " specified location.  Please ensure that"
 
284
                ' "%s" is of the form "machine:/path".' % push_location)
 
285
    print "Pushing to %s" % push_location
 
286
    rsync(cur_branch.base+'/', push_location, ssh=True, excludes=non_source)
 
287
 
 
288
    set_push_data(cur_branch, push_location)
415
289
 
416
290
def run_tests():
417
291
    import doctest