~abentley/bzrtools/bzrtools.dev

« back to all changes in this revision

Viewing changes to bzrtools.py

  • Committer: Aaron Bentley
  • Date: 2005-09-29 13:26:07 UTC
  • mto: (147.2.17)
  • mto: This revision was merged to the branch mainline in revision 324.
  • Revision ID: abentley@panoramicfeedback.com-20050929132607-822df5d29e8e595d
Committed debugging changes

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006, 2007 Aaron Bentley <aaron.bentley@utoronto.ca>
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
 
import bzrlib.errors
28
 
from bzrlib.errors import (BzrCommandError, NotBranchError, NoSuchFile,
29
 
                           UnsupportedFormatError, TransportError,
30
 
                           NoWorkingTree, PermissionDenied)
31
 
from bzrlib.bzrdir import BzrDir, BzrDirFormat
32
 
 
33
 
def temp_tree():
 
26
import codecs
 
27
 
 
28
def temp_branch():
34
29
    dirname = tempfile.mkdtemp("temp-branch")
35
 
    return BzrDir.create_standalone_workingtree(dirname)
36
 
 
37
 
def rm_tree(tree):
38
 
    shutil.rmtree(tree.basedir)
39
 
 
40
 
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):
41
36
    """
42
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, ['foo'])
 
46
    >>> bzrlib.add.smart_add_branch(br, [br.base])
 
47
    1
 
48
    >>> is_clean(br)
 
49
    (False, [])
 
50
    >>> br.commit("added file")
 
51
    added foo
 
52
    >>> is_clean(br)
 
53
    (True, [])
 
54
    >>> rm_branch(br)
43
55
    """
44
 
    old_tree = cur_tree.basis_tree()
45
 
    new_tree = cur_tree
 
56
    from bzrlib.diff import compare_trees
 
57
    old_tree = cur_branch.basis_tree()
 
58
    new_tree = cur_branch.working_tree()
46
59
    non_source = []
47
 
    new_tree.lock_read()
48
 
    try:
49
 
        for path, file_class, kind, file_id, entry in new_tree.list_files():
50
 
            if file_class in ('?', 'I'):
51
 
                non_source.append(path)
52
 
        delta = new_tree.changes_from(old_tree, want_unchanged=False)
53
 
    finally:
54
 
        new_tree.unlock()
55
 
    return not delta.has_changed(), non_source
56
 
 
57
 
def set_push_data(tree, location):
58
 
    tree.branch.control_files.put_utf8("x-push-data", "%s\n" % location)
59
 
 
60
 
def get_push_data(tree):
61
 
    """
62
 
    >>> tree = temp_tree()
63
 
    >>> get_push_data(tree) is None
 
60
    for path, file_class, kind, file_id in new_tree.list_files():
 
61
        if file_class in ('?', 'I'):
 
62
            non_source.append(path)
 
63
    delta = compare_trees(old_tree, new_tree, want_unchanged=False)
 
64
    if len(delta.added) > 0 or len(delta.removed) > 0 or \
 
65
        len(delta.modified) > 0:
 
66
        return False, non_source
 
67
    return True, non_source 
 
68
 
 
69
def set_pull_data(br, location, rev_id):
 
70
    pull_file = file (br.controlfilename("x-pull-data"), "wb")
 
71
    pull_file.write("%s\n%s\n" % (location, rev_id))
 
72
 
 
73
def get_pull_data(br):
 
74
    """
 
75
    >>> br = temp_branch()
 
76
    >>> get_pull_data(br)
 
77
    (None, None)
 
78
    >>> set_pull_data(br, 'http://somewhere', '888-777')
 
79
    >>> get_pull_data(br)
 
80
    ('http://somewhere', '888-777')
 
81
    >>> rm_branch(br)
 
82
    """
 
83
    filename = br.controlfilename("x-pull-data")
 
84
    if not os.path.exists(filename):
 
85
        return (None, None)
 
86
    pull_file = file (filename, "rb")
 
87
    location, rev_id = [f.rstrip('\n') for f in pull_file]
 
88
    return location, rev_id
 
89
 
 
90
def set_push_data(br, location):
 
91
    push_file = file (br.controlfilename("x-push-data"), "wb")
 
92
    push_file.write("%s\n" % location)
 
93
 
 
94
def get_push_data(br):
 
95
    """
 
96
    >>> br = temp_branch()
 
97
    >>> get_push_data(br) is None
64
98
    True
65
 
    >>> set_push_data(tree, 'http://somewhere')
66
 
    >>> get_push_data(tree)
67
 
    u'http://somewhere'
68
 
    >>> rm_tree(tree)
 
99
    >>> set_push_data(br, 'http://somewhere')
 
100
    >>> get_push_data(br)
 
101
    'http://somewhere'
 
102
    >>> rm_branch(br)
69
103
    """
70
 
    try:
71
 
        location = tree.branch.control_files.get_utf8('x-push-data').read()
72
 
    except NoSuchFile:
 
104
    filename = br.controlfilename("x-push-data")
 
105
    if not os.path.exists(filename):
73
106
        return None
74
 
    return location.rstrip('\n')
 
107
    push_file = file (filename, "rb")
 
108
    (location,) = [f.rstrip('\n') for f in push_file]
 
109
    return location
75
110
 
76
111
"""
77
112
>>> shell_escape('hello')
99
134
    def __init__(self, rsync_name):
100
135
        Exception.__init__(self, "%s not found." % rsync_name)
101
136
 
102
 
def rsync(source, target, ssh=False, excludes=(), silent=False,
 
137
def rsync(source, target, ssh=False, excludes=(), silent=False, 
103
138
          rsync_name="rsync"):
104
139
    """
105
 
    >>> new_dir = tempfile.mkdtemp()
106
 
    >>> old_dir = os.getcwd()
107
 
    >>> os.chdir(new_dir)
108
140
    >>> rsync("a", "b", silent=True)
109
141
    Traceback (most recent call last):
110
 
    RsyncNoFile: No such file...
111
 
    >>> rsync(new_dir + "/a", new_dir + "/b", excludes=("*.py",), silent=True)
 
142
    RsyncNoFile: No such file a
 
143
    >>> rsync("a", "b", excludes=("*.py",), silent=True)
112
144
    Traceback (most recent call last):
113
 
    RsyncNoFile: No such file...
114
 
    >>> rsync(new_dir + "/a", new_dir + "/b", excludes=("*.py",), silent=True, rsync_name="rsyncc")
 
145
    RsyncNoFile: No such file a
 
146
    >>> rsync("a", "b", excludes=("*.py",), silent=True, rsync_name="rsyncc")
115
147
    Traceback (most recent call last):
116
148
    NoRsync: rsyncc not found.
117
 
    >>> os.chdir(old_dir)
118
 
    >>> os.rmdir(new_dir)
119
149
    """
120
150
    cmd = [rsync_name, "-av", "--delete"]
121
151
    if ssh:
134
164
    except OSError, e:
135
165
        if e.errno == errno.ENOENT:
136
166
            raise NoRsync(rsync_name)
137
 
 
 
167
            
138
168
    proc.stdin.write('\n'.join(excludes)+'\n')
139
169
    proc.stdin.close()
140
170
    if silent:
176
206
        raise RsyncUnknownStatus(proc.returncode)
177
207
    return [l.split(' ')[-1].rstrip('\n') for l in result.splitlines(True)]
178
208
 
179
 
exclusions = ('.bzr/x-push-data', '.bzr/branch/x-push/data', '.bzr/parent',
180
 
              '.bzr/branch/parent', '.bzr/x-pull-data', '.bzr/x-pull',
181
 
              '.bzr/pull', '.bzr/stat-cache', '.bzr/x-rsync-data',
182
 
              '.bzr/basis-inventory', '.bzr/inventory.backup.weave')
 
209
exclusions = ('.bzr/x-push-data', '.bzr/parent', '.bzr/x-pull-data', 
 
210
              '.bzr/x-pull', '.bzr/pull', '.bzr/stat-cache',
 
211
              '.bzr/x-rsync-data')
183
212
 
184
213
 
185
214
def read_revision_history(fname):
198
227
    tempdir = tempfile.mkdtemp('push')
199
228
    try:
200
229
        history_fname = os.path.join(tempdir, 'revision-history')
201
 
        try:
202
 
            cmd = rsync(location+'.bzr/revision-history', history_fname,
203
 
                        silent=True)
204
 
        except RsyncNoFile:
205
 
            cmd = rsync(location+'.bzr/branch/revision-history', history_fname,
206
 
                        silent=True)
 
230
        cmd = rsync(location+'.bzr/revision-history', history_fname,
 
231
                    silent=True)
207
232
        history = read_revision_history(history_fname)
208
233
    finally:
209
234
        shutil.rmtree(tempdir)
216
241
        return False
217
242
    for local, remote in zip(remote_history, local_history):
218
243
        if local != remote:
219
 
            return False
 
244
            return False 
220
245
    return True
221
246
 
222
247
def empty_or_absent(location):
226
251
    except RsyncNoFile:
227
252
        return True
228
253
 
229
 
def rspush(tree, location=None, overwrite=False, working_tree=True):
230
 
    push_location = get_push_data(tree)
 
254
def push(cur_branch, location=None, overwrite=False):
 
255
    push_location = get_push_data(cur_branch)
231
256
    if location is not None:
232
257
        if not location.endswith('/'):
233
258
            location += '/'
234
259
        push_location = location
235
 
 
 
260
    
236
261
    if push_location is None:
237
 
        raise BzrCommandError("No rspush location known or specified.")
238
 
 
239
 
    if (push_location.find('::') != -1):
240
 
        usessh=False
241
 
    else:
242
 
        usessh=True
243
 
 
244
 
    if (push_location.find('://') != -1 or
245
 
        push_location.find(':') == -1):
246
 
        raise BzrCommandError("Invalid rsync path %r." % push_location)
247
 
 
248
 
    if working_tree:
249
 
        clean, non_source = is_clean(tree)
250
 
        if not clean:
251
 
            print """Error: This tree has uncommitted changes or unknown (?) files.
252
 
    Use "bzr status" to list them."""
253
 
            sys.exit(1)
254
 
        final_exclusions = non_source[:]
255
 
    else:
256
 
        wt = tree
257
 
        final_exclusions = []
258
 
        for path, status, kind, file_id, entry in wt.list_files():
259
 
            final_exclusions.append(path)
260
 
 
261
 
    final_exclusions.extend(exclusions)
 
262
        print "No push location saved.  Please specify one on the command line."
 
263
        sys.exit(1)
 
264
 
 
265
    clean, non_source = is_clean(cur_branch)
 
266
    if not clean:
 
267
        print """Error: This tree has uncommitted changes or unknown (?) files.
 
268
Use "bzr status" to list them."""
 
269
        sys.exit(1)
 
270
    non_source.extend(exclusions)
262
271
    if not overwrite:
263
272
        try:
264
 
            if not history_subset(push_location, tree.branch):
 
273
            if not history_subset(push_location, cur_branch):
265
274
                raise bzrlib.errors.BzrCommandError("Local branch is not a"
266
275
                                                    " newer version of remote"
267
276
                                                    " branch.")
275
284
                " specified location.  Please ensure that"
276
285
                ' "%s" is of the form "machine:/path".' % push_location)
277
286
    print "Pushing to %s" % push_location
278
 
    rsync(tree.basedir+'/', push_location, ssh=usessh,
279
 
          excludes=final_exclusions)
280
 
 
281
 
    set_push_data(tree, push_location)
282
 
 
283
 
 
284
 
def short_committer(committer):
285
 
    new_committer = re.sub('<.*>', '', committer).strip(' ')
286
 
    if len(new_committer) < 2:
287
 
        return committer
288
 
    return new_committer
289
 
 
290
 
 
291
 
def apache_ls(t):
292
 
    """Screen-scrape Apache listings"""
293
 
    apache_dir = '<img border="0" src="/icons/folder.gif" alt="[dir]">'\
294
 
        ' <a href="'
295
 
    lines = t.get('.')
296
 
    expr = re.compile('<a[^>]*href="([^>]*)"[^>]*>', flags=re.I)
297
 
    for line in lines:
298
 
        match = expr.search(line)
299
 
        if match is None:
300
 
            continue
301
 
        url = match.group(1)
302
 
        if url.startswith('http://') or url.startswith('/') or '../' in url:
303
 
            continue
304
 
        if '?' in url:
305
 
            continue
306
 
        yield url.rstrip('/')
307
 
 
308
 
 
309
 
def iter_branches(t, lister=None):
310
 
    """Iterate through all the branches under a transport"""
311
 
    for bzrdir in iter_bzrdirs(t, lister):
312
 
        try:
313
 
            branch = bzrdir.open_branch()
314
 
            if branch.bzrdir is bzrdir:
315
 
                yield branch
316
 
        except (NotBranchError, UnsupportedFormatError):
317
 
            pass
318
 
 
319
 
 
320
 
def iter_branch_tree(t, lister=None):
321
 
    for bzrdir in iter_bzrdirs(t, lister):
322
 
        try:
323
 
            wt = bzrdir.open_workingtree()
324
 
            yield wt.branch, wt
325
 
        except NoWorkingTree, UnsupportedFormatError:
326
 
            try:
327
 
                branch = bzrdir.open_branch()
328
 
                if branch.bzrdir is bzrdir:
329
 
                    yield branch, None
330
 
            except (NotBranchError, UnsupportedFormatError):
331
 
                continue
332
 
 
333
 
 
334
 
def iter_bzrdirs(t, lister=None):
335
 
    if lister is None:
336
 
        def lister(t):
337
 
            return t.list_dir('.')
338
 
    try:
339
 
        bzrdir = bzrdir_from_transport(t)
340
 
        yield bzrdir
341
 
    except (NotBranchError, UnsupportedFormatError, TransportError,
342
 
            PermissionDenied):
343
 
        pass
344
 
    try:
345
 
        for directory in lister(t):
346
 
            if directory == ".bzr":
347
 
                continue
348
 
            try:
349
 
                subt = t.clone(directory)
350
 
            except UnicodeDecodeError:
351
 
                continue
352
 
            for bzrdir in iter_bzrdirs(subt, lister):
353
 
                yield bzrdir
354
 
    except (NoSuchFile, PermissionDenied, TransportError):
355
 
        pass
356
 
 
357
 
 
358
 
def bzrdir_from_transport(t):
359
 
    """Open a bzrdir from a transport (not a location)"""
360
 
    format = BzrDirFormat.find_format(t)
361
 
    BzrDir._check_supported(format, False)
362
 
    return format.open(t)
363
 
 
 
287
    rsync(cur_branch.base+'/', push_location, ssh=True, excludes=non_source)
 
288
 
 
289
    set_push_data(cur_branch, push_location)
364
290
 
365
291
def run_tests():
366
292
    import doctest